Port enb specific classes to use srslog (#2155)

* - Started porting the enb PHY layer to use srslog loggers.
- Updated srslog to manage the none level.

* Finished porting enb phy layer including the NR part.

* Ported MAC, GTPU, PDCP, RLC and S1AP enb classes to use srslog.

* Use new stack logger.

* Ported the enb RRC clases to use srslog.

* Remove unused log macros.

* Replace loggers in sched, sched_carrier, sched_helpers.

* Replaced loggers in sched grid.

* Replaced loggers in sched harq.

* Replaced loggers in sched ue.

* Replaced loggers in sched ue ctrl.

* Replace loggers in sched ue ctrl TPC.

* Replaced loggers in sched subclasses.

* Replaced loggers in rrc_meascfg_test

* Configure loggers in rrc_mobility_test.

* Fix compilation errors left out after the rebase.

* - Implement a custom log sink that will serve as a test spy to intercept and count the number of error and warning log entries.
- Adapt the erab_test_setup and rrc_mobility tests to use this new class and make them pass again.

* - Remove trailing new lines introduced in the rebase.
- Ported the sched_ue_cell class to srslog.

* Remove unused log member.

* Ported mac tests to srslog.

* - Removed remaining trailing newlines from log entries.

* Fix compiler errors detected in CI.

* Fix another static variable without definition passed to log lines.

* Fixed a bug in srslog::flush that would never end when the backend queue is full.

* Fetch the RRC logger instead of injecting it in the constructor.

lib/include/srslte/common/signal_handler.h

@@ -19,6 +19,7 @@
 #define SRSLTE_SIGNAL_HANDLER_H
 
 #include "srslte/srslog/sink.h"
+#include "srslte/srslog/srslog.h"
 #include <signal.h>
 #include <stdio.h>
 
@@ -29,14 +30,15 @@ extern "C" {
 #define SRSLTE_TERM_TIMEOUT_S (5)
 
 // static vars required by signal handling
-static srslog::sink*       log_sink = nullptr;
+static srslog::sink* log_sink = nullptr;
-static bool                running = true;
+static bool          running  = true;
 
 static void srslte_signal_handler(int signal)
 {
   switch (signal) {
     case SIGALRM:
       fprintf(stderr, "Couldn't stop after %ds. Forcing exit.\n", SRSLTE_TERM_TIMEOUT_S);
+      srslog::flush();
       //:TODO: refactor the sighandler, should not depend on log utilities
       if (log_sink) {
         log_sink->flush();

lib/include/srslte/common/test_common.h

@@ -20,6 +20,8 @@
 #include "srslte/common/log.h"
 #include "srslte/common/log_filter.h"
 #include "srslte/common/logmap.h"
+#include "srslte/srslog/srslog.h"
+#include <atomic>
 #include <cstdio>
 
 namespace srslte {
@@ -82,6 +84,65 @@ public:
   uint32_t error_counter = 0, warn_counter = 0;
 };
 
+/// This custom sink intercepts log messages to count error and warning log entries.
+class log_sink_spy : public srslog::sink
+{
+public:
+  explicit log_sink_spy(std::unique_ptr<srslog::log_formatter> f) :
+    srslog::sink(std::move(f)), s(srslog::get_default_sink())
+  {
+    error_counter.store(0);
+    warning_counter.store(0);
+  }
+
+  /// Identifier of this custom sink.
+  static const char* name() { return "log_sink_spy"; }
+
+  /// Returns the number of log entries tagged as errors.
+  unsigned get_error_counter() const
+  {
+    // Flush to make sure all entries have been processed by the backend.
+    srslog::flush();
+    return error_counter.load();
+  }
+
+  /// Returns the number of log entries tagged as warnings.
+  unsigned get_warning_counter() const
+  {
+    // Flush to make sure all entries have been processed by the backend.
+    srslog::flush();
+    return warning_counter.load();
+  }
+
+  /// Resets the counters back to 0.
+  void reset_counters()
+  {
+    // Flush to make sure all entries have been processed by the backend.
+    srslog::flush();
+    error_counter.store(0);
+    warning_counter.store(0);
+  }
+
+  srslog::detail::error_string write(srslog::detail::memory_buffer buffer) override
+  {
+    std::string entry(buffer.data(), buffer.size());
+    if (entry.find("[E]") != std::string::npos) {
+      error_counter.fetch_add(1);
+    } else if (entry.find("[W]") != std::string::npos) {
+      warning_counter.fetch_add(1);
+    }
+
+    return s.write(buffer);
+  }
+
+  srslog::detail::error_string flush() override { return s.flush(); }
+
+private:
+  srslog::sink&         s;
+  std::atomic<unsigned> error_counter;
+  std::atomic<unsigned> warning_counter;
+};
+
 // specialization of test_log_filter to store last logged message
 class nullsink_log : public test_log_filter
 {

lib/include/srslte/srslog/detail/log_backend.h

@@ -31,8 +31,9 @@ public:
   /// NOTE: Calling this function more than once has no side effects.
   virtual void start() = 0;
 
-  /// Pushes a log entry into the backend.
+  /// Pushes a log entry into the backend. Returns true on success, otherwise
-  virtual void push(log_entry&& entry) = 0;
+  /// false.
+  virtual bool push(log_entry&& entry) = 0;
 
   /// Returns true when the backend has been started, otherwise false.
   virtual bool is_running() const = 0;

lib/include/srslte/srslog/detail/support/work_queue.h

@@ -40,32 +40,38 @@ public:
   work_queue(const work_queue&) = delete;
   work_queue& operator=(const work_queue&) = delete;
 
-  /// Inserts a new element into the back of the queue.
+  /// Inserts a new element into the back of the queue. Returns false when the
-  void push(const T& value)
+  /// queue is full, otherwise true.
+  bool push(const T& value)
   {
     cond_var.lock();
     // Discard the new element if we reach the maximum capacity.
     if (queue.size() > capacity) {
       cond_var.unlock();
-      return;
+      return false;
     }
     queue.push(value);
     cond_var.signal();
     cond_var.unlock();
+
+    return true;
   }
 
-  /// Inserts a new element into the back of the queue.
+  /// Inserts a new element into the back of the queue. Returns false when the
-  void push(T&& value)
+  /// queue is full, otherwise true.
+  bool push(T&& value)
   {
     cond_var.lock();
     // Discard the new element if we reach the maximum capacity.
     if (queue.size() > capacity) {
       cond_var.unlock();
-      return;
+      return false;
     }
     queue.push(std::move(value));
     cond_var.signal();
     cond_var.unlock();
+
+    return true;
   }
 
   /// Extracts the top most element from the queue.

lib/include/srslte/srslog/logger.h

@@ -29,14 +29,12 @@ class logger_impl : public T
   static_assert(std::is_enum<Enum>::value, "Expected enum type");
 
   using enum_base_type = typename std::underlying_type<Enum>::type;
-  static constexpr unsigned size = static_cast<enum_base_type>(Enum::LAST);
+  static constexpr unsigned size = static_cast<enum_base_type>(Enum::LAST) - 1;
 
 public:
   template <typename... Args>
   explicit logger_impl(std::string id, Args&&... args) :
-    T{std::forward<Args>(args)...},
+    T{std::forward<Args>(args)...}, logger_id(std::move(id)), channels{&args...}
-    logger_id(std::move(id)),
-    channels{&args...}
   {
     static_assert(
         sizeof...(args) == size,
@@ -53,8 +51,18 @@ public:
   void set_level(Enum lvl)
   {
     detail::scoped_lock lock(m);
+
+    // Disable all channels ...
+    if (lvl == Enum::none) {
+      for (unsigned i = 0, e = channels.size(); i != e; ++i) {
+        channels[i]->set_enabled(false);
+      }
+      return;
+    }
+
+    // ... otherwise do it selectively.
     for (unsigned i = 0, e = channels.size(); i != e; ++i) {
-      channels[i]->set_enabled(static_cast<Enum>(i) <= lvl);
+      channels[i]->set_enabled(static_cast<Enum>(i + 1) <= lvl);
     }
   }
 
@@ -103,8 +111,9 @@ struct is_logger<logger_impl<T, Enum>> : std::true_type {};
 ///
 /// To create a new logger type simply follow these steps:
 ///   1) Define an enum class where each element will represent a logging level.
-///     Order the elements from highest to lowest logging level. The last
+///     Order the elements from highest to lowest logging level. First element
-///     element should be called LAST as it is a sentinel value.
+///     should be "none", which represents a disabled logger.
+///     The last element should be called LAST as it is a sentinel value.
 ///   2) Define a struct composed by only log_channel references. Declare the
 ///     members in the same order as done in the enum.
 ///   3) Define the new logger type by using the build_logger_type alias. Pass
@@ -113,7 +122,8 @@ struct is_logger<logger_impl<T, Enum>> : std::true_type {};
 /// Example to declare a logger with three logging levels: error, warning and
 /// info, being error the highest logging level and info the lowest:
 ///   1) Define the logging level enum:
-///     enum class three_level_logger_levels { error, warning, info, LAST };
+///     enum class three_level_logger_levels { none, error, warning, info, LAST
+///     };
 ///   2) Define the struct of three channels (same order as in the enum):
 ///     struct three_level_logger {
 ///       log_channel &error;
@@ -131,7 +141,7 @@ using build_logger_type = detail::logger_impl<T, Enum>;
 ///
 
 /// Basic logger with four levels.
-enum class basic_levels { error, warning, info, debug, LAST };
+enum class basic_levels { none, error, warning, info, debug, LAST };
 struct basic_logger_channels {
   log_channel& error;
   log_channel& warning;
@@ -140,6 +150,29 @@ struct basic_logger_channels {
 };
 using basic_logger = build_logger_type<basic_logger_channels, basic_levels>;
 
+/// Translates a string to the corresponding logger basic level.
+inline basic_levels str_to_basic_level(std::string s)
+{
+  std::transform(s.begin(), s.end(), s.begin(), ::toupper);
+
+  if ("NONE" == s) {
+    return basic_levels::none;
+  }
+  if ("ERROR" == s) {
+    return basic_levels::error;
+  }
+  if ("WARNING" == s) {
+    return basic_levels::warning;
+  }
+  if ("INFO" == s) {
+    return basic_levels::info;
+  }
+  if ("DEBUG" == s) {
+    return basic_levels::debug;
+  }
+  return basic_levels::none;
+}
+
 } // namespace srslog
 
 #endif // SRSLOG_LOGGER_H

lib/include/srslte/srslog/srslog_c.h

@@ -116,6 +116,7 @@ void srslog_error(srslog_logger* log, const char* fmt, ...);
 const char* srslog_get_logger_id(srslog_logger* log);
 
 typedef enum {
+  srslog_lvl_none,    /**< disable logger */
   srslog_lvl_error,   /**< error logging level */
   srslog_lvl_warning, /**< warning logging level */
   srslog_lvl_info,    /**< info logging level */

lib/src/srslog/formatters/text_formatter.cpp

@@ -60,7 +60,7 @@ static void format_metadata(const detail::log_entry_metadata& metadata,
 
   // Format optional fields if present.
   if (!metadata.log_name.empty()) {
-    fmt::format_to(buffer, "[{: <4.4}] ", metadata.log_name);
+    fmt::format_to(buffer, "[{: <4}] ", metadata.log_name);
   }
   if (metadata.log_tag != '\0') {
     fmt::format_to(buffer, "[{}] ", metadata.log_tag);

lib/src/srslog/log_backend_impl.h

@@ -31,9 +31,9 @@ public:
 
   void start() override { worker.start(); }
 
-  void push(detail::log_entry&& entry) override
+  bool push(detail::log_entry&& entry) override
   {
-    queue.push(std::move(entry));
+    return queue.push(std::move(entry));
   }
 
   bool is_running() const override { return worker.is_running(); }

lib/src/srslog/srslog.cpp

@@ -201,7 +201,10 @@ void srslog::flush()
   cmd.flush_cmd = std::unique_ptr<detail::flush_backend_cmd>(
       new detail::flush_backend_cmd{completion_flag, std::move(sinks)});
 
-  instance.get_backend().push(std::move(cmd));
+  // Make sure the flush command gets into the backend, otherwise we will be
+  // stuck waiting forever for the command to succeed.
+  while (!instance.get_backend().push(std::move(cmd))) {
+  }
 
   // Block the caller thread until we are signaled that the flush is completed.
   while (!completion_flag) {

lib/src/srslog/srslog_c.cpp

@@ -145,6 +145,8 @@ const char* srslog_get_logger_id(srslog_logger* log)
 static basic_levels convert_c_enum_to_basic_levels(srslog_log_levels lvl)
 {
   switch (lvl) {
+    case srslog_lvl_none:
+      return basic_levels::none;
     case srslog_lvl_debug:
       return basic_levels::debug;
     case srslog_lvl_info:
@@ -156,7 +158,7 @@ static basic_levels convert_c_enum_to_basic_levels(srslog_log_levels lvl)
   }
 
   assert(false && "Invalid enum value");
-  return basic_levels::error;
+  return basic_levels::none;
 }
 
 void srslog_set_logger_level(srslog_logger* log, srslog_log_levels lvl)

lib/test/srslog/event_trace_test.cpp

@@ -26,7 +26,11 @@ class backend_spy : public detail::log_backend
 public:
   void start() override {}
 
-  void push(detail::log_entry&& entry) override { ++count; }
+  bool push(detail::log_entry&& entry) override
+  {
+    ++count;
+    return true;
+  }
 
   bool is_running() const override { return true; }
 

lib/test/srslog/log_channel_test.cpp

@@ -62,10 +62,11 @@ class backend_spy : public detail::log_backend
 public:
   void start() override {}
 
-  void push(detail::log_entry&& entry) override
+  bool push(detail::log_entry&& entry) override
   {
     e = std::move(entry);
     ++count;
+    return true;
   }
 
   bool is_running() const override { return true; }

lib/test/srslog/logger_test.cpp

@@ -21,7 +21,7 @@ static constexpr char logger_id[] = "TestLogger";
 namespace {
 
 /// Definition of a three level logger
-enum class test_logger_levels { error, warning, info, LAST };
+enum class test_logger_levels { none, error, warning, info, LAST };
 struct test_logger_channels {
   log_channel& error;
   log_channel& warning;
@@ -100,12 +100,31 @@ static bool when_level_is_set_to_info_then_all_are_enabled()
   return true;
 }
 
+static bool when_level_is_set_to_none_then_all_are_disabled()
+{
+  test_dummies::backend_dummy backend;
+  test_dummies::sink_dummy s;
+  log_channel error("err", s, backend);
+  log_channel warning("warning", s, backend);
+  log_channel info("info", s, backend);
+
+  test_logger logger(logger_id, error, warning, info);
+  logger.set_level(test_logger_levels::none);
+
+  ASSERT_EQ(logger.error.enabled(), false);
+  ASSERT_EQ(logger.warning.enabled(), false);
+  ASSERT_EQ(logger.info.enabled(), false);
+
+  return true;
+}
+
 int main()
 {
   TEST_FUNCTION(when_logger_is_created_then_id_matches_expected_value);
   TEST_FUNCTION(when_level_is_set_to_error_then_info_and_warning_is_disabled);
   TEST_FUNCTION(when_level_is_set_to_warning_then_info_is_disabled);
   TEST_FUNCTION(when_level_is_set_to_info_then_all_are_enabled);
+  TEST_FUNCTION(when_level_is_set_to_none_then_all_are_disabled);
 
   return 0;
 }

lib/test/srslog/srslog_test.cpp

@@ -165,7 +165,7 @@ static bool when_invalid_id_with_valid_type_is_passed_then_no_logger_is_found()
 }
 
 /// Dummy logger type
-enum class dummy_levels { error, LAST };
+enum class dummy_levels { none, error, LAST };
 struct dummy_logger_channels {
   log_channel& error;
 };

lib/test/srslog/test_dummies.h

@@ -88,7 +88,7 @@ class backend_dummy : public srslog::detail::log_backend
 public:
   void start() override {}
 
-  void push(srslog::detail::log_entry&& entry) override {}
+  bool push(srslog::detail::log_entry&& entry) override { return true; }
 
   bool is_running() const override { return true; }
 };

srsenb/hdr/enb.h

@@ -41,6 +41,7 @@
 #include "srslte/interfaces/enb_metrics_interface.h"
 #include "srslte/interfaces/sched_interface.h"
 #include "srslte/interfaces/ue_interfaces.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -111,7 +112,7 @@ struct rrc_cfg_t;
 class enb : public enb_metrics_interface, enb_command_interface
 {
 public:
-  enb();
+  enb(srslog::sink& log_sink);
 
   virtual ~enb();
 
@@ -134,8 +135,9 @@ private:
 
   int parse_args(const all_args_t& args_, rrc_cfg_t& rrc_cfg);
 
-  srslte::logger* logger = nullptr;
+  srslte::logger*       logger = nullptr;
-  srslte::log_ref log; // Own logger for eNB
+  srslog::sink&         log_sink;
+  srslog::basic_logger& enb_log;
 
   srslte::log_filter pool_log;
 

srsenb/hdr/phy/lte/cc_worker.h

@@ -16,6 +16,7 @@
 #include <string.h>
 
 #include "../phy_common.h"
+#include "srslte/srslog/srslog.h"
 
 #define LOG_EXECTIME
 
@@ -25,9 +26,9 @@ namespace lte {
 class cc_worker
 {
 public:
-  cc_worker();
+  cc_worker(srslog::basic_logger& logger);
   ~cc_worker();
-  void init(phy_common* phy, srslte::log* log_h, uint32_t cc_idx);
+  void init(phy_common* phy, uint32_t cc_idx);
   void reset();
 
   cf_t* get_buffer_rx(uint32_t antenna_idx);
@@ -70,9 +71,9 @@ private:
   int  decode_pucch();
 
   /* Common objects */
-  srslte::log* log_h     = nullptr;
+  srslog::basic_logger& logger;
-  phy_common*  phy       = nullptr;
+  phy_common*           phy       = nullptr;
-  bool         initiated = false;
+  bool                  initiated = false;
 
   cf_t*    signal_buffer_rx[SRSLTE_MAX_PORTS] = {};
   cf_t*    signal_buffer_tx[SRSLTE_MAX_PORTS] = {};

srsenb/hdr/phy/lte/sf_worker.h

@@ -18,6 +18,7 @@
 
 #include "../phy_common.h"
 #include "cc_worker.h"
+#include "srslte/srslog/srslog.h"
 #include "srslte/srslte.h"
 
 namespace srsenb {
@@ -26,9 +27,9 @@ namespace lte {
 class sf_worker : public srslte::thread_pool::worker
 {
 public:
-  sf_worker() = default;
+  sf_worker(srslog::basic_logger& logger) : logger(logger) {}
   ~sf_worker();
-  void init(phy_common* phy, srslte::log* log_h);
+  void init(phy_common* phy);
 
   cf_t* get_buffer_rx(uint32_t cc_idx, uint32_t antenna_idx);
   void  set_time(uint32_t tti_, uint32_t tx_worker_cnt_, const srslte::rf_timestamp_t& tx_time_);
@@ -53,11 +54,11 @@ private:
   void work_imp() final;
 
   /* Common objects */
-  srslte::log* log_h     = nullptr;
+  srslog::basic_logger& logger;
-  phy_common*  phy       = nullptr;
+  phy_common*           phy       = nullptr;
-  bool         initiated = false;
+  bool                  initiated = false;
-  bool         running   = false;
+  bool                  running   = false;
-  std::mutex   work_mutex;
+  std::mutex            work_mutex;
 
   uint32_t               tti_rx = 0, tti_tx_dl = 0, tti_tx_ul = 0;
   uint32_t               t_rx = 0, t_tx_dl = 0, t_tx_ul = 0;

srsenb/hdr/phy/lte/worker_pool.h

@@ -30,10 +30,6 @@ namespace lte {
 
 class worker_pool
 {
-
-private:
-  std::vector<std::unique_ptr<srslte::log_filter> > log_vec;
-
   srslte::thread_pool                      pool;
   std::vector<std::unique_ptr<sf_worker> > workers;
 
@@ -42,7 +38,7 @@ public:
   uint32_t   get_nof_workers() { return (uint32_t)workers.size(); }
 
   worker_pool(uint32_t max_workers);
-  bool       init(const phy_args_t& args, phy_common* common, srslte::logger* logger, int prio);
+  bool       init(const phy_args_t& args, phy_common* common, srslog::sink& log_sink, int prio);
   sf_worker* wait_worker(uint32_t tti);
   sf_worker* wait_worker_id(uint32_t id);
   void       start_worker(sf_worker* w);

srsenb/hdr/phy/nr/cc_worker.h

@@ -25,6 +25,7 @@
 #include "srslte/common/log.h"
 #include "srslte/interfaces/gnb_interfaces.h"
 #include "srslte/phy/enb/enb_dl_nr.h"
+#include "srslte/srslog/srslog.h"
 #include <array>
 #include <vector>
 
@@ -61,7 +62,7 @@ public:
 class cc_worker
 {
 public:
-  cc_worker(uint32_t cc_idx, srslte::log* log, phy_nr_state* phy_state_);
+  cc_worker(uint32_t cc_idx, srslog::basic_logger& logger, phy_nr_state* phy_state_);
   ~cc_worker();
 
   bool set_carrier(const srslte_carrier_nr_t* carrier);
@@ -84,7 +85,7 @@ private:
   uint32_t                            buffer_sz   = 0;
   phy_nr_state*                       phy_state;
   srslte_enb_dl_nr_t                  enb_dl = {};
-  srslte::log*                        log_h  = nullptr;
+  srslog::basic_logger&               logger;
 };
 
 } // namespace nr

srsenb/hdr/phy/nr/sf_worker.h

@@ -25,6 +25,7 @@
 #include "cc_worker.h"
 #include "srsenb/hdr/phy/phy_common.h"
 #include "srslte/common/thread_pool.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 namespace nr {
@@ -40,7 +41,7 @@ namespace nr {
 class sf_worker final : public srslte::thread_pool::worker
 {
 public:
-  sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslte::log* log);
+  sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslog::basic_logger& logger);
   ~sf_worker();
 
   bool set_carrier_unlocked(uint32_t cc_idx, const srslte_carrier_nr_t* carrier_);
@@ -57,9 +58,9 @@ private:
 
   std::vector<std::unique_ptr<cc_worker> > cc_workers;
 
-  phy_common*   phy       = nullptr;
+  phy_common*           phy       = nullptr;
-  phy_nr_state* phy_state = nullptr;
+  phy_nr_state*         phy_state = nullptr;
-  srslte::log*  log_h     = nullptr;
+  srslog::basic_logger& logger;
 
   // Temporal attributes
   srslte_softbuffer_tx_t softbuffer_tx = {};

srsenb/hdr/phy/nr/worker_pool.h

@@ -30,10 +30,6 @@ namespace nr {
 
 class worker_pool
 {
-
-private:
-  std::vector<std::unique_ptr<srslte::log_filter> > log_vec;
-
   srslte::thread_pool                      pool;
   std::vector<std::unique_ptr<sf_worker> > workers;
   phy_nr_state                             phy_state;
@@ -42,7 +38,7 @@ public:
   sf_worker* operator[](std::size_t pos) { return workers.at(pos).get(); }
 
   worker_pool(uint32_t max_workers);
-  bool       init(const phy_args_t& args, phy_common* common, srslte::logger* logger, int prio);
+  bool       init(const phy_args_t& args, phy_common* common, srslog::sink& log_sink, int prio);
   sf_worker* wait_worker(uint32_t tti);
   sf_worker* wait_worker_id(uint32_t id);
   void       start_worker(sf_worker* w);

srsenb/hdr/phy/phy.h

@@ -13,8 +13,8 @@
 #ifndef SRSENB_PHY_H
 #define SRSENB_PHY_H
 
-#include "phy_common.h"
 #include "lte/sf_worker.h"
+#include "phy_common.h"
 #include "srsenb/hdr/phy/enb_phy_base.h"
 #include "srslte/common/log.h"
 #include "srslte/common/log_filter.h"
@@ -23,6 +23,7 @@
 #include "srslte/interfaces/enb_metrics_interface.h"
 #include "srslte/interfaces/radio_interfaces.h"
 #include "srslte/radio/radio.h"
+#include "srslte/srslog/srslog.h"
 #include "txrx.h"
 
 namespace srsenb {
@@ -30,7 +31,7 @@ namespace srsenb {
 class phy final : public enb_phy_base, public phy_interface_stack_lte, public srslte::phy_interface_radio
 {
 public:
-  phy(srslte::logger* logger_);
+  phy(srslog::sink& log_sink);
   ~phy();
 
   int  init(const phy_args_t&            args,
@@ -66,7 +67,7 @@ public:
 
 private:
   srslte::phy_cfg_mbsfn_t mbsfn_config = {};
-  uint32_t        nof_workers  = 0;
+  uint32_t                nof_workers  = 0;
 
   const static int MAX_WORKERS = 4;
 
@@ -76,9 +77,9 @@ private:
 
   srslte::radio_interface_phy* radio = nullptr;
 
-  srslte::logger*                     logger        = nullptr;
+  srslog::sink&         log_sink;
-  std::unique_ptr<srslte::log_filter> log_h         = nullptr;
+  srslog::basic_logger& phy_log;
-  std::unique_ptr<srslte::log_filter> log_phy_lib_h = nullptr;
+  srslog::basic_logger& phy_lib_log;
 
   lte::worker_pool  lte_workers;
   nr::worker_pool   nr_workers;

srsenb/hdr/phy/prach_worker.h

@@ -18,6 +18,7 @@
 #include "srslte/common/log.h"
 #include "srslte/common/threads.h"
 #include "srslte/interfaces/enb_interfaces.h"
+#include "srslte/srslog/srslog.h"
 
 // Setting ENABLE_PRACH_GUI to non zero enables a GUI showing signal received in the PRACH window.
 #define ENABLE_PRACH_GUI 0
@@ -31,12 +32,14 @@ namespace srsenb {
 class prach_worker : srslte::thread
 {
 public:
-  prach_worker(uint32_t cc_idx_) : buffer_pool(8), thread("PRACH_WORKER") { cc_idx = cc_idx_; }
+  prach_worker(uint32_t cc_idx_, srslog::basic_logger& logger) : buffer_pool(8), thread("PRACH_WORKER"), logger(logger)
+  {
+    cc_idx = cc_idx_;
+  }
 
   int  init(const srslte_cell_t&      cell_,
             const srslte_prach_cfg_t& prach_cfg_,
             stack_interface_phy_lte*  mac,
-            srslte::log*              log_h,
             int                       priority,
             uint32_t                  nof_workers);
   int  new_tti(uint32_t tti, cf_t* buffer);
@@ -44,7 +47,7 @@ public:
   void stop();
 
 private:
-  uint32_t cc_idx             = 0;
+  uint32_t cc_idx = 0;
 
   uint32_t prach_indices[165] = {};
   float    prach_offsets[165] = {};
@@ -79,8 +82,8 @@ private:
   srslte::buffer_pool<sf_buffer>  buffer_pool;
   srslte::block_queue<sf_buffer*> pending_buffers;
 
+  srslog::basic_logger&    logger;
   sf_buffer*               current_buffer      = nullptr;
-  srslte::log*             log_h               = nullptr;
   stack_interface_phy_lte* stack               = nullptr;
   float                    max_prach_offset_us = 0.0f;
   bool                     initiated           = false;
@@ -106,16 +109,16 @@ public:
             const srslte_cell_t&      cell_,
             const srslte_prach_cfg_t& prach_cfg_,
             stack_interface_phy_lte*  mac,
-            srslte::log*              log_h,
+            srslog::basic_logger&     logger,
             int                       priority,
             uint32_t                  nof_workers_x_cc)
   {
     // Create PRACH worker if required
     while (cc_idx >= prach_vec.size()) {
-      prach_vec.push_back(std::unique_ptr<prach_worker>(new prach_worker(prach_vec.size())));
+      prach_vec.push_back(std::unique_ptr<prach_worker>(new prach_worker(prach_vec.size(), logger)));
     }
 
-    prach_vec[cc_idx]->init(cell_, prach_cfg_, mac, log_h, priority, nof_workers_x_cc);
+    prach_vec[cc_idx]->init(cell_, prach_cfg_, mac, priority, nof_workers_x_cc);
   }
 
   void set_max_prach_offset_us(float delay_us)

srsenb/hdr/phy/txrx.h

@@ -27,23 +27,22 @@ namespace srsenb {
 class txrx final : public srslte::thread
 {
 public:
-  txrx();
+  txrx(srslog::basic_logger& logger);
   bool init(stack_interface_phy_lte*     stack_,
             srslte::radio_interface_phy* radio_handler,
             lte::worker_pool*            lte_workers_,
             nr::worker_pool*             nr_workers_,
             phy_common*                  worker_com,
             prach_worker_pool*           prach_,
-            srslte::log*                 log_h,
             uint32_t                     prio);
   void stop();
 
 private:
   void run_thread() override;
 
-  stack_interface_phy_lte*     stack       = nullptr;
+  stack_interface_phy_lte*     stack   = nullptr;
-  srslte::radio_interface_phy* radio_h     = nullptr;
+  srslte::radio_interface_phy* radio_h = nullptr;
-  srslte::log*                 log_h       = nullptr;
+  srslog::basic_logger&        logger;
   lte::worker_pool*            lte_workers = nullptr;
   nr::worker_pool*             nr_workers  = nullptr;
   prach_worker_pool*           prach       = nullptr;

srsenb/hdr/stack/enb_stack_lte.h

@@ -29,6 +29,7 @@
 #include "enb_stack_base.h"
 #include "srslte/interfaces/enb_interfaces.h"
 #include "srslte/interfaces/enb_rrc_interface_types.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -39,7 +40,7 @@ class enb_stack_lte final : public enb_stack_base,
                             public srslte::thread
 {
 public:
-  enb_stack_lte(srslte::logger* logger_);
+  enb_stack_lte(srslte::logger* logger_, srslog::sink& log_sink);
   ~enb_stack_lte() final;
 
   // eNB stack base interface
@@ -117,6 +118,14 @@ private:
   stack_args_t args    = {};
   rrc_cfg_t    rrc_cfg = {};
 
+  srslog::basic_logger &mac_logger;
+  srslog::basic_logger &rlc_logger;
+  srslog::basic_logger &pdcp_logger;
+  srslog::basic_logger &rrc_logger;
+  srslog::basic_logger &s1ap_logger;
+  srslog::basic_logger &gtpu_logger;
+  srslog::basic_logger &stack_logger;
+
   // task handling
   srslte::task_scheduler    task_sched;
   srslte::task_queue_handle enb_task_queue, gtpu_task_queue, mme_task_queue, sync_task_queue;

srsenb/hdr/stack/mac/mac.h

@@ -24,6 +24,7 @@
 #include "srslte/interfaces/enb_metrics_interface.h"
 #include "srslte/interfaces/enb_rrc_interface_types.h"
 #include "srslte/interfaces/sched_interface.h"
+#include "srslte/srslog/srslog.h"
 #include "ta.h"
 #include "ue.h"
 #include <vector>
@@ -33,7 +34,7 @@ namespace srsenb {
 class mac final : public mac_interface_phy_lte, public mac_interface_rlc, public mac_interface_rrc
 {
 public:
-  mac(srslte::ext_task_sched_handle task_sched_);
+  mac(srslte::ext_task_sched_handle task_sched_, srslog::basic_logger& logger);
   ~mac();
   bool init(const mac_args_t&        args_,
             const cell_list_t&       cells_,
@@ -106,6 +107,8 @@ private:
 
   std::mutex rnti_mutex;
 
+  srslog::basic_logger& logger;
+
   // We use a rwlock in MAC to allow multiple workers to access MAC simultaneously. No conflicts will happen since
   // access for different TTIs
   pthread_rwlock_t rwlock = {};

srsenb/hdr/stack/mac/sched.h

@@ -88,7 +88,6 @@ protected:
   int ue_db_access(uint16_t rnti, Func, const char* func_name = nullptr);
 
   // args
-  srslte::log_ref                  log_h;
   rrc_interface_mac*               rrc       = nullptr;
   sched_args_t                     sched_cfg = {};
   std::vector<sched_cell_params_t> sched_cell_params;

srsenb/hdr/stack/mac/sched_carrier.h

@@ -15,6 +15,7 @@
 
 #include "sched.h"
 #include "schedulers/sched_base.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -50,7 +51,7 @@ private:
 
   // args
   const sched_cell_params_t*    cc_cfg = nullptr;
-  srslte::log_ref               log_h;
+  srslog::basic_logger&         logger;
   rrc_interface_mac*            rrc   = nullptr;
   std::map<uint16_t, sched_ue>* ue_db = nullptr;
   const uint32_t                enb_cc_idx;
@@ -114,7 +115,7 @@ public:
 
 private:
   // args
-  srslte::log_ref               log_h;
+  srslog::basic_logger&         logger;
   const sched_cell_params_t*    cc_cfg = nullptr;
   std::map<uint16_t, sched_ue>* ue_db  = nullptr;
 

srsenb/hdr/stack/mac/sched_grid.h

@@ -17,6 +17,7 @@
 #include "sched_ue.h"
 #include "srslte/adt/bounded_bitset.h"
 #include "srslte/common/log.h"
+#include "srslte/srslog/srslog.h"
 #include <deque>
 #include <vector>
 
@@ -99,6 +100,8 @@ public:
   };
   using alloc_result_t = std::vector<const alloc_t*>;
 
+  pdcch_grid_t() : logger(srslog::fetch_basic_logger("MAC")) {}
+
   void init(const sched_cell_params_t& cell_params_);
   void new_tti(tti_point tti_rx_);
   bool alloc_dci(alloc_type_t alloc_type, uint32_t aggr_idx, sched_ue* user = nullptr);
@@ -147,7 +150,7 @@ private:
 
   // consts
   const sched_cell_params_t* cc_cfg = nullptr;
-  srslte::log_ref            log_h;
+  srslog::basic_logger&      logger;
 
   // tti vars
   tti_point                   tti_rx;
@@ -165,6 +168,8 @@ public:
     rbg_interval    rbg_range;
   };
 
+  sf_grid_t() : logger(srslog::fetch_basic_logger("MAC")) {}
+
   void            init(const sched_cell_params_t& cell_params_);
   void            new_tti(tti_point tti_rx);
   dl_ctrl_alloc_t alloc_dl_ctrl(uint32_t aggr_lvl, alloc_type_t alloc_type);
@@ -185,7 +190,7 @@ private:
 
   // consts
   const sched_cell_params_t* cc_cfg = nullptr;
-  srslte::log_ref            log_h;
+  srslog::basic_logger&      logger;
   uint32_t                   nof_rbgs = 0;
   uint32_t                   si_n_rbg = 0, rar_n_rbg = 0;
 
@@ -305,7 +310,7 @@ private:
 
   // consts
   const sched_cell_params_t* cc_cfg = nullptr;
-  srslte::log_ref            log_h;
+  srslog::basic_logger&      logger;
   sf_sched_result*           cc_results; ///< Results of other CCs for the same Subframe
   prbmask_t                  pucch_mask;
 

srsenb/hdr/stack/mac/sched_helpers.h

@@ -16,6 +16,7 @@
 #include "srsenb/hdr/stack/mac/sched_common.h"
 #include "srslte/common/logmap.h"
 #include "srslte/interfaces/sched_interface.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -154,10 +155,14 @@ inline bool operator==(const sched_interface::ue_cfg_t::cc_cfg_t& lhs, const sch
 int check_ue_cfg_correctness(const sched_interface::ue_cfg_t& ue_cfg);
 
 /// Logs DL MAC PDU contents
-void log_dl_cc_results(srslte::log_ref log_h, uint32_t enb_cc_idx, const sched_interface::dl_sched_res_t& result);
+void log_dl_cc_results(srslog::basic_logger&                  logger,
+                       uint32_t                               enb_cc_idx,
+                       const sched_interface::dl_sched_res_t& result);
 
 /// Logs PHICH contents
-void log_phich_cc_results(srslte::log_ref log_h, uint32_t enb_cc_idx, const sched_interface::ul_sched_res_t& result);
+void log_phich_cc_results(srslog::basic_logger&                  logger,
+                          uint32_t                               enb_cc_idx,
+                          const sched_interface::ul_sched_res_t& result);
 
 const char* to_string(sched_interface::ue_bearer_cfg_t::direction_t dir);
 

srsenb/hdr/stack/mac/sched_ue.h

@@ -15,6 +15,7 @@
 
 #include "sched_common.h"
 #include "srslte/common/log.h"
+#include "srslte/srslog/srslog.h"
 #include <map>
 #include <vector>
 
@@ -180,7 +181,7 @@ private:
   /* Args */
   ue_cfg_t                   cfg  = {};
   srslte_cell_t              cell = {};
-  mutable srslte::log_ref    log_h;
+  srslog::basic_logger&      logger;
   const sched_cell_params_t* main_cc_params = nullptr;
 
   /* Buffer states */

srsenb/hdr/stack/mac/sched_ue_ctrl/sched_harq.h

@@ -17,6 +17,7 @@
 #include "srslte/common/log.h"
 #include "srslte/common/tti_point.h"
 #include "srslte/interfaces/sched_interface.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -54,8 +55,6 @@ protected:
   srslte::tti_point               tti;
   int                             last_mcs[SRSLTE_MAX_TB];
   int                             last_tbs[SRSLTE_MAX_TB];
-
-  srslte::log_ref log_h;
 };
 
 class dl_harq_proc : public harq_proc
@@ -70,7 +69,7 @@ public:
               uint32_t         n_cce_,
               uint32_t         max_retx);
   void new_retx(const rbgmask_t& new_mask, uint32_t tb_idx, tti_point tti_tx_dl, int* mcs, int* tbs, uint32_t n_cce_);
-  int       set_ack(uint32_t tb_idx, bool ack);
+  int  set_ack(uint32_t tb_idx, bool ack);
   rbgmask_t get_rbgmask() const;
   bool      has_pending_retx(uint32_t tb_idx, tti_point tti_tx_dl) const;
   bool      has_pending_retx(tti_point tti_tx_dl) const;
@@ -111,6 +110,7 @@ public:
   static const bool is_async = ASYNC_DL_SCHED;
 
   harq_entity(size_t nof_dl_harqs, size_t nof_ul_harqs);
+
   void reset();
   void new_tti(tti_point tti_rx);
 
@@ -156,7 +156,6 @@ public:
 private:
   dl_harq_proc* get_oldest_dl_harq(tti_point tti_tx_dl);
 
-  srslte::log_ref                            log_h;
   std::array<tti_point, SRSLTE_FDD_NOF_HARQ> last_ttis;
 
   std::vector<dl_harq_proc> dl_harqs;

srsenb/hdr/stack/mac/sched_ue_ctrl/sched_lch.h

@@ -16,6 +16,7 @@
 #include "srslte/common/logmap.h"
 #include "srslte/interfaces/sched_interface.h"
 #include "srslte/mac/pdu.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -25,6 +26,7 @@ class lch_ue_manager
   constexpr static uint32_t MAX_LC       = sched_interface::MAX_LC;
 
 public:
+  lch_ue_manager() : logger(srslog::fetch_basic_logger("MAC")) {}
   void set_cfg(const sched_interface::ue_cfg_t& cfg_);
   void new_tti();
 
@@ -72,7 +74,7 @@ private:
   int alloc_tx_bytes(uint8_t lcid, int rem_bytes);
 
   size_t                                           prio_idx = 0;
-  srslte::log_ref                                  log_h{"MAC"};
+  srslog::basic_logger&                            logger;
   std::array<ue_bearer_t, sched_interface::MAX_LC> lch     = {};
   std::array<int, 4>                               lcg_bsr = {};
 };

srsenb/hdr/stack/mac/sched_ue_ctrl/sched_ue_cell.h

@@ -78,7 +78,7 @@ struct sched_ue_cell {
 private:
   void enter_idle_st();
 
-  srslte::log_ref log_h{"MAC"};
+  srslog::basic_logger& logger;
 
   const sched_interface::ue_cfg_t* ue_cfg = nullptr;
   tti_point                        cfg_tti;

srsenb/hdr/stack/mac/sched_ue_ctrl/tpc.h

@@ -16,6 +16,7 @@
 #include "srslte/adt/accumulators.h"
 #include "srslte/common/common.h"
 #include "srslte/common/logmap.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -124,7 +125,7 @@ private:
       case 3:
         return 3;
       default:
-        srslte::logmap::get("MAC")->warning("Invalid TPC delta value=%d\n", delta);
+        srslog::fetch_basic_logger("MAC").warning("Invalid TPC delta value=%d", delta);
         return 1;
     }
   }

srsenb/hdr/stack/mac/schedulers/sched_base.h

@@ -29,7 +29,7 @@ public:
   virtual void sched_ul_users(std::map<uint16_t, sched_ue>& ue_db, sf_sched* tti_sched) = 0;
 
 protected:
-  srslte::log_ref log_h = srslte::logmap::get("MAC");
+  srslog::basic_logger& logger = srslog::fetch_basic_logger("MAC");
 };
 
 /**************** Helper methods ****************/

srsenb/hdr/stack/mac/ue.h

@@ -22,6 +22,7 @@
 #include "srslte/interfaces/sched_interface.h"
 #include "srslte/mac/pdu.h"
 #include "srslte/mac/pdu_queue.h"
+#include "srslte/srslog/srslog.h"
 #include "ta.h"
 #include <pthread.h>
 #include <vector>
@@ -38,6 +39,7 @@ public:
      rlc_interface_mac*       rlc,
      phy_interface_stack_lte* phy_,
      srslte::log_ref          log_,
+     srslog::basic_logger&    logger,
      uint32_t                 nof_cells_,
      uint32_t                 nof_rx_harq_proc = SRSLTE_FDD_NOF_HARQ,
      uint32_t                 nof_tx_harq_proc = SRSLTE_FDD_NOF_HARQ * SRSLTE_MAX_TB);
@@ -139,6 +141,7 @@ private:
   rrc_interface_mac*       rrc = nullptr;
   phy_interface_stack_lte* phy = nullptr;
   srslte::log_ref          log_h;
+  srslog::basic_logger&    logger;
   sched_interface*         sched = nullptr;
 
   // Mutexes

srsenb/hdr/stack/rrc/mac_controller.h

@@ -64,7 +64,7 @@ private:
   int  apply_basic_conn_cfg(const asn1::rrc::rr_cfg_ded_s& rr_cfg);
   void apply_current_bearers_cfg();
 
-  srslte::log_ref             log_h;
+  srslog::basic_logger&       logger;
   uint16_t                    rnti;
   const ue_cell_ded_list&     ue_cell_list;
   const bearer_cfg_handler&   bearer_list;

srsenb/hdr/stack/rrc/rrc.h

@@ -26,6 +26,7 @@
 #include "srslte/common/task_scheduler.h"
 #include "srslte/common/timeout.h"
 #include "srslte/interfaces/enb_interfaces.h"
+#include "srslte/srslog/srslog.h"
 #include <map>
 #include <queue>
 
@@ -45,7 +46,7 @@ class rrc final : public rrc_interface_pdcp,
                   public rrc_interface_s1ap
 {
 public:
-  rrc(srslte::task_sched_handle task_sched_);
+  explicit rrc(srslte::task_sched_handle task_sched_);
   ~rrc();
 
   void init(const rrc_cfg_t&       cfg_,
@@ -121,14 +122,14 @@ public:
                        const std::string&      msg_type)
   {
     static const char* dir_str[] = {"Rx", "Tx", "S1AP Tx", "S1AP Rx"};
-    if (rrc_log->get_level() == srslte::LOG_LEVEL_INFO) {
+    if (logger.info.enabled()) {
-      rrc_log->info("%s - %s %s (%zd B)\n", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
+      logger.info("%s - %s %s (%zd B)", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
-    } else if (rrc_log->get_level() >= srslte::LOG_LEVEL_DEBUG) {
+    } else if (logger.debug.enabled()) {
       asn1::json_writer json_writer;
       msg.to_json(json_writer);
-      rrc_log->debug_hex(
+      logger.debug(
-          pdu.data(), pdu.size(), "%s - %s %s (%zd B)\n", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
+          pdu.data(), pdu.size(), "%s - %s %s (%zd B)", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
-      rrc_log->debug_long("Content:\n%s\n", json_writer.to_string().c_str());
+      logger.debug("Content:\n%s", json_writer.to_string().c_str());
     }
   }
 
@@ -144,6 +145,7 @@ private:
   gtpu_interface_rrc*       gtpu = nullptr;
   s1ap_interface_rrc*       s1ap = nullptr;
   srslte::log_ref           rrc_log;
+  srslog::basic_logger&     logger;
 
   // derived params
   std::unique_ptr<enb_cell_common_list> cell_common_list;

srsenb/hdr/stack/rrc/rrc_bearer_cfg.h

@@ -18,13 +18,24 @@
 #include "srslte/common/logmap.h"
 #include "srslte/interfaces/enb_interfaces.h"
 #include "srslte/interfaces/enb_rrc_interface_types.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
 class security_cfg_handler
 {
 public:
-  explicit security_cfg_handler(const rrc_cfg_t& cfg_) : cfg(&cfg_) {}
+  explicit security_cfg_handler(const rrc_cfg_t& cfg_) : cfg(&cfg_), logger(srslog::fetch_basic_logger("RRC")) {}
+  security_cfg_handler& operator=(const security_cfg_handler& other)
+  {
+    cfg                   = other.cfg;
+    k_enb_present         = other.k_enb_present;
+    security_capabilities = other.security_capabilities;
+    std::copy(other.k_enb, other.k_enb + 32, k_enb);
+    sec_cfg = other.sec_cfg;
+    ncc     = other.ncc;
+    return *this;
+  }
 
   bool set_security_capabilities(const asn1::s1ap::ue_security_cap_s& caps);
   void set_security_key(const asn1::fixed_bitstring<256, false, true>& key);
@@ -40,7 +51,7 @@ public:
 private:
   void generate_as_keys();
 
-  srslte::log_ref               log_h{"RRC"};
+  srslog::basic_logger&         logger;
   const rrc_cfg_t*              cfg                   = nullptr;
   bool                          k_enb_present         = false;
   asn1::s1ap::ue_security_cap_s security_capabilities = {};
@@ -84,9 +95,9 @@ public:
   std::map<uint8_t, erab_t>                erabs;
 
 private:
-  srslte::log_ref  log_h{"RRC"};
+  srslog::basic_logger& logger;
-  uint16_t         rnti = 0;
+  uint16_t              rnti = 0;
-  const rrc_cfg_t* cfg  = nullptr;
+  const rrc_cfg_t*      cfg  = nullptr;
 
   // last cfg
   asn1::rrc::drb_to_add_mod_list_l current_drbs;

srsenb/hdr/stack/rrc/rrc_cell_cfg.h

@@ -15,6 +15,7 @@
 
 #include "rrc_config.h"
 #include "srslte/common/logmap.h"
+#include "srslte/srslog/srslog.h"
 
 namespace srsenb {
 
@@ -169,7 +170,7 @@ private:
   bool alloc_pucch_cs_resources();
   bool dealloc_pucch_cs_resources();
 
-  srslte::log_ref             log_h{"RRC"};
+  srslog::basic_logger&       logger;
   const rrc_cfg_t&            cfg;
   const enb_cell_common_list& common_list;
   freq_res_common_list&       cell_res_list;

srsenb/hdr/stack/rrc/rrc_mobility.h

@@ -33,7 +33,7 @@ public:
   };
   struct ho_cancel_ev {};
 
-  explicit rrc_mobility(srsenb::rrc::ue* outer_ue);
+  rrc_mobility(srsenb::rrc::ue* outer_ue);
 
   bool fill_conn_recfg_no_ho_cmd(asn1::rrc::rrc_conn_recfg_r8_ies_s* conn_recfg);
   void handle_ue_meas_report(const asn1::rrc::meas_report_s& msg);
@@ -50,9 +50,9 @@ public:
 
 private:
   // helper methods
-  bool update_ue_var_meas_cfg(uint32_t                src_earfcn,
+  bool update_ue_var_meas_cfg(uint32_t               src_earfcn,
                               const enb_cell_common& target_pcell,
-                              asn1::rrc::meas_cfg_s*  diff_meas_cfg);
+                              asn1::rrc::meas_cfg_s* diff_meas_cfg);
 
   // Handover from source cell
   bool start_ho_preparation(uint32_t target_eci, uint8_t measobj_id, bool fwd_direct_path_available);
@@ -60,7 +60,7 @@ private:
 
   // Handover to target cell
   void fill_mobility_reconf_common(asn1::rrc::dl_dcch_msg_s& msg,
-                                   const enb_cell_common&   target_cell,
+                                   const enb_cell_common&    target_cell,
                                    uint32_t                  src_dl_earfcn,
                                    uint32_t                  src_pci);
   bool apply_ho_prep_cfg(const asn1::rrc::ho_prep_info_r8_ies_s& ho_prep, const asn1::s1ap::ho_request_s& ho_req_msg);
@@ -68,7 +68,7 @@ private:
   rrc::ue*                  rrc_ue  = nullptr;
   rrc*                      rrc_enb = nullptr;
   srslte::byte_buffer_pool* pool    = nullptr;
-  srslte::log_ref           rrc_log;
+  srslog::basic_logger&     logger;
 
   // vars
   asn1::rrc::meas_cfg_s                current_meas_cfg;
@@ -92,7 +92,7 @@ private:
   struct intraenb_ho_st {
     const enb_cell_common* target_cell     = nullptr;
     const enb_cell_common* source_cell     = nullptr;
-    uint16_t                last_temp_crnti = SRSLTE_INVALID_RNTI;
+    uint16_t               last_temp_crnti = SRSLTE_INVALID_RNTI;
 
     void enter(rrc_mobility* f, const ho_meas_report_ev& meas_report);
   };

srsenb/hdr/stack/upper/gtpu.h

@@ -18,6 +18,7 @@
 #include "srslte/common/logmap.h"
 #include "srslte/common/threads.h"
 #include "srslte/interfaces/enb_interfaces.h"
+#include "srslte/srslog/srslog.h"
 #include "srslte/srslte.h"
 
 #ifndef SRSENB_GTPU_H
@@ -28,7 +29,7 @@ namespace srsenb {
 class gtpu final : public gtpu_interface_rrc, public gtpu_interface_pdcp
 {
 public:
-  gtpu();
+  explicit gtpu(srslog::basic_logger& logger);
 
   int  init(std::string               gtp_bind_addr_,
             std::string               mme_addr_,
@@ -63,12 +64,13 @@ private:
   std::string                  mme_addr;
   srsenb::pdcp_interface_gtpu* pdcp = nullptr;
   srslte::log_ref              gtpu_log;
+  srslog::basic_logger&        logger;
 
   // Class to create
   class m1u_handler
   {
   public:
-    explicit m1u_handler(gtpu* gtpu_) : parent(gtpu_) {}
+    explicit m1u_handler(gtpu* gtpu_) : parent(gtpu_), logger(parent->logger) {}
     ~m1u_handler();
     m1u_handler(const m1u_handler&) = delete;
     m1u_handler(m1u_handler&&)      = delete;
@@ -78,11 +80,12 @@ private:
     void         handle_rx_packet(srslte::unique_byte_buffer_t pdu, const sockaddr_in& addr);
 
   private:
-    gtpu*                parent = nullptr;
+    gtpu*                 parent = nullptr;
-    pdcp_interface_gtpu* pdcp   = nullptr;
+    pdcp_interface_gtpu*  pdcp   = nullptr;
-    srslte::log_ref      gtpu_log;
+    srslte::log_ref       gtpu_log;
-    std::string          m1u_multiaddr;
+    srslog::basic_logger& logger;
-    std::string          m1u_if_addr;
+    std::string           m1u_multiaddr;
+    std::string           m1u_if_addr;
 
     bool initiated    = false;
     int  m1u_sd       = -1;

srsenb/hdr/stack/upper/pdcp.h

@@ -13,6 +13,7 @@
 #include "srslte/common/timers.h"
 #include "srslte/interfaces/enb_interfaces.h"
 #include "srslte/interfaces/ue_interfaces.h"
+#include "srslte/srslog/srslog.h"
 #include "srslte/upper/pdcp.h"
 #include <map>
 
@@ -24,7 +25,7 @@ namespace srsenb {
 class pdcp : public pdcp_interface_rlc, public pdcp_interface_gtpu, public pdcp_interface_rrc
 {
 public:
-  pdcp(srslte::task_sched_handle task_sched_, const char* logname);
+  pdcp(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger);
   virtual ~pdcp() {}
   void init(rlc_interface_pdcp* rlc_, rrc_interface_pdcp* rrc_, gtpu_interface_pdcp* gtpu_);
   void stop();
@@ -101,7 +102,7 @@ private:
   rrc_interface_pdcp*       rrc;
   gtpu_interface_pdcp*      gtpu;
   srslte::task_sched_handle task_sched;
-  srslte::log_ref           log_h;
+  srslog::basic_logger&     logger;
   srslte::byte_buffer_pool* pool;
 };
 

srsenb/hdr/stack/upper/rlc.h

@@ -13,6 +13,7 @@
 #include "srslte/interfaces/enb_interfaces.h"
 #include "srslte/interfaces/enb_metrics_interface.h"
 #include "srslte/interfaces/ue_interfaces.h"
+#include "srslte/srslog/srslog.h"
 #include "srslte/upper/rlc.h"
 #include <map>
 
@@ -31,11 +32,9 @@ namespace srsenb {
 class rlc : public rlc_interface_mac, public rlc_interface_rrc, public rlc_interface_pdcp
 {
 public:
-  void init(pdcp_interface_rlc*    pdcp_,
+  explicit rlc(srslog::basic_logger& logger) : logger(logger) {}
-            rrc_interface_rlc*     rrc_,
+  void
-            mac_interface_rlc*     mac_,
+       init(pdcp_interface_rlc* pdcp_, rrc_interface_rlc* rrc_, mac_interface_rlc* mac_, srslte::timer_handler* timers_);
-            srslte::timer_handler* timers_,
-            srslte::log_ref        log_h);
   void stop();
   void get_metrics(rlc_metrics_t& m, const uint32_t nof_tti);
 
@@ -92,7 +91,7 @@ private:
   mac_interface_rlc*        mac;
   pdcp_interface_rlc*       pdcp;
   rrc_interface_rlc*        rrc;
-  srslte::log_ref           log_h;
+  srslog::basic_logger&     logger;
   srslte::byte_buffer_pool* pool;
   srslte::timer_handler*    timers;
 };

srsenb/hdr/stack/upper/s1ap.h

@@ -28,6 +28,7 @@
 #include "srslte/common/network_utils.h"
 #include "srslte/common/stack_procedure.h"
 #include "srslte/common/task_scheduler.h"
+#include "srslte/srslog/srslog.h"
 #include <unordered_map>
 
 namespace srsenb {
@@ -48,14 +49,14 @@ public:
   static const uint32_t ts1_reloc_prep_timeout_ms    = 10000;
   static const uint32_t ts1_reloc_overall_timeout_ms = 10000;
 
-  s1ap(srslte::task_sched_handle task_sched_);
+  s1ap(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger);
   int  init(s1ap_args_t args_, rrc_interface_s1ap* rrc_, srsenb::stack_interface_s1ap_lte* stack_);
   void stop();
   void get_metrics(s1ap_metrics_t& m);
 
   // RRC interface
   void
-  initial_ue(uint16_t rnti, asn1::s1ap::rrc_establishment_cause_e cause, srslte::unique_byte_buffer_t pdu) override;
+       initial_ue(uint16_t rnti, asn1::s1ap::rrc_establishment_cause_e cause, srslte::unique_byte_buffer_t pdu) override;
   void initial_ue(uint16_t                              rnti,
                   asn1::s1ap::rrc_establishment_cause_e cause,
                   srslte::unique_byte_buffer_t          pdu,
@@ -84,7 +85,7 @@ public:
 
   // Stack interface
   bool
-  handle_mme_rx_msg(srslte::unique_byte_buffer_t pdu, const sockaddr_in& from, const sctp_sndrcvinfo& sri, int flags);
+       handle_mme_rx_msg(srslte::unique_byte_buffer_t pdu, const sockaddr_in& from, const sctp_sndrcvinfo& sri, int flags);
   void start_pcap(srslte::s1ap_pcap* pcap_);
 
 private:
@@ -98,7 +99,7 @@ private:
   // args
   rrc_interface_s1ap*               rrc = nullptr;
   s1ap_args_t                       args;
-  srslte::log_ref                   s1ap_log;
+  srslog::basic_logger&             logger;
   srslte::byte_buffer_pool*         pool  = nullptr;
   srsenb::stack_interface_s1ap_lte* stack = nullptr;
   srslte::task_sched_handle         task_sched;
@@ -158,7 +159,7 @@ private:
       struct ts1_reloc_prep_expired {};
       ho_prep_proc_t(s1ap::ue* ue_);
       srslte::proc_outcome_t
-      init(uint32_t target_eci_, srslte::plmn_id_t target_plmn_, srslte::unique_byte_buffer_t rrc_container);
+                             init(uint32_t target_eci_, srslte::plmn_id_t target_plmn_, srslte::unique_byte_buffer_t rrc_container);
       srslte::proc_outcome_t step() { return srslte::proc_outcome_t::yield; }
       srslte::proc_outcome_t react(ts1_reloc_prep_expired e);
       srslte::proc_outcome_t react(const asn1::s1ap::ho_prep_fail_s& msg);
@@ -206,8 +207,8 @@ private:
     //! TS 36.413, Section 8.4.6 - eNB Status Transfer procedure
 
     // args
-    s1ap*           s1ap_ptr;
+    s1ap*                 s1ap_ptr;
-    srslte::log_ref s1ap_log;
+    srslog::basic_logger& logger;
 
     // state
     bool                 release_requested = false;

srsenb/hdr/stack/upper/sdap.h

@@ -35,7 +35,6 @@ public:
   void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) final;
 
 private:
-  srslte::log_ref           m_log{"SDAP"};
   gtpu_interface_sdap_nr*   m_gtpu = nullptr;
   pdcp_interface_sdap_nr*   m_pdcp = nullptr;
   srsue::gw_interface_pdcp* m_gw   = nullptr;

srsenb/src/enb.cc

@@ -24,10 +24,15 @@
 
 namespace srsenb {
 
-enb::enb() : started(false), pool(srslte::byte_buffer_pool::get_instance(ENB_POOL_SIZE))
+enb::enb(srslog::sink& log_sink) :
+  started(false),
+  log_sink(log_sink),
+  enb_log(srslog::fetch_basic_logger("ENB", log_sink, false)),
+  pool(srslte::byte_buffer_pool::get_instance(ENB_POOL_SIZE))
 {
+
   // print build info
-  std::cout << std::endl << get_build_string() << std::endl;
+  std::cout << std::endl << get_build_string() << std::endl << std::endl;
 }
 
 enb::~enb()
@@ -42,9 +47,8 @@ int enb::init(const all_args_t& args_, srslte::logger* logger_)
 
   // Init eNB log
   srslte::logmap::set_default_logger(logger);
-  log = srslte::logmap::get("ENB");
+  enb_log.set_level(srslog::basic_levels::info);
-  log->set_level(srslte::LOG_LEVEL_INFO);
+  enb_log.info("%s", get_build_string().c_str());
-  log->info("%s", get_build_string().c_str());
 
   // Validate arguments
   if (parse_args(args_, rrc_cfg)) {
@@ -58,7 +62,7 @@ int enb::init(const all_args_t& args_, srslte::logger* logger_)
 
   // Create layers
   if (args.stack.type == "lte") {
-    std::unique_ptr<enb_stack_lte> lte_stack(new enb_stack_lte(logger));
+    std::unique_ptr<enb_stack_lte> lte_stack(new enb_stack_lte(logger, log_sink));
     if (!lte_stack) {
       srslte::console("Error creating eNB stack.\n");
       return SRSLTE_ERROR;
@@ -70,7 +74,7 @@ int enb::init(const all_args_t& args_, srslte::logger* logger_)
       return SRSLTE_ERROR;
     }
 
-    std::unique_ptr<srsenb::phy> lte_phy = std::unique_ptr<srsenb::phy>(new srsenb::phy(logger));
+    std::unique_ptr<srsenb::phy> lte_phy = std::unique_ptr<srsenb::phy>(new srsenb::phy(log_sink));
     if (!lte_phy) {
       srslte::console("Error creating LTE PHY instance.\n");
       return SRSLTE_ERROR;
@@ -139,7 +143,7 @@ int enb::init(const all_args_t& args_, srslte::logger* logger_)
     radio = std::move(nr_radio);
 #else
     srslte::console("ERROR: 5G NR stack not compiled. Please, activate CMAKE HAVE_5GNR flag.\n");
-    log->error("5G NR stack not compiled. Please, activate CMAKE HAVE_5GNR flag.\n");
+    enb_log.error("5G NR stack not compiled. Please, activate CMAKE HAVE_5GNR flag.");
 #endif
   }
 
@@ -251,7 +255,7 @@ std::string enb::get_build_info()
 std::string enb::get_build_string()
 {
   std::stringstream ss;
-  ss << "Built in " << get_build_mode() << " mode using " << get_build_info() << "." << std::endl;
+  ss << "Built in " << get_build_mode() << " mode using " << get_build_info() << ".";
   return ss.str();
 }
 

srsenb/src/enb_cfg_parser.cc

@@ -127,7 +127,7 @@ int field_carrier_freqs_info_list::parse(libconfig::Setting& root)
   data->carrier_freqs_info_list.resize((uint32_t)root.getLength());
   data->carrier_freqs_info_list_present = data->carrier_freqs_info_list.size() > 0;
   if (data->carrier_freqs_info_list.size() > ASN1_RRC_MAX_GNFG) {
-    ERROR("CarrierFreqsInfoGERAN cannot have more than %d entries\n", ASN1_RRC_MAX_GNFG);
+    ERROR("CarrierFreqsInfoGERAN cannot have more than %d entries", ASN1_RRC_MAX_GNFG);
     return -1;
   }
   for (uint32_t i = 0; i < data->carrier_freqs_info_list.size(); i++) {
@@ -147,27 +147,27 @@ int field_carrier_freqs_info_list::parse(libconfig::Setting& root)
     field_asn1_bitstring_number<asn1::fixed_bitstring<8>, uint8_t> ncc_permitted(
         "ncc_permitted", &data->carrier_freqs_info_list[i].common_info.ncc_permitted);
     if (ncc_permitted.parse(root[i])) {
-      ERROR("Error parsing `ncc_permitted` in carrier_freqs_info_lsit=%d\n", i);
+      ERROR("Error parsing `ncc_permitted` in carrier_freqs_info_lsit=%d", i);
       return -1;
     }
 
     int q_rx_lev_min = 0;
     if (!root[i].lookupValue("q_rx_lev_min", q_rx_lev_min)) {
-      ERROR("Missing field `q_rx_lev_min` in carrier_freqs_info_list=%d\n", i);
+      ERROR("Missing field `q_rx_lev_min` in carrier_freqs_info_list=%d", i);
       return -1;
     }
     data->carrier_freqs_info_list[i].common_info.q_rx_lev_min = q_rx_lev_min;
 
     int thresh_x_high = 0;
     if (!root[i].lookupValue("thresh_x_high", thresh_x_high)) {
-      ERROR("Missing field `thresh_x_high` in carrier_freqs_info_list=%d\n", i);
+      ERROR("Missing field `thresh_x_high` in carrier_freqs_info_list=%d", i);
       return -1;
     }
     data->carrier_freqs_info_list[i].common_info.thresh_x_high = thresh_x_high;
 
     int thresh_x_low = 0;
     if (!root[i].lookupValue("thresh_x_low", thresh_x_low)) {
-      ERROR("Missing field `thresh_x_low` in carrier_freqs_info_list=%d\n", i);
+      ERROR("Missing field `thresh_x_low` in carrier_freqs_info_list=%d", i);
       return -1;
     }
     data->carrier_freqs_info_list[i].common_info.thresh_x_low = thresh_x_low;
@@ -180,7 +180,7 @@ int field_carrier_freqs_info_list::parse(libconfig::Setting& root)
     field_asn1_enum_str<asn1::rrc::band_ind_geran_e> band_ind("band_ind",
                                                               &data->carrier_freqs_info_list[i].carrier_freqs.band_ind);
     if (band_ind.parse(root[i])) {
-      ERROR("Error parsing `band_ind` in carrier_freqs_info_list=%d\n", i);
+      ERROR("Error parsing `band_ind` in carrier_freqs_info_list=%d", i);
       return -1;
     }
 
@@ -435,7 +435,7 @@ int field_qci::parse(libconfig::Setting& root)
 
       field_asn1_enum_number<sn_field_len_e> sn_field_len("sn_field_length", &um_rlc->sn_field_len);
       if (sn_field_len.parse(q["rlc_config"]["ul_um"])) {
-        ERROR("Error can't find sn_field_length in section ul_um\n");
+        ERROR("Error can't find sn_field_length in section ul_um");
       }
     }
 
@@ -450,12 +450,12 @@ int field_qci::parse(libconfig::Setting& root)
 
       field_asn1_enum_number<sn_field_len_e> sn_field_len("sn_field_length", &um_rlc->sn_field_len);
       if (sn_field_len.parse(q["rlc_config"]["dl_um"])) {
-        ERROR("Error can't find sn_field_length in section dl_um\n");
+        ERROR("Error can't find sn_field_length in section dl_um");
       }
 
       field_asn1_enum_number<t_reordering_e> t_reordering("t_reordering", &um_rlc->t_reordering);
       if (t_reordering.parse(q["rlc_config"]["dl_um"])) {
-        ERROR("Error can't find t_reordering in section dl_um\n");
+        ERROR("Error can't find t_reordering in section dl_um");
       }
     }
 
@@ -465,23 +465,23 @@ int field_qci::parse(libconfig::Setting& root)
 
       field_asn1_enum_number<t_poll_retx_e> t_poll_retx("t_poll_retx", &am_rlc->t_poll_retx);
       if (t_poll_retx.parse(q["rlc_config"]["ul_am"])) {
-        ERROR("Error can't find t_poll_retx in section ul_am\n");
+        ERROR("Error can't find t_poll_retx in section ul_am");
       }
 
       field_asn1_enum_number<poll_pdu_e> poll_pdu("poll_pdu", &am_rlc->poll_pdu);
       if (poll_pdu.parse(q["rlc_config"]["ul_am"])) {
-        ERROR("Error can't find poll_pdu in section ul_am\n");
+        ERROR("Error can't find poll_pdu in section ul_am");
       }
 
       field_asn1_enum_number<poll_byte_e> poll_byte("poll_byte", &am_rlc->poll_byte);
       if (poll_byte.parse(q["rlc_config"]["ul_am"])) {
-        ERROR("Error can't find poll_byte in section ul_am\n");
+        ERROR("Error can't find poll_byte in section ul_am");
       }
 
       field_asn1_enum_number<ul_am_rlc_s::max_retx_thres_e_> max_retx_thresh("max_retx_thresh",
                                                                              &am_rlc->max_retx_thres);
       if (max_retx_thresh.parse(q["rlc_config"]["ul_am"])) {
-        ERROR("Error can't find max_retx_thresh in section ul_am\n");
+        ERROR("Error can't find max_retx_thresh in section ul_am");
       }
     }
 
@@ -490,12 +490,12 @@ int field_qci::parse(libconfig::Setting& root)
 
       field_asn1_enum_number<t_reordering_e> t_reordering("t_reordering", &am_rlc->t_reordering);
       if (t_reordering.parse(q["rlc_config"]["dl_am"])) {
-        ERROR("Error can't find t_reordering in section dl_am\n");
+        ERROR("Error can't find t_reordering in section dl_am");
       }
 
       field_asn1_enum_number<t_status_prohibit_e> t_status_prohibit("t_status_prohibit", &am_rlc->t_status_prohibit);
       if (t_status_prohibit.parse(q["rlc_config"]["dl_am"])) {
-        ERROR("Error can't find t_status_prohibit in section dl_am\n");
+        ERROR("Error can't find t_status_prohibit in section dl_am");
       }
     }
 
@@ -509,7 +509,7 @@ int field_qci::parse(libconfig::Setting& root)
 
     parser::field<uint8> priority("priority", &lc_cfg->prio);
     if (priority.parse(q["logical_channel_config"])) {
-      ERROR("Error can't find logical_channel_config in section priority\n");
+      ERROR("Error can't find logical_channel_config in section priority");
     }
 
     field_asn1_enum_number<lc_ch_cfg_s::ul_specific_params_s_::prioritised_bit_rate_e_> prioritised_bit_rate(
@@ -521,7 +521,7 @@ int field_qci::parse(libconfig::Setting& root)
     field_asn1_enum_number<lc_ch_cfg_s::ul_specific_params_s_::bucket_size_dur_e_> bucket_size_duration(
         "bucket_size_duration", &lc_cfg->bucket_size_dur);
     if (bucket_size_duration.parse(q["logical_channel_config"])) {
-      ERROR("Error can't find bucket_size_duration in section logical_channel_config\n");
+      ERROR("Error can't find bucket_size_duration in section logical_channel_config");
     }
 
     parser::field<uint8> log_chan_group("log_chan_group", &lc_cfg->lc_ch_group);
@@ -538,15 +538,15 @@ int parse_rr(all_args_t* args_, rrc_cfg_t* rrc_cfg_)
 {
   /* Transmission mode config section */
   if (args_->enb.transmission_mode < 1 || args_->enb.transmission_mode > 4) {
-    ERROR("Invalid transmission mode (%d). Only indexes 1-4 are implemented.\n", args_->enb.transmission_mode);
+    ERROR("Invalid transmission mode (%d). Only indexes 1-4 are implemented.", args_->enb.transmission_mode);
     return SRSLTE_ERROR;
   } else if (args_->enb.transmission_mode == 1 && args_->enb.nof_ports > 1) {
-    ERROR("Invalid number of ports (%d) for transmission mode (%d). Only one antenna port is allowed.\n",
+    ERROR("Invalid number of ports (%d) for transmission mode (%d). Only one antenna port is allowed.",
           args_->enb.nof_ports,
           args_->enb.transmission_mode);
     return SRSLTE_ERROR;
   } else if (args_->enb.transmission_mode > 1 && args_->enb.nof_ports != 2) {
-    ERROR("The selected number of ports (%d) are insufficient for the selected transmission mode (%d).\n",
+    ERROR("The selected number of ports (%d) are insufficient for the selected transmission mode (%d).",
           args_->enb.nof_ports,
           args_->enb.transmission_mode);
     return SRSLTE_ERROR;
@@ -576,7 +576,7 @@ int parse_rr(all_args_t* args_, rrc_cfg_t* rrc_cfg_)
       rrc_cfg_->antenna_info.codebook_subset_restrict.n2_tx_ant_tm4().from_number(0b111111);
       break;
     default:
-      ERROR("Unsupported transmission mode %d\n", rrc_cfg_->antenna_info.tx_mode.to_number());
+      ERROR("Unsupported transmission mode %d", rrc_cfg_->antenna_info.tx_mode.to_number());
       return SRSLTE_ERROR;
   }
 
@@ -758,12 +758,12 @@ static int parse_cell_list(all_args_t* args, rrc_cfg_t* rrc_cfg, Setting& root)
     for (auto it2 = it + 1; it2 != rrc_cfg->cell_list.end(); it2++) {
       // Check RF port is not repeated
       if (it->rf_port == it2->rf_port) {
-        ERROR("Repeated RF port for multiple cells\n");
+        ERROR("Repeated RF port for multiple cells");
       }
 
       // Check cell ID is not repeated
       if (it->cell_id == it2->cell_id) {
-        ERROR("Repeated Cell identifier\n");
+        ERROR("Repeated Cell identifier");
       }
     }
   }
@@ -886,20 +886,20 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
     auto& cfg = rrc_cfg_->cell_list.at(0);
     if (args_->enb.dl_earfcn > 0) {
       cfg.dl_earfcn = args_->enb.dl_earfcn;
-      ERROR("Force DL EARFCN for cell PCI=%d to %d\n", cfg.pci, cfg.dl_earfcn);
+      ERROR("Force DL EARFCN for cell PCI=%d to %d", cfg.pci, cfg.dl_earfcn);
     }
     if (args_->rf.dl_freq > 0) {
       cfg.dl_freq_hz = args_->rf.dl_freq;
-      ERROR("Force DL freq for cell PCI=%d to %f MHz\n", cfg.pci, cfg.dl_freq_hz / 1e6f);
+      ERROR("Force DL freq for cell PCI=%d to %f MHz", cfg.pci, cfg.dl_freq_hz / 1e6f);
     }
     if (args_->rf.ul_freq > 0) {
       cfg.ul_freq_hz = args_->rf.ul_freq;
-      ERROR("Force UL freq for cell PCI=%d to %f MHz\n", cfg.pci, cfg.ul_freq_hz / 1e6f);
+      ERROR("Force UL freq for cell PCI=%d to %f MHz", cfg.pci, cfg.ul_freq_hz / 1e6f);
     }
   } else {
     // If more than one cell is defined, single EARFCN or DL freq will be ignored
     if (args_->enb.dl_earfcn > 0 || args_->rf.dl_freq > 0) {
-      INFO("Multiple cells defined in rr.conf. Ignoring single EARFCN and/or frequency config.\n");
+      INFO("Multiple cells defined in rr.conf. Ignoring single EARFCN and/or frequency config.");
     }
   }
 
@@ -943,10 +943,10 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
                                   rrc_cfg_->cell_list.end(),
                                   [scell_it](const cell_cfg_t& c) { return scell_it->cell_id == c.cell_id; });
       if (cell_it == rrc_cfg_->cell_list.end()) {
-        ERROR("Scell with cell_id=0x%x is not present in rr.conf. Ignoring it.\n", scell_it->cell_id);
+        ERROR("Scell with cell_id=0x%x is not present in rr.conf. Ignoring it.", scell_it->cell_id);
         scell_it = cfg.scell_list.erase(scell_it);
       } else if (cell_it->cell_id == cfg.cell_id) {
-        ERROR("A cell cannot have an scell with the same cell_id=0x%x\n", cfg.cell_id);
+        ERROR("A cell cannot have an scell with the same cell_id=0x%x", cfg.cell_id);
         return SRSLTE_ERROR;
       } else {
         scell_it++;
@@ -960,7 +960,7 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
     auto collision_it = std::find_if(it + 1, rrc_cfg_->cell_list.end(), is_pss_collision);
     if (collision_it != rrc_cfg_->cell_list.end()) {
       ERROR("The cells pci1=%d and pci2=%d will have the same PSS. Consider changing one of the cells' PCI values, "
-            "otherwise a UE may fail to correctly detect and distinguish them\n",
+            "otherwise a UE may fail to correctly detect and distinguish them",
             it->pci,
             collision_it->pci);
     }
@@ -1013,7 +1013,7 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
   uint32_t n310                     = rrc_cfg_->sibs[1].sib2().ue_timers_and_consts.n310.to_number();
   uint32_t min_rrc_inactivity_timer = t310 + t311 + n310 + 50;
   if (args_->general.rrc_inactivity_timer < min_rrc_inactivity_timer) {
-    ERROR("rrc_inactivity_timer=%d is too low. Consider setting it to a value equal or above %d\n",
+    ERROR("rrc_inactivity_timer=%d is too low. Consider setting it to a value equal or above %d",
           args_->general.rrc_inactivity_timer,
           min_rrc_inactivity_timer);
   }
@@ -1022,7 +1022,7 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
 
   // Check number of control symbols
   if (args_->stack.mac.sched.min_nof_ctrl_symbols > args_->stack.mac.sched.max_nof_ctrl_symbols) {
-    ERROR("Invalid minimum number of control symbols %d. Setting it to 1.\n",
+    ERROR("Invalid minimum number of control symbols %d. Setting it to 1.",
           args_->stack.mac.sched.min_nof_ctrl_symbols);
     args_->stack.mac.sched.min_nof_ctrl_symbols = 1;
   }
@@ -1538,7 +1538,7 @@ int parse_sibs(all_args_t* args_, rrc_cfg_t* rrc_cfg_, srsenb::phy_cfg_t* phy_co
   cell_access->plmn_id_list.resize(1);
   srslte::plmn_id_t plmn;
   if (plmn.from_string(mcc_str + mnc_str) == SRSLTE_ERROR) {
-    ERROR("Could not convert %s to a plmn_id\n", (mcc_str + mnc_str).c_str());
+    ERROR("Could not convert %s to a plmn_id", (mcc_str + mnc_str).c_str());
     return -1;
   }
   srslte::to_asn1(&cell_access->plmn_id_list[0].plmn_id, plmn);

srsenb/src/main.cc

@@ -480,19 +480,13 @@ int main(int argc, char* argv[])
   srslte_debug_handle_crash(argc, argv);
   parse_args(&args, argc, argv);
 
-  // Setup logging.
+  // Setup the default log sink.
-  log_sink = (args.log.filename == "stdout")
+  srslog::set_default_sink(
-                 ? srslog::create_stdout_sink()
+      (args.log.filename == "stdout")
-                 : srslog::create_file_sink(args.log.filename, fixup_log_file_maxsize(args.log.file_max_size));
+          ? srslog::fetch_stdout_sink()
-  if (!log_sink) {
+          : srslog::fetch_file_sink(args.log.filename, fixup_log_file_maxsize(args.log.file_max_size)));
-    return SRSLTE_ERROR;
-  }
 
-  srslog::log_channel* chan = srslog::create_log_channel("main_channel", *log_sink);
+  srslte::srslog_wrapper log_wrapper(srslog::fetch_log_channel("main_channel"));
-  if (!chan) {
-    return SRSLTE_ERROR;
-  }
-  srslte::srslog_wrapper log_wrapper(*chan);
 
   // Alarms log channel creation.
   srslog::sink&        alarm_sink     = srslog::fetch_file_sink(args.general.alarms_filename);
@@ -520,7 +514,7 @@ int main(int argc, char* argv[])
   }
 
   // Create eNB
-  unique_ptr<srsenb::enb> enb{new srsenb::enb};
+  unique_ptr<srsenb::enb> enb{new srsenb::enb(srslog::get_default_sink())};
   if (enb->init(args, &log_wrapper) != SRSLTE_SUCCESS) {
     enb->stop();
     return SRSLTE_ERROR;

srsenb/src/phy/lte/cc_worker.cc

@@ -18,16 +18,16 @@
 
 #define Error(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->error(fmt, ##__VA_ARGS__)
+  logger.error(fmt, ##__VA_ARGS__)
 #define Warning(fmt, ...)                                                                                              \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->warning(fmt, ##__VA_ARGS__)
+  logger.warning(fmt, ##__VA_ARGS__)
 #define Info(fmt, ...)                                                                                                 \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->info(fmt, ##__VA_ARGS__)
+  logger.info(fmt, ##__VA_ARGS__)
 #define Debug(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->debug(fmt, ##__VA_ARGS__)
+  logger.debug(fmt, ##__VA_ARGS__)
 
 using namespace std;
 
@@ -46,7 +46,7 @@ using namespace asn1::rrc;
 namespace srsenb {
 namespace lte {
 
-cc_worker::cc_worker()
+cc_worker::cc_worker(srslog::basic_logger& logger) : logger(logger)
 {
   reset();
 }
@@ -76,10 +76,9 @@ cc_worker::~cc_worker()
 FILE* f;
 #endif
 
-void cc_worker::init(phy_common* phy_, srslte::log* log_h_, uint32_t cc_idx_)
+void cc_worker::init(phy_common* phy_, uint32_t cc_idx_)
 {
   phy                   = phy_;
-  log_h                 = log_h_;
   cc_idx                = cc_idx_;
   srslte_cell_t cell    = phy_->get_cell(cc_idx);
   uint32_t      nof_prb = phy_->get_nof_prb(cc_idx);
@@ -89,32 +88,32 @@ void cc_worker::init(phy_common* phy_, srslte::log* log_h_, uint32_t cc_idx_)
   for (uint32_t p = 0; p < phy->get_nof_ports(cc_idx); p++) {
     signal_buffer_rx[p] = srslte_vec_cf_malloc(2 * sf_len);
     if (!signal_buffer_rx[p]) {
-      ERROR("Error allocating memory\n");
+      ERROR("Error allocating memory");
       return;
     }
     srslte_vec_cf_zero(signal_buffer_rx[p], 2 * sf_len);
     signal_buffer_tx[p] = srslte_vec_cf_malloc(2 * sf_len);
     if (!signal_buffer_tx[p]) {
-      ERROR("Error allocating memory\n");
+      ERROR("Error allocating memory");
       return;
     }
     srslte_vec_cf_zero(signal_buffer_tx[p], 2 * sf_len);
   }
   if (srslte_enb_dl_init(&enb_dl, signal_buffer_tx, nof_prb)) {
-    ERROR("Error initiating ENB DL (cc=%d)\n", cc_idx);
+    ERROR("Error initiating ENB DL (cc=%d)", cc_idx);
     return;
   }
   if (srslte_enb_dl_set_cell(&enb_dl, cell)) {
-    ERROR("Error initiating ENB DL (cc=%d)\n", cc_idx);
+    ERROR("Error initiating ENB DL (cc=%d)", cc_idx);
     return;
   }
   if (srslte_enb_ul_init(&enb_ul, signal_buffer_rx[0], nof_prb)) {
-    ERROR("Error initiating ENB UL\n");
+    ERROR("Error initiating ENB UL");
     return;
   }
 
   if (srslte_enb_ul_set_cell(&enb_ul, cell, &phy->dmrs_pusch_cfg, nullptr)) {
-    ERROR("Error initiating ENB UL\n");
+    ERROR("Error initiating ENB UL");
     return;
   }
 
@@ -130,13 +129,13 @@ void cc_worker::init(phy_common* phy_, srslte::log* log_h_, uint32_t cc_idx_)
   }
 
   if (srslte_softbuffer_tx_init(&temp_mbsfn_softbuffer, nof_prb)) {
-    ERROR("Error initiating soft buffer\n");
+    ERROR("Error initiating soft buffer");
     exit(-1);
   }
 
   srslte_softbuffer_tx_reset(&temp_mbsfn_softbuffer);
 
-  Info("Component Carrier Worker %d configured cell %d PRB\n", cc_idx, nof_prb);
+  Info("Component Carrier Worker %d configured cell %d PRB", cc_idx, nof_prb);
 
   if (phy->params.pusch_8bit_decoder) {
     enb_ul.pusch.llr_is_8bit        = true;
@@ -217,7 +216,7 @@ void cc_worker::work_ul(const srslte_ul_sf_cfg_t& ul_sf_cfg, stack_interface_phy
 {
   std::lock_guard<std::mutex> lock(mutex);
   ul_sf = ul_sf_cfg;
-  log_h->step(ul_sf.tti);
+  logger.set_context(ul_sf.tti);
 
   // Process UL signal
   srslte_enb_ul_fft(&enb_ul);
@@ -296,7 +295,7 @@ void cc_worker::decode_pusch_rnti(stack_interface_phy_lte::ul_sched_grant_t& ul_
   // Compute UL grant
   srslte_pusch_grant_t& grant = ul_cfg.pusch.grant;
   if (srslte_ra_ul_dci_to_grant(&enb_ul.cell, &ul_sf, &ul_cfg.hopping, &ul_grant.dci, &grant)) {
-    Error("Computing PUSCH dci for RNTI %x\n", rnti);
+    Error("Computing PUSCH dci for RNTI %x", rnti);
     return;
   }
 
@@ -308,7 +307,7 @@ void cc_worker::decode_pusch_rnti(stack_interface_phy_lte::ul_sched_grant_t& ul_
     int rv_idx  = grant.tb.rv;
     grant.tb    = phy->ue_db.get_last_ul_tb(rnti, cc_idx, ul_pid);
     grant.tb.rv = rv_idx;
-    Info("Adaptive retx: rnti=0x%x, pid=%d, rv_idx=%d, mcs=%d, old_tbs=%d\n",
+    Info("Adaptive retx: rnti=0x%x, pid=%d, rv_idx=%d, mcs=%d, old_tbs=%d",
          rnti,
          ul_pid,
          grant.tb.rv,
@@ -322,7 +321,7 @@ void cc_worker::decode_pusch_rnti(stack_interface_phy_lte::ul_sched_grant_t& ul_
   pusch_res.data              = ul_grant.data;
   if (pusch_res.data) {
     if (srslte_enb_ul_get_pusch(&enb_ul, &ul_sf, &ul_cfg.pusch, &pusch_res)) {
-      Error("Decoding PUSCH for RNTI %x\n", rnti);
+      Error("Decoding PUSCH for RNTI %x", rnti);
       return;
     }
   }
@@ -376,10 +375,10 @@ void cc_worker::decode_pusch(stack_interface_phy_lte::ul_sched_grant_t* grants,
       // Push PDU buffer
       phy->stack->push_pdu(tti_rx, rnti, cc_idx, ul_cfg.pusch.grant.tb.tbs / 8, pusch_res.crc);
       // Logging
-      if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+      if (logger.info.enabled()) {
         char str[512];
         srslte_pusch_rx_info(&ul_cfg.pusch, &pusch_res, &enb_ul.chest_res, str, sizeof(str));
-        log_h->info("PUSCH: cc=%d, %s\n", cc_idx, str);
+        logger.info("PUSCH: cc=%d, %s", cc_idx, str);
       }
     }
   }
@@ -400,7 +399,7 @@ int cc_worker::decode_pucch()
       if (phy->ue_db.fill_uci_cfg(tti_rx, cc_idx, rnti, false, false, ul_cfg.pucch.uci_cfg)) {
         // Decode PUCCH
         if (srslte_enb_ul_get_pucch(&enb_ul, &ul_sf, &ul_cfg.pucch, &pucch_res)) {
-          ERROR("Error getting PUCCH\n");
+          ERROR("Error getting PUCCH");
           return SRSLTE_ERROR;
         }
 
@@ -413,10 +412,10 @@ int cc_worker::decode_pucch()
         }
 
         // Logging
-        if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+        if (logger.info.enabled()) {
           char str[512];
           srslte_pucch_rx_info(&ul_cfg.pucch, &pucch_res, str, sizeof(str));
-          log_h->info("PUCCH: cc=%d; %s\n", cc_idx, str);
+          logger.info("PUCCH: cc=%d; %s", cc_idx, str);
         }
 
         // Save metrics
@@ -433,7 +432,7 @@ int cc_worker::encode_phich(stack_interface_phy_lte::ul_sched_ack_t* acks, uint3
     if (acks[i].rnti && ue_db.count(acks[i].rnti)) {
       srslte_enb_dl_put_phich(&enb_dl, &ue_db[acks[i].rnti]->phich_grant, acks[i].ack);
 
-      Info("PHICH: rnti=0x%x, hi=%d, I_lowest=%d, n_dmrs=%d, tti_tx_dl=%d\n",
+      Info("PHICH: rnti=0x%x, hi=%d, I_lowest=%d, n_dmrs=%d, tti_tx_dl=%d",
            acks[i].rnti,
            acks[i].ack,
            ue_db[acks[i].rnti]->phich_grant.n_prb_lowest,
@@ -459,15 +458,15 @@ int cc_worker::encode_pdcch_ul(stack_interface_phy_lte::ul_sched_grant_t* grants
       }
 
       if (srslte_enb_dl_put_pdcch_ul(&enb_dl, &dci_cfg, &grants[i].dci)) {
-        ERROR("Error putting PUSCH %d\n", i);
+        ERROR("Error putting PUSCH %d", i);
         return SRSLTE_ERROR;
       }
 
       // Logging
-      if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+      if (logger.info.enabled()) {
         char str[512];
         srslte_dci_ul_info(&grants[i].dci, str, 512);
-        log_h->info("PDCCH: cc=%d, %s, tti_tx_dl=%d\n", cc_idx, str, tti_tx_dl);
+        logger.info("PDCCH: cc=%d, %s, tti_tx_dl=%d", cc_idx, str, tti_tx_dl);
       }
     }
   }
@@ -489,15 +488,15 @@ int cc_worker::encode_pdcch_dl(stack_interface_phy_lte::dl_sched_grant_t* grants
       }
 
       if (srslte_enb_dl_put_pdcch_dl(&enb_dl, &dci_cfg, &grants[i].dci)) {
-        ERROR("Error putting PDCCH %d\n", i);
+        ERROR("Error putting PDCCH %d", i);
         return SRSLTE_ERROR;
       }
 
-      if (LOG_THIS(rnti) and log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+      if (LOG_THIS(rnti) and logger.info.enabled()) {
         // Logging
         char str[512];
         srslte_dci_dl_info(&grants[i].dci, str, 512);
-        log_h->info("PDCCH: cc=%d, %s, tti_tx_dl=%d\n", cc_idx, str, tti_tx_dl);
+        logger.info("PDCCH: cc=%d, %s, tti_tx_dl=%d", cc_idx, str, tti_tx_dl);
       }
     }
   }
@@ -516,15 +515,15 @@ int cc_worker::encode_pmch(stack_interface_phy_lte::dl_sched_grant_t* grant, srs
 
   // Encode PMCH
   if (srslte_enb_dl_put_pmch(&enb_dl, &pmch_cfg, grant->data[0])) {
-    Error("Error putting PMCH\n");
+    Error("Error putting PMCH");
     return SRSLTE_ERROR;
   }
 
   // Logging
-  if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+  if (logger.info.enabled()) {
     char str[512];
     srslte_pdsch_tx_info(&pmch_cfg.pdsch_cfg, str, 512);
-    log_h->info("PMCH: %s\n", str);
+    logger.info("PMCH: %s", str);
   }
 
   // Save metrics stats
@@ -548,7 +547,7 @@ int cc_worker::encode_pdsch(stack_interface_phy_lte::dl_sched_grant_t* grants, u
       // Compute DL grant
       if (srslte_ra_dl_dci_to_grant(
               &enb_dl.cell, &dl_sf, dl_cfg.tm, dl_cfg.pdsch.use_tbs_index_alt, &grants[i].dci, &dl_cfg.pdsch.grant)) {
-        Error("Computing DL grant\n");
+        Error("Computing DL grant");
       }
 
       // Set soft buffer
@@ -558,7 +557,7 @@ int cc_worker::encode_pdsch(stack_interface_phy_lte::dl_sched_grant_t* grants, u
 
       // Encode PDSCH
       if (srslte_enb_dl_put_pdsch(&enb_dl, &dl_cfg.pdsch, grants[i].data)) {
-        Error("Error putting PDSCH %d\n", i);
+        Error("Error putting PDSCH %d", i);
         return SRSLTE_ERROR;
       }
 
@@ -568,17 +567,17 @@ int cc_worker::encode_pdsch(stack_interface_phy_lte::dl_sched_grant_t* grants, u
         phy->ue_db.set_ack_pending(tti_tx_ul, cc_idx, grants[i].dci);
       }
 
-      if (LOG_THIS(rnti) and log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+      if (LOG_THIS(rnti) and logger.info.enabled()) {
         // Logging
         char str[512];
         srslte_pdsch_tx_info(&dl_cfg.pdsch, str, 512);
-        log_h->info("PDSCH: cc=%d, %s, tti_tx_dl=%d\n", cc_idx, str, tti_tx_dl);
+        logger.info("PDSCH: cc=%d, %s, tti_tx_dl=%d", cc_idx, str, tti_tx_dl);
       }
 
       // Save metrics stats
       ue_db[rnti]->metrics_dl(grants[i].dci.tb[0].mcs_idx);
     } else {
-      Error("User rnti=0x%x not found in cc_worker=%d\n", rnti, cc_idx);
+      Error("User rnti=0x%x not found in cc_worker=%d", rnti, cc_idx);
     }
   }
 

srsenb/src/phy/lte/sf_worker.cc

@@ -18,16 +18,16 @@
 
 #define Error(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->error(fmt, ##__VA_ARGS__)
+  logger.error(fmt, ##__VA_ARGS__)
 #define Warning(fmt, ...)                                                                                              \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->warning(fmt, ##__VA_ARGS__)
+  logger.warning(fmt, ##__VA_ARGS__)
 #define Info(fmt, ...)                                                                                                 \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->info(fmt, ##__VA_ARGS__)
+  logger.info(fmt, ##__VA_ARGS__)
 #define Debug(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->debug(fmt, ##__VA_ARGS__)
+  logger.debug(fmt, ##__VA_ARGS__)
 
 using namespace std;
 
@@ -64,31 +64,30 @@ namespace lte {
 FILE* f;
 #endif
 
-void sf_worker::init(phy_common* phy_, srslte::log* log_h_)
+void sf_worker::init(phy_common* phy_)
 {
-  phy   = phy_;
+  phy = phy_;
-  log_h = log_h_;
 
   // Initialise each component carrier workers
   for (uint32_t i = 0; i < phy->get_nof_carriers_lte(); i++) {
     // Create pointer
-    auto q = new cc_worker();
+    auto q = new cc_worker(logger);
 
     // Initialise
-    q->init(phy, log_h, i);
+    q->init(phy, i);
 
     // Create unique pointer
     cc_workers.push_back(std::unique_ptr<cc_worker>(q));
   }
 
   if (srslte_softbuffer_tx_init(&temp_mbsfn_softbuffer, phy->get_nof_prb(0))) {
-    ERROR("Error initiating soft buffer\n");
+    ERROR("Error initiating soft buffer");
     exit(-1);
   }
 
   srslte_softbuffer_tx_reset(&temp_mbsfn_softbuffer);
 
-  Info("Worker %d configured cell %d PRB\n", get_id(), phy->get_nof_prb(0));
+  Info("Worker %d configured cell %d PRB", get_id(), phy->get_nof_prb(0));
 
   initiated = true;
   running   = true;
@@ -188,9 +187,9 @@ void sf_worker::work_imp()
 
   stack_interface_phy_lte* stack = phy->stack;
 
-  log_h->step(tti_rx);
+  logger.set_context(tti_rx);
 
-  Debug("Worker %d running\n", get_id());
+  Debug("Worker %d running", get_id());
 
   // Configure UL subframe
   ul_sf.tti = tti_rx;
@@ -206,14 +205,14 @@ void sf_worker::work_imp()
   // Get DL scheduling for the TX TTI from MAC
   if (sf_type == SRSLTE_SF_NORM) {
     if (stack->get_dl_sched(tti_tx_dl, dl_grants) < 0) {
-      Error("Getting DL scheduling from MAC\n");
+      Error("Getting DL scheduling from MAC");
       phy->worker_end(this, tx_buffer, tx_time);
       return;
     }
   } else {
     dl_grants[0].cfi = mbsfn_cfg.non_mbsfn_region_length;
     if (stack->get_mch_sched(tti_tx_dl, mbsfn_cfg.is_mcch, dl_grants)) {
-      Error("Getting MCH packets from MAC\n");
+      Error("Getting MCH packets from MAC");
       phy->worker_end(this, tx_buffer, tx_time);
       return;
     }
@@ -225,7 +224,7 @@ void sf_worker::work_imp()
 
   // Get UL scheduling for the TX TTI from MAC
   if (stack->get_ul_sched(tti_tx_ul, ul_grants_tx) < 0) {
-    Error("Getting UL scheduling from MAC\n");
+    Error("Getting UL scheduling from MAC");
     phy->worker_end(this, tx_buffer, tx_time);
     return;
   }
@@ -248,7 +247,7 @@ void sf_worker::work_imp()
   phy->set_ul_grants(t_tx_ul, ul_grants_tx);
   phy->set_ul_grants(t_rx, ul_grants);
 
-  Debug("Sending to radio\n");
+  Debug("Sending to radio");
   tx_buffer.set_nof_samples(SRSLTE_SF_LEN_PRB(phy->get_nof_prb(0)));
   phy->worker_end(this, tx_buffer, tx_time);
 

srsenb/src/phy/lte/worker_pool.cc

@@ -25,24 +25,17 @@ namespace lte {
 
 worker_pool::worker_pool(uint32_t max_workers) : pool(max_workers) {}
 
-bool worker_pool::init(const phy_args_t& args, phy_common* common, srslte::logger* logger, int prio)
+bool worker_pool::init(const phy_args_t& args, phy_common* common, srslog::sink& log_sink, int prio)
 {
-  // Create logs
+  // Add workers to workers pool and start threads.
-  // Create array of pointers to phy_logs
+  srslog::basic_levels log_level = srslog::str_to_basic_level(args.log.phy_level);
   for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
-    auto* mylog = new srslte::log_filter;
+    auto& log = srslog::fetch_basic_logger(fmt::format("PHY{}", i), log_sink);
-    char  tmp[16];
+    log.set_level(log_level);
-    sprintf(tmp, "PHY%d", i);
+    log.set_hex_dump_max_size(args.log.phy_hex_limit);
-    mylog->init(tmp, logger, true);
-    mylog->set_level(args.log.phy_level);
-    mylog->set_hex_limit(args.log.phy_hex_limit);
-    log_vec.push_back(std::unique_ptr<srslte::log_filter>(mylog));
-  }
 
-  // Add workers to workers pool and start threads
+    auto w = std::unique_ptr<lte::sf_worker>(new sf_worker(log));
-  for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
+    w->init(common);
-    auto w = std::unique_ptr<lte::sf_worker>(new sf_worker());
-    w->init(common, (srslte::log*)log_vec[i].get());
     pool.init_worker(i, w.get(), prio);
     workers.push_back(std::move(w));
   }

srsenb/src/phy/nr/cc_worker.cc

@@ -24,8 +24,8 @@
 
 namespace srsenb {
 namespace nr {
-cc_worker::cc_worker(uint32_t cc_idx_, srslte::log* log, phy_nr_state* phy_state_) :
+cc_worker::cc_worker(uint32_t cc_idx_, srslog::basic_logger& logger, phy_nr_state* phy_state_) :
-  cc_idx(cc_idx_), phy_state(phy_state_), log_h(log)
+  cc_idx(cc_idx_), phy_state(phy_state_), logger(logger)
 {
   cf_t* buffer_c[SRSLTE_MAX_PORTS] = {};
 
@@ -38,7 +38,7 @@ cc_worker::cc_worker(uint32_t cc_idx_, srslte::log* log, phy_nr_state* phy_state
   }
 
   if (srslte_enb_dl_nr_init(&enb_dl, buffer_c, &phy_state_->args.dl)) {
-    ERROR("Error initiating UE DL NR\n");
+    ERROR("Error initiating UE DL NR");
     return;
   }
 }
@@ -61,7 +61,7 @@ cc_worker::~cc_worker()
 bool cc_worker::set_carrier(const srslte_carrier_nr_t* carrier)
 {
   if (srslte_enb_dl_nr_set_carrier(&enb_dl, carrier) < SRSLTE_SUCCESS) {
-    ERROR("Error setting carrier\n");
+    ERROR("Error setting carrier");
     return false;
   }
 
@@ -70,7 +70,7 @@ bool cc_worker::set_carrier(const srslte_carrier_nr_t* carrier)
   coreset.duration          = 2;
 
   if (srslte_enb_dl_nr_set_coreset(&enb_dl, &coreset) < SRSLTE_SUCCESS) {
-    ERROR("Error setting coreset\n");
+    ERROR("Error setting coreset");
     return false;
   }
 
@@ -114,12 +114,12 @@ int cc_worker::encode_pdcch_dl(stack_interface_phy_nr::dl_sched_grant_t* grants,
 
     // Put actual DCI
     if (srslte_enb_dl_nr_pdcch_put(&enb_dl, &dl_slot_cfg, &grants[i].dci) < SRSLTE_SUCCESS) {
-      ERROR("Error putting PDCCH\n");
+      ERROR("Error putting PDCCH");
       return SRSLTE_ERROR;
     }
 
-    if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+    if (logger.info.enabled()) {
-      log_h->info("PDCCH: cc=%d, ...\n", cc_idx);
+      logger.info("PDCCH: cc=%d, ...", cc_idx);
     }
   }
 
@@ -136,7 +136,7 @@ int cc_worker::encode_pdsch(stack_interface_phy_nr::dl_sched_grant_t* grants, ui
 
     // Compute DL grant
     if (srslte_ra_dl_dci_to_grant_nr(&enb_dl.carrier, &pdsch_cfg, &grants[i].dci, &pdsch_cfg.grant)) {
-      ERROR("Computing DL grant\n");
+      ERROR("Computing DL grant");
     }
 
     // Set soft buffer
@@ -145,15 +145,15 @@ int cc_worker::encode_pdsch(stack_interface_phy_nr::dl_sched_grant_t* grants, ui
     }
 
     if (srslte_enb_dl_nr_pdsch_put(&enb_dl, &dl_slot_cfg, &pdsch_cfg, grants[i].data) < SRSLTE_SUCCESS) {
-      ERROR("Error putting PDSCH\n");
+      ERROR("Error putting PDSCH");
       return false;
     }
 
     // Logging
-    if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
+    if (logger.info.enabled()) {
       char str[512];
       srslte_enb_dl_nr_pdsch_info(&enb_dl, &pdsch_cfg, str, sizeof(str));
-      log_h->info("PDSCH: cc=%d, %s\n", cc_idx, str);
+      logger.info("PDSCH: cc=%d, %s", cc_idx, str);
     }
   }
 
@@ -164,7 +164,7 @@ bool cc_worker::work_dl(const srslte_dl_slot_cfg_t& dl_sf_cfg, stack_interface_p
 {
   // Reset resource grid
   if (srslte_enb_dl_nr_base_zero(&enb_dl) < SRSLTE_SUCCESS) {
-    ERROR("Error setting base to zero\n");
+    ERROR("Error setting base to zero");
     return SRSLTE_ERROR;
   }
 

srsenb/src/phy/nr/sf_worker.cc

@@ -23,17 +23,17 @@
 
 namespace srsenb {
 namespace nr {
-sf_worker::sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslte::log* log) :
+sf_worker::sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslog::basic_logger& logger) :
-  phy(phy_), phy_state(phy_state_), log_h(log)
+  phy(phy_), phy_state(phy_state_), logger(logger)
 {
   for (uint32_t i = 0; i < phy_state->args.nof_carriers; i++) {
-    cc_worker* w = new cc_worker(i, log, phy_state);
+    cc_worker* w = new cc_worker(i, logger, phy_state);
     cc_workers.push_back(std::unique_ptr<cc_worker>(w));
   }
 
   if (srslte_softbuffer_tx_init_guru(&softbuffer_tx, SRSLTE_SCH_NR_MAX_NOF_CB_LDPC, SRSLTE_LDPC_MAX_LEN_ENCODED_CB) <
       SRSLTE_SUCCESS) {
-    ERROR("Error init soft-buffer\n");
+    ERROR("Error init soft-buffer");
     return;
   }
   data.resize(SRSLTE_SCH_NR_MAX_NOF_CB_LDPC * SRSLTE_LDPC_MAX_LEN_ENCODED_CB / 8);
@@ -80,7 +80,7 @@ uint32_t sf_worker::get_buffer_len()
 
 void sf_worker::set_tti(uint32_t tti)
 {
-  log_h->step(tti);
+  logger.set_context(tti);
   for (auto& w : cc_workers) {
     w->set_tti(tti);
   }

srsenb/src/phy/nr/worker_pool.cc

@@ -25,23 +25,16 @@ namespace nr {
 
 worker_pool::worker_pool(uint32_t max_workers) : pool(max_workers) {}
 
-bool worker_pool::init(const phy_args_t& args, phy_common* common, srslte::logger* logger, int prio)
+bool worker_pool::init(const phy_args_t& args, phy_common* common, srslog::sink& log_sink, int prio)
 {
-  // Create logs
-  // Create array of pointers to phy_logs
-  for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
-    auto* mylog = new srslte::log_filter;
-    char  tmp[16];
-    sprintf(tmp, "PHY%d", i);
-    mylog->init(tmp, logger, true);
-    mylog->set_level(args.log.phy_level);
-    mylog->set_hex_limit(args.log.phy_hex_limit);
-    log_vec.push_back(std::unique_ptr<srslte::log_filter>(mylog));
-  }
-
   // Add workers to workers pool and start threads
+  srslog::basic_levels log_level = srslog::str_to_basic_level(args.log.phy_level);
   for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
-    auto w = new sf_worker(common, &phy_state, (srslte::log*)log_vec[i].get());
+    auto& log = srslog::fetch_basic_logger(fmt::format("PHY{}", i), log_sink);
+    log.set_level(log_level);
+    log.set_hex_dump_max_size(args.log.phy_hex_limit);
+
+    auto w = new sf_worker(common, &phy_state, log);
     pool.init_worker(i, w, prio);
     workers.push_back(std::unique_ptr<sf_worker>(w));
 

srsenb/src/phy/phy.cc

@@ -24,16 +24,16 @@
 
 #define Error(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->error(fmt, ##__VA_ARGS__)
+  phy_log.error(fmt, ##__VA_ARGS__)
 #define Warning(fmt, ...)                                                                                              \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->warning(fmt, ##__VA_ARGS__)
+  phy_log.warning(fmt, ##__VA_ARGS__)
 #define Info(fmt, ...)                                                                                                 \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->info(fmt, ##__VA_ARGS__)
+  phy_log.info(fmt, ##__VA_ARGS__)
 #define Debug(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->debug(fmt, ##__VA_ARGS__)
+  phy_log.debug(fmt, ##__VA_ARGS__)
 
 using namespace std;
 using namespace asn1::rrc;
@@ -48,27 +48,30 @@ static void srslte_phy_handler(phy_logger_level_t log_level, void* ctx, char* st
 
 void phy::srslte_phy_logger(phy_logger_level_t log_level, char* str)
 {
-  if (log_phy_lib_h) {
+  switch (log_level) {
-    switch (log_level) {
+    case LOG_LEVEL_INFO_S:
-      case LOG_LEVEL_INFO_S:
+      phy_lib_log.info(" %s", str);
-        log_phy_lib_h->info(" %s", str);
+      break;
-        break;
+    case LOG_LEVEL_DEBUG_S:
-      case LOG_LEVEL_DEBUG_S:
+      phy_lib_log.debug(" %s", str);
-        log_phy_lib_h->debug(" %s", str);
+      break;
-        break;
+    case LOG_LEVEL_ERROR_S:
-      case LOG_LEVEL_ERROR_S:
+      phy_lib_log.error(" %s", str);
-        log_phy_lib_h->error(" %s", str);
+      break;
-        break;
+    default:
-      default:
+      break;
-        break;
-    }
-  } else {
-    printf("[PHY_LIB]: %s\n", str);
   }
 }
 
-phy::phy(srslte::logger* logger_) :
+phy::phy(srslog::sink& log_sink) :
-  logger(logger_), lte_workers(MAX_WORKERS), nr_workers(MAX_WORKERS), workers_common(), nof_workers(0)
+  log_sink(log_sink),
+  phy_log(srslog::fetch_basic_logger("PHY", log_sink)),
+  phy_lib_log(srslog::fetch_basic_logger("PHY_LIB", log_sink)),
+  lte_workers(MAX_WORKERS),
+  nr_workers(MAX_WORKERS),
+  workers_common(),
+  nof_workers(0),
+  tx_rx(phy_log)
 {}
 
 phy::~phy()
@@ -99,22 +102,18 @@ int phy::init(const phy_args_t&            args,
 {
   mlockall((uint32_t)MCL_CURRENT | (uint32_t)MCL_FUTURE);
 
-  // Add PHY lib log
+  // Add PHY lib log.
-  if (srslte::log::get_level_from_string(args.log.phy_lib_level) != srslte::LOG_LEVEL_NONE) {
+  srslog::basic_levels log_lvl = srslog::str_to_basic_level(args.log.phy_lib_level);
-    log_phy_lib_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter);
+
-    log_phy_lib_h->init("PHY_LIB", logger, true);
+  phy_lib_log.set_level(log_lvl);
-    log_phy_lib_h->set_level(args.log.phy_lib_level);
+  phy_lib_log.set_hex_dump_max_size(args.log.phy_hex_limit);
-    log_phy_lib_h->set_hex_limit(args.log.phy_hex_limit);
+  if (log_lvl != srslog::basic_levels::none) {
     srslte_phy_log_register_handler(this, srslte_phy_handler);
   }
 
-  // Create default log
+  // Create default log.
-  {
+  phy_log.set_level(log_lvl);
-    log_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter);
+  phy_log.set_hex_dump_max_size(args.log.phy_hex_limit);
-    log_h->init("PHY", logger, true);
-    log_h->set_level(args.log.phy_level);
-    log_h->set_hex_limit(args.log.phy_hex_limit);
-  }
 
   radio       = radio_;
   nof_workers = args.nof_phy_threads;
@@ -126,24 +125,19 @@ int phy::init(const phy_args_t&            args,
   parse_common_config(cfg);
 
   // Add workers to workers pool and start threads
-  lte_workers.init(args, &workers_common, logger, WORKERS_THREAD_PRIO);
+  lte_workers.init(args, &workers_common, log_sink, WORKERS_THREAD_PRIO);
-  nr_workers.init(args, &workers_common, logger, WORKERS_THREAD_PRIO);
+  nr_workers.init(args, &workers_common, log_sink, WORKERS_THREAD_PRIO);
 
   // For each carrier, initialise PRACH worker
   for (uint32_t cc = 0; cc < cfg.phy_cell_cfg.size(); cc++) {
     prach_cfg.root_seq_idx = cfg.phy_cell_cfg[cc].root_seq_idx;
-    prach.init(cc,
+    prach.init(
-               cfg.phy_cell_cfg[cc].cell,
+        cc, cfg.phy_cell_cfg[cc].cell, prach_cfg, stack_, phy_log, PRACH_WORKER_THREAD_PRIO, args.nof_prach_threads);
-               prach_cfg,
-               stack_,
-               log_h.get(),
-               PRACH_WORKER_THREAD_PRIO,
-               args.nof_prach_threads);
   }
   prach.set_max_prach_offset_us(args.max_prach_offset_us);
 
   // Warning this must be initialized after all workers have been added to the pool
-  tx_rx.init(stack_, radio, &lte_workers, &nr_workers, &workers_common, &prach, log_h.get(), SF_RECV_THREAD_PRIO);
+  tx_rx.init(stack_, radio, &lte_workers, &nr_workers, &workers_common, &prach, SF_RECV_THREAD_PRIO);
 
   initialized = true;
 
@@ -237,7 +231,7 @@ void phy::get_metrics(std::vector<phy_metrics_t>& metrics)
 
 void phy::cmd_cell_gain(uint32_t cell_id, float gain_db)
 {
-  Info("set_cell_gain: cell_id=%d, gain_db=%.2f\n", cell_id, gain_db);
+  Info("set_cell_gain: cell_id=%d, gain_db=%.2f", cell_id, gain_db);
   workers_common.set_cell_gain(cell_id, gain_db);
 }
 
@@ -272,10 +266,10 @@ void phy::configure_mbsfn(srslte::sib2_mbms_t* sib2, srslte::sib13_t* sib13, con
 {
   if (sib2->mbsfn_sf_cfg_list_present) {
     if (sib2->nof_mbsfn_sf_cfg == 0) {
-      Warning("SIB2 does not have any MBSFN config although it was set as present\n");
+      Warning("SIB2 does not have any MBSFN config although it was set as present");
     } else {
       if (sib2->nof_mbsfn_sf_cfg > 1) {
-        Warning("SIB2 has %d MBSFN subframe configs - only 1 supported\n", sib2->nof_mbsfn_sf_cfg);
+        Warning("SIB2 has %d MBSFN subframe configs - only 1 supported", sib2->nof_mbsfn_sf_cfg);
       }
       mbsfn_config.mbsfn_subfr_cnfg = sib2->mbsfn_sf_cfg_list[0];
     }
@@ -287,7 +281,7 @@ void phy::configure_mbsfn(srslte::sib2_mbms_t* sib2, srslte::sib13_t* sib13, con
   mbsfn_config.mbsfn_notification_cnfg = sib13->notif_cfg;
   if (sib13->nof_mbsfn_area_info > 0) {
     if (sib13->nof_mbsfn_area_info > 1) {
-      Warning("SIB13 has %d MBSFN area info elements - only 1 supported\n", sib13->nof_mbsfn_area_info);
+      Warning("SIB13 has %d MBSFN area info elements - only 1 supported", sib13->nof_mbsfn_area_info);
     }
     mbsfn_config.mbsfn_area_info = sib13->mbsfn_area_info_list[0];
   }

srsenb/src/phy/phy_common.cc

@@ -17,19 +17,6 @@
 
 #include <assert.h>
 
-#define Error(fmt, ...)                                                                                                \
-  if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->error(fmt, ##__VA_ARGS__)
-#define Warning(fmt, ...)                                                                                              \
-  if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->warning(fmt, ##__VA_ARGS__)
-#define Info(fmt, ...)                                                                                                 \
-  if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->info(fmt, ##__VA_ARGS__)
-#define Debug(fmt, ...)                                                                                                \
-  if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->debug(fmt, ##__VA_ARGS__)
-
 using namespace std;
 using namespace asn1::rrc;
 

srsenb/src/phy/phy_ue_db.cc

@@ -129,7 +129,7 @@ uint32_t phy_ue_db::_get_uci_enb_cc_idx(uint32_t tti, uint16_t rnti) const
 inline int phy_ue_db::_assert_rnti(uint16_t rnti) const
 {
   if (not ue_db.count(rnti)) {
-    ERROR("Trying to access RNTI 0x%X, it does not exist.\n", rnti);
+    ERROR("Trying to access RNTI 0x%X, it does not exist.", rnti);
     return SRSLTE_ERROR;
   }
 
@@ -233,7 +233,7 @@ inline srslte::phy_cfg_t phy_ue_db::_get_rnti_config(uint16_t rnti, uint32_t enb
 
   // Make sure the C-RNTI exists and the cell/carrier is configured
   if (_assert_enb_cc(rnti, enb_cc_idx) != SRSLTE_SUCCESS) {
-    ERROR("Trying to access cell/carrier %d in RNTI 0x%X. It is not active.\n", enb_cc_idx, rnti);
+    ERROR("Trying to access cell/carrier %d in RNTI 0x%X. It is not active.", enb_cc_idx, rnti);
     return default_cfg;
   }
 
@@ -383,7 +383,7 @@ void phy_ue_db::activate_deactivate_scell(uint16_t rnti, uint32_t ue_cc_idx, boo
 
   // If scell is default only complain
   if (activate and cell_info.state == cell_state_none) {
-    ERROR("RNTI 0x%X SCell %d has received an activation MAC command but it was not configured\n", rnti, ue_cc_idx);
+    ERROR("RNTI 0x%X SCell %d has received an activation MAC command but it was not configured", rnti, ue_cc_idx);
     return;
   }
   // Set scell state
@@ -659,7 +659,7 @@ void phy_ue_db::send_uci_data(uint32_t                  tti,
           pmi_value = uci_value.cqi.subband_hl.pmi;
           break;
         default:
-          ERROR("CQI type=%d not implemented for PMI\n", uci_cfg.cqi.type);
+          ERROR("CQI type=%d not implemented for PMI", uci_cfg.cqi.type);
           break;
       }
       stack->pmi_info(tti, rnti, cqi_cc_idx, pmi_value);

srsenb/src/phy/prach_worker.cc

@@ -18,11 +18,9 @@ namespace srsenb {
 int prach_worker::init(const srslte_cell_t&      cell_,
                        const srslte_prach_cfg_t& prach_cfg_,
                        stack_interface_phy_lte*  stack_,
-                       srslte::log*              log_h_,
                        int                       priority,
                        uint32_t                  nof_workers_)
 {
-  log_h       = log_h_;
   stack       = stack_;
   prach_cfg   = prach_cfg_;
   cell        = cell_;
@@ -35,7 +33,7 @@ int prach_worker::init(const srslte_cell_t&      cell_,
   }
 
   if (srslte_prach_set_cfg(&prach, &prach_cfg, cell.nof_prb)) {
-    ERROR("Error initiating PRACH\n");
+    ERROR("Error initiating PRACH");
     return -1;
   }
 
@@ -91,12 +89,12 @@ int prach_worker::new_tti(uint32_t tti_rx, cf_t* buffer_rx)
     if (sf_cnt == 0) {
       current_buffer = buffer_pool.allocate();
       if (!current_buffer) {
-        log_h->warning("PRACH skipping tti=%d due to lack of available buffers\n", tti_rx);
+        logger.warning("PRACH skipping tti=%d due to lack of available buffers", tti_rx);
         return 0;
       }
     }
     if (!current_buffer) {
-      log_h->error("PRACH: Expected available current_buffer\n");
+      logger.error("PRACH: Expected available current_buffer");
       return -1;
     }
     if (current_buffer->nof_samples + SRSLTE_SF_LEN_PRB(cell.nof_prb) < sf_buffer_sz) {
@@ -108,7 +106,7 @@ int prach_worker::new_tti(uint32_t tti_rx, cf_t* buffer_rx)
         current_buffer->tti = tti_rx;
       }
     } else {
-      log_h->error("PRACH: Not enough space in current_buffer\n");
+      logger.error("PRACH: Not enough space in current_buffer");
       return -1;
     }
     sf_cnt++;
@@ -139,13 +137,13 @@ int prach_worker::run_tti(sf_buffer* b)
                                    prach_offsets,
                                    prach_p2avg,
                                    &prach_nof_det)) {
-      log_h->error("Error detecting PRACH\n");
+      logger.error("Error detecting PRACH");
       return SRSLTE_ERROR;
     }
 
     if (prach_nof_det) {
       for (uint32_t i = 0; i < prach_nof_det; i++) {
-        log_h->info("PRACH: cc=%d, %d/%d, preamble=%d, offset=%.1f us, peak2avg=%.1f, max_offset=%.1f us\n",
+        logger.info("PRACH: cc=%d, %d/%d, preamble=%d, offset=%.1f us, peak2avg=%.1f, max_offset=%.1f us",
                     cc_idx,
                     i,
                     prach_nof_det,

srsenb/src/phy/txrx.cc

@@ -20,22 +20,22 @@
 
 #define Error(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->error(fmt, ##__VA_ARGS__)
+  logger.error(fmt, ##__VA_ARGS__)
 #define Warning(fmt, ...)                                                                                              \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->warning(fmt, ##__VA_ARGS__)
+  logger.warning(fmt, ##__VA_ARGS__)
 #define Info(fmt, ...)                                                                                                 \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->info(fmt, ##__VA_ARGS__)
+  logger.info(fmt, ##__VA_ARGS__)
 #define Debug(fmt, ...)                                                                                                \
   if (SRSLTE_DEBUG_ENABLED)                                                                                            \
-  log_h->debug(fmt, ##__VA_ARGS__)
+  logger.debug(fmt, ##__VA_ARGS__)
 
 using namespace std;
 
 namespace srsenb {
 
-txrx::txrx() : thread("TXRX")
+txrx::txrx(srslog::basic_logger& logger) : thread("TXRX"), logger(logger)
 {
   /* Do nothing */
 }
@@ -46,12 +46,10 @@ bool txrx::init(stack_interface_phy_lte*     stack_,
                 nr::worker_pool*             nr_workers_,
                 phy_common*                  worker_com_,
                 prach_worker_pool*           prach_,
-                srslte::log*                 log_h_,
                 uint32_t                     prio_)
 {
   stack         = stack_;
   radio_h       = radio_h_;
-  log_h         = log_h_;
   lte_workers   = lte_workers_;
   nr_workers    = nr_workers_;
   worker_com    = worker_com_;
@@ -110,7 +108,7 @@ void txrx::run_thread()
     ul_channel->set_srate(static_cast<uint32_t>(samp_rate));
   }
 
-  log_h->info("Starting RX/TX thread nof_prb=%d, sf_len=%d\n", worker_com->get_nof_prb(0), sf_len);
+  logger.info("Starting RX/TX thread nof_prb=%d, sf_len=%d", worker_com->get_nof_prb(0), sf_len);
 
   // Set TTI so that first TX is at tti=0
   tti = TTI_SUB(0, FDD_HARQ_DELAY_UL_MS + 1);
@@ -118,10 +116,7 @@ void txrx::run_thread()
   // Main loop
   while (running) {
     tti = TTI_ADD(tti, 1);
-
+    logger.set_context(tti);
-    if (log_h) {
-      log_h->step(tti);
-    }
 
     lte::sf_worker* lte_worker = nullptr;
     if (worker_com->get_nof_carriers_lte() > 0) {
@@ -173,7 +168,7 @@ void txrx::run_thread()
     // Compute TX time: Any transmission happens in TTI+4 thus advance 4 ms the reception time
     timestamp.add(FDD_HARQ_DELAY_UL_MS * 1e-3);
 
-    Debug("Setting TTI=%d, tx_mutex=%d, tx_time=%ld:%f to worker %d\n",
+    Debug("Setting TTI=%d, tx_mutex=%d, tx_time=%ld:%f to worker %d",
           tti,
           tx_worker_cnt,
           timestamp.get(0).full_secs,

srsenb/src/stack/enb_stack_lte.cc

@@ -20,14 +20,23 @@ using namespace srslte;
 
 namespace srsenb {
 
-enb_stack_lte::enb_stack_lte(srslte::logger* logger_) :
+enb_stack_lte::enb_stack_lte(srslte::logger* logger_, srslog::sink& log_sink) :
-  task_sched(512, 0, 128),
-  logger(logger_),
-  pdcp(&task_sched, "PDCP"),
   thread("STACK"),
-  mac(&task_sched),
+  mac_logger(srslog::fetch_basic_logger("MAC", log_sink)),
-  s1ap(&task_sched),
+  rlc_logger(srslog::fetch_basic_logger("RLC", log_sink, false)),
-  rrc(&task_sched)
+  pdcp_logger(srslog::fetch_basic_logger("PDCP", log_sink, false)),
+  rrc_logger(srslog::fetch_basic_logger("RRC", log_sink, false)),
+  s1ap_logger(srslog::fetch_basic_logger("S1AP", log_sink, false)),
+  gtpu_logger(srslog::fetch_basic_logger("GTPU", log_sink, false)),
+  stack_logger(srslog::fetch_basic_logger("STCK", log_sink, false)),
+  task_sched(512, 0, 128),
+  pdcp(&task_sched, pdcp_logger),
+  mac(&task_sched, mac_logger),
+  rlc(rlc_logger),
+  gtpu(gtpu_logger),
+  s1ap(&task_sched, s1ap_logger),
+  rrc(&task_sched),
+  logger(logger_)
 {
   enb_task_queue  = task_sched.make_task_queue();
   mme_task_queue  = task_sched.make_task_queue();
@@ -66,21 +75,35 @@ int enb_stack_lte::init(const stack_args_t& args_, const rrc_cfg_t& rrc_cfg_)
   srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"MAC ", logger, true}});
   mac_log->set_level(args.log.mac_level);
   mac_log->set_hex_limit(args.log.mac_hex_limit);
+  mac_logger.set_level(srslog::str_to_basic_level(args.log.mac_level));
+  mac_logger.set_hex_dump_max_size(args.log.mac_hex_limit);
 
   // Init logs
   rlc_log->set_level(args.log.rlc_level);
+  rlc_logger.set_level(srslog::str_to_basic_level(args.log.rlc_level));
   pdcp_log->set_level(args.log.pdcp_level);
+  pdcp_logger.set_level(srslog::str_to_basic_level(args.log.pdcp_level));
   rrc_log->set_level(args.log.rrc_level);
+  rrc_logger.set_level(srslog::str_to_basic_level(args.log.rrc_level));
   gtpu_log->set_level(args.log.gtpu_level);
+  gtpu_logger.set_level(srslog::str_to_basic_level(args.log.gtpu_level));
   s1ap_log->set_level(args.log.s1ap_level);
+  s1ap_logger.set_level(srslog::str_to_basic_level(args.log.s1ap_level));
   stack_log->set_level(args.log.stack_level);
+  stack_logger.set_level(srslog::str_to_basic_level(args.log.stack_level));
 
   rlc_log->set_hex_limit(args.log.rlc_hex_limit);
+  rlc_logger.set_hex_dump_max_size(args.log.rlc_hex_limit);
   pdcp_log->set_hex_limit(args.log.pdcp_hex_limit);
+  pdcp_logger.set_hex_dump_max_size(args.log.pdcp_hex_limit);
   rrc_log->set_hex_limit(args.log.rrc_hex_limit);
+  rrc_logger.set_hex_dump_max_size(args.log.rrc_hex_limit);
   gtpu_log->set_hex_limit(args.log.gtpu_hex_limit);
+  gtpu_logger.set_hex_dump_max_size(args.log.gtpu_hex_limit);
   s1ap_log->set_hex_limit(args.log.s1ap_hex_limit);
+  s1ap_logger.set_hex_dump_max_size(args.log.s1ap_hex_limit);
   stack_log->set_hex_limit(args.log.stack_hex_limit);
+  stack_logger.set_hex_dump_max_size(args.log.stack_hex_limit);
 
   // Set up pcap and trace
   if (args.mac_pcap.enable) {
@@ -100,11 +123,11 @@ int enb_stack_lte::init(const stack_args_t& args_, const rrc_cfg_t& rrc_cfg_)
 
   // Init all layers
   mac.init(args.mac, rrc_cfg.cell_list, phy, &rlc, &rrc, mac_log);
-  rlc.init(&pdcp, &rrc, &mac, task_sched.get_timer_handler(), rlc_log);
+  rlc.init(&pdcp, &rrc, &mac, task_sched.get_timer_handler());
   pdcp.init(&rlc, &rrc, &gtpu);
   rrc.init(rrc_cfg, phy, &mac, &rlc, &pdcp, &s1ap, &gtpu);
   if (s1ap.init(args.s1ap, &rrc, this) != SRSLTE_SUCCESS) {
-    stack_log->error("Couldn't initialize S1AP\n");
+    stack_logger.error("Couldn't initialize S1AP");
     return SRSLTE_ERROR;
   }
   if (gtpu.init(args.s1ap.gtp_bind_addr,
@@ -114,7 +137,7 @@ int enb_stack_lte::init(const stack_args_t& args_, const rrc_cfg_t& rrc_cfg_)
                 &pdcp,
                 this,
                 args.embms.enable)) {
-    stack_log->error("Couldn't initialize GTPU\n");
+    stack_logger.error("Couldn't initialize GTPU");
     return SRSLTE_ERROR;
   }
 

srsenb/src/stack/mac/mac.cc

@@ -27,10 +27,8 @@ using namespace asn1::rrc;
 
 namespace srsenb {
 
-mac::mac(srslte::ext_task_sched_handle task_sched_) :
+mac::mac(srslte::ext_task_sched_handle task_sched_, srslog::basic_logger& logger) :
-  rar_payload(),
+  logger(logger), rar_payload(), common_buffers(SRSLTE_MAX_CARRIERS), task_sched(task_sched_)
-  common_buffers(SRSLTE_MAX_CARRIERS),
-  task_sched(task_sched_)
 {
   pthread_rwlock_init(&rwlock, nullptr);
 }
@@ -111,7 +109,7 @@ void mac::stop()
 // Implement Section 5.9
 void mac::reset()
 {
-  Info("Resetting MAC\n");
+  logger.info("Resetting MAC");
 
   last_rnti = 70;
 
@@ -149,7 +147,7 @@ int mac::rlc_buffer_state(uint16_t rnti, uint32_t lc_id, uint32_t tx_queue, uint
       ret = 0;
     }
   } else {
-    Error("User rnti=0x%x not found\n", rnti);
+    logger.error("User rnti=0x%x not found", rnti);
   }
   return ret;
 }
@@ -161,7 +159,7 @@ int mac::bearer_ue_cfg(uint16_t rnti, uint32_t lc_id, sched_interface::ue_bearer
   if (ue_db.count(rnti)) {
     ret = scheduler.bearer_ue_cfg(rnti, lc_id, *cfg);
   } else {
-    Error("User rnti=0x%x not found\n", rnti);
+    logger.error("User rnti=0x%x not found", rnti);
   }
   return ret;
 }
@@ -173,7 +171,7 @@ int mac::bearer_ue_rem(uint16_t rnti, uint32_t lc_id)
   if (ue_db.count(rnti)) {
     ret = scheduler.bearer_ue_rem(rnti, lc_id);
   } else {
-    Error("User rnti=0x%x not found\n", rnti);
+    logger.error("User rnti=0x%x not found", rnti);
   }
   return ret;
 }
@@ -191,7 +189,7 @@ int mac::ue_cfg(uint16_t rnti, sched_interface::ue_cfg_t* cfg)
   auto it     = ue_db.find(rnti);
   ue*  ue_ptr = nullptr;
   if (it == ue_db.end()) {
-    Error("User rnti=0x%x not found\n", rnti);
+    logger.error("User rnti=0x%x not found", rnti);
     return SRSLTE_ERROR;
   }
   ue_ptr = it->second.get();
@@ -201,18 +199,18 @@ int mac::ue_cfg(uint16_t rnti, sched_interface::ue_cfg_t* cfg)
 
   // Add RNTI to the PHY (pregenerate signals) now instead of after PRACH
   if (not ue_ptr->is_phy_added) {
-    Info("Registering RNTI=0x%X to PHY...\n", rnti);
+    logger.info("Registering RNTI=0x%X to PHY...", rnti);
     // Register new user in PHY with first CC index
     if (phy_h->pregen_sequences(rnti) == SRSLTE_ERROR) {
-      Error("Generating sequences for UE RNTI=0x%X\n", rnti);
+      logger.error("Generating sequences for UE RNTI=0x%X", rnti);
     }
-    Info("Done registering RNTI=0x%X to PHY...\n", rnti);
+    logger.info("Done registering RNTI=0x%X to PHY...", rnti);
     ue_ptr->is_phy_added = true;
   }
 
   // Update Scheduler configuration
   if (cfg != nullptr and scheduler.ue_cfg(rnti, *cfg) == SRSLTE_ERROR) {
-    Error("Registering new UE rnti=0x%x to SCHED\n", rnti);
+    logger.error("Registering new UE rnti=0x%x to SCHED", rnti);
     return SRSLTE_ERROR;
   }
   return SRSLTE_SUCCESS;
@@ -228,7 +226,7 @@ int mac::ue_rem(uint16_t rnti)
       ues_to_rem[rnti] = std::move(ue_db[rnti]);
       ue_db.erase(rnti);
     } else {
-      Error("User rnti=0x%x not found\n", rnti);
+      logger.error("User rnti=0x%x not found", rnti);
       return SRSLTE_ERROR;
     }
   }
@@ -239,7 +237,7 @@ int mac::ue_rem(uint16_t rnti)
   task_sched.defer_callback(FDD_HARQ_DELAY_DL_MS + FDD_HARQ_DELAY_UL_MS, [this, rnti]() {
     phy_h->rem_rnti(rnti);
     ues_to_rem.erase(rnti);
-    Info("User rnti=0x%x removed from MAC/PHY\n", rnti);
+    logger.info("User rnti=0x%x removed from MAC/PHY", rnti);
   });
   return SRSLTE_SUCCESS;
 }
@@ -288,6 +286,7 @@ void mac::get_metrics(mac_metrics_t& metrics)
 
 int mac::ack_info(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t tb_idx, bool ack)
 {
+  logger.set_context(tti_rx);
   log_h->step(tti_rx);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -301,7 +300,7 @@ int mac::ack_info(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t
   if (ack) {
     if (nof_bytes > 64) { // do not count RLC status messages only
       rrc_h->set_activity_user(rnti);
-      log_h->info("DL activity rnti=0x%x, n_bytes=%d\n", rnti, nof_bytes);
+      logger.info("DL activity rnti=0x%x, n_bytes=%d", rnti, nof_bytes);
     }
   }
   return SRSLTE_SUCCESS;
@@ -309,6 +308,7 @@ int mac::ack_info(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t
 
 int mac::crc_info(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t nof_bytes, bool crc)
 {
+  logger.set_context(tti_rx);
   log_h->step(tti_rx);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -333,18 +333,18 @@ int mac::push_pdu(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t
 
   std::array<int, SRSLTE_MAX_CARRIERS> enb_ue_cc_map = scheduler.get_enb_ue_cc_map(rnti);
   if (enb_ue_cc_map[enb_cc_idx] < 0) {
-    Error("User rnti=0x%x is not activated for carrier %d\n", rnti, enb_cc_idx);
+    logger.error("User rnti=0x%x is not activated for carrier %d", rnti, enb_cc_idx);
     return SRSLTE_ERROR;
   }
   uint32_t ue_cc_idx = enb_ue_cc_map[enb_cc_idx];
 
   // push the pdu through the queue if received correctly
   if (crc) {
-    Info("Pushing PDU rnti=0x%x, tti_rx=%d, nof_bytes=%d\n", rnti, tti_rx, nof_bytes);
+    logger.info("Pushing PDU rnti=0x%x, tti_rx=%d, nof_bytes=%d", rnti, tti_rx, nof_bytes);
     ue_db[rnti]->push_pdu(tti_rx, ue_cc_idx, nof_bytes);
     stack_task_queue.push([this]() { process_pdus(); });
   } else {
-    Debug("Discarting PDU rnti=0x%x, tti_rx=%d, nof_bytes=%d\n", rnti, tti_rx, nof_bytes);
+    logger.debug("Discarting PDU rnti=0x%x, tti_rx=%d, nof_bytes=%d", rnti, tti_rx, nof_bytes);
     ue_db[rnti]->deallocate_pdu(tti_rx, ue_cc_idx);
   }
   return SRSLTE_SUCCESS;
@@ -352,6 +352,7 @@ int mac::push_pdu(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, uint32_t
 
 int mac::ri_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t ri_value)
 {
+  logger.set_context(tti);
   log_h->step(tti);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -367,6 +368,7 @@ int mac::ri_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t ri_v
 
 int mac::pmi_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t pmi_value)
 {
+  logger.set_context(tti);
   log_h->step(tti);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -382,6 +384,7 @@ int mac::pmi_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t pmi
 
 int mac::cqi_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t cqi_value)
 {
+  logger.set_context(tti);
   log_h->step(tti);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -397,6 +400,7 @@ int mac::cqi_info(uint32_t tti, uint16_t rnti, uint32_t enb_cc_idx, uint32_t cqi
 
 int mac::snr_info(uint32_t tti_rx, uint16_t rnti, uint32_t enb_cc_idx, float snr, ul_channel_t ch)
 {
+  logger.set_context(tti_rx);
   log_h->step(tti_rx);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -424,6 +428,7 @@ int mac::ta_info(uint32_t tti, uint16_t rnti, float ta_us)
 
 int mac::sr_detected(uint32_t tti, uint16_t rnti)
 {
+  logger.set_context(tti);
   log_h->step(tti);
   srslte::rwlock_read_guard lock(rwlock);
 
@@ -452,14 +457,14 @@ uint16_t mac::allocate_ue()
   {
     srslte::rwlock_read_guard lock(rwlock);
     if (ue_db.size() >= args.max_nof_ues) {
-      Warning("Maximum number of connected UEs %d reached. Ignoring PRACH\n", args.max_nof_ues);
+      logger.warning("Maximum number of connected UEs %d reached. Ignoring PRACH", args.max_nof_ues);
       return SRSLTE_INVALID_RNTI;
     }
   }
 
   // Get pre-allocated UE object
   if (ue_pool.empty()) {
-    Error("Ignoring RACH attempt. UE pool empty.\n");
+    logger.error("Ignoring RACH attempt. UE pool empty.");
     return SRSLTE_INVALID_RNTI;
   }
   std::unique_ptr<ue> ue_ptr = ue_pool.wait_pop();
@@ -492,7 +497,7 @@ uint16_t mac::reserve_new_crnti(const sched_interface::ue_cfg_t& ue_cfg)
 
   // Add new user to the scheduler so that it can RX/TX SRB0
   if (scheduler.ue_cfg(rnti, ue_cfg) != SRSLTE_SUCCESS) {
-    Error("Registering new user rnti=0x%x to SCHED\n", rnti);
+    logger.error("Registering new user rnti=0x%x to SCHED", rnti);
     return SRSLTE_INVALID_RNTI;
   }
 
@@ -502,6 +507,7 @@ uint16_t mac::reserve_new_crnti(const sched_interface::ue_cfg_t& ue_cfg)
 void mac::rach_detected(uint32_t tti, uint32_t enb_cc_idx, uint32_t preamble_idx, uint32_t time_adv)
 {
   static srslte::mutexed_tprof<srslte::avg_time_stats> rach_tprof("rach_tprof", "MAC", 1);
+  logger.set_context(tti);
   log_h->step(tti);
   auto rach_tprof_meas = rach_tprof.start();
 
@@ -531,7 +537,7 @@ void mac::rach_detected(uint32_t tti, uint32_t enb_cc_idx, uint32_t preamble_idx
     ue_cfg.ue_bearers[0].direction             = srsenb::sched_interface::ue_bearer_cfg_t::BOTH;
     ue_cfg.supported_cc_list[0].dl_cfg.tm      = SRSLTE_TM1;
     if (scheduler.ue_cfg(rnti, ue_cfg) != SRSLTE_SUCCESS) {
-      Error("Registering new user rnti=0x%x to SCHED\n", rnti);
+      logger.error("Registering new user rnti=0x%x to SCHED", rnti);
       ue_rem(rnti);
       return;
     }
@@ -545,12 +551,8 @@ void mac::rach_detected(uint32_t tti, uint32_t enb_cc_idx, uint32_t preamble_idx
     // Trigger scheduler RACH
     scheduler.dl_rach_info(enb_cc_idx, rar_info);
 
-    log_h->info("RACH:  tti=%d, cc=%d, preamble=%d, offset=%d, temp_crnti=0x%x\n",
+    logger.info(
-                tti,
+        "RACH:  tti=%d, cc=%d, preamble=%d, offset=%d, temp_crnti=0x%x", tti, enb_cc_idx, preamble_idx, time_adv, rnti);
-                enb_cc_idx,
-                preamble_idx,
-                time_adv,
-                rnti);
     srslte::console("RACH:  tti=%d, cc=%d, preamble=%d, offset=%d, temp_crnti=0x%x\n",
                     tti,
                     enb_cc_idx,
@@ -567,7 +569,7 @@ void mac::prealloc_ue(uint32_t nof_ue)
 {
   for (uint32_t i = 0; i < nof_ue; i++) {
     std::unique_ptr<ue> ptr = std::unique_ptr<ue>(
-        new ue(allocate_rnti(), args.nof_prb, &scheduler, rrc_h, rlc_h, phy_h, log_h, cells.size()));
+        new ue(allocate_rnti(), args.nof_prb, &scheduler, rrc_h, rlc_h, phy_h, log_h, logger, cells.size()));
     ue_pool.push(std::move(ptr));
   }
 }
@@ -578,13 +580,14 @@ int mac::get_dl_sched(uint32_t tti_tx_dl, dl_sched_list_t& dl_sched_res_list)
     return 0;
   }
 
+  logger.set_context(TTI_SUB(tti_tx_dl, FDD_HARQ_DELAY_UL_MS));
   log_h->step(TTI_SUB(tti_tx_dl, FDD_HARQ_DELAY_UL_MS));
 
   for (uint32_t enb_cc_idx = 0; enb_cc_idx < cell_config.size(); enb_cc_idx++) {
     // Run scheduler with current info
     sched_interface::dl_sched_res_t sched_result = {};
     if (scheduler.dl_sched(tti_tx_dl, enb_cc_idx, sched_result) < 0) {
-      Error("Running scheduler\n");
+      logger.error("Running scheduler");
       return SRSLTE_ERROR;
     }
 
@@ -624,7 +627,7 @@ int mac::get_dl_sched(uint32_t tti_tx_dl, dl_sched_list_t& dl_sched_res_list)
                                                                           sched_result.data[i].tbs[tb]);
 
               if (!dl_sched_res->pdsch[n].data[tb]) {
-                Error("Error! PDU was not generated (rnti=0x%04x, tb=%d)\n", rnti, tb);
+                logger.error("Error! PDU was not generated (rnti=0x%04x, tb=%d)", rnti, tb);
               }
 
               if (pcap) {
@@ -644,7 +647,7 @@ int mac::get_dl_sched(uint32_t tti_tx_dl, dl_sched_list_t& dl_sched_res_list)
             n++;
           }
         } else {
-          Warning("Invalid DL scheduling result. User 0x%x does not exist\n", rnti);
+          logger.warning("Invalid DL scheduling result. User 0x%x does not exist", rnti);
         }
       }
 
@@ -760,6 +763,7 @@ void mac::build_mch_sched(uint32_t tbs)
 int mac::get_mch_sched(uint32_t tti, bool is_mcch, dl_sched_list_t& dl_sched_res_list)
 {
   dl_sched_t* dl_sched_res = &dl_sched_res_list[0];
+  logger.set_context(tti);
   log_h->step(tti);
   srslte_ra_tb_t mcs      = {};
   srslte_ra_tb_t mcs_data = {};
@@ -771,10 +775,10 @@ int mac::get_mch_sched(uint32_t tti, bool is_mcch, dl_sched_list_t& dl_sched_res
     build_mch_sched(mcs_data.tbs);
     mch.mcch_payload              = mcch_payload_buffer;
     mch.current_sf_allocation_num = 1;
-    Info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d \n",
+    logger.info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d ",
-         mch.mtch_sched[0].lcid,
+                mch.mtch_sched[0].lcid,
-         mch.mtch_sched[mch.num_mtch_sched - 1].stop,
+                mch.mtch_sched[mch.num_mtch_sched - 1].stop,
-         tti);
+                tti);
     phy_h->set_mch_period_stop(mch.mtch_sched[mch.num_mtch_sched - 1].stop);
     for (uint32_t i = 0; i < mch.num_mtch_sched; i++) {
       mch.pdu[i].lcid = (uint32_t)srslte::mch_lcid::MCH_SCHED_INFO;
@@ -856,11 +860,11 @@ uint8_t* mac::assemble_rar(sched_interface::dl_sched_rar_grant_t* grants,
     }
   }
 
-  Error("Assembling RAR: rar_idx=%d, pdu_len=%d, rar_payload_len=%d, nof_grants=%d\n",
+  logger.error("Assembling RAR: rar_idx=%d, pdu_len=%d, rar_payload_len=%d, nof_grants=%d",
-        rar_idx,
+               rar_idx,
-        pdu_len,
+               pdu_len,
-        rar_payload_len,
+               int(rar_payload_len),
-        nof_grants);
+               nof_grants);
   return nullptr;
 }
 
@@ -870,6 +874,7 @@ int mac::get_ul_sched(uint32_t tti_tx_ul, ul_sched_list_t& ul_sched_res_list)
     return SRSLTE_SUCCESS;
   }
 
+  logger.set_context(TTI_SUB(tti_tx_ul, FDD_HARQ_DELAY_UL_MS + FDD_HARQ_DELAY_DL_MS));
   log_h->step(TTI_SUB(tti_tx_ul, FDD_HARQ_DELAY_UL_MS + FDD_HARQ_DELAY_DL_MS));
 
   // Execute UE FSMs (e.g. TA)
@@ -883,7 +888,7 @@ int mac::get_ul_sched(uint32_t tti_tx_ul, ul_sched_list_t& ul_sched_res_list)
     // Run scheduler with current info
     sched_interface::ul_sched_res_t sched_result = {};
     if (scheduler.ul_sched(tti_tx_ul, enb_cc_idx, sched_result) < 0) {
-      Error("Running scheduler\n");
+      logger.error("Running scheduler");
       return SRSLTE_ERROR;
     }
 
@@ -920,15 +925,15 @@ int mac::get_ul_sched(uint32_t tti_tx_ul, ul_sched_list_t& ul_sched_res_list)
             if (phy_ul_sched_res->pusch[n].data) {
               phy_ul_sched_res->nof_grants++;
             } else {
-              Error("Grant for rnti=0x%x could not be allocated due to lack of buffers\n", rnti);
+              logger.error("Grant for rnti=0x%x could not be allocated due to lack of buffers", rnti);
             }
             n++;
           } else {
-            Warning("Invalid UL scheduling result. User 0x%x does not exist\n", rnti);
+            logger.warning("Invalid UL scheduling result. User 0x%x does not exist", rnti);
           }
 
         } else {
-          Warning("Grant %d for rnti=0x%x has zero TBS\n", i, sched_result.pusch[i].dci.rnti);
+          logger.warning("Grant %d for rnti=0x%x has zero TBS", i, sched_result.pusch[i].dci.rnti);
         }
       }
 
@@ -974,8 +979,8 @@ void mac::write_mcch(const srslte::sib2_mbms_t* sib2_,
   sib13 = *sib13_;
   memcpy(mcch_payload_buffer, mcch_payload, mcch_payload_length * sizeof(uint8_t));
   current_mcch_length = mcch_payload_length;
-  ue_db[SRSLTE_MRNTI] =
+  ue_db[SRSLTE_MRNTI] = std::unique_ptr<ue>{
-      std::unique_ptr<ue>{new ue(SRSLTE_MRNTI, args.nof_prb, &scheduler, rrc_h, rlc_h, phy_h, log_h, cells.size())};
+      new ue(SRSLTE_MRNTI, args.nof_prb, &scheduler, rrc_h, rlc_h, phy_h, log_h, logger, cells.size())};
 
   rrc_h->add_user(SRSLTE_MRNTI, {});
 }
@@ -984,7 +989,7 @@ bool mac::check_ue_exists(uint16_t rnti)
 {
   if (not ue_db.count(rnti)) {
     if (not ues_to_rem.count(rnti)) {
-      Error("User rnti=0x%x not found\n", rnti);
+      logger.error("User rnti=0x%x not found", rnti);
     }
     return false;
   }

srsenb/src/stack/mac/sched.cc

@@ -17,10 +17,11 @@
 #include "srsenb/hdr/stack/mac/sched_carrier.h"
 #include "srsenb/hdr/stack/mac/sched_helpers.h"
 #include "srslte/common/logmap.h"
+#include "srslte/srslog/srslog.h"
 #include "srslte/srslte.h"
 
 #define Console(fmt, ...) srslte::console(fmt, ##__VA_ARGS__)
-#define Error(fmt, ...) srslte::logmap::get("MAC ")->error(fmt, ##__VA_ARGS__)
+#define Error(fmt, ...) srslog::fetch_basic_logger("MAC").error(fmt, ##__VA_ARGS__)
 
 using srslte::tti_point;
 
@@ -32,7 +33,7 @@ namespace srsenb {
  *
  *******************************************************/
 
-sched::sched() : log_h(srslte::logmap::get("MAC")) {}
+sched::sched() {}
 
 sched::~sched() {}
 
@@ -120,7 +121,7 @@ int sched::ue_rem(uint16_t rnti)
   if (ue_db.count(rnti) > 0) {
     ue_db.erase(rnti);
   } else {
-    Error("User rnti=0x%x not found\n", rnti);
+    Error("User rnti=0x%x not found", rnti);
     return SRSLTE_ERROR;
   }
   return SRSLTE_SUCCESS;
@@ -365,9 +366,9 @@ int sched::ue_db_access(uint16_t rnti, Func f, const char* func_name)
     f(it->second);
   } else {
     if (func_name != nullptr) {
-      Error("User rnti=0x%x not found. Failed to call %s.\n", rnti, func_name);
+      Error("User rnti=0x%x not found. Failed to call %s.", rnti, func_name);
     } else {
-      Error("User rnti=0x%x not found.\n", rnti);
+      Error("User rnti=0x%x not found.", rnti);
     }
     return SRSLTE_ERROR;
   }

srsenb/src/stack/mac/sched_carrier.cc

@@ -130,7 +130,7 @@ void bc_sched::reset()
  *******************************************************/
 
 ra_sched::ra_sched(const sched_cell_params_t& cfg_, std::map<uint16_t, sched_ue>& ue_db_) :
-  cc_cfg(&cfg_), log_h(srslte::logmap::get("MAC")), ue_db(&ue_db_)
+  cc_cfg(&cfg_), logger(srslog::fetch_basic_logger("MAC")), ue_db(&ue_db_)
 {}
 
 // Schedules RAR
@@ -152,13 +152,13 @@ void ra_sched::dl_sched(sf_sched* tti_sched)
         char error_msg[128];
         int  len       = snprintf(error_msg,
                            sizeof(error_msg),
-                           "SCHED: Could not transmit RAR within the window (RA=%d, Window=%s, RAR=%d)\n",
+                           "SCHED: Could not transmit RAR within the window (RA=%d, Window=%s, RAR=%d)",
                            rar.prach_tti.to_uint(),
                            rar_window.to_string().c_str(),
                            tti_tx_dl.to_uint());
         error_msg[len] = '\0';
-        srslte::console("%s", error_msg);
+        srslte::console("%s\n", error_msg);
-        log_h->error("%s", error_msg);
+        logger.error("%s", error_msg);
         // Remove from pending queue and get next one if window has passed already
         pending_rars.pop_front();
         continue;
@@ -192,7 +192,7 @@ void ra_sched::dl_sched(sf_sched* tti_sched)
 
 int ra_sched::dl_rach_info(dl_sched_rar_info_t rar_info)
 {
-  log_h->info("SCHED: New PRACH tti=%d, preamble=%d, temp_crnti=0x%x, ta_cmd=%d, msg3_size=%d\n",
+  logger.info("SCHED: New PRACH tti=%d, preamble=%d, temp_crnti=0x%x, ta_cmd=%d, msg3_size=%d",
               rar_info.prach_tti,
               rar_info.preamble_idx,
               rar_info.temp_crnti,
@@ -207,7 +207,7 @@ int ra_sched::dl_rach_info(dl_sched_rar_info_t rar_info)
   for (sf_sched::pending_rar_t& r : pending_rars) {
     if (r.prach_tti.to_uint() == rar_info.prach_tti and ra_rnti == r.ra_rnti) {
       if (r.nof_grants >= sched_interface::MAX_RAR_LIST) {
-        log_h->warning("PRACH ignored, as the the maximum number of RAR grants per tti has been reached\n");
+        logger.warning("PRACH ignored, as the the maximum number of RAR grants per tti has been reached");
         return SRSLTE_ERROR;
       }
       r.msg3_grant[r.nof_grants] = rar_info;
@@ -238,11 +238,10 @@ void ra_sched::ul_sched(sf_sched* sf_dl_sched, sf_sched* sf_msg3_sched)
       uint16_t crnti   = msg3grant.data.temp_crnti;
       auto     user_it = ue_db->find(crnti);
       if (user_it != ue_db->end() and sf_msg3_sched->alloc_msg3(&user_it->second, msg3grant)) {
-        log_h->debug("SCHED: Queueing Msg3 for rnti=0x%x at tti=%d\n", crnti, sf_msg3_sched->get_tti_tx_ul().to_uint());
+        logger.debug("SCHED: Queueing Msg3 for rnti=0x%x at tti=%d", crnti, sf_msg3_sched->get_tti_tx_ul().to_uint());
       } else {
-        log_h->error("SCHED: Failed to allocate Msg3 for rnti=0x%x at tti=%d\n",
+        logger.error(
-                     crnti,
+            "SCHED: Failed to allocate Msg3 for rnti=0x%x at tti=%d", crnti, sf_msg3_sched->get_tti_tx_ul().to_uint());
-                     sf_msg3_sched->get_tti_tx_ul().to_uint());
       }
     }
   }
@@ -263,7 +262,7 @@ sched::carrier_sched::carrier_sched(rrc_interface_mac*            rrc_,
                                     sched_result_list*            sched_results_) :
   rrc(rrc_),
   ue_db(ue_db_),
-  log_h(srslte::logmap::get("MAC ")),
+  logger(srslog::fetch_basic_logger("MAC")),
   enb_cc_idx(enb_cc_idx_),
   prev_sched_results(sched_results_)
 {
@@ -290,10 +289,10 @@ void sched::carrier_sched::carrier_cfg(const sched_cell_params_t& cell_params_)
   // Setup data scheduling algorithms
   if (cell_params_.sched_cfg->sched_policy == "time_rr") {
     sched_algo.reset(new sched_time_rr{*cc_cfg, *cell_params_.sched_cfg});
-    log_h->info("Using time-domain RR scheduling policy for cc=%d\n", cc_cfg->enb_cc_idx);
+    logger.info("Using time-domain RR scheduling policy for cc=%d", cc_cfg->enb_cc_idx);
   } else {
     sched_algo.reset(new sched_time_pf{*cc_cfg, *cell_params_.sched_cfg});
-    log_h->info("Using time-domain PF scheduling policy for cc=%d\n", cc_cfg->enb_cc_idx);
+    logger.info("Using time-domain PF scheduling policy for cc=%d", cc_cfg->enb_cc_idx);
   }
 
   // Initiate the tti_scheduler for each TTI
@@ -361,8 +360,8 @@ const cc_sched_result& sched::carrier_sched::generate_tti_result(tti_point tti_r
     user.second.finish_tti(tti_rx, enb_cc_idx);
   }
 
-  log_dl_cc_results(log_h, enb_cc_idx, cc_result->dl_sched_result);
+  log_dl_cc_results(logger, enb_cc_idx, cc_result->dl_sched_result);
-  log_phich_cc_results(log_h, enb_cc_idx, cc_result->ul_sched_result);
+  log_phich_cc_results(logger, enb_cc_idx, cc_result->ul_sched_result);
 
   return *cc_result;
 }

srsenb/src/stack/mac/sched_grid.cc

@@ -119,7 +119,6 @@ void pdcch_grid_t::alloc_tree_t::reset()
 void pdcch_grid_t::init(const sched_cell_params_t& cell_params_)
 {
   cc_cfg = &cell_params_;
-  log_h  = srslte::logmap::get("MAC ");
 
   // init alloc trees
   alloc_trees.reserve(cc_cfg->sched_cfg->max_nof_ctrl_symbols);
@@ -174,7 +173,7 @@ bool pdcch_grid_t::alloc_dci(alloc_type_t alloc_type, uint32_t aggr_idx, sched_u
   if (not success) {
     // DCI allocation failed. go back to original CFI
     if (get_cfi() != first_cfi and not set_cfi(first_cfi)) {
-      log_h->error("SCHED: Failed to return back to original PDCCH state\n");
+      logger.error("SCHED: Failed to return back to original PDCCH state");
     }
     return false;
   }
@@ -275,7 +274,7 @@ bool pdcch_grid_t::add_tree_node_leaves(alloc_tree_t&          tree,
 bool pdcch_grid_t::set_cfi(uint32_t cfi)
 {
   if (cfi < cc_cfg->sched_cfg->min_nof_ctrl_symbols or cfi > cc_cfg->sched_cfg->max_nof_ctrl_symbols) {
-    srslte::logmap::get("MAC")->error("Invalid CFI value. Defaulting to current CFI.\n");
+    logger.error("Invalid CFI value. Defaulting to current CFI.");
     return false;
   }
 
@@ -379,7 +378,6 @@ std::string pdcch_grid_t::result_to_string(bool verbose) const
 void sf_grid_t::init(const sched_cell_params_t& cell_params_)
 {
   cc_cfg    = &cell_params_;
-  log_h     = srslte::logmap::get("MAC ");
   nof_rbgs  = cc_cfg->nof_rbgs;
   si_n_rbg  = srslte::ceil_div(4, cc_cfg->P);
   rar_n_rbg = srslte::ceil_div(3, cc_cfg->P);
@@ -413,8 +411,8 @@ alloc_outcome_t sf_grid_t::alloc_dl(uint32_t aggr_idx, alloc_type_t alloc_type,
   // Allocate DCI in PDCCH
   if (not pdcch_alloc.alloc_dci(alloc_type, aggr_idx, user)) {
     if (user != nullptr) {
-      if (log_h->get_level() == srslte::LOG_LEVEL_DEBUG) {
+      if (logger.debug.enabled()) {
-        log_h->debug("No space in PDCCH for rnti=0x%x DL tx. Current PDCCH allocation: %s\n",
+        logger.debug("No space in PDCCH for rnti=0x%x DL tx. Current PDCCH allocation: %s",
                      user->get_rnti(),
                      pdcch_alloc.result_to_string(true).c_str());
       }
@@ -437,7 +435,7 @@ sf_grid_t::dl_ctrl_alloc_t sf_grid_t::alloc_dl_ctrl(uint32_t aggr_idx, alloc_typ
 
   if (alloc_type != alloc_type_t::DL_RAR and alloc_type != alloc_type_t::DL_BC and
       alloc_type != alloc_type_t::DL_PCCH) {
-    log_h->error("SCHED: DL control allocations must be RAR/BC/PDCCH\n");
+    logger.error("SCHED: DL control allocations must be RAR/BC/PDCCH");
     return {alloc_outcome_t::ERROR, range};
   }
   // Setup range starting from left
@@ -479,8 +477,8 @@ alloc_outcome_t sf_grid_t::alloc_ul_data(sched_ue* user, prb_interval alloc, boo
     uint32_t nof_bits = srslte_dci_format_sizeof(&cc_cfg->cfg.cell, nullptr, nullptr, SRSLTE_DCI_FORMAT0);
     uint32_t aggr_idx = user->get_aggr_level(cc_cfg->enb_cc_idx, nof_bits);
     if (not pdcch_alloc.alloc_dci(alloc_type_t::UL_DATA, aggr_idx, user)) {
-      if (log_h->get_level() == srslte::LOG_LEVEL_DEBUG) {
+      if (logger.debug.enabled()) {
-        log_h->debug("No space in PDCCH for rnti=0x%x UL tx. Current PDCCH allocation: %s\n",
+        logger.debug("No space in PDCCH for rnti=0x%x UL tx. Current PDCCH allocation: %s",
                      user->get_rnti(),
                      pdcch_alloc.result_to_string(true).c_str());
       }
@@ -503,7 +501,7 @@ bool sf_grid_t::reserve_ul_prbs(const prbmask_t& prbmask, bool strict)
 {
   bool ret = true;
   if (strict and (ul_mask & prbmask).any()) {
-    log_h->error("There was a collision in UL channel. current mask=0x%s, new alloc mask=0x%s\n",
+    logger.error("There was a collision in UL channel. current mask=0x%s, new alloc mask=0x%s",
                  ul_mask.to_hex().c_str(),
                  prbmask.to_hex().c_str());
     ret = false;
@@ -551,7 +549,7 @@ bool sf_grid_t::find_ul_alloc(uint32_t L, prb_interval* alloc) const
  *          TTI resource Scheduling Methods
  *******************************************************/
 
-sf_sched::sf_sched() : log_h(srslte::logmap::get("MAC")) {}
+sf_sched::sf_sched() : logger(srslog::fetch_basic_logger("MAC")) {}
 
 void sf_sched::init(const sched_cell_params_t& cell_params_)
 {
@@ -586,7 +584,7 @@ void sf_sched::new_tti(tti_point tti_rx_, sf_sched_result* cc_results_)
     prbmask_t prach_mask{cc_cfg->nof_prb()};
     prach_mask.fill(cc_cfg->cfg.prach_freq_offset, cc_cfg->cfg.prach_freq_offset + 6);
     reserve_ul_prbs(prach_mask, cc_cfg->nof_prb() != 6);
-    log_h->debug("SCHED: Allocated PRACH RBs for tti_tx_ul=%d. Mask: 0x%s\n",
+    logger.debug("SCHED: Allocated PRACH RBs for tti_tx_ul=%d. Mask: 0x%s",
                  to_tx_ul(tti_rx).to_uint(),
                  prach_mask.to_hex().c_str());
   }
@@ -653,11 +651,11 @@ alloc_outcome_t sf_sched::alloc_bc(uint32_t aggr_lvl, uint32_t sib_idx, uint32_t
   uint32_t    rv      = get_rvidx(sib_ntx);
   ctrl_code_t ret     = alloc_dl_ctrl(aggr_lvl, sib_len, SRSLTE_SIRNTI);
   if (not ret.first) {
-    Warning("SCHED: Could not allocate SIB=%d, L=%d, len=%d, cause=%s\n",
+    logger.warning("SCHED: Could not allocate SIB=%d, L=%d, len=%d, cause=%s",
-            sib_idx + 1,
+                   sib_idx + 1,
-            aggr_lvl,
+                   aggr_lvl,
-            sib_len,
+                   sib_len,
-            ret.first.to_string());
+                   ret.first.to_string());
     return ret.first;
   }
 
@@ -673,13 +671,13 @@ alloc_outcome_t sf_sched::alloc_bc(uint32_t aggr_lvl, uint32_t sib_idx, uint32_t
 alloc_outcome_t sf_sched::alloc_paging(uint32_t aggr_lvl, uint32_t paging_payload)
 {
   if (bc_allocs.size() >= sched_interface::MAX_BC_LIST) {
-    Warning("SCHED: Maximum number of Broadcast allocations reached\n");
+    logger.warning("SCHED: Maximum number of Broadcast allocations reached");
     return alloc_outcome_t::ERROR;
   }
   ctrl_code_t ret = alloc_dl_ctrl(aggr_lvl, paging_payload, SRSLTE_PRNTI);
   if (not ret.first) {
-    Warning(
+    logger.warning(
-        "SCHED: Could not allocate Paging with payload length=%d, cause=%s\n", paging_payload, ret.first.to_string());
+        "SCHED: Could not allocate Paging with payload length=%d, cause=%s", paging_payload, ret.first.to_string());
     return ret.first;
   }
 
@@ -695,7 +693,7 @@ std::pair<alloc_outcome_t, uint32_t> sf_sched::alloc_rar(uint32_t aggr_lvl, cons
   const uint32_t                       msg3_grant_size = 3;
   std::pair<alloc_outcome_t, uint32_t> ret             = {alloc_outcome_t::ERROR, 0};
   if (rar_allocs.size() >= sched_interface::MAX_RAR_LIST) {
-    Warning("SCHED: Maximum number of RAR allocations per TTI reached.\n");
+    logger.warning("SCHED: Maximum number of RAR allocations per TTI reached.");
     return ret;
   }
 
@@ -720,7 +718,7 @@ std::pair<alloc_outcome_t, uint32_t> sf_sched::alloc_rar(uint32_t aggr_lvl, cons
     }
     // if any other error, return
     if (ret.first != alloc_outcome_t::SUCCESS) {
-      log_h->warning("SCHED: Could not allocate RAR for L=%d, cause=%s\n", aggr_lvl, ret.first.to_string());
+      logger.warning("SCHED: Could not allocate RAR for L=%d, cause=%s", aggr_lvl, ret.first.to_string());
       return ret;
     }
 
@@ -741,7 +739,7 @@ std::pair<alloc_outcome_t, uint32_t> sf_sched::alloc_rar(uint32_t aggr_lvl, cons
     break;
   }
   if (ret.first != alloc_outcome_t::SUCCESS) {
-    log_h->info("SCHED: Failed to allocate RAR due to lack of RBs\n");
+    logger.info("SCHED: Failed to allocate RAR due to lack of RBs");
   }
   return ret;
 }
@@ -761,12 +759,12 @@ bool is_periodic_cqi_expected(const sched_interface::ue_cfg_t& ue_cfg, tti_point
 alloc_outcome_t sf_sched::alloc_dl_user(sched_ue* user, const rbgmask_t& user_mask, uint32_t pid)
 {
   if (data_allocs.size() >= sched_interface::MAX_DATA_LIST) {
-    Warning("SCHED: Maximum number of DL allocations reached\n");
+    logger.warning("SCHED: Maximum number of DL allocations reached");
     return alloc_outcome_t::ERROR;
   }
 
   if (is_dl_alloc(user->get_rnti())) {
-    Warning("SCHED: Attempt to assign multiple harq pids to the same user rnti=0x%x\n", user->get_rnti());
+    logger.warning("SCHED: Attempt to assign multiple harq pids to the same user rnti=0x%x", user->get_rnti());
     return alloc_outcome_t::ALREADY_ALLOC;
   }
 
@@ -784,7 +782,7 @@ alloc_outcome_t sf_sched::alloc_dl_user(sched_ue* user, const rbgmask_t& user_ma
     // It is newTx
     rbg_interval r = user->get_required_dl_rbgs(cc_cfg->enb_cc_idx);
     if (r.start() > user_mask.count()) {
-      log_h->warning("The number of RBGs allocated to rnti=0x%x will force segmentation\n", user->get_rnti());
+      logger.warning("The number of RBGs allocated to rnti=0x%x will force segmentation", user->get_rnti());
       return alloc_outcome_t::NOF_RB_INVALID;
     }
   }
@@ -829,13 +827,13 @@ alloc_outcome_t sf_sched::alloc_dl_user(sched_ue* user, const rbgmask_t& user_ma
 alloc_outcome_t sf_sched::alloc_ul(sched_ue* user, prb_interval alloc, ul_alloc_t::type_t alloc_type, int msg3_mcs)
 {
   if (ul_data_allocs.size() >= sched_interface::MAX_DATA_LIST) {
-    Warning("SCHED: Maximum number of UL allocations reached\n");
+    logger.warning("SCHED: Maximum number of UL allocations reached");
     return alloc_outcome_t::ERROR;
   }
 
   // Check whether user was already allocated
   if (is_ul_alloc(user->get_rnti())) {
-    log_h->warning("SCHED: Attempt to assign multiple ul_harq_proc to the same user rnti=0x%x\n", user->get_rnti());
+    logger.warning("SCHED: Attempt to assign multiple ul_harq_proc to the same user rnti=0x%x", user->get_rnti());
     return alloc_outcome_t::ALREADY_ALLOC;
   }
 
@@ -884,7 +882,7 @@ alloc_outcome_t sf_sched::alloc_ul_user(sched_ue* user, prb_interval alloc)
 bool sf_sched::alloc_phich(sched_ue* user, sched_interface::ul_sched_res_t* ul_sf_result)
 {
   if (ul_sf_result->nof_phich_elems >= sched_interface::MAX_PHICH_LIST) {
-    Warning("SCHED: Maximum number of PHICH allocations has been reached\n");
+    logger.warning("SCHED: Maximum number of PHICH allocations has been reached");
     return false;
   }
   using phich_t    = sched_interface::ul_sched_phich_t;
@@ -924,7 +922,7 @@ void sf_sched::set_bc_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
     // Setup BC/Paging processes
     if (bc_alloc.alloc_type == alloc_type_t::DL_BC) {
       if (tbs <= (int)bc_alloc.req_bytes) {
-        log_h->warning("SCHED: Error SIB%d, rbgs=(%d,%d), dci=(%d,%d), len=%d\n",
+        logger.warning("SCHED: Error SIB%d, rbgs=(%d,%d), dci=(%d,%d), len=%d",
                        bc_alloc.sib_idx + 1,
                        bc_alloc.rbg_range.start(),
                        bc_alloc.rbg_range.stop(),
@@ -939,7 +937,7 @@ void sf_sched::set_bc_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
       bc->type  = sched_interface::dl_sched_bc_t::BCCH;
       bc->tbs   = (uint32_t)bc_alloc.req_bytes;
 
-      log_h->debug("SCHED: SIB%d, rbgs=(%d,%d), dci=(%d,%d), rv=%d, len=%d, period=%d, mcs=%d\n",
+      logger.debug("SCHED: SIB%d, rbgs=(%d,%d), dci=(%d,%d), rv=%d, len=%d, period=%d, mcs=%d",
                    bc_alloc.sib_idx + 1,
                    bc_alloc.rbg_range.start(),
                    bc_alloc.rbg_range.stop(),
@@ -952,7 +950,7 @@ void sf_sched::set_bc_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
     } else {
       // Paging
       if (tbs <= 0) {
-        log_h->warning("SCHED: Error Paging, rbgs=%s, dci=(%d,%d)\n",
+        logger.warning("SCHED: Error Paging, rbgs=%s, dci=(%d,%d)",
                        bc_alloc.rbg_range.to_string().c_str(),
                        bc->dci.location.L,
                        bc->dci.location.ncce);
@@ -963,7 +961,7 @@ void sf_sched::set_bc_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
       bc->type = sched_interface::dl_sched_bc_t::PCCH;
       bc->tbs  = (uint32_t)tbs;
 
-      log_h->info("SCHED: PCH, rbgs=%s, dci=(%d,%d), tbs=%d, mcs=%d\n",
+      logger.info("SCHED: PCH, rbgs=%s, dci=(%d,%d), tbs=%d, mcs=%d",
                   bc_alloc.rbg_range.to_string().c_str(),
                   bc->dci.location.L,
                   bc->dci.location.ncce,
@@ -988,7 +986,7 @@ void sf_sched::set_rar_sched_result(const pdcch_grid_t::alloc_result_t& dci_resu
     prb_interval prb_range = prb_interval::rbgs_to_prbs(rar_alloc.alloc_data.rbg_range, cc_cfg->nof_prb());
     int tbs = generate_format1a(prb_range, rar_alloc.alloc_data.req_bytes, 0, rar_alloc.alloc_data.rnti, &rar->dci);
     if (tbs <= 0) {
-      log_h->warning("SCHED: Error RAR, ra_rnti_idx=%d, rbgs=%s, dci=(%d,%d)\n",
+      logger.warning("SCHED: Error RAR, ra_rnti_idx=%d, rbgs=%s, dci=(%d,%d)",
                      rar_alloc.alloc_data.rnti,
                      rar_alloc.alloc_data.rbg_range.to_string().c_str(),
                      rar->dci.location.L,
@@ -1004,8 +1002,8 @@ void sf_sched::set_rar_sched_result(const pdcch_grid_t::alloc_result_t& dci_resu
     for (uint32_t i = 0; i < rar->msg3_grant.size(); ++i) {
       const auto& msg3_grant    = rar->msg3_grant[i];
       uint16_t    expected_rnti = msg3_grant.data.temp_crnti;
-      log_h->info("SCHED: RAR, temp_crnti=0x%x, ra-rnti=%d, rbgs=%s, dci=(%d,%d), rar_grant_rba=%d, "
+      logger.info("SCHED: RAR, temp_crnti=0x%x, ra-rnti=%d, rbgs=%s, dci=(%d,%d), rar_grant_rba=%d, "
-                  "rar_grant_mcs=%d\n",
+                  "rar_grant_mcs=%d",
                   expected_rnti,
                   rar_alloc.alloc_data.rnti,
                   rar_alloc.alloc_data.rbg_range.to_string().c_str(),
@@ -1043,7 +1041,7 @@ void sf_sched::set_dl_data_sched_result(const pdcch_grid_t::alloc_result_t& dci_
         data_alloc.pid, data, get_tti_tx_dl(), cc_cfg->enb_cc_idx, tti_alloc.get_cfi(), data_alloc.user_mask);
 
     if (tbs <= 0) {
-      log_h->warning("SCHED: DL %s failed rnti=0x%x, pid=%d, mask=%s, tbs=%d, buffer=%d\n",
+      logger.warning("SCHED: DL %s failed rnti=0x%x, pid=%d, mask=%s, tbs=%d, buffer=%d",
                      is_newtx ? "tx" : "retx",
                      user->get_rnti(),
                      data_alloc.pid,
@@ -1054,7 +1052,7 @@ void sf_sched::set_dl_data_sched_result(const pdcch_grid_t::alloc_result_t& dci_
     }
 
     // Print Resulting DL Allocation
-    log_h->info("SCHED: DL %s rnti=0x%x, cc=%d, pid=%d, mask=0x%s, dci=(%d,%d), n_rtx=%d, tbs=%d, buffer=%d/%d\n",
+    logger.info("SCHED: DL %s rnti=0x%x, cc=%d, pid=%d, mask=0x%s, dci=(%d,%d), n_rtx=%d, tbs=%d, buffer=%d/%d",
                 !is_newtx ? "retx" : "tx",
                 user->get_rnti(),
                 cc_cfg->enb_cc_idx,
@@ -1194,7 +1192,7 @@ void sf_sched::set_ul_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
     uint32_t      new_pending_bytes = user->get_pending_ul_new_data(get_tti_tx_ul(), cc_cfg->enb_cc_idx);
     // Allow TBS=0 in case of UCI-only PUSCH
     if (tbs < 0 || (tbs == 0 && pusch->dci.tb.mcs_idx != 29)) {
-      log_h->warning("SCHED: Error %s %s rnti=0x%x, pid=%d, dci=(%d,%d), prb=%s, bsr=%d\n",
+      logger.warning("SCHED: Error %s %s rnti=0x%x, pid=%d, dci=(%d,%d), prb=%s, bsr=%d",
                      ul_alloc.type == ul_alloc_t::MSG3 ? "Msg3" : "UL",
                      ul_alloc.is_retx() ? "retx" : "tx",
                      user->get_rnti(),
@@ -1208,7 +1206,7 @@ void sf_sched::set_ul_sched_result(const pdcch_grid_t::alloc_result_t& dci_resul
 
     // Print Resulting UL Allocation
     uint32_t old_pending_bytes = user->get_pending_ul_old_data();
-    log_h->info("SCHED: %s %s rnti=0x%x, cc=%d, pid=%d, dci=(%d,%d), prb=%s, n_rtx=%d, tbs=%d, bsr=%d (%d-%d)\n",
+    logger.info("SCHED: %s %s rnti=0x%x, cc=%d, pid=%d, dci=(%d,%d), prb=%s, n_rtx=%d, tbs=%d, bsr=%d (%d-%d)",
                 ul_alloc.is_msg3() ? "Msg3" : "UL",
                 ul_alloc.is_retx() ? "retx" : "tx",
                 user->get_rnti(),
@@ -1236,7 +1234,7 @@ alloc_outcome_t sf_sched::alloc_msg3(sched_ue* user, const sched_interface::dl_s
 
   alloc_outcome_t ret = alloc_ul(user, msg3_alloc, sf_sched::ul_alloc_t::MSG3, rargrant.grant.trunc_mcs);
   if (not ret) {
-    log_h->warning("SCHED: Could not allocate msg3 within %s\n", msg3_alloc.to_string().c_str());
+    logger.warning("SCHED: Could not allocate msg3 within %s", msg3_alloc.to_string().c_str());
   }
   return ret;
 }
@@ -1256,7 +1254,7 @@ void sf_sched::generate_sched_results(sched_ue_list& ue_db)
       if (not is_ul_alloc(ue.get_rnti()) and h != nullptr and not h->is_empty()) {
         // There was a missed UL harq retx. Halt+Resume the HARQ
         phich.phich = phich_t::ACK;
-        log_h->debug("SCHED: rnti=0x%x UL harq pid=%d is being resumed\n", ue.get_rnti(), h->get_id());
+        logger.debug("SCHED: rnti=0x%x UL harq pid=%d is being resumed", ue.get_rnti(), h->get_id());
       }
     }
   }
@@ -1314,16 +1312,16 @@ int sf_sched::generate_format1a(prb_interval     prb_range,
     }
   }
   if (i == 28) {
-    Error("Can't allocate Format 1A for TBS=%d\n", tbs);
+    logger.error("Can't allocate Format 1A for TBS=%d", tbs);
     return -1;
   }
 
-  Debug("ra_tbs=%d/%d, tbs_bytes=%d, tbs=%d, mcs=%d\n",
+  logger.debug("ra_tbs=%d/%d, tbs_bytes=%d, tbs=%d, mcs=%d",
-        srslte_ra_tbs_from_idx(mcs, 2),
+               srslte_ra_tbs_from_idx(mcs, 2),
-        srslte_ra_tbs_from_idx(mcs, 3),
+               srslte_ra_tbs_from_idx(mcs, 3),
-        tbs_bytes,
+               tbs_bytes,
-        tbs,
+               tbs,
-        mcs);
+               mcs);
 
   dci->alloc_type       = SRSLTE_RA_ALLOC_TYPE2;
   dci->type2_alloc.mode = srslte_ra_type2_t::SRSLTE_RA_TYPE2_LOC;

srsenb/src/stack/mac/sched_helpers.cc

@@ -15,10 +15,10 @@
 #include "srslte/srslog/bundled/fmt/format.h"
 #include <array>
 
-#define Debug(fmt, ...) srslte::logmap::get("MAC")->debug(fmt, ##__VA_ARGS__)
+#define Debug(fmt, ...) srslog::fetch_basic_logger("MAC").debug(fmt, ##__VA_ARGS__)
-#define Info(fmt, ...) srslte::logmap::get("MAC")->info(fmt, ##__VA_ARGS__)
+#define Info(fmt, ...) srslog::fetch_basic_logger("MAC").info(fmt, ##__VA_ARGS__)
-#define Warning(fmt, ...) srslte::logmap::get("MAC")->warning(fmt, ##__VA_ARGS__)
+#define Warning(fmt, ...) srslog::fetch_basic_logger("MAC").warning(fmt, ##__VA_ARGS__)
-#define Error(fmt, ...) srslte::logmap::get("MAC")->error(fmt, ##__VA_ARGS__)
+#define Error(fmt, ...) srslog::fetch_basic_logger("MAC").error(fmt, ##__VA_ARGS__)
 
 namespace srsenb {
 
@@ -98,36 +98,38 @@ void fill_dl_cc_result_debug(custom_mem_buffer& strbuf, const dl_sched_data_t& d
       }
     }
   }
-  fmt::format_to(strbuf, "]\n");
+  fmt::format_to(strbuf, "]");
 }
 
-void log_dl_cc_results(srslte::log_ref log_h, uint32_t enb_cc_idx, const sched_interface::dl_sched_res_t& result)
+void log_dl_cc_results(srslog::basic_logger& logger, uint32_t enb_cc_idx, const sched_interface::dl_sched_res_t& result)
 {
-  if (log_h->get_level() < srslte::LOG_LEVEL_INFO) {
+  if (!logger.info.enabled()) {
     return;
   }
   custom_mem_buffer strbuf;
   for (uint32_t i = 0; i < result.nof_data_elems; ++i) {
     const dl_sched_data_t& data = result.data[i];
-    if (log_h->get_level() == srslte::LOG_LEVEL_INFO) {
+    if (logger.info.enabled()) {
       fill_dl_cc_result_info(strbuf, data);
-    } else if (log_h->get_level() == srslte::LOG_LEVEL_DEBUG) {
+    } else if (logger.debug.enabled()) {
       fill_dl_cc_result_debug(strbuf, data);
     }
   }
   if (strbuf.size() != 0) {
-    if (log_h->get_level() == srslte::LOG_LEVEL_DEBUG) {
+    if (logger.debug.enabled()) {
-      log_h->debug("SCHED: DL MAC PDU payload cc=%d:\n%s", enb_cc_idx, fmt::to_string(strbuf).c_str());
+      logger.debug("SCHED: DL MAC PDU payload cc=%d:\n%s", enb_cc_idx, fmt::to_string(strbuf).c_str());
     } else {
-      log_h->info("SCHED: DL MAC CEs cc=%d: %s", enb_cc_idx, fmt::to_string(strbuf).c_str());
+      logger.info("SCHED: DL MAC CEs cc=%d: %s", enb_cc_idx, fmt::to_string(strbuf).c_str());
     }
   }
 }
 
-void log_phich_cc_results(srslte::log_ref log_h, uint32_t enb_cc_idx, const sched_interface::ul_sched_res_t& result)
+void log_phich_cc_results(srslog::basic_logger&                  logger,
+                          uint32_t                               enb_cc_idx,
+                          const sched_interface::ul_sched_res_t& result)
 {
   using phich_t = sched_interface::ul_sched_phich_t;
-  if (log_h->get_level() < srslte::LOG_LEVEL_INFO) {
+  if (!logger.info.enabled()) {
     return;
   }
   custom_mem_buffer strbuf;
@@ -138,7 +140,7 @@ void log_phich_cc_results(srslte::log_ref log_h, uint32_t enb_cc_idx, const sche
     fmt::format_to(strbuf, "{}rnti=0x{:0x}, val={}", prefix, phich.rnti, val);
   }
   if (strbuf.size() != 0) {
-    log_h->debug("SCHED: Allocated PHICHs, cc=%d: [%s]", enb_cc_idx, fmt::to_string(strbuf).c_str());
+    logger.debug("SCHED: Allocated PHICHs, cc=%d: [%s]", enb_cc_idx, fmt::to_string(strbuf).c_str());
   }
 }
 
@@ -250,7 +252,7 @@ bool sched_cell_params_t::set_cfg(uint32_t                             enb_cc_id
 
   // Basic cell config checks
   if (cfg.si_window_ms == 0) {
-    Error("SCHED: Invalid si-window length 0 ms\n");
+    Error("SCHED: Invalid si-window length 0 ms");
     return false;
   }
 
@@ -270,7 +272,7 @@ bool sched_cell_params_t::set_cfg(uint32_t                             enb_cc_id
                     ((int)cfg.prach_freq_offset < cfg.nrb_pucch);
   }
   if (invalid_prach) {
-    Error("Invalid PRACH configuration: frequency offset=%d outside bandwidth limits\n", cfg.prach_freq_offset);
+    Error("Invalid PRACH configuration: frequency offset=%d outside bandwidth limits", cfg.prach_freq_offset);
     srslte::console("Invalid PRACH configuration: frequency offset=%d outside bandwidth limits\n",
                     cfg.prach_freq_offset);
     return false;
@@ -281,7 +283,7 @@ bool sched_cell_params_t::set_cfg(uint32_t                             enb_cc_id
   // init regs
   regs.reset(new srslte_regs_t{});
   if (srslte_regs_init(regs.get(), cfg.cell) != SRSLTE_SUCCESS) {
-    Error("Getting DCI locations\n");
+    Error("Getting DCI locations");
     return false;
   }
 
@@ -290,7 +292,7 @@ bool sched_cell_params_t::set_cfg(uint32_t                             enb_cc_id
     generate_cce_location(regs.get(), &common_locations[cfix], cfix + 1);
   }
   if (common_locations[sched_cfg->max_nof_ctrl_symbols - 1].nof_loc[2] == 0) {
-    Error("SCHED: Current cfi=%d is not valid for broadcast (check scheduler.max_nof_ctrl_symbols in conf file).\n",
+    Error("SCHED: Current cfi=%d is not valid for broadcast (check scheduler.max_nof_ctrl_symbols in conf file).",
           sched_cfg->max_nof_ctrl_symbols);
     srslte::console(
         "SCHED: Current cfi=%d is not valid for broadcast (check scheduler.max_nof_ctrl_symbols in conf file).\n",
@@ -309,7 +311,7 @@ bool sched_cell_params_t::set_cfg(uint32_t                             enb_cc_id
   for (uint32_t cfix = 0; cfix < nof_cce_table.size(); ++cfix) {
     int ret = srslte_regs_pdcch_ncce(regs.get(), cfix + 1);
     if (ret < 0) {
-      Error("SCHED: Failed to calculate the number of CCEs in the PDCCH\n");
+      Error("SCHED: Failed to calculate the number of CCEs in the PDCCH");
       return false;
     }
     nof_cce_table[cfix] = (uint32_t)ret;
@@ -404,8 +406,6 @@ void generate_cce_location(srslte_regs_t*   regs_,
 uint32_t
 get_aggr_level(uint32_t nof_bits, uint32_t dl_cqi, uint32_t max_aggr_lvl, uint32_t cell_nof_prb, bool use_tbs_index_alt)
 {
-  static srslte::log_ref cached_log = srslte::logmap::get("MAC");
-
   uint32_t l            = 0;
   float    max_coderate = srslte_cqi_to_coderate(dl_cqi, use_tbs_index_alt);
   float    coderate;
@@ -422,12 +422,12 @@ get_aggr_level(uint32_t nof_bits, uint32_t dl_cqi, uint32_t max_aggr_lvl, uint32
     l++;
   } while (l < l_max && factor * coderate > max_coderate);
 
-  cached_log->debug("SCHED: CQI=%d, l=%d, nof_bits=%d, coderate=%.2f, max_coderate=%.2f\n",
+  Debug("SCHED: CQI=%d, l=%d, nof_bits=%d, coderate=%.2f, max_coderate=%.2f",
-                    dl_cqi,
+        dl_cqi,
-                    l,
+        l,
-                    nof_bits,
+        nof_bits,
-                    coderate,
+        coderate,
-                    max_coderate);
+        max_coderate);
   return l;
 }
 
@@ -451,14 +451,13 @@ int check_ue_cfg_correctness(const sched_interface::ue_cfg_t& ue_cfg)
         continue;
       }
       if (not cc1.dl_cfg.cqi_report.periodic_configured and not cc1.dl_cfg.cqi_report.aperiodic_configured) {
-        Warning("SCHED: No CQI configuration was provided for UE scell index=%d \n", i);
+        Warning("SCHED: No CQI configuration was provided for UE scell index=%d", i);
         ret = SRSLTE_ERROR;
       } else if (cc1.dl_cfg.cqi_report.periodic_configured) {
         for (uint32_t j = i + 1; j < cc_list.size(); ++j) {
           if (cc_list[j].active and cc_list[j].dl_cfg.cqi_report.periodic_configured and
               cc_list[j].dl_cfg.cqi_report.pmi_idx == cc1.dl_cfg.cqi_report.pmi_idx) {
-            Warning(
+            Warning("SCHED: The provided CQI configurations for UE scells %d and %d collide in time resources.", i, j);
-                "SCHED: The provided CQI configurations for UE scells %d and %d collide in time resources.\n", i, j);
             ret = SRSLTE_ERROR;
           }
         }

srsenb/src/stack/mac/sched_ue.cc

@@ -35,7 +35,7 @@ namespace srsenb {
  *
  *******************************************************/
 
-sched_ue::sched_ue() : log_h(srslte::logmap::get("MAC")) {}
+sched_ue::sched_ue() : logger(srslog::fetch_basic_logger("MAC")) {}
 
 void sched_ue::init(uint16_t rnti_, const std::vector<sched_cell_params_t>& cell_list_params_)
 {
@@ -44,7 +44,7 @@ void sched_ue::init(uint16_t rnti_, const std::vector<sched_cell_params_t>& cell
   for (auto& c : cell_list_params_) {
     cells.emplace_back(rnti_, c, current_tti);
   }
-  Info("SCHED: Added user rnti=0x%x\n", rnti);
+  logger.info("SCHED: Added user rnti=0x%x", rnti);
 }
 
 void sched_ue::set_cfg(const ue_cfg_t& cfg_)
@@ -55,7 +55,7 @@ void sched_ue::set_cfg(const ue_cfg_t& cfg_)
     if (not cfg_.supported_cc_list.empty()) {
       primary_cc_idx = cfg_.supported_cc_list[0].enb_cc_idx;
     } else {
-      Warning("Primary cc idx not provided in scheduler ue_cfg. Defaulting to cc_idx=0\n");
+      logger.warning("Primary cc idx not provided in scheduler ue_cfg. Defaulting to cc_idx=0");
     }
     // setup primary cc
     main_cc_params = cells[primary_cc_idx].cell_cfg;
@@ -78,11 +78,11 @@ void sched_ue::set_cfg(const ue_cfg_t& cfg_)
         c.is_scell() and (c.cc_state() == cc_st::activating or c.cc_state() == cc_st::deactivating);
   }
   if (prev_supported_cc_list.empty() or prev_supported_cc_list[0].enb_cc_idx != cfg.supported_cc_list[0].enb_cc_idx) {
-    log_h->info("SCHED: rnti=0x%x PCell is now enb_cc_idx=%d.\n", rnti, cfg.supported_cc_list[0].enb_cc_idx);
+    logger.info("SCHED: rnti=0x%x PCell is now enb_cc_idx=%d", rnti, cfg.supported_cc_list[0].enb_cc_idx);
   }
   if (scell_activation_state_changed) {
     lch_handler.pending_ces.emplace_back(srslte::dl_sch_lcid::SCELL_ACTIVATION);
-    log_h->info("SCHED: Enqueueing SCell Activation CMD for rnti=0x%x\n", rnti);
+    logger.info("SCHED: Enqueueing SCell Activation CMD for rnti=0x%x", rnti);
   }
 
   check_ue_cfg_correctness(cfg);
@@ -163,7 +163,7 @@ void sched_ue::mac_buffer_state(uint32_t ce_code, uint32_t nof_cmds)
       lch_handler.pending_ces.push_back(cmd);
     }
   }
-  Info("SCHED: %s for rnti=0x%x needs to be scheduled\n", to_string(cmd), rnti);
+  logger.info("SCHED: %s for rnti=0x%x needs to be scheduled", to_string(cmd), rnti);
 }
 
 void sched_ue::set_sr()
@@ -255,13 +255,13 @@ int sched_ue::set_ack_info(tti_point tti_rx, uint32_t enb_cc_idx, uint32_t tb_id
     std::pair<uint32_t, int> p2 = cells[enb_cc_idx].harq_ent.set_ack_info(tti_rx, tb_idx, ack);
     tbs_acked                   = p2.second;
     if (tbs_acked > 0) {
-      Debug(
+      logger.debug(
-          "SCHED: Set DL ACK=%d for rnti=0x%x, pid=%d, tb=%d, tti=%d\n", ack, rnti, p2.first, tb_idx, tti_rx.to_uint());
+          "SCHED: Set DL ACK=%d for rnti=0x%x, pid=%d, tb=%d, tti=%d", ack, rnti, p2.first, tb_idx, tti_rx.to_uint());
     } else {
-      Warning("SCHED: Received ACK info for unknown TTI=%d\n", tti_rx.to_uint());
+      logger.warning("SCHED: Received ACK info for unknown TTI=%d", tti_rx.to_uint());
     }
   } else {
-    log_h->warning("Received DL ACK for invalid cell index %d\n", enb_cc_idx);
+    logger.warning("Received DL ACK for invalid cell index %d", enb_cc_idx);
   }
   return tbs_acked;
 }
@@ -271,10 +271,10 @@ void sched_ue::set_ul_crc(tti_point tti_rx, uint32_t enb_cc_idx, bool crc_res)
   if (cells[enb_cc_idx].cc_state() != cc_st::idle) {
     int ret = cells[enb_cc_idx].harq_ent.set_ul_crc(tti_rx, 0, crc_res);
     if (ret < 0) {
-      log_h->warning("Received UL CRC for invalid tti_rx=%d\n", (int)tti_rx.to_uint());
+      logger.warning("Received UL CRC for invalid tti_rx=%d", (int)tti_rx.to_uint());
     }
   } else {
-    log_h->warning("Received UL CRC for invalid cell index %d\n", enb_cc_idx);
+    logger.warning("Received UL CRC for invalid cell index %d", enb_cc_idx);
   }
 }
 
@@ -284,7 +284,7 @@ void sched_ue::set_dl_ri(tti_point tti_rx, uint32_t enb_cc_idx, uint32_t ri)
     cells[enb_cc_idx].dl_ri        = ri;
     cells[enb_cc_idx].dl_ri_tti_rx = tti_rx;
   } else {
-    log_h->warning("Received DL RI for invalid cell index %d\n", enb_cc_idx);
+    logger.warning("Received DL RI for invalid cell index %d", enb_cc_idx);
   }
 }
 
@@ -294,7 +294,7 @@ void sched_ue::set_dl_pmi(tti_point tti_rx, uint32_t enb_cc_idx, uint32_t pmi)
     cells[enb_cc_idx].dl_pmi        = pmi;
     cells[enb_cc_idx].dl_pmi_tti_rx = tti_rx;
   } else {
-    log_h->warning("Received DL PMI for invalid cell index %d\n", enb_cc_idx);
+    logger.warning("Received DL PMI for invalid cell index %d", enb_cc_idx);
   }
 }
 
@@ -303,7 +303,7 @@ void sched_ue::set_dl_cqi(tti_point tti_rx, uint32_t enb_cc_idx, uint32_t cqi)
   if (cells[enb_cc_idx].cc_state() != cc_st::idle) {
     cells[enb_cc_idx].set_dl_cqi(tti_rx, cqi);
   } else {
-    log_h->warning("Received DL CQI for invalid enb cell index %d\n", enb_cc_idx);
+    logger.warning("Received DL CQI for invalid enb cell index %d", enb_cc_idx);
   }
 }
 
@@ -314,7 +314,7 @@ void sched_ue::set_ul_snr(tti_point tti_rx, uint32_t enb_cc_idx, float snr, uint
     cells[enb_cc_idx].ul_cqi        = srslte_cqi_from_snr(snr);
     cells[enb_cc_idx].ul_cqi_tti_rx = tti_rx;
   } else {
-    log_h->warning("Received SNR info for invalid cell index %d\n", enb_cc_idx);
+    logger.warning("Received SNR info for invalid cell index %d", enb_cc_idx);
   }
 }
 
@@ -356,13 +356,13 @@ tbs_info sched_ue::allocate_new_dl_mac_pdu(sched::dl_sched_data_t* data,
     //       emptied by another allocated tb_idx.
     uint32_t pending_bytes = lch_handler.get_dl_tx_total();
     if (pending_bytes > 0) {
-      Warning("SCHED: Failed to allocate DL TB with tb_idx=%d, tbs=%d, pid=%d. Pending DL buffer data=%d\n",
+      logger.warning("SCHED: Failed to allocate DL TB with tb_idx=%d, tbs=%d, pid=%d. Pending DL buffer data=%d",
-              tb,
+                     tb,
-              rem_tbs,
+                     rem_tbs,
-              h->get_id(),
+                     h->get_id(),
-              pending_bytes);
+                     pending_bytes);
     } else {
-      Info("SCHED: DL TB tb_idx=%d, tbs=%d, pid=%d did not get allocated.\n", tb, rem_tbs, h->get_id());
+      logger.info("SCHED: DL TB tb_idx=%d, tbs=%d, pid=%d did not get allocated.", tb, rem_tbs, h->get_id());
     }
     tb_info.tbs_bytes = 0;
     tb_info.mcs       = 0;
@@ -392,7 +392,7 @@ int sched_ue::generate_dl_dci_format(uint32_t                          pid,
       tbs = generate_format2a(pid, data, tti_tx_dl, enb_cc_idx, cfi, user_mask);
       break;
     default:
-      Error("DCI format (%d) not implemented\n", dci_format);
+      logger.error("DCI format (%d) not implemented", dci_format);
   }
   return tbs;
 }
@@ -422,7 +422,7 @@ int sched_ue::generate_format1(uint32_t                          pid,
     dci->format           = SRSLTE_DCI_FORMAT1A;
     if (L_crb != count_prb_per_tb(user_mask)) {
       // This happens if Type0 was using distributed allocation
-      Warning("SCHED: Can't use distributed RA due to DCI size ambiguity\n");
+      logger.warning("SCHED: Can't use distributed RA due to DCI size ambiguity");
     }
   } else {
     dci->alloc_type              = SRSLTE_RA_ALLOC_TYPE0;
@@ -435,7 +435,7 @@ int sched_ue::generate_format1(uint32_t                          pid,
     tbinfo = allocate_new_dl_mac_pdu(data, h, user_mask, tti_tx_dl, enb_cc_idx, cfi, 0);
   } else {
     h->new_retx(user_mask, 0, tti_tx_dl, &tbinfo.mcs, &tbinfo.tbs_bytes, data->dci.location.ncce);
-    Debug("SCHED: Alloc format1 previous mcs=%d, tbs=%d\n", tbinfo.mcs, tbinfo.tbs_bytes);
+    logger.debug("SCHED: Alloc format1 previous mcs=%d, tbs=%d", tbinfo.mcs, tbinfo.tbs_bytes);
   }
 
   if (tbinfo.tbs_bytes > 0) {
@@ -478,7 +478,7 @@ tbs_info sched_ue::compute_mcs_and_tbs(uint32_t               enb_cc_idx,
   tbs_info tb = alloc_tbs_dl(cells[enb_cc_idx], nof_alloc_prbs, nof_re, req_bytes.stop());
 
   if (tb.tbs_bytes > 0 and tb.tbs_bytes < (int)req_bytes.start()) {
-    log_h->info("SCHED: Could not get PRB allocation that avoids MAC CE or RLC SRB0 PDU segmentation\n");
+    logger.info("SCHED: Could not get PRB allocation that avoids MAC CE or RLC SRB0 PDU segmentation");
     // Note: This is not a warning, because the srb0 buffer can be updated after the ue sched decision
   }
 
@@ -689,9 +689,9 @@ int sched_ue::generate_format0(sched_interface::ul_sched_data_t* data,
         dci->tb.mcs_idx = tbinfo.mcs;
       }
     } else if (tbinfo.tbs_bytes == 0) {
-      log_h->warning("SCHED: No space for ULSCH while allocating format0. Discarding grant.\n");
+      logger.warning("SCHED: No space for ULSCH while allocating format0. Discarding grant.");
     } else {
-      log_h->error("SCHED: Unkown error while allocating format0\n");
+      logger.error("SCHED: Unkown error while allocating format0");
     }
   }
 
@@ -722,7 +722,7 @@ bool sched_ue::needs_cqi(uint32_t tti, uint32_t enb_cc_idx, bool will_send)
         if (will_send) {
           cqi_request_tti = tti;
         }
-        Debug("SCHED: Needs_cqi, last_sent=%d, will_be_sent=%d\n", cqi_request_tti, will_send);
+        logger.debug("SCHED: Needs_cqi, last_sent=%d, will_be_sent=%d", cqi_request_tti, will_send);
         ret = true;
       }
     }
@@ -746,8 +746,8 @@ rbg_interval sched_ue::get_required_dl_rbgs(uint32_t enb_cc_idx)
   int pending_prbs = get_required_prb_dl(cells[enb_cc_idx], to_tx_dl(current_tti), req_bytes.start());
   if (pending_prbs < 0) {
     // Cannot fit allocation in given PRBs
-    log_h->error("SCHED: DL CQI=%d does now allow fitting %d non-segmentable DL tx bytes into the cell bandwidth. "
+    logger.error("SCHED: DL CQI=%d does now allow fitting %d non-segmentable DL tx bytes into the cell bandwidth. "
-                 "Consider increasing initial CQI value.\n",
+                 "Consider increasing initial CQI value.",
                  cells[enb_cc_idx].dl_cqi,
                  req_bytes.start());
     return {cellparams->nof_prb(), cellparams->nof_prb()};
@@ -782,7 +782,7 @@ srslte::interval<uint32_t> sched_ue::get_requested_dl_bytes(uint32_t enb_cc_idx)
   // Ensure there is space for ConRes and RRC Setup
   // SRB0 is a special case due to being RLC TM (no segmentation possible)
   if (not lch_handler.is_bearer_dl(0)) {
-    log_h->error("SRB0 must always be activated for DL\n");
+    logger.error("SRB0 must always be activated for DL");
     return {};
   }
   if (cells[enb_cc_idx].cc_state() != cc_st::active) {
@@ -936,10 +936,10 @@ uint32_t sched_ue::get_pending_ul_new_data(tti_point tti_tx_ul, int this_enb_cc_
   pending_data             = (pending_data > pending_ul_data) ? pending_data - pending_ul_data : 0;
 
   if (pending_data > 0) {
-    Debug("SCHED: pending_data=%d, in_harq_data=%d, bsr=%s\n",
+    logger.debug("SCHED: pending_data=%d, in_harq_data=%d, bsr=%s",
-          pending_data,
+                 pending_data,
-          pending_ul_data,
+                 pending_ul_data,
-          lch_handler.get_bsr_text().c_str());
+                 lch_handler.get_bsr_text().c_str());
   }
   return pending_data;
 }
@@ -1026,7 +1026,8 @@ srslte_dci_format_t sched_ue::get_dci_format()
       case sched_interface::ant_info_ded_t::tx_mode_t::tm7:
       case sched_interface::ant_info_ded_t::tx_mode_t::tm8_v920:
       default:
-        Warning("Incorrect transmission mode (rnti=%04x; tm=%d)\n", rnti, static_cast<int>(cfg.dl_ant_info.tx_mode));
+        logger.warning(
+            "Incorrect transmission mode (rnti=%04x; tm=%d)", rnti, static_cast<int>(cfg.dl_ant_info.tx_mode));
     }
   }
 
@@ -1038,7 +1039,7 @@ const sched_dci_cce_t* sched_ue::get_locations(uint32_t enb_cc_idx, uint32_t cfi
   if (cfi > 0 && cfi <= 3) {
     return &cells[enb_cc_idx].dci_locations[cfi - 1][sf_idx];
   } else {
-    Error("SCHED: Invalid CFI=%d\n", cfi);
+    logger.error("SCHED: Invalid CFI=%d", cfi);
     return &cells[enb_cc_idx].dci_locations[0][sf_idx];
   }
 }

srsenb/src/stack/mac/sched_ue_ctrl/sched_harq.cc

@@ -30,8 +30,7 @@ namespace srsenb {
 
 void harq_proc::init(uint32_t id_)
 {
-  log_h = srslte::logmap::get("MAC ");
+  id = id_;
-  id    = id_;
 }
 
 void harq_proc::reset(uint32_t tb_idx)
@@ -78,17 +77,19 @@ tti_point harq_proc::get_tti() const
 int harq_proc::set_ack_common(uint32_t tb_idx, bool ack_)
 {
   if (is_empty(tb_idx)) {
-    log_h->warning("Received ACK for inactive harq\n");
+    srslog::fetch_basic_logger("MAC").warning("Received ACK for inactive harq");
     return SRSLTE_ERROR;
   }
   ack_state[tb_idx] = ack_;
-  log_h->debug("ACK=%d received pid=%d, tb_idx=%d, n_rtx=%d, max_retx=%d\n", ack_, id, tb_idx, n_rtx[tb_idx], max_retx);
+  srslog::fetch_basic_logger("MAC").debug(
+      "ACK=%d received pid=%d, tb_idx=%d, n_rtx=%d, max_retx=%d", ack_, id, tb_idx, n_rtx[tb_idx], max_retx);
   if (!ack_ && (n_rtx[tb_idx] + 1 >= max_retx)) {
-    Info("SCHED: discarding TB=%d pid=%d, tti=%d, maximum number of retx exceeded (%d)\n",
+    srslog::fetch_basic_logger("MAC").info(
-         tb_idx,
+        "SCHED: discarding TB=%d pid=%d, tti=%d, maximum number of retx exceeded (%d)",
-         id,
+        tb_idx,
-         tti.to_uint(),
+        id,
-         max_retx);
+        tti.to_uint(),
+        max_retx);
     active[tb_idx] = false;
   } else if (ack_) {
     active[tb_idx] = false;
@@ -294,8 +295,7 @@ uint32_t ul_harq_proc::get_pending_data() const
  *   Harq Entity
  *******************/
 
-harq_entity::harq_entity(size_t nof_dl_harqs, size_t nof_ul_harqs) :
+harq_entity::harq_entity(size_t nof_dl_harqs, size_t nof_ul_harqs) : dl_harqs(nof_dl_harqs), ul_harqs(nof_ul_harqs)
-  dl_harqs(nof_dl_harqs), ul_harqs(nof_ul_harqs), log_h(srslte::logmap::get("MAC "))
 {
   for (uint32_t i = 0; i < dl_harqs.size(); ++i) {
     dl_harqs[i].init(i);

srsenb/src/stack/mac/sched_ue_ctrl/sched_lch.cc

@@ -76,11 +76,11 @@ void lch_ue_manager::new_tti()
 void lch_ue_manager::config_lcid(uint32_t lc_id, const sched_interface::ue_bearer_cfg_t& bearer_cfg)
 {
   if (lc_id >= sched_interface::MAX_LC) {
-    Warning("Adding bearer with invalid logical channel id=%d\n", lc_id);
+    logger.warning("Adding bearer with invalid logical channel id=%d", lc_id);
     return;
   }
   if (bearer_cfg.group >= sched_interface::MAX_LC_GROUP) {
-    Warning("Adding bearer with invalid logical channel group id=%d\n", bearer_cfg.group);
+    logger.warning("Adding bearer with invalid logical channel group id=%d", bearer_cfg.group);
     return;
   }
 
@@ -96,42 +96,42 @@ void lch_ue_manager::config_lcid(uint32_t lc_id, const sched_interface::ue_beare
       lch[lc_id].bucket_size = lch[lc_id].cfg.bsd * lch[lc_id].cfg.pbr;
       lch[lc_id].Bj          = 0;
     }
-    Info("SCHED: bearer configured: lc_id=%d, mode=%s, prio=%d\n",
+    logger.info("SCHED: bearer configured: lc_id=%d, mode=%s, prio=%d",
-         lc_id,
+                lc_id,
-         to_string(lch[lc_id].cfg.direction),
+                to_string(lch[lc_id].cfg.direction),
-         lch[lc_id].cfg.priority);
+                lch[lc_id].cfg.priority);
   }
 }
 
 void lch_ue_manager::ul_bsr(uint8_t lcg_id, uint32_t bsr)
 {
   if (lcg_id >= sched_interface::MAX_LC_GROUP) {
-    Warning("The provided logical channel group id=%d is not valid\n", lcg_id);
+    logger.warning("The provided logical channel group id=%d is not valid", lcg_id);
     return;
   }
   lcg_bsr[lcg_id] = bsr;
-  Debug("SCHED: bsr=%d, lcg_id=%d, bsr=%s\n", bsr, lcg_id, get_bsr_text().c_str());
+  logger.debug("SCHED: bsr=%d, lcg_id=%d, bsr=%s", bsr, lcg_id, get_bsr_text().c_str());
 }
 
 void lch_ue_manager::ul_buffer_add(uint8_t lcid, uint32_t bytes)
 {
   if (lcid >= sched_interface::MAX_LC) {
-    Warning("The provided lcid=%d is not valid\n", lcid);
+    logger.warning("The provided lcid=%d is not valid", lcid);
     return;
   }
   lcg_bsr[lch[lcid].cfg.group] += bytes;
-  Debug("SCHED: UL buffer update=%d, lcg_id=%d, bsr=%s\n", bytes, lch[lcid].cfg.group, get_bsr_text().c_str());
+  logger.debug("SCHED: UL buffer update=%d, lcg_id=%d, bsr=%s", bytes, lch[lcid].cfg.group, get_bsr_text().c_str());
 }
 
 void lch_ue_manager::dl_buffer_state(uint8_t lcid, uint32_t tx_queue, uint32_t retx_queue)
 {
   if (lcid >= sched_interface::MAX_LC) {
-    Warning("The provided lcid=%d is not valid\n", lcid);
+    logger.warning("The provided lcid=%d is not valid", lcid);
     return;
   }
   lch[lcid].buf_retx = retx_queue;
   lch[lcid].buf_tx   = tx_queue;
-  Debug("SCHED: DL lcid=%d buffer_state=%d,%d\n", lcid, tx_queue, retx_queue);
+  logger.debug("SCHED: DL lcid=%d buffer_state=%d,%d", lcid, tx_queue, retx_queue);
 }
 
 int lch_ue_manager::get_max_prio_lcid() const

srsenb/src/stack/mac/sched_ue_ctrl/sched_ue_cell.cc

@@ -21,6 +21,7 @@ namespace srsenb {
  *******************************************************/
 
 sched_ue_cell::sched_ue_cell(uint16_t rnti_, const sched_cell_params_t& cell_cfg_, tti_point current_tti_) :
+  logger(srslog::fetch_basic_logger("MAC")),
   rnti(rnti_),
   cell_cfg(&cell_cfg_),
   dci_locations(generate_cce_location_table(rnti_, cell_cfg_)),
@@ -77,7 +78,7 @@ void sched_ue_cell::set_ue_cfg(const sched_interface::ue_cfg_t& ue_cfg_)
       case cc_st::active:
         if (ue_cc_idx < 0 or not ue_cfg->supported_cc_list[ue_cc_idx].active) {
           cc_state_ = cc_st::deactivating;
-          log_h->info("SCHED: Deactivating rnti=0x%x, SCellIndex=%d...\n", rnti, ue_cc_idx);
+          logger.info("SCHED: Deactivating rnti=0x%x, SCellIndex=%d...", rnti, ue_cc_idx);
         }
         break;
       case cc_st::deactivating:
@@ -85,7 +86,7 @@ void sched_ue_cell::set_ue_cfg(const sched_interface::ue_cfg_t& ue_cfg_)
         if (ue_cc_idx > 0 and ue_cfg->supported_cc_list[ue_cc_idx].active) {
           cc_state_ = cc_st::activating;
           dl_cqi    = 0;
-          log_h->info("SCHED: Activating rnti=0x%x, SCellIndex=%d...\n", rnti, ue_cc_idx);
+          logger.info("SCHED: Activating rnti=0x%x, SCellIndex=%d...", rnti, ue_cc_idx);
         }
         break;
       default:
@@ -136,7 +137,7 @@ void sched_ue_cell::set_dl_cqi(tti_point tti_rx, uint32_t dl_cqi_)
   if (ue_cc_idx > 0 and cc_state_ == cc_st::activating and dl_cqi_rx) {
     // Wait for SCell to receive a positive CQI before activating it
     cc_state_ = cc_st::active;
-    log_h->info("SCHED: SCell index=%d is now active\n", ue_cc_idx);
+    logger.info("SCHED: SCell index=%d is now active", ue_cc_idx);
   }
 }
 
@@ -165,7 +166,7 @@ std::tuple<int, YType, int, YType>
 false_position_method(int x1, int x2, YType y0, const Callable& f, const ErrorDetect& is_error)
 {
   static_assert(std::is_same<YType, decltype(f(x1))>::value,
-                "The type of the final result and callable return do not match\n");
+                "The type of the final result and callable return do not match");
   YType y1 = f(x1);
   if (is_error(y1) or y1 >= y0) {
     return std::make_tuple(x1, y1, x1, y1);

srsenb/src/stack/mac/schedulers/sched_time_pf.cc

@@ -95,7 +95,7 @@ uint32_t sched_time_pf::try_dl_alloc(ue_ctxt& ue_ctxt, sched_ue& ue, sf_sched* t
     }
   }
   if (code == alloc_outcome_t::DCI_COLLISION) {
-    log_h->info("SCHED: Couldn't find space in PDCCH for DL tx for rnti=0x%x\n", ue.get_rnti());
+    logger.info("SCHED: Couldn't find space in PDCCH for DL tx for rnti=0x%x", ue.get_rnti());
   }
   return 0;
 }
@@ -152,7 +152,7 @@ uint32_t sched_time_pf::try_ul_alloc(ue_ctxt& ue_ctxt, sched_ue& ue, sf_sched* t
                           : 0;
   }
   if (code == alloc_outcome_t::DCI_COLLISION) {
-    log_h->info("SCHED: Couldn't find space in PDCCH for UL retx of rnti=0x%x\n", ue.get_rnti());
+    logger.info("SCHED: Couldn't find space in PDCCH for UL retx of rnti=0x%x", ue.get_rnti());
   }
   return estim_tbs_bytes;
 }

srsenb/src/stack/mac/schedulers/sched_time_rr.cc

@@ -52,7 +52,7 @@ void sched_time_rr::sched_dl_retxs(std::map<uint16_t, sched_ue>& ue_db, sf_sched
     }
     alloc_outcome_t code = try_dl_retx_alloc(*tti_sched, user, *h);
     if (code == alloc_outcome_t::DCI_COLLISION) {
-      log_h->info("SCHED: Couldn't find space in PDCCH for DL retx for rnti=0x%x\n", user.get_rnti());
+      logger.info("SCHED: Couldn't find space in PDCCH for DL retx for rnti=0x%x", user.get_rnti());
     }
   }
 }
@@ -81,7 +81,7 @@ void sched_time_rr::sched_dl_newtxs(std::map<uint16_t, sched_ue>& ue_db, sf_sche
       // empty RBGs were found
       alloc_outcome_t code = tti_sched->alloc_dl_user(&user, newtx_mask, h->get_id());
       if (code == alloc_outcome_t::DCI_COLLISION) {
-        log_h->info("SCHED: Couldn't find space in PDCCH for DL tx for rnti=0x%x\n", user.get_rnti());
+        logger.info("SCHED: Couldn't find space in PDCCH for DL tx for rnti=0x%x", user.get_rnti());
       }
     }
   }
@@ -118,7 +118,7 @@ void sched_time_rr::sched_ul_retxs(std::map<uint16_t, sched_ue>& ue_db, sf_sched
     }
     alloc_outcome_t code = try_ul_retx_alloc(*tti_sched, user, *h);
     if (code == alloc_outcome_t::DCI_COLLISION) {
-      log_h->info("SCHED: Couldn't find space in PDCCH for UL retx of rnti=0x%x\n", user.get_rnti());
+      logger.info("SCHED: Couldn't find space in PDCCH for UL retx of rnti=0x%x", user.get_rnti());
     }
   }
 }
@@ -149,7 +149,7 @@ void sched_time_rr::sched_ul_newtxs(std::map<uint16_t, sched_ue>& ue_db, sf_sche
     }
     alloc_outcome_t ret = tti_sched->alloc_ul_user(&user, alloc);
     if (ret == alloc_outcome_t::DCI_COLLISION) {
-      log_h->info("SCHED: Couldn't find space in PDCCH for UL tx of rnti=0x%x\n", user.get_rnti());
+      logger.info("SCHED: Couldn't find space in PDCCH for UL tx of rnti=0x%x", user.get_rnti());
     }
   }
 }

srsenb/src/stack/mac/ue.cc

@@ -28,6 +28,7 @@ ue::ue(uint16_t                 rnti_,
        rlc_interface_mac*       rlc_,
        phy_interface_stack_lte* phy_,
        srslte::log_ref          log_,
+       srslog::basic_logger&    logger,
        uint32_t                 nof_cells_,
        uint32_t                 nof_rx_harq_proc_,
        uint32_t                 nof_tx_harq_proc_) :
@@ -38,6 +39,7 @@ ue::ue(uint16_t                 rnti_,
   rlc(rlc_),
   phy(phy_),
   log_h(log_),
+  logger(logger),
   mac_msg_dl(20, log_),
   mch_mac_msg_dl(10, log_),
   mac_msg_ul(20, log_),
@@ -143,12 +145,12 @@ void ue::start_pcap(srslte::mac_pcap* pcap_)
 srslte_softbuffer_rx_t* ue::get_rx_softbuffer(const uint32_t ue_cc_idx, const uint32_t tti)
 {
   if ((size_t)ue_cc_idx >= softbuffer_rx.size()) {
-    ERROR("UE CC Index (%d/%zd) out-of-range\n", ue_cc_idx, softbuffer_rx.size());
+    ERROR("UE CC Index (%d/%zd) out-of-range", ue_cc_idx, softbuffer_rx.size());
     return nullptr;
   }
 
   if ((size_t)nof_rx_harq_proc > softbuffer_rx.at(ue_cc_idx).size()) {
-    ERROR("HARQ process index (%d/%zd) out-of-range\n", nof_rx_harq_proc, softbuffer_rx.at(ue_cc_idx).size());
+    ERROR("HARQ process index (%d/%zd) out-of-range", nof_rx_harq_proc, softbuffer_rx.at(ue_cc_idx).size());
     return nullptr;
   }
 
@@ -159,12 +161,12 @@ srslte_softbuffer_tx_t*
 ue::get_tx_softbuffer(const uint32_t ue_cc_idx, const uint32_t harq_process, const uint32_t tb_idx)
 {
   if ((size_t)ue_cc_idx >= softbuffer_tx.size()) {
-    ERROR("UE CC Index (%d/%zd) out-of-range\n", ue_cc_idx, softbuffer_tx.size());
+    ERROR("UE CC Index (%d/%zd) out-of-range", ue_cc_idx, softbuffer_tx.size());
     return nullptr;
   }
 
   if ((size_t)nof_tx_harq_proc > softbuffer_tx.at(ue_cc_idx).size()) {
-    ERROR("HARQ process index (%d/%zd) out-of-range\n", harq_process, softbuffer_tx.at(ue_cc_idx).size());
+    ERROR("HARQ process index (%d/%zd) out-of-range", harq_process, softbuffer_tx.at(ue_cc_idx).size());
     return nullptr;
   }
 
@@ -174,7 +176,7 @@ ue::get_tx_softbuffer(const uint32_t ue_cc_idx, const uint32_t harq_process, con
 uint8_t* ue::request_buffer(uint32_t tti, uint32_t ue_cc_idx, const uint32_t len)
 {
   std::unique_lock<std::mutex> lock(rx_buffers_mutex);
-  uint8_t* pdu = nullptr;
+  uint8_t*                     pdu = nullptr;
   if (len > 0) {
     // Deallocate oldest buffer if we didn't deallocate it
     if (!rx_used_buffers.at(ue_cc_idx).count(tti)) {
@@ -182,13 +184,13 @@ uint8_t* ue::request_buffer(uint32_t tti, uint32_t ue_cc_idx, const uint32_t len
       if (pdu) {
         rx_used_buffers.at(ue_cc_idx).emplace(tti, pdu);
       } else {
-        Error("UE buffers: Requesting buffer from pool\n");
+        logger.error("UE buffers: Requesting buffer from pool");
       }
     } else {
-      Error("UE buffers: buffer for tti=%d already allocated\n", tti);
+      logger.error("UE buffers: buffer for tti=%d already allocated", tti);
     }
   } else {
-    Error("UE buffers: Requesting buffer for zero bytes\n");
+    logger.error("UE buffers: Requesting buffer for zero bytes");
   }
   return pdu;
 }
@@ -201,11 +203,11 @@ void ue::clear_old_buffers(uint32_t tti)
   for (auto& rx_buffer_cc : rx_used_buffers) {
     for (auto it = rx_buffer_cc.begin(); it != rx_buffer_cc.end();) {
       if (srslte_tti_interval(tti, it->first) > 20 && srslte_tti_interval(tti, it->first) < 500) {
-        Warning("UE buffers: Removing old buffer tti=%d, rnti=%d, now is %d, interval=%d\n",
+        logger.warning("UE buffers: Removing old buffer tti=%d, rnti=%d, now is %d, interval=%d",
-                it->first,
+                       it->first,
-                rnti,
+                       rnti,
-                tti,
+                       tti,
-                srslte_tti_interval(tti, it->first));
+                       srslte_tti_interval(tti, it->first));
         pdus.deallocate(it->second);
         it = rx_buffer_cc.erase(it);
       } else {
@@ -236,7 +238,7 @@ uint32_t ue::set_ta(int ta_)
     uint32_t ta_cmd = (uint32_t)(ta_value + 31);
     pending_ta_commands.try_push(ta_cmd);
     nof_cmd++;
-    Info("Added TA CMD: rnti=0x%x, ta=%d, ta_value=%d, ta_cmd=%d\n", rnti, ta_, ta_value, ta_cmd);
+    logger.info("Added TA CMD: rnti=0x%x, ta=%d, ta_value=%d, ta_cmd=%d", rnti, ta_, ta_value, ta_cmd);
   } while (ta_value <= -31 || ta_value >= 32);
   return nof_cmd;
 }
@@ -249,7 +251,7 @@ void ue::process_pdu(uint8_t* pdu, uint32_t nof_bytes, srslte::pdu_queue::channe
   mac_msg_ul.init_rx(nof_bytes, true);
   mac_msg_ul.parse_packet(pdu);
 
-  Info("0x%x %s\n", rnti, mac_msg_ul.to_string().c_str());
+  logger.info("0x%x %s", rnti, mac_msg_ul.to_string().c_str());
 
   if (pcap) {
     pcap->write_ul_crnti(pdu, nof_bytes, rnti, true, last_tti, UL_CC_IDX);
@@ -275,7 +277,7 @@ void ue::process_pdu(uint8_t* pdu, uint32_t nof_bytes, srslte::pdu_queue::channe
         }
         if (sum == 0) {
           route_pdu = false;
-          Debug("Received all zero PDU\n");
+          logger.debug("Received all zero PDU");
         }
       }
 
@@ -292,7 +294,7 @@ void ue::process_pdu(uint8_t* pdu, uint32_t nof_bytes, srslte::pdu_queue::channe
       // Indicate RRC about successful activity if valid RLC message is received
       if (mac_msg_ul.get()->get_payload_size() > 64) { // do not count RLC status messages only
         rrc->set_activity_user(rnti);
-        log_h->debug("UL activity rnti=0x%x, n_bytes=%d\n", rnti, nof_bytes);
+        logger.debug("UL activity rnti=0x%x, n_bytes=%d", rnti, nof_bytes);
       }
 
       if ((int)mac_msg_ul.get()->get_payload_size() > most_data) {
@@ -310,7 +312,7 @@ void ue::process_pdu(uint8_t* pdu, uint32_t nof_bytes, srslte::pdu_queue::channe
             ue_cri_ptr[nbytes - i - 1] = pkt_ptr[i];
           }
         } else {
-          Error("Received CCCH UL message of invalid size=%d bytes\n", mac_msg_ul.get()->get_payload_size());
+          logger.error("Received CCCH UL message of invalid size=%d bytes", mac_msg_ul.get()->get_payload_size());
         }
       }
     }
@@ -331,10 +333,10 @@ void ue::process_pdu(uint8_t* pdu, uint32_t nof_bytes, srslte::pdu_queue::channe
   if (!bsr_received && lcid_most_data > 2) {
     // Add BSR to the LCID for which most data was received
     sched->ul_buffer_add(rnti, lcid_most_data, 256);
-    Debug("BSR not received. Giving extra dci\n");
+    logger.debug("BSR not received. Giving extra dci");
   }
 
-  Debug("MAC PDU processed\n");
+  logger.debug("MAC PDU processed");
 }
 
 void ue::deallocate_pdu(uint32_t tti, uint32_t ue_cc_idx)
@@ -345,10 +347,10 @@ void ue::deallocate_pdu(uint32_t tti, uint32_t ue_cc_idx)
     pdus.deallocate(rx_used_buffers.at(ue_cc_idx).at(tti));
     rx_used_buffers.at(ue_cc_idx).erase(tti);
   } else {
-    Warning("UE buffers: Null RX PDU pointer in deallocate_pdu for rnti=0x%x pid=%d cc_idx=%d\n",
+    logger.warning("UE buffers: Null RX PDU pointer in deallocate_pdu for rnti=0x%x pid=%d cc_idx=%d",
-            rnti,
+                   rnti,
-            tti % nof_rx_harq_proc,
+                   tti % nof_rx_harq_proc,
-            ue_cc_idx);
+                   ue_cc_idx);
   }
 }
 
@@ -359,14 +361,14 @@ void ue::push_pdu(uint32_t tti, uint32_t ue_cc_idx, uint32_t len)
     if (len > 0) {
       pdus.push(rx_used_buffers.at(ue_cc_idx).at(tti), len);
     } else {
-      Error("Error pushing PDU: null length\n");
+      logger.error("Error pushing PDU: null length");
     }
     rx_used_buffers.at(ue_cc_idx).erase(tti);
   } else {
-    Warning("UE buffers: Null RX PDU pointer in push_pdu for rnti=0x%x pid=%d cc_idx=%d\n",
+    logger.warning("UE buffers: Null RX PDU pointer in push_pdu for rnti=0x%x pid=%d cc_idx=%d",
-            rnti,
+                   rnti,
-            tti % nof_rx_harq_proc,
+                   tti % nof_rx_harq_proc,
-            ue_cc_idx);
+                   ue_cc_idx);
   }
 }
 
@@ -390,14 +392,14 @@ bool ue::process_ce(srslte::sch_subh* subh)
         rrc->upd_user(rnti, old_rnti);
         rnti = old_rnti;
       } else {
-        Error("Updating user C-RNTI: rnti=0x%x already released\n", old_rnti);
+        logger.error("Updating user C-RNTI: rnti=0x%x already released", old_rnti);
       }
       break;
     case srslte::ul_sch_lcid::TRUNC_BSR:
     case srslte::ul_sch_lcid::SHORT_BSR:
       idx = subh->get_bsr(buff_size_idx, buff_size_bytes);
       if (idx == -1) {
-        Error("Invalid Index Passed to lc groups\n");
+        logger.error("Invalid Index Passed to lc groups");
         break;
       }
       // Indicate BSR to scheduler
@@ -414,7 +416,7 @@ bool ue::process_ce(srslte::sch_subh* subh)
     case srslte::ul_sch_lcid::PADDING:
       break;
     default:
-      Error("CE:    Invalid lcid=0x%x\n", (int)subh->ul_sch_ce_type());
+      logger.error("CE:    Invalid lcid=0x%x", (int)subh->ul_sch_ce_type());
       break;
   }
   return is_bsr;
@@ -434,13 +436,13 @@ void ue::allocate_sdu(srslte::sch_pdu* pdu, uint32_t lcid, uint32_t total_sdu_le
     int n       = 1;
     while (sdu_len >= min_sdu_len && n > 0) { // minimum size is a single RLC AM status PDU (2 Byte)
       if (pdu->new_subh()) {                  // there is space for a new subheader
-        log_h->debug("SDU:   set_sdu(), lcid=%d, sdu_len=%d, sdu_space=%d\n", lcid, sdu_len, sdu_space);
+        logger.debug("SDU:   set_sdu(), lcid=%d, sdu_len=%d, sdu_space=%d", lcid, sdu_len, sdu_space);
         n = pdu->get()->set_sdu(lcid, sdu_len, this);
         if (n > 0) { // new SDU could be added
           sdu_len -= n;
-          log_h->debug("SDU:   rnti=0x%x, lcid=%d, nbytes=%d, rem_len=%d\n", rnti, lcid, n, sdu_len);
+          logger.debug("SDU:   rnti=0x%x, lcid=%d, nbytes=%d, rem_len=%d", rnti, lcid, n, sdu_len);
         } else {
-          Debug("Could not add SDU lcid=%d nbytes=%d, space=%d\n", lcid, sdu_len, sdu_space);
+          logger.debug("Could not add SDU lcid=%d nbytes=%d, space=%d", lcid, sdu_len, sdu_space);
           pdu->del_subh();
         }
       } else {
@@ -458,19 +460,19 @@ void ue::allocate_ce(srslte::sch_pdu* pdu, uint32_t lcid)
         uint32_t ta_cmd = 31;
         pending_ta_commands.try_pop(&ta_cmd);
         if (!pdu->get()->set_ta_cmd(ta_cmd)) {
-          Error("CE:    Setting TA CMD CE\n");
+          logger.error("CE:    Setting TA CMD CE");
         }
       } else {
-        Error("CE:    Setting TA CMD CE. No space for a subheader\n");
+        logger.error("CE:    Setting TA CMD CE. No space for a subheader");
       }
       break;
     case srslte::dl_sch_lcid::CON_RES_ID:
       if (pdu->new_subh()) {
         if (!pdu->get()->set_con_res_id(conres_id)) {
-          Error("CE:    Setting Contention Resolution ID CE\n");
+          logger.error("CE:    Setting Contention Resolution ID CE");
         }
       } else {
-        Error("CE:    Setting Contention Resolution ID CE. No space for a subheader\n");
+        logger.error("CE:    Setting Contention Resolution ID CE. No space for a subheader");
       }
       break;
     case srslte::dl_sch_lcid::SCELL_ACTIVATION:
@@ -481,14 +483,14 @@ void ue::allocate_ce(srslte::sch_pdu* pdu, uint32_t lcid)
           // Allocate and initialize Rx/Tx softbuffers for new carriers (exclude PCell)
           allocate_cc_buffers(active_scell_list.size() - 1);
         } else {
-          Error("CE:    Setting SCell Activation CE\n");
+          logger.error("CE:    Setting SCell Activation CE");
         }
       } else {
-        Error("CE:    Setting SCell Activation CE. No space for a subheader\n");
+        logger.error("CE:    Setting SCell Activation CE. No space for a subheader");
       }
       break;
     default:
-      Error("CE:    Allocating CE=0x%x. Not supported\n", lcid);
+      logger.error("CE:    Allocating CE=0x%x. Not supported", lcid);
       break;
   }
 }
@@ -514,10 +516,10 @@ uint8_t* ue::generate_pdu(uint32_t                        ue_cc_idx,
         }
       }
       ret = mac_msg_dl.write_packet(log_h);
-      Info("0x%x %s\n", rnti, mac_msg_dl.to_string().c_str());
+      logger.info("0x%x %s", rnti, mac_msg_dl.to_string().c_str());
     } else {
-      log_h->error(
+      logger.error(
-          "Invalid parameters calling generate_pdu: cc_idx=%d, harq_pid=%d, tb_idx=%d\n", ue_cc_idx, harq_pid, tb_idx);
+          "Invalid parameters calling generate_pdu: cc_idx=%d, harq_pid=%d, tb_idx=%d", ue_cc_idx, harq_pid, tb_idx);
     }
   } else {
     std::cout << "Error ue not configured (must call config() first" << std::endl;

srsenb/src/stack/rrc/mac_controller.cc

@@ -82,7 +82,7 @@ mac_controller::mac_controller(uint16_t                    rnti_,
                                mac_interface_rrc*          mac_,
                                const enb_cell_common_list& cell_common_list_,
                                const ue_cfg_t&             sched_ue_cfg) :
-  log_h("RRC"),
+  logger(srslog::fetch_basic_logger("RRC")),
   rnti(rnti_),
   ue_cell_list(ue_cell_list_),
   bearer_list(bearer_list_),
@@ -92,7 +92,7 @@ mac_controller::mac_controller(uint16_t                    rnti_,
   current_sched_ue_cfg(sched_ue_cfg)
 {
   if (current_sched_ue_cfg.supported_cc_list.empty() or not current_sched_ue_cfg.supported_cc_list[0].active) {
-    log_h->warning("No PCell set. Picking enb_cc_idx=0 as PCell\n");
+    logger.warning("No PCell set. Picking enb_cc_idx=0 as PCell");
     current_sched_ue_cfg.supported_cc_list.resize(1);
     current_sched_ue_cfg.supported_cc_list[0].active     = true;
     current_sched_ue_cfg.supported_cc_list[0].enb_cc_idx = 0;
@@ -351,7 +351,7 @@ void ue_cfg_apply_phy_cfg_ded(ue_cfg_t& ue_cfg, const asn1::rrc::phys_cfg_ded_s&
     if (phy_cfg.ant_info.type().value == phys_cfg_ded_s::ant_info_c_::types_opts::explicit_value) {
       ue_cfg.dl_ant_info = srslte::make_ant_info_ded(phy_cfg.ant_info.explicit_value());
     } else {
-      srslte::logmap::get("RRC")->warning("No antenna configuration provided\n");
+      srslog::fetch_basic_logger("RRC").warning("No antenna configuration provided");
       pcell_cfg.dl_cfg.tm        = SRSLTE_TM1;
       ue_cfg.dl_ant_info.tx_mode = sched_interface::ant_info_ded_t::tx_mode_t::tm1;
     }
@@ -370,7 +370,7 @@ void ue_cfg_apply_srb_updates(ue_cfg_t& ue_cfg, const srb_to_add_mod_list_l& srb
         bcfg = get_bearer_default_srb2_config();
         break;
       default:
-        srslte::logmap::get("RRC")->warning("Invalid SRB ID %d\n", (int)srb.srb_id);
+        srslog::fetch_basic_logger("RRC").warning("Invalid SRB ID %d", (int)srb.srb_id);
         bcfg = {};
     }
     bcfg.direction = srsenb::sched_interface::ue_bearer_cfg_t::BOTH;
@@ -450,7 +450,7 @@ void ue_cfg_apply_reconf_complete_updates(ue_cfg_t&                      ue_cfg,
                 ul_cfg.cqi_report_cfg_scell_r10.cqi_report_mode_aperiodic_r10_present;
             mac_scell.aperiodic_cqi_period = ul_cfg.cqi_report_cfg_scell_r10.cqi_report_mode_aperiodic_r10.to_number();
           } else {
-            srslte::logmap::get("RRC")->warning("Invalid Scell index %d CQI configuration\n", scell.scell_idx_r10);
+            srslog::fetch_basic_logger("RRC").warning("Invalid Scell index %d CQI configuration", scell.scell_idx_r10);
           }
         }
       }
@@ -476,7 +476,7 @@ void ue_cfg_apply_meas_cfg(ue_cfg_t& ue_cfg, const meas_cfg_s& meas_cfg, const r
           ue_cfg.measgap_offset = setup.gap_offset.gp1();
           break;
         default:
-          srslte::logmap::get("RRC")->warning("Invalid measGap configuration\n");
+          srslog::fetch_basic_logger("RRC").warning("Invalid measGap configuration");
           ue_cfg.measgap_period = 0;
           ue_cfg.measgap_offset = 0;
       }

srsenb/src/stack/rrc/rrc.cc

@@ -28,7 +28,8 @@ using namespace asn1::rrc;
 
 namespace srsenb {
 
-rrc::rrc(srslte::task_sched_handle task_sched_) : rrc_log("RRC"), task_sched(task_sched_)
+rrc::rrc(srslte::task_sched_handle task_sched_) :
+  rrc_log("RRC"), logger(srslog::fetch_basic_logger("RRC")), task_sched(task_sched_)
 {
   pending_paging.clear();
   ue_pool.reserve(16);
@@ -72,14 +73,14 @@ void rrc::init(const rrc_cfg_t&       cfg_,
   uint32_t t310 = cfg.sibs[1].sib2().ue_timers_and_consts.t310.to_number();
   uint32_t t311 = cfg.sibs[1].sib2().ue_timers_and_consts.t311.to_number();
   uint32_t n310 = cfg.sibs[1].sib2().ue_timers_and_consts.n310.to_number();
-  rrc_log->info("T310 %d, T311 %d, N310 %d \n", t310, t311, n310);
+  logger.info("T310 %d, T311 %d, N310 %d", t310, t311, n310);
   if (cfg.inactivity_timeout_ms < t310 + t311 + n310) {
     srslte::console("\nWarning: Inactivity timeout is smaller than the sum of t310, t311 and n310.\n"
                     "This may break the UE's re-establishment procedure.\n");
-    rrc_log->warning("Inactivity timeout is smaller than the sum of t310, t311 and n310. This may break the UE's "
+    logger.warning("Inactivity timeout is smaller than the sum of t310, t311 and n310. This may break the UE's "
-                     "re-establishment procedure.\n");
+                   "re-establishment procedure.");
   }
-  rrc_log->info("Inactivity timeout: %d ms\n", cfg.inactivity_timeout_ms);
+  logger.info("Inactivity timeout: %d ms", cfg.inactivity_timeout_ms);
 
   running = true;
 }
@@ -152,7 +153,7 @@ int rrc::add_user(uint16_t rnti, const sched_interface::ue_cfg_t& sched_ue_cfg)
       // only non-eMBMS RNTIs are present in user map
       std::unique_ptr<ue> u{new ue(this, rnti, sched_ue_cfg)};
       if (u->init() != SRSLTE_SUCCESS) {
-        rrc_log->error("Adding user rnti=0x%x - Failed to allocate user resources\n", rnti);
+        logger.error("Adding user rnti=0x%x - Failed to allocate user resources", rnti);
         return SRSLTE_ERROR;
       }
       if (ue_pool.capacity() <= 4) {
@@ -162,9 +163,9 @@ int rrc::add_user(uint16_t rnti, const sched_interface::ue_cfg_t& sched_ue_cfg)
     }
     rlc->add_user(rnti);
     pdcp->add_user(rnti);
-    rrc_log->info("Added new user rnti=0x%x\n", rnti);
+    logger.info("Added new user rnti=0x%x", rnti);
   } else {
-    rrc_log->error("Adding user rnti=0x%x (already exists)\n", rnti);
+    logger.error("Adding user rnti=0x%x (already exists)", rnti);
   }
 
   if (rnti == SRSLTE_MRNTI) {
@@ -238,7 +239,7 @@ void rrc::write_dl_info(uint16_t rnti, srslte::unique_byte_buffer_t sdu)
 
     user_it->second->send_dl_dcch(&dl_dcch_msg, std::move(sdu));
   } else {
-    rrc_log->error("Rx SDU for unknown rnti=0x%x\n", rnti);
+    logger.error("Rx SDU for unknown rnti=0x%x", rnti);
   }
 }
 
@@ -250,11 +251,11 @@ void rrc::release_complete(uint16_t rnti)
 
 bool rrc::setup_ue_ctxt(uint16_t rnti, const asn1::s1ap::init_context_setup_request_s& msg)
 {
-  rrc_log->info("Adding initial context for 0x%x\n", rnti);
+  logger.info("Adding initial context for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return false;
   }
 
@@ -264,11 +265,11 @@ bool rrc::setup_ue_ctxt(uint16_t rnti, const asn1::s1ap::init_context_setup_requ
 
 bool rrc::modify_ue_ctxt(uint16_t rnti, const asn1::s1ap::ue_context_mod_request_s& msg)
 {
-  rrc_log->info("Modifying context for 0x%x\n", rnti);
+  logger.info("Modifying context for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return false;
   }
 
@@ -277,11 +278,11 @@ bool rrc::modify_ue_ctxt(uint16_t rnti, const asn1::s1ap::ue_context_mod_request
 
 bool rrc::setup_ue_erabs(uint16_t rnti, const asn1::s1ap::erab_setup_request_s& msg)
 {
-  rrc_log->info("Setting up erab(s) for 0x%x\n", rnti);
+  logger.info("Setting up erab(s) for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return false;
   }
 
@@ -298,11 +299,11 @@ bool rrc::setup_ue_erabs(uint16_t rnti, const asn1::s1ap::erab_setup_request_s&
 
 bool rrc::release_erabs(uint32_t rnti)
 {
-  rrc_log->info("Releasing E-RABs for 0x%x\n", rnti);
+  logger.info("Releasing E-RABs for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return false;
   }
 
@@ -315,11 +316,11 @@ void rrc::release_erabs(uint32_t                              rnti,
                         std::vector<uint16_t>*                erabs_released,
                         std::vector<uint16_t>*                erabs_failed_to_release)
 {
-  rrc_log->info("Releasing E-RAB for 0x%x\n", rnti);
+  logger.info("Releasing E-RAB for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return;
   }
 
@@ -341,11 +342,11 @@ void rrc::modify_erabs(uint16_t                                 rnti,
                        std::vector<uint16_t>*                   erabs_modified,
                        std::vector<uint16_t>*                   erabs_failed_to_modify)
 {
-  rrc_log->info("Modifying E-RABs for 0x%x\n", rnti);
+  logger.info("Modifying E-RABs for 0x%x", rnti);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return;
   }
 
@@ -374,11 +375,11 @@ bool rrc::modify_ue_erab(uint16_t                                   rnti,
                          const asn1::s1ap::erab_level_qos_params_s& qos_params,
                          const asn1::unbounded_octstring<true>*     nas_pdu)
 {
-  rrc_log->info("Modifying E-RAB for 0x%x. E-RAB Id %d\n", rnti, erab_id);
+  logger.info("Modifying E-RAB for 0x%x. E-RAB Id %d", rnti, erab_id);
   auto user_it = users.find(rnti);
 
   if (user_it == users.end()) {
-    rrc_log->warning("Unrecognised rnti: 0x%x\n", rnti);
+    logger.warning("Unrecognised rnti: 0x%x", rnti);
     return false;
   }
 
@@ -396,7 +397,7 @@ void rrc::add_paging_id(uint32_t ueid, const asn1::s1ap::ue_paging_id_c& ue_pagi
 {
   std::lock_guard<std::mutex> lock(paging_mutex);
   if (pending_paging.count(ueid) > 0) {
-    rrc_log->warning("Received Paging for UEID=%d but not yet transmitted\n", ueid);
+    logger.warning("Received Paging for UEID=%d but not yet transmitted", ueid);
     return;
   }
 
@@ -428,7 +429,7 @@ bool rrc::is_paging_opportunity(uint32_t tti, uint32_t* payload_len)
 
   if (tti == paging_tti) {
     *payload_len = byte_buf_paging.N_bytes;
-    rrc_log->debug("Sending paging to extra carriers. Payload len=%d, TTI=%d\n", *payload_len, tti);
+    logger.debug("Sending paging to extra carriers. Payload len=%d, TTI=%d", *payload_len, tti);
     return true;
   } else {
     paging_tti = INVALID_TTI;
@@ -470,7 +471,7 @@ bool rrc::is_paging_opportunity(uint32_t tti, uint32_t* payload_len)
 
       int sf_idx = sf_pattern[i_s % 4][(Ns - 1) % 4];
       if (sf_idx < 0) {
-        rrc_log->error("SF pattern is N/A for Ns=%d, i_s=%d, imsi_decimal=%d\n", Ns, i_s, ueid);
+        logger.error("SF pattern is N/A for Ns=%d, i_s=%d, imsi_decimal=%d", Ns, i_s, ueid);
         continue;
       }
 
@@ -479,7 +480,7 @@ bool rrc::is_paging_opportunity(uint32_t tti, uint32_t* payload_len)
         paging_rec->paging_record_list.push_back(u);
         ue_to_remove.push_back(ueid);
         n++;
-        rrc_log->info("Assembled paging for ue_id=%d, tti=%d\n", ueid, tti);
+        logger.info("Assembled paging for ue_id=%d, tti=%d", ueid, tti);
       }
     }
 
@@ -492,7 +493,7 @@ bool rrc::is_paging_opportunity(uint32_t tti, uint32_t* payload_len)
     byte_buf_paging.clear();
     asn1::bit_ref bref(byte_buf_paging.msg, byte_buf_paging.get_tailroom());
     if (pcch_msg.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-      rrc_log->error("Failed to pack PCCH\n");
+      logger.error("Failed to pack PCCH");
       return false;
     }
     byte_buf_paging.N_bytes = (uint32_t)bref.distance_bytes();
@@ -501,10 +502,10 @@ bool rrc::is_paging_opportunity(uint32_t tti, uint32_t* payload_len)
     if (payload_len) {
       *payload_len = byte_buf_paging.N_bytes;
     }
-    rrc_log->info("Assembling PCCH payload with %d UE identities, payload_len=%d bytes, nbits=%d\n",
+    logger.info("Assembling PCCH payload with %d UE identities, payload_len=%d bytes, nbits=%d",
-                  paging_rec->paging_record_list.size(),
+                paging_rec->paging_record_list.size(),
-                  byte_buf_paging.N_bytes,
+                byte_buf_paging.N_bytes,
-                  N_bits);
+                N_bits);
     log_rrc_message("PCCH-Message", Tx, &byte_buf_paging, pcch_msg, pcch_msg.msg.c1().type().to_string());
 
     paging_tti = tti; // Store paging tti for other carriers
@@ -535,7 +536,7 @@ void rrc::set_erab_status(uint16_t rnti, const asn1::s1ap::bearers_subject_to_st
 {
   auto ue_it = users.find(rnti);
   if (ue_it == users.end()) {
-    rrc_log->warning("rnti=0x%x does not exist\n", rnti);
+    logger.warning("rnti=0x%x does not exist", rnti);
     return;
   }
   ue_it->second->mobility_handler->trigger(erabs);
@@ -554,7 +555,7 @@ void rrc::parse_ul_ccch(uint16_t rnti, srslte::unique_byte_buffer_t pdu)
     asn1::cbit_ref bref(pdu->msg, pdu->N_bytes);
     if (ul_ccch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or
         ul_ccch_msg.msg.type().value != ul_ccch_msg_type_c::types_opts::c1) {
-      rrc_log->error("Failed to unpack UL-CCCH message\n");
+      logger.error("Failed to unpack UL-CCCH message");
       return;
     }
 
@@ -566,18 +567,18 @@ void rrc::parse_ul_ccch(uint16_t rnti, srslte::unique_byte_buffer_t pdu)
         if (user_it != users.end()) {
           user_it->second->handle_rrc_con_req(&ul_ccch_msg.msg.c1().rrc_conn_request());
         } else {
-          rrc_log->error("Received ConnectionSetup for rnti=0x%x without context\n", rnti);
+          logger.error("Received ConnectionSetup for rnti=0x%x without context", rnti);
         }
         break;
       case ul_ccch_msg_type_c::c1_c_::types::rrc_conn_reest_request:
         if (user_it != users.end()) {
           user_it->second->handle_rrc_con_reest_req(&ul_ccch_msg.msg.c1().rrc_conn_reest_request());
         } else {
-          rrc_log->error("Received ConnectionReestablishment for rnti=0x%x without context.\n", rnti);
+          logger.error("Received ConnectionReestablishment for rnti=0x%x without context.", rnti);
         }
         break;
       default:
-        rrc_log->error("UL CCCH message not recognised\n");
+        logger.error("UL CCCH message not recognised");
         break;
     }
   }
@@ -591,7 +592,7 @@ void rrc::parse_ul_dcch(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer
     if (user_it != users.end()) {
       user_it->second->parse_ul_dcch(lcid, std::move(pdu));
     } else {
-      rrc_log->error("Processing %s: Unknown rnti=0x%x\n", srsenb::to_string((rb_id_t)lcid), rnti);
+      logger.error("Processing %s: Unknown rnti=0x%x", srsenb::to_string((rb_id_t)lcid), rnti);
     }
   }
 }
@@ -599,10 +600,10 @@ void rrc::parse_ul_dcch(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer
 ///< User mutex must be hold by caller
 void rrc::process_release_complete(uint16_t rnti)
 {
-  rrc_log->info("Received Release Complete rnti=0x%x\n", rnti);
+  logger.info("Received Release Complete rnti=0x%x", rnti);
   auto user_it = users.find(rnti);
   if (user_it == users.end()) {
-    rrc_log->error("Received ReleaseComplete for unknown rnti=0x%x\n", rnti);
+    logger.error("Received ReleaseComplete for unknown rnti=0x%x", rnti);
     return;
   }
   ue* u = user_it->second.get();
@@ -622,7 +623,7 @@ void rrc::rem_user(uint16_t rnti)
   auto user_it = users.find(rnti);
   if (user_it != users.end()) {
     srslte::console("Disconnecting rnti=0x%x.\n", rnti);
-    rrc_log->info("Disconnecting rnti=0x%x.\n", rnti);
+    logger.info("Disconnecting rnti=0x%x.", rnti);
 
     /* First remove MAC and GTPU to stop processing DL/UL traffic for this user
      */
@@ -634,9 +635,9 @@ void rrc::rem_user(uint16_t rnti)
     pdcp->rem_user(rnti);
 
     users.erase(rnti);
-    rrc_log->info("Removed user rnti=0x%x\n", rnti);
+    logger.info("Removed user rnti=0x%x", rnti);
   } else {
-    rrc_log->error("Removing user rnti=0x%x (does not exist)\n", rnti);
+    logger.error("Removing user rnti=0x%x (does not exist)", rnti);
   }
 }
 
@@ -673,7 +674,7 @@ void rrc::config_mac()
     item.enable_phr_handling = cfg.cell_list[ccidx].enable_phr_handling;
 
     item.nrb_pucch = SRSLTE_MAX(cfg.sr_cfg.nof_prb, cfg.cqi_cfg.nof_prb);
-    rrc_log->info("Allocating %d PRBs for PUCCH\n", item.nrb_pucch);
+    logger.info("Allocating %d PRBs for PUCCH", item.nrb_pucch);
 
     // Copy base cell configuration
     item.cell = cfg.cell;
@@ -687,7 +688,7 @@ void rrc::config_mac()
         return e.cell_id == scellitem.cell_id;
       });
       if (it == cfg.cell_list.end()) {
-        rrc_log->warning("Secondary cell 0x%x not configured\n", scellitem.cell_id);
+        logger.warning("Secondary cell 0x%x not configured", scellitem.cell_id);
         continue;
       }
       sched_interface::cell_cfg_t::scell_cfg_t scellcfg;
@@ -755,7 +756,7 @@ uint32_t rrc::generate_sibs()
       srslte::unique_byte_buffer_t sib_buffer = srslte::allocate_unique_buffer(*pool);
       asn1::bit_ref                bref(sib_buffer->msg, sib_buffer->get_tailroom());
       if (msg[msg_index].pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-        rrc_log->error("Failed to pack SIB message %d\n", msg_index);
+        logger.error("Failed to pack SIB message %d", msg_index);
       }
       sib_buffer->N_bytes = bref.distance_bytes();
       cell_ctxt->sib_buffer.push_back(std::move(sib_buffer));
@@ -845,9 +846,9 @@ void rrc::configure_mbsfn_sibs()
   uint16_t mbms_mcs = cfg.mbms_mcs;
   if (mbms_mcs > 28) {
     mbms_mcs = 28; // TS 36.213, Table 8.6.1-1
-    rrc_log->warning("PMCH data MCS too high, setting it to 28\n");
+    logger.warning("PMCH data MCS too high, setting it to 28");
   }
-  rrc_log->debug("PMCH data MCS=%d\n", mbms_mcs);
+  logger.debug("PMCH data MCS=%d", mbms_mcs);
   pmch_item->data_mcs         = mbms_mcs;
   pmch_item->mch_sched_period = srslte::pmch_info_t::mch_sched_period_t::rf64;
   pmch_item->sf_alloc_end     = 64 * 6;
@@ -896,10 +897,10 @@ int rrc::pack_mcch()
   uint16_t mbms_mcs = cfg.mbms_mcs;
   if (mbms_mcs > 28) {
     mbms_mcs = 28; // TS 36.213, Table 8.6.1-1
-    rrc_log->warning("PMCH data MCS too high, setting it to 28\n");
+    logger.warning("PMCH data MCS too high, setting it to 28");
   }
 
-  rrc_log->debug("PMCH data MCS=%d\n", mbms_mcs);
+  logger.debug("PMCH data MCS=%d", mbms_mcs);
   pmch_item->pmch_cfg_r9.data_mcs_r9         = mbms_mcs;
   pmch_item->pmch_cfg_r9.mch_sched_period_r9 = pmch_cfg_r9_s::mch_sched_period_r9_e_::rf64;
   pmch_item->pmch_cfg_r9.sf_alloc_end_r9     = 64 * 6;
@@ -923,13 +924,13 @@ void rrc::tti_clock()
   while (rx_pdu_queue.try_pop(&p)) {
     // print Rx PDU
     if (p.pdu != nullptr) {
-      rrc_log->info_hex(p.pdu->msg, p.pdu->N_bytes, "Rx %s PDU", to_string((rb_id_t)p.lcid));
+      logger.info(p.pdu->msg, p.pdu->N_bytes, "Rx %s PDU", to_string((rb_id_t)p.lcid));
     }
 
     // check if user exists
     auto user_it = users.find(p.rnti);
     if (user_it == users.end()) {
-      rrc_log->warning("Discarding PDU for removed rnti=0x%x\n", p.rnti);
+      logger.warning("Discarding PDU for removed rnti=0x%x", p.rnti);
       continue;
     }
 
@@ -952,10 +953,10 @@ void rrc::tti_clock()
         user_it->second->set_activity();
         break;
       case LCID_EXIT:
-        rrc_log->info("Exiting thread\n");
+        logger.info("Exiting thread");
         break;
       default:
-        rrc_log->error("Rx PDU with invalid bearer id: %d", p.lcid);
+        logger.error("Rx PDU with invalid bearer id: %d", p.lcid);
         break;
     }
   }

srsenb/src/stack/rrc/rrc_bearer_cfg.cc

@@ -55,17 +55,17 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
         // just assume that EEA0 is always supported even this can not be explicity signaled by S1AP
         sec_cfg.cipher_algo = srslte::CIPHERING_ALGORITHM_ID_EEA0;
         enc_algo_found      = true;
-        log_h->info("Selected EEA0 as RRC encryption algorithm\n");
+        logger.info("Selected EEA0 as RRC encryption algorithm");
         break;
       case srslte::CIPHERING_ALGORITHM_ID_128_EEA1:
         // “first bit” – 128-EEA1,
         if (v.get(v.length() - srslte::CIPHERING_ALGORITHM_ID_128_EEA1)) {
           sec_cfg.cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA1;
           enc_algo_found      = true;
-          log_h->info("Selected EEA1 as RRC encryption algorithm\n");
+          logger.info("Selected EEA1 as RRC encryption algorithm");
           break;
         } else {
-          log_h->info("Failed to selected EEA1 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EEA1 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       case srslte::CIPHERING_ALGORITHM_ID_128_EEA2:
@@ -73,10 +73,10 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
         if (v.get(v.length() - srslte::CIPHERING_ALGORITHM_ID_128_EEA2)) {
           sec_cfg.cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA2;
           enc_algo_found      = true;
-          log_h->info("Selected EEA2 as RRC encryption algorithm\n");
+          logger.info("Selected EEA2 as RRC encryption algorithm");
           break;
         } else {
-          log_h->info("Failed to selected EEA2 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EEA2 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       case srslte::CIPHERING_ALGORITHM_ID_128_EEA3:
@@ -84,10 +84,10 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
         if (v.get(v.length() - srslte::CIPHERING_ALGORITHM_ID_128_EEA3)) {
           sec_cfg.cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA3;
           enc_algo_found      = true;
-          log_h->info("Selected EEA3 as RRC encryption algorithm\n");
+          logger.info("Selected EEA3 as RRC encryption algorithm");
           break;
         } else {
-          log_h->info("Failed to selected EEA2 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EEA2 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       default:
@@ -104,16 +104,16 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
     switch (eia_enum) {
       case srslte::INTEGRITY_ALGORITHM_ID_EIA0:
         // Null integrity is not supported
-        log_h->info("Skipping EIA0 as RRC integrity algorithm. Null integrity is not supported.\n");
+        logger.info("Skipping EIA0 as RRC integrity algorithm. Null integrity is not supported.");
         break;
       case srslte::INTEGRITY_ALGORITHM_ID_128_EIA1:
         // “first bit” – 128-EIA1,
         if (v.get(v.length() - srslte::INTEGRITY_ALGORITHM_ID_128_EIA1)) {
           sec_cfg.integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA1;
           integ_algo_found   = true;
-          log_h->info("Selected EIA1 as RRC integrity algorithm.\n");
+          logger.info("Selected EIA1 as RRC integrity algorithm.");
         } else {
-          log_h->info("Failed to selected EIA1 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EIA1 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       case srslte::INTEGRITY_ALGORITHM_ID_128_EIA2:
@@ -121,9 +121,9 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
         if (v.get(v.length() - srslte::INTEGRITY_ALGORITHM_ID_128_EIA2)) {
           sec_cfg.integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA2;
           integ_algo_found   = true;
-          log_h->info("Selected EIA2 as RRC integrity algorithm.\n");
+          logger.info("Selected EIA2 as RRC integrity algorithm.");
         } else {
-          log_h->info("Failed to selected EIA2 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EIA2 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       case srslte::INTEGRITY_ALGORITHM_ID_128_EIA3:
@@ -131,9 +131,9 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
         if (v.get(v.length() - srslte::INTEGRITY_ALGORITHM_ID_128_EIA3)) {
           sec_cfg.integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA3;
           integ_algo_found   = true;
-          log_h->info("Selected EIA3 as RRC integrity algorithm.\n");
+          logger.info("Selected EIA3 as RRC integrity algorithm.");
         } else {
-          log_h->info("Failed to selected EIA3 as RRC encryption algorithm, due to unsupported algorithm\n");
+          logger.info("Failed to selected EIA3 as RRC encryption algorithm, due to unsupported algorithm");
         }
         break;
       default:
@@ -149,7 +149,7 @@ bool security_cfg_handler::set_security_capabilities(const asn1::s1ap::ue_securi
   if (not integ_algo_found || not enc_algo_found) {
     // TODO: if no security algorithm found abort radio connection and issue
     // encryption-and-or-integrity-protection-algorithms-not-supported message
-    log_h->error("Did not find a matching integrity or encryption algorithm with the UE\n");
+    logger.error("Did not find a matching integrity or encryption algorithm with the UE");
     return false;
   }
   return true;
@@ -161,7 +161,7 @@ void security_cfg_handler::set_security_key(const asn1::fixed_bitstring<256, fal
   for (uint32_t i = 0; i < key.nof_octets(); ++i) {
     k_enb[i] = key.data()[key.nof_octets() - 1 - i];
   }
-  log_h->info_hex(k_enb, 32, "Key eNodeB (k_enb)");
+  logger.info(k_enb, 32, "Key eNodeB (k_enb)");
 
   generate_as_keys();
 }
@@ -176,16 +176,16 @@ void security_cfg_handler::generate_as_keys()
   security_generate_k_up(
       k_enb, sec_cfg.cipher_algo, sec_cfg.integ_algo, sec_cfg.k_up_enc.data(), sec_cfg.k_up_int.data());
 
-  log_h->info_hex(k_enb, 32, "K_eNB (k_enb)");
+  logger.info(k_enb, 32, "K_eNB (k_enb)");
-  log_h->info_hex(sec_cfg.k_rrc_enc.data(), 32, "RRC Encryption Key (k_rrc_enc)");
+  logger.info(sec_cfg.k_rrc_enc.data(), 32, "RRC Encryption Key (k_rrc_enc)");
-  log_h->info_hex(sec_cfg.k_rrc_int.data(), 32, "RRC Integrity Key (k_rrc_int)");
+  logger.info(sec_cfg.k_rrc_int.data(), 32, "RRC Integrity Key (k_rrc_int)");
-  log_h->info_hex(sec_cfg.k_up_enc.data(), 32, "UP Encryption Key (k_up_enc)");
+  logger.info(sec_cfg.k_up_enc.data(), 32, "UP Encryption Key (k_up_enc)");
 }
 
 void security_cfg_handler::regenerate_keys_handover(uint32_t new_pci, uint32_t new_dl_earfcn)
 {
-  log_h->info("Regenerating KeNB with PCI=0x%02x, DL-EARFCN=%d\n", new_pci, new_dl_earfcn);
+  logger.info("Regenerating KeNB with PCI=0x%02x, DL-EARFCN=%d", new_pci, new_dl_earfcn);
-  log_h->info_hex(k_enb, 32, "Old K_eNB (k_enb)");
+  logger.info(k_enb, 32, "Old K_eNB (k_enb)");
   // Generate K_enb*
   uint8_t k_enb_star[32];
   srslte::security_generate_k_enb_star(k_enb, new_pci, new_dl_earfcn, k_enb_star);
@@ -200,7 +200,9 @@ void security_cfg_handler::regenerate_keys_handover(uint32_t new_pci, uint32_t n
  *      Bearer Handler
  ****************************/
 
-bearer_cfg_handler::bearer_cfg_handler(uint16_t rnti_, const rrc_cfg_t& cfg_) : rnti(rnti_), cfg(&cfg_) {}
+bearer_cfg_handler::bearer_cfg_handler(uint16_t rnti_, const rrc_cfg_t& cfg_) :
+  rnti(rnti_), cfg(&cfg_), logger(srslog::fetch_basic_logger("RRC"))
+{}
 
 int bearer_cfg_handler::add_erab(uint8_t                                            erab_id,
                                  const asn1::s1ap::erab_level_qos_params_s&         qos,
@@ -209,22 +211,22 @@ int bearer_cfg_handler::add_erab(uint8_t
                                  const asn1::unbounded_octstring<true>*             nas_pdu)
 {
   if (erab_id < 5) {
-    log_h->error("ERAB id=%d is invalid\n", erab_id);
+    logger.error("ERAB id=%d is invalid", erab_id);
     return SRSLTE_ERROR;
   }
   uint8_t lcid  = erab_id - 2; // Map e.g. E-RAB 5 to LCID 3 (==DRB1)
   uint8_t drbid = erab_id - 4;
 
   if (qos.qci >= MAX_NOF_QCI) {
-    log_h->error("Invalid QCI=%d for ERAB_id=%d, DRB_id=%d\n", qos.qci, erab_id, drbid);
+    logger.error("Invalid QCI=%d for ERAB_id=%d, DRB_id=%d", qos.qci, erab_id, drbid);
     return SRSLTE_ERROR;
   }
   if (not cfg->qci_cfg[qos.qci].configured) {
-    log_h->error("QCI=%d not configured\n", qos.qci);
+    logger.error("QCI=%d not configured", qos.qci);
     return SRSLTE_ERROR;
   }
   if (lcid < 3 or lcid > 10) {
-    log_h->error("DRB logical channel ids must be within 3 and 10\n");
+    logger.error("DRB logical channel ids must be within 3 and 10");
     return SRSLTE_ERROR;
   }
 
@@ -234,13 +236,13 @@ int bearer_cfg_handler::add_erab(uint8_t
   erabs[erab_id].teid_out   = teid_out;
 
   if (addr.length() > 32) {
-    log_h->error("Only addresses with length <= 32 are supported\n");
+    logger.error("Only addresses with length <= 32 are supported");
     return SRSLTE_ERROR;
   }
 
   if (nas_pdu != nullptr and nas_pdu->size() > 0) {
     erab_info_list[erab_id].assign(nas_pdu->data(), nas_pdu->data() + nas_pdu->size());
-    log_h->info_hex(
+    logger.info(
         &erab_info_list[erab_id][0], erab_info_list[erab_id].size(), "setup_erab nas_pdu -> erab_info rnti 0x%x", rnti);
   }
 
@@ -266,7 +268,7 @@ bool bearer_cfg_handler::release_erab(uint8_t erab_id)
 {
   auto it = erabs.find(erab_id);
   if (it == erabs.end()) {
-    log_h->warning("The user rnti=0x%x does not contain ERAB-ID=%d\n", rnti, erab_id);
+    logger.warning("The user rnti=0x%x does not contain ERAB-ID=%d", rnti, erab_id);
     return false;
   }
 
@@ -293,10 +295,10 @@ bool bearer_cfg_handler::modify_erab(uint8_t
                                      const asn1::s1ap::erab_level_qos_params_s& qos,
                                      const asn1::unbounded_octstring<true>*     nas_pdu)
 {
-  log_h->info("Modifying E-RAB %d\n", erab_id);
+  logger.info("Modifying E-RAB %d", erab_id);
   std::map<uint8_t, erab_t>::iterator erab_it = erabs.find(erab_id);
   if (erab_it == erabs.end()) {
-    log_h->error("Could not find E-RAB to modify\n");
+    logger.error("Could not find E-RAB to modify");
     return false;
   }
   auto     address  = erab_it->second.address;
@@ -315,7 +317,7 @@ void bearer_cfg_handler::add_gtpu_bearer(srsenb::gtpu_interface_rrc* gtpu, uint3
     uint32_t addr_ = erab.address.to_number();
     erab.teid_in   = gtpu->add_bearer(rnti, erab.id - 2, addr_, erab.teid_out);
   } else {
-    log_h->error("Adding erab_id=%d to GTPU\n", erab_id);
+    logger.error("Adding erab_id=%d to GTPU", erab_id);
   }
 }
 
@@ -337,12 +339,12 @@ void bearer_cfg_handler::fill_pending_nas_info(asn1::rrc::rrc_conn_recfg_r8_ies_
       auto    it      = erab_info_list.find(erab_id);
       if (it != erab_info_list.end()) {
         const std::vector<uint8_t>& erab_info = it->second;
-        log_h->info_hex(&erab_info[0], erab_info.size(), "connection_reconf erab_info -> nas_info rnti 0x%x\n", rnti);
+        logger.info(&erab_info[0], erab_info.size(), "connection_reconf erab_info -> nas_info rnti 0x%x", rnti);
         msg->ded_info_nas_list[idx].resize(erab_info.size());
         memcpy(msg->ded_info_nas_list[idx].data(), &erab_info[0], erab_info.size());
         erab_info_list.erase(it);
       } else {
-        log_h->debug("Not adding NAS message to connection reconfiguration. E-RAB id %d\n", erab_id);
+        logger.debug("Not adding NAS message to connection reconfiguration. E-RAB id %d", erab_id);
       }
       idx++;
     }

srsenb/src/stack/rrc/rrc_cell_cfg.cc

@@ -140,7 +140,7 @@ cell_res_common* freq_res_common_list::get_earfcn(uint32_t earfcn)
 ue_cell_ded_list::ue_cell_ded_list(const rrc_cfg_t&            cfg_,
                                    freq_res_common_list&       cell_res_list_,
                                    const enb_cell_common_list& enb_common_list) :
-  cfg(cfg_), cell_res_list(cell_res_list_), common_list(enb_common_list)
+  logger(srslog::fetch_basic_logger("RRC")), cfg(cfg_), cell_res_list(cell_res_list_), common_list(enb_common_list)
 {
   cell_list.reserve(common_list.nof_cells());
 }
@@ -174,12 +174,12 @@ ue_cell_ded* ue_cell_ded_list::add_cell(uint32_t enb_cc_idx)
 {
   const enb_cell_common* cell_common = common_list.get_cc_idx(enb_cc_idx);
   if (cell_common == nullptr) {
-    log_h->error("cell with enb_cc_idx=%d does not exist.\n", enb_cc_idx);
+    logger.error("cell with enb_cc_idx=%d does not exist.", enb_cc_idx);
     return nullptr;
   }
   ue_cell_ded* ret = get_enb_cc_idx(enb_cc_idx);
   if (ret != nullptr) {
-    log_h->error("UE already registered cell %d\n", enb_cc_idx);
+    logger.error("UE already registered cell %d", enb_cc_idx);
     return nullptr;
   }
 
@@ -221,7 +221,7 @@ bool ue_cell_ded_list::alloc_cell_resources(uint32_t ue_cc_idx)
   // Allocate CQI, SR, and PUCCH CS resources. If failure, do not add new cell
   if (ue_cc_idx == UE_PCELL_CC_IDX) {
     if (not alloc_sr_resources(cfg.sr_cfg.period)) {
-      log_h->error("Failed to allocate SR resources for PCell\n");
+      logger.error("Failed to allocate SR resources for PCell");
       return false;
     }
 
@@ -233,7 +233,7 @@ bool ue_cell_ded_list::alloc_cell_resources(uint32_t ue_cc_idx)
     if (ue_cc_idx == 1 and not n_pucch_cs_present) {
       // Allocate resources for Format1b CS (will be optional PUCCH3/CS)
       if (not alloc_pucch_cs_resources()) {
-        log_h->error("Error allocating PUCCH Format1b CS resource for SCell\n");
+        logger.error("Error allocating PUCCH Format1b CS resource for SCell");
         return false;
       }
     } else {
@@ -242,7 +242,7 @@ bool ue_cell_ded_list::alloc_cell_resources(uint32_t ue_cc_idx)
     }
   }
   if (not alloc_cqi_resources(ue_cc_idx, cfg.cqi_cfg.period)) {
-    log_h->error("Failed to allocate CQIresources for cell ue_cc_idx=%d\n", ue_cc_idx);
+    logger.error("Failed to allocate CQIresources for cell ue_cc_idx=%d", ue_cc_idx);
     return false;
   }
 
@@ -293,7 +293,7 @@ bool ue_cell_ded_list::set_cells(const std::vector<uint32_t>& enb_cc_idxs)
     uint32_t               enb_cc_idx  = enb_cc_idxs[ue_cc_idx];
     const enb_cell_common* cell_common = common_list.get_cc_idx(enb_cc_idx);
     if (cell_common == nullptr) {
-      log_h->error("cell with enb_cc_idx=%d does not exist.\n", enb_cc_idx);
+      logger.error("cell with enb_cc_idx=%d does not exist.", enb_cc_idx);
       break;
     }
     auto* prev_cell_common = cell_list[ue_cc_idx].cell_common;
@@ -305,7 +305,7 @@ bool ue_cell_ded_list::set_cells(const std::vector<uint32_t>& enb_cc_idxs)
     dealloc_cqi_resources(ue_cc_idx);
     cell_list[ue_cc_idx] = ue_cell_ded{ue_cc_idx, *cell_common};
     if (not alloc_cqi_resources(ue_cc_idx, cfg.cqi_cfg.period)) {
-      log_h->error("Failed to allocate CQI resources for cell ue_cc_idx=%d\n", ue_cc_idx);
+      logger.error("Failed to allocate CQI resources for cell ue_cc_idx=%d", ue_cc_idx);
       break;
     }
   }
@@ -324,11 +324,11 @@ bool ue_cell_ded_list::alloc_cqi_resources(uint32_t ue_cc_idx, uint32_t period)
 {
   ue_cell_ded* cell = get_ue_cc_idx(ue_cc_idx);
   if (cell == nullptr) {
-    log_h->error("The user cell ue_cc_idx=%d has not been allocated\n", ue_cc_idx);
+    logger.error("The user cell ue_cc_idx=%d has not been allocated", ue_cc_idx);
     return false;
   }
   if (cell->cqi_res_present) {
-    log_h->error("The user cqi resources for cell ue_cc_idx=%d are already allocated\n", ue_cc_idx);
+    logger.error("The user cqi resources for cell ue_cc_idx=%d are already allocated", ue_cc_idx);
     return false;
   }
 
@@ -352,7 +352,7 @@ bool ue_cell_ded_list::alloc_cqi_resources(uint32_t ue_cc_idx, uint32_t period)
     }
   }
   if (pucch_res->cqi_sched.nof_users[i_min][j_min] > max_users) {
-    log_h->error("Not enough PUCCH resources to allocate Scheduling Request\n");
+    logger.error("Not enough PUCCH resources to allocate Scheduling Request");
     return false;
   }
 
@@ -361,7 +361,7 @@ bool ue_cell_ded_list::alloc_cqi_resources(uint32_t ue_cc_idx, uint32_t period)
   // Compute I_sr
   if (period != 2 && period != 5 && period != 10 && period != 20 && period != 40 && period != 80 && period != 160 &&
       period != 32 && period != 64 && period != 128) {
-    log_h->error("Invalid CQI Report period %d ms\n", period);
+    logger.error("Invalid CQI Report period %d ms", period);
     return false;
   }
   if (cfg.cqi_cfg.sf_mapping[j_min] < period) {
@@ -381,7 +381,7 @@ bool ue_cell_ded_list::alloc_cqi_resources(uint32_t ue_cc_idx, uint32_t period)
       }
     }
   } else {
-    log_h->error("Allocating CQI: invalid sf_idx=%d for period=%d\n", cfg.cqi_cfg.sf_mapping[j_min], period);
+    logger.error("Allocating CQI: invalid sf_idx=%d for period=%d", cfg.cqi_cfg.sf_mapping[j_min], period);
     return false;
   }
 
@@ -399,7 +399,7 @@ bool ue_cell_ded_list::alloc_cqi_resources(uint32_t ue_cc_idx, uint32_t period)
 
   pucch_res->cqi_sched.nof_users[i_min][j_min]++;
 
-  log_h->info("Allocated CQI resources for ue_cc_idx=%d, time-frequency slot (%d, %d), n_pucch_2=%d, pmi_cfg_idx=%d\n",
+  logger.info("Allocated CQI resources for ue_cc_idx=%d, time-frequency slot (%d, %d), n_pucch_2=%d, pmi_cfg_idx=%d",
               ue_cc_idx,
               i_min,
               j_min,
@@ -417,10 +417,10 @@ bool ue_cell_ded_list::dealloc_cqi_resources(uint32_t ue_cc_idx)
 
   if (pucch_res->cqi_sched.nof_users[c->cqi_res.prb_idx][c->cqi_res.sf_idx] > 0) {
     pucch_res->cqi_sched.nof_users[c->cqi_res.prb_idx][c->cqi_res.sf_idx]--;
-    log_h->info("Deallocated CQI resources for time-frequency slot (%d, %d)\n", c->cqi_res.prb_idx, c->cqi_res.sf_idx);
+    logger.info("Deallocated CQI resources for time-frequency slot (%d, %d)", c->cqi_res.prb_idx, c->cqi_res.sf_idx);
   } else {
-    log_h->warning(
+    logger.warning(
-        "Removing CQI resources: no users in time-frequency slot (%d, %d)\n", c->cqi_res.prb_idx, c->cqi_res.sf_idx);
+        "Removing CQI resources: no users in time-frequency slot (%d, %d)", c->cqi_res.prb_idx, c->cqi_res.sf_idx);
   }
   c->cqi_res_present = false;
   return true;
@@ -430,11 +430,11 @@ bool ue_cell_ded_list::alloc_sr_resources(uint32_t period)
 {
   ue_cell_ded* cell = get_ue_cc_idx(UE_PCELL_CC_IDX);
   if (cell == nullptr) {
-    log_h->error("The user cell pcell has not been allocated\n");
+    logger.error("The user cell pcell has not been allocated");
     return false;
   }
   if (sr_res_present) {
-    log_h->error("The user sr resources are already allocated\n");
+    logger.error("The user sr resources are already allocated");
     return false;
   }
 
@@ -457,19 +457,19 @@ bool ue_cell_ded_list::alloc_sr_resources(uint32_t period)
   }
 
   if (pucch_res->sr_sched.nof_users[i_min][j_min] > max_users) {
-    log_h->error("Not enough PUCCH resources to allocate Scheduling Request\n");
+    logger.error("Not enough PUCCH resources to allocate Scheduling Request");
     return false;
   }
 
   // Compute I_sr
   if (period != 5 && period != 10 && period != 20 && period != 40 && period != 80) {
-    log_h->error("Invalid SchedulingRequest period %d ms\n", period);
+    logger.error("Invalid SchedulingRequest period %d ms", period);
     return false;
   }
   if (cfg.sr_cfg.sf_mapping[j_min] < period) {
     sr_res.sr_I = period - 5 + cfg.sr_cfg.sf_mapping[j_min];
   } else {
-    log_h->error("Allocating SR: invalid sf_idx=%d for period=%d\n", cfg.sr_cfg.sf_mapping[j_min], period);
+    logger.error("Allocating SR: invalid sf_idx=%d for period=%d", cfg.sr_cfg.sf_mapping[j_min], period);
     return false;
   }
 
@@ -485,7 +485,7 @@ bool ue_cell_ded_list::alloc_sr_resources(uint32_t period)
   sr_res.sr_sched_sf_idx  = j_min;
   sr_res_present          = true;
 
-  log_h->info("Allocated SR resources in time-freq slot (%d, %d), sf_cfg_idx=%d\n",
+  logger.info("Allocated SR resources in time-freq slot (%d, %d), sf_cfg_idx=%d",
               sr_res.sr_sched_sf_idx,
               sr_res.sr_sched_prb_idx,
               cfg.sr_cfg.sf_mapping[sr_res.sr_sched_sf_idx]);
@@ -499,13 +499,13 @@ bool ue_cell_ded_list::dealloc_sr_resources()
     if (pucch_res->sr_sched.nof_users[sr_res.sr_sched_prb_idx][sr_res.sr_sched_sf_idx] > 0) {
       pucch_res->sr_sched.nof_users[sr_res.sr_sched_prb_idx][sr_res.sr_sched_sf_idx]--;
     } else {
-      log_h->warning("Removing SR resources: no users in time-frequency slot (%d, %d)\n",
+      logger.warning("Removing SR resources: no users in time-frequency slot (%d, %d)",
                      sr_res.sr_sched_prb_idx,
                      sr_res.sr_sched_sf_idx);
     }
-    log_h->info(
+    logger.info(
-        "Deallocated SR resources for time-frequency slot (%d, %d)\n", sr_res.sr_sched_prb_idx, sr_res.sr_sched_sf_idx);
+        "Deallocated SR resources for time-frequency slot (%d, %d)", sr_res.sr_sched_prb_idx, sr_res.sr_sched_sf_idx);
-    log_h->debug("Remaining SR allocations for slot (%d, %d): %d\n",
+    logger.debug("Remaining SR allocations for slot (%d, %d): %d",
                  sr_res.sr_sched_prb_idx,
                  sr_res.sr_sched_sf_idx,
                  pucch_res->sr_sched.nof_users[sr_res.sr_sched_prb_idx][sr_res.sr_sched_sf_idx]);
@@ -519,11 +519,11 @@ bool ue_cell_ded_list::alloc_pucch_cs_resources()
 {
   ue_cell_ded* cell = get_ue_cc_idx(UE_PCELL_CC_IDX);
   if (cell == nullptr) {
-    log_h->error("The user cell pcell has not been allocated\n");
+    logger.error("The user cell pcell has not been allocated");
     return false;
   }
   if (n_pucch_cs_present) {
-    log_h->error("The user sr resources are already allocated\n");
+    logger.error("The user sr resources are already allocated");
     return false;
   }
 
@@ -536,11 +536,11 @@ bool ue_cell_ded_list::alloc_pucch_cs_resources()
       pucch_res->n_pucch_cs_used[i] = true;
       n_pucch_cs_idx                = i;
       n_pucch_cs_present            = true;
-      log_h->info("Allocated N_pucch_cs=%d\n", n_pucch_cs_idx);
+      logger.info("Allocated N_pucch_cs=%d", n_pucch_cs_idx);
       return true;
     }
   }
-  log_h->warning("Could not allocated N_pucch_cs\n");
+  logger.warning("Could not allocated N_pucch_cs");
   return false;
 }
 
@@ -549,7 +549,7 @@ bool ue_cell_ded_list::dealloc_pucch_cs_resources()
   if (n_pucch_cs_present) {
     pucch_res->n_pucch_cs_used[n_pucch_cs_idx] = false;
     n_pucch_cs_present                         = false;
-    log_h->info("Deallocated N_pucch_cs=%d\n", n_pucch_cs_idx);
+    logger.info("Deallocated N_pucch_cs=%d", n_pucch_cs_idx);
     return true;
   }
   return false;

srsenb/src/stack/rrc/rrc_mobility.cc

@@ -26,14 +26,14 @@
 
 namespace srsenb {
 
-#define Info(fmt, ...) rrc_log->info("Mobility: " fmt, ##__VA_ARGS__)
+#define Info(fmt, ...) logger.info("Mobility: " fmt, ##__VA_ARGS__)
-#define Error(fmt, ...) rrc_log->error("Mobility: " fmt, ##__VA_ARGS__)
+#define Error(fmt, ...) logger.error("Mobility: " fmt, ##__VA_ARGS__)
-#define Warning(fmt, ...) rrc_log->warning("Mobility: " fmt, ##__VA_ARGS__)
+#define Warning(fmt, ...) logger.warning("Mobility: " fmt, ##__VA_ARGS__)
-#define Debug(fmt, ...) rrc_log->debug("Mobility: " fmt, ##__VA_ARGS__)
+#define Debug(fmt, ...) logger.debug("Mobility: " fmt, ##__VA_ARGS__)
 
-#define procInfo(fmt, ...) parent->rrc_log->info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procInfo(fmt, ...) parent->logger.info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
-#define procWarning(fmt, ...) parent->rrc_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procWarning(fmt, ...) parent->logger.warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
-#define procError(fmt, ...) parent->rrc_log->error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procError(fmt, ...) parent->logger.error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
 
 using namespace asn1::rrc;
 
@@ -71,11 +71,11 @@ uint16_t compute_mac_i(uint16_t                            crnti,
 
   asn1::bit_ref bref(varShortMAC_packed, sizeof(varShortMAC_packed));
   if (var_short_mac.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) { // already zeroed, so no need to align
-    printf("Error packing varShortMAC\n");
+    printf("Error packing varShortMAC");
   }
   uint32_t N_bytes = bref.distance_bytes();
 
-  printf("Encoded varShortMAC: cellId=0x%x, PCI=%d, rnti=0x%x (%d bytes)\n", cellid, pci, crnti, N_bytes);
+  printf("Encoded varShortMAC: cellId=0x%x, PCI=%d, rnti=0x%x (%d bytes)", cellid, pci, crnti, N_bytes);
 
   // Compute MAC-I
   switch (integ_algo) {
@@ -98,7 +98,7 @@ uint16_t compute_mac_i(uint16_t                            crnti,
                                 mac_key);
       break;
     default:
-      printf("Unsupported integrity algorithm %d.\n", integ_algo);
+      printf("Unsupported integrity algorithm %d.", integ_algo);
   }
 
   uint16_t short_mac_i = (((uint16_t)mac_key[2] << 8u) | (uint16_t)mac_key[3]);
@@ -135,10 +135,10 @@ uint16_t rrc::start_ho_ue_resource_alloc(const asn1::s1ap::ho_request_s&
   // TODO: Decision Making on whether the same QoS of the source eNB can be provided by target eNB
 
   /* Evaluate if cell exists */
-  uint32_t                target_eci  = container.target_cell_id.cell_id.to_number();
+  uint32_t               target_eci  = container.target_cell_id.cell_id.to_number();
   const enb_cell_common* target_cell = cell_common_list->get_cell_id(rrc_details::eci_to_cellid(target_eci));
   if (target_cell == nullptr) {
-    rrc_log->error("The S1-handover target cell_id=0x%x does not exist\n", rrc_details::eci_to_cellid(target_eci));
+    logger.error("The S1-handover target cell_id=0x%x does not exist", rrc_details::eci_to_cellid(target_eci));
     return SRSLTE_INVALID_RNTI;
   }
 
@@ -153,7 +153,7 @@ uint16_t rrc::start_ho_ue_resource_alloc(const asn1::s1ap::ho_request_s&
   ue_cfg.supported_cc_list[0].dl_cfg.tm  = SRSLTE_TM1;
   uint16_t rnti                          = mac->reserve_new_crnti(ue_cfg);
   if (rnti == SRSLTE_INVALID_RNTI) {
-    rrc_log->error("Failed to allocate C-RNTI resources\n");
+    logger.error("Failed to allocate C-RNTI resources");
     return SRSLTE_INVALID_RNTI;
   }
 
@@ -166,7 +166,7 @@ uint16_t rrc::start_ho_ue_resource_alloc(const asn1::s1ap::ho_request_s&
 
   //  /* Setup e-RABs & DRBs / establish an UL/DL S1 bearer to the S-GW */
   //  if (not setup_ue_erabs(rnti, msg)) {
-  //    rrc_ptr->rrc_log->error("Failed to setup e-RABs for rnti=0x%x\n", );
+  //    rrc_ptr->logger.error("Failed to setup e-RABs for rnti=0x%x", );
   //  }
 
   // TODO: KeNB derivations
@@ -187,7 +187,7 @@ rrc::ue::rrc_mobility::rrc_mobility(rrc::ue* outer_ue) :
   rrc_ue(outer_ue),
   rrc_enb(outer_ue->parent),
   pool(outer_ue->pool),
-  rrc_log(outer_ue->parent->rrc_log)
+  logger(outer_ue->parent->logger)
 {}
 
 //! Method to add Mobility Info to a RRC Connection Reconfiguration Message
@@ -209,25 +209,25 @@ bool rrc::ue::rrc_mobility::fill_conn_recfg_no_ho_cmd(asn1::rrc::rrc_conn_recfg_
 void rrc::ue::rrc_mobility::handle_ue_meas_report(const meas_report_s& msg)
 {
   if (not is_in_state<idle_st>()) {
-    Info("Received a MeasReport while UE is performing Handover. Ignoring...\n");
+    Info("Received a MeasReport while UE is performing Handover. Ignoring...");
     return;
   }
   // Check if meas_id is valid
   const meas_results_s& meas_res = msg.crit_exts.c1().meas_report_r8().meas_results;
   if (not meas_res.meas_result_neigh_cells_present) {
-    Info("Received a MeasReport, but the UE did not detect any cell.\n");
+    Info("Received a MeasReport, but the UE did not detect any cell.");
     return;
   }
   if (meas_res.meas_result_neigh_cells.type().value !=
       meas_results_s::meas_result_neigh_cells_c_::types::meas_result_list_eutra) {
-    Error("MeasReports regarding non-EUTRA are not supported!\n");
+    Error("MeasReports regarding non-EUTRA are not supported!");
     return;
   }
   const meas_id_list&  measid_list  = rrc_ue->current_ue_cfg.meas_cfg.meas_id_to_add_mod_list;
   const meas_obj_list& measobj_list = rrc_ue->current_ue_cfg.meas_cfg.meas_obj_to_add_mod_list;
   auto                 measid_it    = srslte::find_rrc_obj_id(measid_list, meas_res.meas_id);
   if (measid_it == measid_list.end()) {
-    Warning("The measurement ID %d provided by the UE does not exist.\n", meas_res.meas_id);
+    Warning("The measurement ID %d provided by the UE does not exist.", meas_res.meas_id);
     return;
   }
   const meas_result_list_eutra_l& eutra_report_list = meas_res.meas_result_neigh_cells.meas_result_list_eutra();
@@ -239,17 +239,17 @@ void rrc::ue::rrc_mobility::handle_ue_meas_report(const meas_report_s& msg)
 
   // iterate from strongest to weakest cell
   const ue_cell_ded* pcell         = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
-  const auto&                meas_list_cfg = pcell->cell_common->cell_cfg.meas_cfg.meas_cells;
+  const auto&        meas_list_cfg = pcell->cell_common->cell_cfg.meas_cfg.meas_cells;
   for (const meas_result_eutra_s& e : eutra_report_list) {
-    auto                    same_pci = [&e](const meas_cell_cfg_t& c) { return c.pci == e.pci; };
+    auto                   same_pci = [&e](const meas_cell_cfg_t& c) { return c.pci == e.pci; };
-    auto                    meas_it  = std::find_if(meas_list_cfg.begin(), meas_list_cfg.end(), same_pci);
+    auto                   meas_it  = std::find_if(meas_list_cfg.begin(), meas_list_cfg.end(), same_pci);
     const enb_cell_common* c        = rrc_enb->cell_common_list->get_pci(e.pci);
     if (meas_it != meas_list_cfg.end()) {
       meas_ev.target_eci = meas_it->eci;
     } else if (c != nullptr) {
       meas_ev.target_eci = (rrc_enb->cfg.enb_id << 8u) + c->cell_cfg.cell_id;
     } else {
-      rrc_log->warning("The PCI=%d inside the MeasReport is not recognized.\n", e.pci);
+      logger.warning("The PCI=%d inside the MeasReport is not recognized.", e.pci);
       continue;
     }
 
@@ -272,14 +272,14 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
                                                  bool     fwd_direct_path_available)
 {
   if (fwd_direct_path_available) {
-    Error("Direct tunnels not supported supported\n");
+    Error("Direct tunnels not supported supported");
     return false;
   }
 
   srslte::plmn_id_t target_plmn =
       srslte::make_plmn_id_t(rrc_enb->cfg.sib1.cell_access_related_info.plmn_id_list[0].plmn_id);
-  const ue_cell_ded* src_cell_ded = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
+  const ue_cell_ded*     src_cell_ded = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
-  const enb_cell_common*    src_cell_cfg = src_cell_ded->cell_common;
+  const enb_cell_common* src_cell_cfg = src_cell_ded->cell_common;
 
   /*** Fill HO Preparation Info ***/
   asn1::rrc::ho_prep_info_s         hoprep;
@@ -310,12 +310,12 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
       uint8_t       buffer[128];
       asn1::bit_ref bref(&buffer[0], sizeof(buffer));
       if (capitem.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-        rrc_log->error("Failed to pack UE EUTRA Capability\n");
+        logger.error("Failed to pack UE EUTRA Capability");
       }
       hoprep_r8.ue_radio_access_cap_info[0].ue_cap_rat_container.resize((uint32_t)bref.distance_bytes());
       memcpy(&hoprep_r8.ue_radio_access_cap_info[0].ue_cap_rat_container[0], &buffer[0], bref.distance_bytes());
     }
-    Debug("UE RA Category: %d\n", capitem.ue_category);
+    Debug("UE RA Category: %d", capitem.ue_category);
   } else {
     hoprep_r8.ue_radio_access_cap_info.resize(1);
     hoprep_r8.ue_radio_access_cap_info[0].rat_type = asn1::rrc::rat_type_e::eutra;
@@ -323,7 +323,7 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
     srslte::unique_byte_buffer_t buffer = srslte::allocate_unique_buffer(*pool);
     asn1::bit_ref                bref(buffer->msg, buffer->get_tailroom());
     if (rrc_ue->eutra_capabilities.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-      rrc_log->error("Failed to pack UE EUTRA Capability\n");
+      logger.error("Failed to pack UE EUTRA Capability");
       return false;
     }
     hoprep_r8.ue_radio_access_cap_info[0].ue_cap_rat_container.resize(bref.distance_bytes());
@@ -362,13 +362,13 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
   srslte::unique_byte_buffer_t buffer = srslte::allocate_unique_buffer(*pool);
   asn1::bit_ref                bref(buffer->msg, buffer->get_tailroom());
   if (hoprep.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-    Error("Failed to pack HO preparation msg\n");
+    Error("Failed to pack HO preparation msg");
     return false;
   }
   buffer->N_bytes = bref.distance_bytes();
 
   bool success = rrc_enb->s1ap->send_ho_required(rrc_ue->rnti, target_eci, target_plmn, std::move(buffer));
-  Info("sent s1ap msg with HO Required\n");
+  Info("sent s1ap msg with HO Required");
   return success;
 }
 
@@ -383,7 +383,7 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
 void rrc::ue::rrc_mobility::handle_ho_preparation_complete(bool is_success, srslte::unique_byte_buffer_t container)
 {
   if (not is_success) {
-    log_h->info("Received S1AP HandoverFailure. Aborting Handover...\n");
+    log_h->info("Received S1AP HandoverFailure. Aborting Handover...");
     trigger(srslte::failure_ev{});
     return;
   }
@@ -392,15 +392,15 @@ void rrc::ue::rrc_mobility::handle_ho_preparation_complete(bool is_success, srsl
   {
     asn1::cbit_ref bref(container->msg, container->N_bytes);
     if (rrchocmd.unpack(bref) != asn1::SRSASN_SUCCESS) {
-      get_log()->warning("Unpacking of RRC HOCommand was unsuccessful\n");
+      get_log()->warning("Unpacking of RRC HOCommand was unsuccessful");
-      get_log()->warning_hex(container->msg, container->N_bytes, "Received container:\n");
+      get_log()->warning_hex(container->msg, container->N_bytes, "Received container:");
       trigger(ho_cancel_ev{});
       return;
     }
   }
   if (rrchocmd.crit_exts.type().value != c1_or_crit_ext_opts::c1 or
       rrchocmd.crit_exts.c1().type().value != ho_cmd_s::crit_exts_c_::c1_c_::types_opts::ho_cmd_r8) {
-    get_log()->warning("Only handling r8 Handover Commands\n");
+    get_log()->warning("Only handling r8 Handover Commands");
     trigger(ho_cancel_ev{});
     return;
   }
@@ -429,7 +429,7 @@ bool rrc::ue::rrc_mobility::start_s1_tenb_ho(
  * @param target_cell
  */
 void rrc::ue::rrc_mobility::fill_mobility_reconf_common(asn1::rrc::dl_dcch_msg_s& msg,
-                                                        const enb_cell_common&   target_cell,
+                                                        const enb_cell_common&    target_cell,
                                                         uint32_t                  src_dl_earfcn,
                                                         uint32_t                  src_pci)
 {
@@ -492,7 +492,7 @@ bool rrc::ue::rrc_mobility::start_enb_status_transfer()
     b.erab_id                                   = erab_pair.second.id;
     srslte::pdcp_lte_state_t pdcp_state         = {};
     if (not rrc_enb->pdcp->get_bearer_state(rrc_ue->rnti, lcid, &pdcp_state)) {
-      Error("PDCP bearer lcid=%d for rnti=0x%x was not found\n", lcid, rrc_ue->rnti);
+      Error("PDCP bearer lcid=%d for rnti=0x%x was not found", lcid, rrc_ue->rnti);
       return false;
     }
     b.dl_hfn     = pdcp_state.tx_hfn;
@@ -502,7 +502,7 @@ bool rrc::ue::rrc_mobility::start_enb_status_transfer()
     s1ap_bearers.push_back(b);
   }
 
-  Info("PDCP Bearer list sent to S1AP to initiate the eNB Status Transfer\n");
+  Info("PDCP Bearer list sent to S1AP to initiate the eNB Status Transfer");
   return rrc_enb->s1ap->send_enb_status_transfer_proc(rrc_ue->rnti, s1ap_bearers);
 }
 
@@ -538,7 +538,7 @@ void rrc::ue::rrc_mobility::s1_source_ho_st::wait_ho_req_ack_st::enter(s1_source
 {
   srslte::console("Starting S1 Handover of rnti=0x%x to cellid=0x%x.\n", f->parent_fsm()->rrc_ue->rnti, ev.target_eci);
   f->get_log()->info(
-      "Starting S1 Handover of rnti=0x%x to cellid=0x%x.\n", f->parent_fsm()->rrc_ue->rnti, ev.target_eci);
+      "Starting S1 Handover of rnti=0x%x to cellid=0x%x.", f->parent_fsm()->rrc_ue->rnti, ev.target_eci);
   f->report = ev;
 
   bool success = f->parent_fsm()->start_ho_preparation(f->report.target_eci, f->report.meas_obj->meas_obj_id, false);
@@ -554,20 +554,20 @@ void rrc::ue::rrc_mobility::s1_source_ho_st::send_ho_cmd(wait_ho_req_ack_st& s,
   {
     asn1::cbit_ref bref(&ho_cmd.ho_cmd_msg[0], ho_cmd.ho_cmd_msg.size());
     if (dl_dcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS) {
-      get_log()->warning("Unpacking of RRC DL-DCCH message with HO Command was unsuccessful.\n");
+      get_log()->warning("Unpacking of RRC DL-DCCH message with HO Command was unsuccessful.");
       trigger(ho_cancel_ev{});
       return;
     }
   }
   if (dl_dcch_msg.msg.type().value != dl_dcch_msg_type_c::types_opts::c1 or
       dl_dcch_msg.msg.c1().type().value != dl_dcch_msg_type_c::c1_c_::types_opts::rrc_conn_recfg) {
-    get_log()->warning("HandoverCommand is expected to contain an RRC Connection Reconf message inside\n");
+    get_log()->warning("HandoverCommand is expected to contain an RRC Connection Reconf message inside");
     trigger(ho_cancel_ev{});
     return;
   }
   asn1::rrc::rrc_conn_recfg_s& reconf = dl_dcch_msg.msg.c1().rrc_conn_recfg();
   if (not reconf.crit_exts.c1().rrc_conn_recfg_r8().mob_ctrl_info_present) {
-    get_log()->warning("HandoverCommand is expected to have mobility control subfield\n");
+    get_log()->warning("HandoverCommand is expected to have mobility control subfield");
     trigger(ho_cancel_ev{});
     return;
   }
@@ -591,7 +591,7 @@ void rrc::ue::rrc_mobility::s1_source_ho_st::handle_ho_cancel(const ho_cancel_ev
 
 void rrc::ue::rrc_mobility::s1_source_ho_st::status_transfer_st::enter(s1_source_ho_st* f)
 {
-  f->get_log()->info("HandoverCommand of rnti=0x%x handled successfully.\n", f->parent_fsm()->rrc_ue->rnti);
+  f->get_log()->info("HandoverCommand of rnti=0x%x handled successfully.", f->parent_fsm()->rrc_ue->rnti);
 
   // TODO: Do anything with MeasCfg info within the Msg (e.g. update ue_var_meas)?
 
@@ -613,13 +613,13 @@ void rrc::ue::rrc_mobility::handle_ho_req(idle_st& s, const ho_req_rx_ev& ho_req
   asn1::cbit_ref            bref{rrc_container.data(), rrc_container.size()};
   asn1::rrc::ho_prep_info_s hoprep;
   if (hoprep.unpack(bref) != asn1::SRSASN_SUCCESS) {
-    rrc_enb->rrc_log->error("Failed to decode HandoverPreparationinformation in S1AP SourceENBToTargetENBContainer\n");
+    rrc_enb->logger.error("Failed to decode HandoverPreparationinformation in S1AP SourceENBToTargetENBContainer");
     trigger(srslte::failure_ev{});
     return;
   }
   if (hoprep.crit_exts.type().value != c1_or_crit_ext_opts::c1 or
       hoprep.crit_exts.c1().type().value != ho_prep_info_s::crit_exts_c_::c1_c_::types_opts::ho_prep_info_r8) {
-    rrc_enb->rrc_log->error("Only release 8 supported\n");
+    rrc_enb->logger.error("Only release 8 supported");
     trigger(srslte::failure_ev{});
     return;
   }
@@ -632,7 +632,7 @@ void rrc::ue::rrc_mobility::handle_ho_req(idle_st& s, const ho_req_rx_ev& ho_req
   }
 
   /* Prepare Handover Request Acknowledgment - Handover Command */
-  dl_dcch_msg_s              dl_dcch_msg;
+  dl_dcch_msg_s      dl_dcch_msg;
   const ue_cell_ded* target_cell = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
 
   // Fill fields common to all types of handover (e.g. new CQI/SR configuration, mobControlInfo)
@@ -657,7 +657,7 @@ void rrc::ue::rrc_mobility::handle_ho_req(idle_st& s, const ho_req_rx_ev& ho_req
   srslte::unique_byte_buffer_t ho_cmd_pdu = srslte::allocate_unique_buffer(*pool);
   asn1::bit_ref                bref2{ho_cmd_pdu->msg, ho_cmd_pdu->get_tailroom()};
   if (dl_dcch_msg.pack(bref2) != asn1::SRSASN_SUCCESS) {
-    rrc_log->error("Failed to pack HandoverCommand\n");
+    logger.error("Failed to pack HandoverCommand");
     trigger(srslte::failure_ev{});
     return;
   }
@@ -670,7 +670,7 @@ void rrc::ue::rrc_mobility::handle_ho_req(idle_st& s, const ho_req_rx_ev& ho_req
   memcpy(ho_cmd_r8.ho_cmd_msg.data(), ho_cmd_pdu->msg, bref2.distance_bytes());
   bref2 = {ho_cmd_pdu->msg, ho_cmd_pdu->get_tailroom()};
   if (ho_cmd.pack(bref2) != asn1::SRSASN_SUCCESS) {
-    rrc_log->error("Failed to pack HandoverCommand\n");
+    logger.error("Failed to pack HandoverCommand");
     trigger(srslte::failure_ev{});
     return;
   }
@@ -701,16 +701,16 @@ bool rrc::ue::rrc_mobility::apply_ho_prep_cfg(const ho_prep_info_r8_ies_s&    ho
                                               const asn1::s1ap::ho_request_s& ho_req_msg)
 {
   const ue_cell_ded* target_cell     = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
-  const cell_cfg_t&          target_cell_cfg = target_cell->cell_common->cell_cfg;
+  const cell_cfg_t&  target_cell_cfg = target_cell->cell_common->cell_cfg;
 
   // Establish ERABs/DRBs
   for (const auto& erab_item : ho_req_msg.protocol_ies.erab_to_be_setup_list_ho_req.value) {
     auto& erab = erab_item.value.erab_to_be_setup_item_ho_req();
     if (erab.ext) {
-      get_log()->warning("Not handling E-RABToBeSetupList extensions\n");
+      get_log()->warning("Not handling E-RABToBeSetupList extensions");
     }
     if (erab.transport_layer_address.length() > 32) {
-      get_log()->error("IPv6 addresses not currently supported\n");
+      get_log()->error("IPv6 addresses not currently supported");
       trigger(srslte::failure_ev{});
       return false;
     }
@@ -718,7 +718,7 @@ bool rrc::ue::rrc_mobility::apply_ho_prep_cfg(const ho_prep_info_r8_ies_s&    ho
     if (not erab.ie_exts_present or not erab.ie_exts.data_forwarding_not_possible_present or
         erab.ie_exts.data_forwarding_not_possible.ext.value !=
             asn1::s1ap::data_forwarding_not_possible_opts::data_forwarding_not_possible) {
-      get_log()->warning("Data Forwarding of E-RABs not supported\n");
+      get_log()->warning("Data Forwarding of E-RABs not supported");
     }
 
     uint32_t teid_out;
@@ -740,13 +740,13 @@ bool rrc::ue::rrc_mobility::apply_ho_prep_cfg(const ho_prep_info_r8_ies_s&    ho
     if (cap.rat_type.value == rat_type_opts::eutra) {
       asn1::cbit_ref bref(cap.ue_cap_rat_container.data(), cap.ue_cap_rat_container.size());
       if (rrc_ue->eutra_capabilities.unpack(bref) != asn1::SRSASN_SUCCESS) {
-        rrc_log->warning("Failed to unpack UE EUTRA Capability\n");
+        logger.warning("Failed to unpack UE EUTRA Capability");
         continue;
       }
-      if (rrc_log->get_level() == srslte::LOG_LEVEL_DEBUG) {
+      if (logger.debug.enabled()) {
         asn1::json_writer js{};
         rrc_ue->eutra_capabilities.to_json(js);
-        rrc_log->debug_long("New rnti=0x%x EUTRA capabilities: %s\n", rrc_ue->rnti, js.to_string().c_str());
+        logger.debug("New rnti=0x%x EUTRA capabilities: %s", rrc_ue->rnti, js.to_string().c_str());
       }
       rrc_ue->ue_capabilities             = srslte::make_rrc_ue_capabilities(rrc_ue->eutra_capabilities);
       rrc_ue->eutra_capabilities_unpacked = true;
@@ -771,9 +771,9 @@ bool rrc::ue::rrc_mobility::apply_ho_prep_cfg(const ho_prep_info_r8_ies_s&    ho
 void rrc::ue::rrc_mobility::handle_recfg_complete(wait_recfg_comp& s, const recfg_complete_ev& ev)
 {
   ue_cell_ded* target_cell = rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
-  rrc_log->info("User rnti=0x%x successfully handovered to cell_id=0x%x\n",
+  logger.info("User rnti=0x%x successfully handovered to cell_id=0x%x",
-                rrc_ue->rnti,
+              rrc_ue->rnti,
-                target_cell->cell_common->cell_cfg.cell_id);
+              target_cell->cell_common->cell_cfg.cell_id);
   uint64_t target_eci = (rrc_enb->cfg.enb_id << 8u) + target_cell->cell_common->cell_cfg.cell_id;
 
   rrc_enb->s1ap->send_ho_notify(rrc_ue->rnti, target_eci);
@@ -789,7 +789,7 @@ void rrc::ue::rrc_mobility::handle_status_transfer(s1_target_ho_st& s, const sta
     const auto& erab_item = erab.value.bearers_subject_to_status_transfer_item();
     auto        erab_it   = rrc_ue->bearer_list.get_erabs().find(erab_item.erab_id);
     if (erab_it == rrc_ue->bearer_list.get_erabs().end()) {
-      rrc_log->warning("The E-RAB Id=%d is not recognized\n", erab_item.erab_id);
+      logger.warning("The E-RAB Id=%d is not recognized", erab_item.erab_id);
       continue;
     }
     const auto& drbs  = rrc_ue->bearer_list.get_established_drbs();
@@ -797,7 +797,7 @@ void rrc::ue::rrc_mobility::handle_status_transfer(s1_target_ho_st& s, const sta
     auto        drb_it =
         std::find_if(drbs.begin(), drbs.end(), [drbid](const drb_to_add_mod_s& drb) { return drb.drb_id == drbid; });
     if (drb_it == drbs.end()) {
-      rrc_log->warning("The DRB id=%d does not exist\n", erab_item.erab_id - 4);
+      logger.warning("The DRB id=%d does not exist", erab_item.erab_id - 4);
     }
 
     srslte::pdcp_lte_state_t drb_state{};
@@ -806,10 +806,10 @@ void rrc::ue::rrc_mobility::handle_status_transfer(s1_target_ho_st& s, const sta
     drb_state.rx_hfn                    = erab_item.ul_coun_tvalue.hfn;
     drb_state.next_pdcp_rx_sn           = erab_item.ul_coun_tvalue.pdcp_sn;
     drb_state.last_submitted_pdcp_rx_sn = erab_item.ul_coun_tvalue.pdcp_sn;
-    rrc_log->info("Setting lcid=%d PDCP state to {Tx SN: %d, Rx SN: %d}\n",
+    logger.info("Setting lcid=%d PDCP state to {Tx SN: %d, Rx SN: %d}",
-                  drb_it->lc_ch_id,
+                drb_it->lc_ch_id,
-                  drb_state.next_pdcp_tx_sn,
+                drb_state.next_pdcp_tx_sn,
-                  drb_state.next_pdcp_rx_sn);
+                drb_state.next_pdcp_rx_sn);
     rrc_enb->pdcp->set_bearer_state(rrc_ue->rnti, drb_it->lc_ch_id, drb_state);
   }
 
@@ -835,12 +835,12 @@ void rrc::ue::rrc_mobility::intraenb_ho_st::enter(rrc_mobility* f, const ho_meas
   target_cell      = f->rrc_enb->cell_common_list->get_cell_id(cell_id);
   source_cell      = f->rrc_ue->ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX)->cell_common;
   if (target_cell == nullptr) {
-    f->log_h->error("The target cell_id=0x%x was not found in the list of eNB cells\n", cell_id);
+    f->log_h->error("The target cell_id=0x%x was not found in the list of eNB cells", cell_id);
     f->trigger(srslte::failure_ev{});
     return;
   }
 
-  f->log_h->info("Starting intraeNB Handover of rnti=0x%x to 0x%x.\n", f->rrc_ue->rnti, meas_report.target_eci);
+  f->log_h->info("Starting intraeNB Handover of rnti=0x%x to 0x%x.", f->rrc_ue->rnti, meas_report.target_eci);
 
   if (target_cell == nullptr) {
     f->trigger(srslte::failure_ev{});
@@ -875,7 +875,7 @@ void rrc::ue::rrc_mobility::intraenb_ho_st::enter(rrc_mobility* f, const ho_meas
 
 void rrc::ue::rrc_mobility::handle_crnti_ce(intraenb_ho_st& s, const user_crnti_upd_ev& ev)
 {
-  rrc_log->info("UE performing handover updated its temp-crnti=0x%x to rnti=0x%x\n", ev.temp_crnti, ev.crnti);
+  logger.info("UE performing handover updated its temp-crnti=0x%x to rnti=0x%x", ev.temp_crnti, ev.crnti);
   bool is_first_crnti_ce = s.last_temp_crnti == SRSLTE_INVALID_RNTI;
   s.last_temp_crnti      = ev.temp_crnti;
 
@@ -894,14 +894,14 @@ void rrc::ue::rrc_mobility::handle_crnti_ce(intraenb_ho_st& s, const user_crnti_
     rrc_ue->apply_pdcp_srb_updates(rrc_ue->current_ue_cfg.rr_cfg);
     rrc_ue->apply_pdcp_drb_updates(rrc_ue->current_ue_cfg.rr_cfg);
   } else {
-    rrc_log->info("Received duplicate C-RNTI CE during rnti=0x%x handover.\n", rrc_ue->rnti);
+    logger.info("Received duplicate C-RNTI CE during rnti=0x%x handover.", rrc_ue->rnti);
   }
 }
 
 void rrc::ue::rrc_mobility::handle_recfg_complete(intraenb_ho_st& s, const recfg_complete_ev& ev)
 {
-  rrc_log->info(
+  logger.info(
-      "User rnti=0x%x successfully handovered to cell_id=0x%x\n", rrc_ue->rnti, s.target_cell->cell_cfg.cell_id);
+      "User rnti=0x%x successfully handovered to cell_id=0x%x", rrc_ue->rnti, s.target_cell->cell_cfg.cell_id);
 }
 
 } // namespace srsenb

srsenb/src/stack/rrc/rrc_ue.cc

@@ -94,17 +94,15 @@ void rrc::ue::set_activity()
   // re-start activity timer with current timeout value
   activity_timer.run();
 
-  if (parent && parent->rrc_log) {
+  if (parent) {
-    parent->rrc_log->debug("Activity registered for rnti=0x%x (timeout_value=%dms)\n", rnti, activity_timer.duration());
+    parent->logger.debug("Activity registered for rnti=0x%x (timeout_value=%dms)", rnti, activity_timer.duration());
   }
 }
 
 void rrc::ue::activity_timer_expired()
 {
   if (parent) {
-    if (parent->rrc_log) {
+    parent->logger.info("Activity timer for rnti=0x%x expired after %d ms", rnti, activity_timer.time_elapsed());
-      parent->rrc_log->info("Activity timer for rnti=0x%x expired after %d ms\n", rnti, activity_timer.time_elapsed());
-    }
 
     if (parent->s1ap->user_exists(rnti)) {
       parent->s1ap->user_release(rnti, asn1::s1ap::cause_radio_network_opts::user_inactivity);
@@ -134,12 +132,12 @@ void rrc::ue::set_activity_timeout(const activity_timeout_type_t type)
       deadline_ms = parent->cfg.inactivity_timeout_ms % 1000;
       break;
     default:
-      parent->rrc_log->error("Unknown timeout type %d", type);
+      parent->logger.error("Unknown timeout type %d", type);
   }
 
   uint32_t deadline = deadline_s * 1e3 + deadline_ms;
   activity_timer.set(deadline, [this](uint32_t tid) { activity_timer_expired(); });
-  parent->rrc_log->debug("Setting timer for %s for rnti=0x%x to %dms\n", to_string(type).c_str(), rnti, deadline);
+  parent->logger.debug("Setting timer for %s for rnti=0x%x to %dms", to_string(type).c_str(), rnti, deadline);
 
   set_activity();
 }
@@ -162,7 +160,7 @@ void rrc::ue::parse_ul_dcch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
   asn1::cbit_ref bref(pdu->msg, pdu->N_bytes);
   if (ul_dcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or
       ul_dcch_msg.msg.type().value != ul_dcch_msg_type_c::types_opts::c1) {
-    parent->rrc_log->error("Failed to unpack UL-DCCH message\n");
+    parent->logger.error("Failed to unpack UL-DCCH message");
     return;
   }
 
@@ -226,14 +224,14 @@ void rrc::ue::parse_ul_dcch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
       if (mobility_handler != nullptr) {
         mobility_handler->handle_ue_meas_report(ul_dcch_msg.msg.c1().meas_report());
       } else {
-        parent->rrc_log->warning("Received MeasReport but no mobility configuration is available\n");
+        parent->logger.warning("Received MeasReport but no mobility configuration is available");
       }
       break;
     case ul_dcch_msg_type_c::c1_c_::types::ue_info_resp_r9:
       handle_ue_info_resp(ul_dcch_msg.msg.c1().ue_info_resp_r9());
       break;
     default:
-      parent->rrc_log->error("Msg: %s not supported\n", ul_dcch_msg.msg.c1().type().to_string().c_str());
+      parent->logger.error("Msg: %s not supported", ul_dcch_msg.msg.c1().type().to_string().c_str());
       break;
   }
 }
@@ -250,7 +248,7 @@ std::string rrc::ue::to_string(const activity_timeout_type_t& type)
 void rrc::ue::handle_rrc_con_req(rrc_conn_request_s* msg)
 {
   if (not parent->s1ap->is_mme_connected()) {
-    parent->rrc_log->error("MME isn't connected. Sending Connection Reject\n");
+    parent->logger.error("MME isn't connected. Sending Connection Reject");
     send_connection_reject();
     return;
   }
@@ -303,7 +301,7 @@ void rrc::ue::handle_rrc_con_setup_complete(rrc_conn_setup_complete_s* msg, srsl
   // Inform PHY about the configuration completion
   parent->phy->complete_config(rnti);
 
-  parent->rrc_log->info("RRCConnectionSetupComplete transaction ID: %d\n", msg->rrc_transaction_id);
+  parent->logger.info("RRCConnectionSetupComplete transaction ID: %d", msg->rrc_transaction_id);
   rrc_conn_setup_complete_r8_ies_s* msg_r8 = &msg->crit_exts.c1().rrc_conn_setup_complete_r8();
 
   // TODO: msg->selected_plmn_id - used to select PLMN from SIB1 list
@@ -353,15 +351,15 @@ void rrc::ue::send_connection_reject()
 void rrc::ue::handle_rrc_con_reest_req(rrc_conn_reest_request_s* msg)
 {
   if (not parent->s1ap->is_mme_connected()) {
-    parent->rrc_log->error("MME isn't connected. Sending Connection Reject\n");
+    parent->logger.error("MME isn't connected. Sending Connection Reject");
     send_connection_reject();
     return;
   }
-  parent->rrc_log->debug("rnti=0x%x, phyid=0x%x, smac=0x%x, cause=%s\n",
+  parent->logger.debug("rnti=0x%x, phyid=0x%x, smac=0x%x, cause=%s",
-                         (uint32_t)msg->crit_exts.rrc_conn_reest_request_r8().ue_id.c_rnti.to_number(),
+                       (uint32_t)msg->crit_exts.rrc_conn_reest_request_r8().ue_id.c_rnti.to_number(),
-                         msg->crit_exts.rrc_conn_reest_request_r8().ue_id.pci,
+                       msg->crit_exts.rrc_conn_reest_request_r8().ue_id.pci,
-                         (uint32_t)msg->crit_exts.rrc_conn_reest_request_r8().ue_id.short_mac_i.to_number(),
+                       (uint32_t)msg->crit_exts.rrc_conn_reest_request_r8().ue_id.short_mac_i.to_number(),
-                         msg->crit_exts.rrc_conn_reest_request_r8().reest_cause.to_string().c_str());
+                       msg->crit_exts.rrc_conn_reest_request_r8().reest_cause.to_string().c_str());
   if (is_idle()) {
     uint16_t               old_rnti = msg->crit_exts.rrc_conn_reest_request_r8().ue_id.c_rnti.to_number();
     uint16_t               old_pci  = msg->crit_exts.rrc_conn_reest_request_r8().ue_id.pci;
@@ -370,8 +368,8 @@ void rrc::ue::handle_rrc_con_reest_req(rrc_conn_reest_request_s* msg)
     // Reject unrecognized rntis, and PCIs that do not belong to eNB
     if (ue_it != parent->users.end() and old_cell != nullptr and
         ue_it->second->ue_cell_list.get_enb_cc_idx(old_cell->enb_cc_idx) != nullptr) {
-      parent->rrc_log->info("ConnectionReestablishmentRequest for rnti=0x%x. Sending Connection Reestablishment\n",
+      parent->logger.info("ConnectionReestablishmentRequest for rnti=0x%x. Sending Connection Reestablishment",
-                            old_rnti);
+                          old_rnti);
 
       // Cancel Handover in Target eNB if on-going
       parent->users.at(old_rnti)->mobility_handler->trigger(rrc_mobility::ho_cancel_ev{});
@@ -390,35 +388,35 @@ void rrc::ue::handle_rrc_con_reest_req(rrc_conn_reest_request_s* msg)
         old_reest_pdcp_state[lcid] = {};
         parent->pdcp->get_bearer_state(old_rnti, lcid, &old_reest_pdcp_state[lcid]);
 
-        parent->rrc_log->debug("Getting PDCP state for E-RAB with LCID %d\n", lcid);
+        parent->logger.debug("Getting PDCP state for E-RAB with LCID %d", lcid);
-        parent->rrc_log->debug("Got PDCP state: TX HFN %d, NEXT_PDCP_TX_SN %d, RX_HFN %d, NEXT_PDCP_RX_SN %d, "
+        parent->logger.debug("Got PDCP state: TX HFN %d, NEXT_PDCP_TX_SN %d, RX_HFN %d, NEXT_PDCP_RX_SN %d, "
-                               "LAST_SUBMITTED_PDCP_RX_SN %d\n",
+                             "LAST_SUBMITTED_PDCP_RX_SN %d",
-                               old_reest_pdcp_state[lcid].tx_hfn,
+                             old_reest_pdcp_state[lcid].tx_hfn,
-                               old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
+                             old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
-                               old_reest_pdcp_state[lcid].rx_hfn,
+                             old_reest_pdcp_state[lcid].rx_hfn,
-                               old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
+                             old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
-                               old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
+                             old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
       }
 
       // Make sure UE capabilities are copied over to new RNTI
       eutra_capabilities          = parent->users.at(old_rnti)->eutra_capabilities;
       eutra_capabilities_unpacked = parent->users.at(old_rnti)->eutra_capabilities_unpacked;
       ue_capabilities             = parent->users.at(old_rnti)->ue_capabilities;
-      if (parent->rrc_log->get_level() == srslte::LOG_LEVEL_DEBUG) {
+      if (parent->logger.debug.enabled()) {
         asn1::json_writer js{};
         eutra_capabilities.to_json(js);
-        parent->rrc_log->debug_long("rnti=0x%x EUTRA capabilities: %s\n", rnti, js.to_string().c_str());
+        parent->logger.debug("rnti=0x%x EUTRA capabilities: %s", rnti, js.to_string().c_str());
       }
 
       old_reest_rnti = old_rnti;
       state          = RRC_STATE_WAIT_FOR_CON_REEST_COMPLETE;
       set_activity_timeout(UE_INACTIVITY_TIMEOUT);
     } else {
-      parent->rrc_log->error("Received ConnectionReestablishment for rnti=0x%x without context\n", old_rnti);
+      parent->logger.error("Received ConnectionReestablishment for rnti=0x%x without context", old_rnti);
       send_connection_reest_rej();
     }
   } else {
-    parent->rrc_log->error("Received ReestablishmentRequest from an rnti=0x%x not in IDLE\n", rnti);
+    parent->logger.error("Received ReestablishmentRequest from an rnti=0x%x not in IDLE", rnti);
   }
 }
 
@@ -457,7 +455,7 @@ void rrc::ue::handle_rrc_con_reest_complete(rrc_conn_reest_complete_s* msg, srsl
   // Inform PHY about the configuration completion
   parent->phy->complete_config(rnti);
 
-  parent->rrc_log->info("RRCConnectionReestablishComplete transaction ID: %d\n", msg->rrc_transaction_id);
+  parent->logger.info("RRCConnectionReestablishComplete transaction ID: %d", msg->rrc_transaction_id);
 
   // TODO: msg->selected_plmn_id - used to select PLMN from SIB1 list
   // TODO: if(msg->registered_mme_present) - the indicated MME should be used from a pool
@@ -510,7 +508,7 @@ void rrc::ue::send_connection_reest_rej()
  */
 void rrc::ue::send_connection_reconf(srslte::unique_byte_buffer_t pdu, bool phy_cfg_updated)
 {
-  parent->rrc_log->debug("RRC state %d\n", state);
+  parent->logger.debug("RRC state %d", state);
 
   update_scells();
 
@@ -564,9 +562,8 @@ void rrc::ue::handle_rrc_reconf_complete(rrc_conn_recfg_complete_s* msg, srslte:
   parent->phy->complete_config(rnti);
 
   if (transaction_id != msg->rrc_transaction_id) {
-    parent->rrc_log->error("Expected RRCReconfigurationComplete with transaction ID: %d, got %d\n",
+    parent->logger.error(
-                           transaction_id,
+        "Expected RRCReconfigurationComplete with transaction ID: %d, got %d", transaction_id, msg->rrc_transaction_id);
-                           msg->rrc_transaction_id);
     return;
   }
 
@@ -629,14 +626,14 @@ void rrc::ue::send_security_mode_command()
 
 void rrc::ue::handle_security_mode_complete(security_mode_complete_s* msg)
 {
-  parent->rrc_log->info("SecurityModeComplete transaction ID: %d\n", msg->rrc_transaction_id);
+  parent->logger.info("SecurityModeComplete transaction ID: %d", msg->rrc_transaction_id);
 
   parent->pdcp->enable_encryption(rnti, RB_ID_SRB1);
 }
 
 void rrc::ue::handle_security_mode_failure(security_mode_fail_s* msg)
 {
-  parent->rrc_log->info("SecurityModeFailure transaction ID: %d\n", msg->rrc_transaction_id);
+  parent->logger.info("SecurityModeFailure transaction ID: %d", msg->rrc_transaction_id);
 }
 
 /*
@@ -658,29 +655,29 @@ void rrc::ue::send_ue_cap_enquiry()
 
 bool rrc::ue::handle_ue_cap_info(ue_cap_info_s* msg)
 {
-  parent->rrc_log->info("UECapabilityInformation transaction ID: %d\n", msg->rrc_transaction_id);
+  parent->logger.info("UECapabilityInformation transaction ID: %d", msg->rrc_transaction_id);
   ue_cap_info_r8_ies_s* msg_r8 = &msg->crit_exts.c1().ue_cap_info_r8();
 
   for (uint32_t i = 0; i < msg_r8->ue_cap_rat_container_list.size(); i++) {
     if (msg_r8->ue_cap_rat_container_list[i].rat_type != rat_type_e::eutra) {
-      parent->rrc_log->warning("Not handling UE capability information for RAT type %s\n",
+      parent->logger.warning("Not handling UE capability information for RAT type %s",
-                               msg_r8->ue_cap_rat_container_list[i].rat_type.to_string().c_str());
+                             msg_r8->ue_cap_rat_container_list[i].rat_type.to_string().c_str());
     } else {
       asn1::cbit_ref bref(msg_r8->ue_cap_rat_container_list[0].ue_cap_rat_container.data(),
                           msg_r8->ue_cap_rat_container_list[0].ue_cap_rat_container.size());
       if (eutra_capabilities.unpack(bref) != asn1::SRSASN_SUCCESS) {
-        parent->rrc_log->error("Failed to unpack EUTRA capabilities message\n");
+        parent->logger.error("Failed to unpack EUTRA capabilities message");
         return false;
       }
-      if (parent->rrc_log->get_level() == srslte::LOG_LEVEL_DEBUG) {
+      if (parent->logger.debug.enabled()) {
         asn1::json_writer js{};
         eutra_capabilities.to_json(js);
-        parent->rrc_log->debug_long("rnti=0x%x EUTRA capabilities: %s\n", rnti, js.to_string().c_str());
+        parent->logger.debug("rnti=0x%x EUTRA capabilities: %s", rnti, js.to_string().c_str());
       }
       eutra_capabilities_unpacked = true;
       ue_capabilities             = srslte::make_rrc_ue_capabilities(eutra_capabilities);
 
-      parent->rrc_log->info("UE rnti: 0x%x category: %d\n", rnti, eutra_capabilities.ue_category);
+      parent->logger.info("UE rnti: 0x%x category: %d", rnti, eutra_capabilities.ue_category);
     }
   }
 
@@ -724,40 +721,40 @@ void rrc::ue::send_connection_release()
 void rrc::ue::handle_ue_init_ctxt_setup_req(const asn1::s1ap::init_context_setup_request_s& msg)
 {
   if (msg.protocol_ies.add_cs_fallback_ind_present) {
-    parent->rrc_log->warning("Not handling AdditionalCSFallbackIndicator\n");
+    parent->logger.warning("Not handling AdditionalCSFallbackIndicator");
   }
   if (msg.protocol_ies.csg_membership_status_present) {
-    parent->rrc_log->warning("Not handling CSGMembershipStatus\n");
+    parent->logger.warning("Not handling CSGMembershipStatus");
   }
   if (msg.protocol_ies.gummei_id_present) {
-    parent->rrc_log->warning("Not handling GUMMEI_ID\n");
+    parent->logger.warning("Not handling GUMMEI_ID");
   }
   if (msg.protocol_ies.ho_restrict_list_present) {
-    parent->rrc_log->warning("Not handling HandoverRestrictionList\n");
+    parent->logger.warning("Not handling HandoverRestrictionList");
   }
   if (msg.protocol_ies.management_based_mdt_allowed_present) {
-    parent->rrc_log->warning("Not handling ManagementBasedMDTAllowed\n");
+    parent->logger.warning("Not handling ManagementBasedMDTAllowed");
   }
   if (msg.protocol_ies.management_based_mdtplmn_list_present) {
-    parent->rrc_log->warning("Not handling ManagementBasedMDTPLMNList\n");
+    parent->logger.warning("Not handling ManagementBasedMDTPLMNList");
   }
   if (msg.protocol_ies.mme_ue_s1ap_id_minus2_present) {
-    parent->rrc_log->warning("Not handling MME_UE_S1AP_ID_2\n");
+    parent->logger.warning("Not handling MME_UE_S1AP_ID_2");
   }
   if (msg.protocol_ies.registered_lai_present) {
-    parent->rrc_log->warning("Not handling RegisteredLAI\n");
+    parent->logger.warning("Not handling RegisteredLAI");
   }
   if (msg.protocol_ies.srvcc_operation_possible_present) {
-    parent->rrc_log->warning("Not handling SRVCCOperationPossible\n");
+    parent->logger.warning("Not handling SRVCCOperationPossible");
   }
   if (msg.protocol_ies.subscriber_profile_idfor_rfp_present) {
-    parent->rrc_log->warning("Not handling SubscriberProfileIDforRFP\n");
+    parent->logger.warning("Not handling SubscriberProfileIDforRFP");
   }
   if (msg.protocol_ies.trace_activation_present) {
-    parent->rrc_log->warning("Not handling TraceActivation\n");
+    parent->logger.warning("Not handling TraceActivation");
   }
   if (msg.protocol_ies.ue_radio_cap_present) {
-    parent->rrc_log->warning("Not handling UERadioCapability\n");
+    parent->logger.warning("Not handling UERadioCapability");
   }
 
   set_bitrates(msg.protocol_ies.ueaggregate_maximum_bitrate.value);
@@ -790,16 +787,16 @@ bool rrc::ue::handle_ue_ctxt_mod_req(const asn1::s1ap::ue_context_mod_request_s&
   }
 
   if (msg.protocol_ies.add_cs_fallback_ind_present) {
-    parent->rrc_log->warning("Not handling AdditionalCSFallbackIndicator\n");
+    parent->logger.warning("Not handling AdditionalCSFallbackIndicator");
   }
   if (msg.protocol_ies.csg_membership_status_present) {
-    parent->rrc_log->warning("Not handling CSGMembershipStatus\n");
+    parent->logger.warning("Not handling CSGMembershipStatus");
   }
   if (msg.protocol_ies.registered_lai_present) {
-    parent->rrc_log->warning("Not handling RegisteredLAI\n");
+    parent->logger.warning("Not handling RegisteredLAI");
   }
   if (msg.protocol_ies.subscriber_profile_idfor_rfp_present) {
-    parent->rrc_log->warning("Not handling SubscriberProfileIDforRFP\n");
+    parent->logger.warning("Not handling SubscriberProfileIDforRFP");
   }
 
   // UEAggregateMaximumBitrate
@@ -847,13 +844,13 @@ bool rrc::ue::setup_erabs(const asn1::s1ap::erab_to_be_setup_list_ctxt_su_req_l&
   for (const auto& item : e) {
     auto& erab = item.value.erab_to_be_setup_item_ctxt_su_req();
     if (erab.ext) {
-      parent->rrc_log->warning("Not handling E-RABToBeSetupListCtxtSURequest extensions\n");
+      parent->logger.warning("Not handling E-RABToBeSetupListCtxtSURequest extensions");
     }
     if (erab.ie_exts_present) {
-      parent->rrc_log->warning("Not handling E-RABToBeSetupListCtxtSURequest extensions\n");
+      parent->logger.warning("Not handling E-RABToBeSetupListCtxtSURequest extensions");
     }
     if (erab.transport_layer_address.length() > 32) {
-      parent->rrc_log->error("IPv6 addresses not currently supported\n");
+      parent->logger.error("IPv6 addresses not currently supported");
       return false;
     }
 
@@ -871,13 +868,13 @@ bool rrc::ue::setup_erabs(const asn1::s1ap::erab_to_be_setup_list_bearer_su_req_
   for (const auto& item : e) {
     auto& erab = item.value.erab_to_be_setup_item_bearer_su_req();
     if (erab.ext) {
-      parent->rrc_log->warning("Not handling E-RABToBeSetupListBearerSUReq extensions\n");
+      parent->logger.warning("Not handling E-RABToBeSetupListBearerSUReq extensions");
     }
     if (erab.ie_exts_present) {
-      parent->rrc_log->warning("Not handling E-RABToBeSetupListBearerSUReq extensions\n");
+      parent->logger.warning("Not handling E-RABToBeSetupListBearerSUReq extensions");
     }
     if (erab.transport_layer_address.length() > 32) {
-      parent->rrc_log->error("IPv6 addresses not currently supported\n");
+      parent->logger.error("IPv6 addresses not currently supported");
       return false;
     }
 
@@ -970,7 +967,7 @@ void rrc::ue::update_scells()
       not eutra_capabilities.non_crit_ext.non_crit_ext.non_crit_ext.rf_params_v1020_present or
       eutra_capabilities.non_crit_ext.non_crit_ext.non_crit_ext.rf_params_v1020.supported_band_combination_r10.size() ==
           0) {
-    parent->rrc_log->info("UE doesn't support CA. Skipping SCell activation\n");
+    parent->logger.info("UE doesn't support CA. Skipping SCell activation");
     return;
   }
 
@@ -978,7 +975,7 @@ void rrc::ue::update_scells()
     ue_cell_list.add_cell(scell->enb_cc_idx);
   }
 
-  parent->rrc_log->info("SCells activated for rnti=0x%x\n", rnti);
+  parent->logger.info("SCells activated for rnti=0x%x", rnti);
 }
 
 /********************** Handover **************************/
@@ -997,7 +994,7 @@ void rrc::ue::send_dl_ccch(dl_ccch_msg_s* dl_ccch_msg)
   if (pdu) {
     asn1::bit_ref bref(pdu->msg, pdu->get_tailroom());
     if (dl_ccch_msg->pack(bref) != asn1::SRSASN_SUCCESS) {
-      parent->rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Failed to pack DL-CCCH-Msg:\n");
+      parent->logger.error(pdu->msg, pdu->N_bytes, "Failed to pack DL-CCCH-Msg:");
       return;
     }
     pdu->N_bytes = (uint32_t)bref.distance_bytes();
@@ -1007,7 +1004,7 @@ void rrc::ue::send_dl_ccch(dl_ccch_msg_s* dl_ccch_msg)
     parent->log_rrc_message(buf, Tx, pdu.get(), *dl_ccch_msg, dl_ccch_msg->msg.c1().type().to_string());
     parent->rlc->write_sdu(rnti, RB_ID_SRB0, std::move(pdu));
   } else {
-    parent->rrc_log->error("Allocating pdu\n");
+    parent->logger.error("Allocating pdu");
   }
 }
 
@@ -1019,7 +1016,7 @@ bool rrc::ue::send_dl_dcch(const dl_dcch_msg_s* dl_dcch_msg, srslte::unique_byte
   if (pdu) {
     asn1::bit_ref bref(pdu->msg, pdu->get_tailroom());
     if (dl_dcch_msg->pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
-      parent->rrc_log->error("Failed to encode DL-DCCH-Msg\n");
+      parent->logger.error("Failed to encode DL-DCCH-Msg");
       return false;
     }
     pdu->N_bytes = (uint32_t)bref.distance_bytes();
@@ -1034,7 +1031,7 @@ bool rrc::ue::send_dl_dcch(const dl_dcch_msg_s* dl_dcch_msg, srslte::unique_byte
 
     parent->pdcp->write_sdu(rnti, lcid, std::move(pdu));
   } else {
-    parent->rrc_log->error("Allocating pdu\n");
+    parent->logger.error("Allocating pdu");
     return false;
   }
   return true;
@@ -1197,13 +1194,13 @@ void rrc::ue::apply_pdcp_drb_updates(const rr_cfg_ded_s& pending_rr_cfg)
       bool     is_am = parent->cfg.qci_cfg[erab_pair.second.qos_params.qci].rlc_cfg.type().value ==
                    asn1::rrc::rlc_cfg_c::types_opts::am;
       if (is_am) {
-        parent->rrc_log->debug("Set PDCP state: TX HFN %d, NEXT_PDCP_TX_SN %d, RX_HFN %d, NEXT_PDCP_RX_SN %d, "
+        parent->logger.debug("Set PDCP state: TX HFN %d, NEXT_PDCP_TX_SN %d, RX_HFN %d, NEXT_PDCP_RX_SN %d, "
-                               "LAST_SUBMITTED_PDCP_RX_SN %d\n",
+                             "LAST_SUBMITTED_PDCP_RX_SN %d",
-                               old_reest_pdcp_state[lcid].tx_hfn,
+                             old_reest_pdcp_state[lcid].tx_hfn,
-                               old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
+                             old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
-                               old_reest_pdcp_state[lcid].rx_hfn,
+                             old_reest_pdcp_state[lcid].rx_hfn,
-                               old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
+                             old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
-                               old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
+                             old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
         parent->pdcp->set_bearer_state(rnti, lcid, old_reest_pdcp_state[lcid]);
       }
     }
@@ -1216,11 +1213,11 @@ void rrc::ue::apply_rlc_rb_updates(const rr_cfg_ded_s& pending_rr_cfg)
     parent->rlc->add_bearer(rnti, srb.srb_id, srslte::rlc_config_t::srb_config(srb.srb_id));
   }
   if (pending_rr_cfg.drb_to_release_list.size() > 0) {
-    parent->rrc_log->error("Removing DRBs not currently supported\n");
+    parent->logger.error("Removing DRBs not currently supported");
   }
   for (const drb_to_add_mod_s& drb : pending_rr_cfg.drb_to_add_mod_list) {
     if (not drb.rlc_cfg_present) {
-      parent->rrc_log->warning("Default RLC DRB config not supported\n");
+      parent->logger.warning("Default RLC DRB config not supported");
     }
     parent->rlc->add_bearer(rnti, drb.lc_ch_id, srslte::make_rlc_config_t(drb.rlc_cfg));
   }
@@ -1234,7 +1231,7 @@ int rrc::ue::get_cqi(uint16_t* pmi_idx, uint16_t* n_pucch, uint32_t ue_cc_idx)
     *n_pucch = c->cqi_res.pucch_res;
     return SRSLTE_SUCCESS;
   } else {
-    parent->rrc_log->error("CQI resources for ue_cc_idx=%d have not been allocated\n", ue_cc_idx);
+    parent->logger.error("CQI resources for ue_cc_idx=%d have not been allocated", ue_cc_idx);
     return SRSLTE_ERROR;
   }
 }
@@ -1273,7 +1270,7 @@ int rrc::ue::get_ri(uint32_t m_ri, uint16_t* ri_idx)
       I_ri = 805 - N_offset_ri;
       break;
     default:
-      parent->rrc_log->error("Allocating RI: invalid m_ri=%d\n", m_ri);
+      parent->logger.error("Allocating RI: invalid m_ri=%d", m_ri);
   }
 
   // If ri_dix is available, copy

srsenb/src/stack/rrc/ue_meas_cfg.cc

@@ -22,7 +22,6 @@ namespace srsenb {
  *          measObjToAddMod
  **********************************/
 
-
 bool is_same_earfcn(const meas_obj_t& lhs, const meas_obj_t& rhs)
 {
   int freq1 = srslte::get_carrier_freq(lhs);
@@ -247,7 +246,7 @@ meas_gap_cfg_c make_measgap(const meas_obj_list& measobjs, const ue_cell_ded& pc
     case 0: // no meas gaps configured
       break;
     default:
-      srslte::logmap::get("RRC")->error("Error setting measurement gap.\n");
+      srslog::fetch_basic_logger("RRC").error("Error setting measurement gap.");
   }
   return meas_gap;
 }
@@ -285,8 +284,8 @@ bool apply_meas_gap_updates(const meas_gap_cfg_c& src_gaps,
           }
           break;
         default:
-          srslte::logmap::get("RRC")->warning("MeasGap of type %s not supported\n",
+          srslog::fetch_basic_logger("RRC").warning("MeasGap of type %s not supported",
-                                              target_offset.type().to_string().c_str());
+                                                    target_offset.type().to_string().c_str());
       }
     }
   }
@@ -319,7 +318,7 @@ bool fill_meascfg_enb_cfg(meas_cfg_s& meascfg, const ue_cell_ded_list& ue_cell_l
   const ue_cell_ded* pcell = ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
   assert(pcell != nullptr);
   const enb_cell_common* pcell_cfg     = pcell->cell_common;
-  const auto&             pcell_meascfg = pcell_cfg->cell_cfg.meas_cfg;
+  const auto&            pcell_meascfg = pcell_cfg->cell_cfg.meas_cfg;
 
   // Add PCell+Scells to measObjToAddModList
   // NOTE: sort by EARFCN to avoid unnecessary reconfigurations of measObjToAddModList
@@ -327,11 +326,9 @@ bool fill_meascfg_enb_cfg(meas_cfg_s& meascfg, const ue_cell_ded_list& ue_cell_l
   for (uint32_t ue_cc_idx = 0; ue_cc_idx < ue_cell_list.nof_cells(); ++ue_cc_idx) {
     sorted_ue_cells[ue_cc_idx] = ue_cell_list.get_ue_cc_idx(ue_cc_idx);
   }
-  std::sort(sorted_ue_cells.begin(),
+  std::sort(sorted_ue_cells.begin(), sorted_ue_cells.end(), [](const ue_cell_ded* cc1, const ue_cell_ded* cc2) {
-            sorted_ue_cells.end(),
+    return cc1->get_dl_earfcn() < cc2->get_dl_earfcn();
-            [](const ue_cell_ded* cc1, const ue_cell_ded* cc2) {
+  });
-              return cc1->get_dl_earfcn() < cc2->get_dl_earfcn();
-            });
   for (auto* cc : sorted_ue_cells) {
     add_meas_obj(meascfg.meas_obj_to_add_mod_list, cc->get_dl_earfcn());
   }
@@ -393,16 +390,16 @@ bool compute_diff_meascfg(const meas_cfg_s& current_meascfg, const meas_cfg_s& t
   return set_meascfg_presence_flags(diff_meascfg);
 }
 
-bool apply_meascfg_updates(meas_cfg_s&                     meascfg,
+bool apply_meascfg_updates(meas_cfg_s&             meascfg,
-                           meas_cfg_s&                     current_meascfg,
+                           meas_cfg_s&             current_meascfg,
                            const ue_cell_ded_list& ue_cell_list,
-                           int                             prev_earfcn,
+                           int                     prev_earfcn,
-                           int                             prev_pci)
+                           int                     prev_pci)
 {
   meascfg = {};
 
   const ue_cell_ded* pcell         = ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
-  uint32_t                   target_earfcn = pcell->get_dl_earfcn();
+  uint32_t           target_earfcn = pcell->get_dl_earfcn();
 
   if (static_cast<uint32_t>(prev_pci) == pcell->get_pci() and static_cast<uint32_t>(prev_earfcn) == target_earfcn) {
     // Shortcut: No PCell change -> no measConfig updates

srsenb/src/stack/rrc/ue_rr_cfg.cc

@@ -36,7 +36,7 @@ namespace srsenb {
 srb_to_add_mod_s* add_srb(srb_to_add_mod_list_l& srbs, uint8_t srb_id)
 {
   if (srb_id > 2 or srb_id == 0) {
-    srslte::logmap::get("RRC")->error("Invalid SRB id=%d\n", srb_id);
+    srslog::fetch_basic_logger("RRC").error("Invalid SRB id=%d", srb_id);
     return nullptr;
   }
 
@@ -105,7 +105,7 @@ int16_t get_ri(uint32_t m_ri)
       ri_idx = 805 - N_offset_ri;
       break;
     default:
-      srslte::logmap::get("RRC")->error("Allocating RI: invalid m_ri=%d\n", m_ri);
+      srslog::fetch_basic_logger("RRC").error("Allocating RI: invalid m_ri=%d", m_ri);
       return -1;
   }
 
@@ -135,7 +135,7 @@ int fill_cqi_report_setup(cqi_report_cfg_s& cqi_rep, const rrc_cfg_t& enb_cfg, c
   if (cqi_rep.cqi_report_periodic_present) {
     const ue_cell_ded* pcell = ue_cell_list.get_ue_cc_idx(UE_PCELL_CC_IDX);
     if (pcell == nullptr or not pcell->cqi_res_present) {
-      srslte::logmap::get("RRC")->warning("PCell CQI resources haven\'t been allocated yet\n");
+      srslog::fetch_basic_logger("RRC").warning("PCell CQI resources haven\'t been allocated yet");
       return SRSLTE_ERROR;
     }
     auto& cqi_periodic             = cqi_rep.cqi_report_periodic.setup();
@@ -173,7 +173,7 @@ void fill_cqi_report_reconf(cqi_report_cfg_s& cqi_rep, const rrc_cfg_t& enb_cfg,
         cqi_setup.ri_cfg_idx_present = true;
         cqi_setup.ri_cfg_idx         = ri_idx;
       } else {
-        srslte::logmap::get("RRC")->warning("Warning: Configured wrong M_ri parameter.\n");
+        srslog::fetch_basic_logger("RRC").warning("Warning: Configured wrong M_ri parameter.");
       }
     }
   }

srsenb/src/stack/upper/gtpu.cc

@@ -22,7 +22,7 @@
 using namespace srslte;
 namespace srsenb {
 
-gtpu::gtpu() : m1u(this), gtpu_log("GTPU") {}
+gtpu::gtpu(srslog::basic_logger& logger) : m1u(this), gtpu_log("GTPU"), logger(logger) {}
 
 int gtpu::init(std::string                  gtp_bind_addr_,
                std::string                  mme_addr_,
@@ -43,17 +43,17 @@ int gtpu::init(std::string                  gtp_bind_addr_,
   // Set up socket
   fd = socket(AF_INET, SOCK_DGRAM, 0);
   if (fd < 0) {
-    gtpu_log->error("Failed to create socket\n");
+    logger.error("Failed to create socket");
     return SRSLTE_ERROR;
   }
   int enable = 1;
 #if defined(SO_REUSEADDR)
   if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0)
-    gtpu_log->error("setsockopt(SO_REUSEADDR) failed\n");
+    logger.error("setsockopt(SO_REUSEADDR) failed");
 #endif
 #if defined(SO_REUSEPORT)
   if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0)
-    gtpu_log->error("setsockopt(SO_REUSEPORT) failed\n");
+    logger.error("setsockopt(SO_REUSEPORT) failed");
 #endif
 
   struct sockaddr_in bindaddr;
@@ -64,8 +64,8 @@ int gtpu::init(std::string                  gtp_bind_addr_,
 
   if (bind(fd, (struct sockaddr*)&bindaddr, sizeof(struct sockaddr_in))) {
     snprintf(errbuf, sizeof(errbuf), "%s", strerror(errno));
-    gtpu_log->error("Failed to bind on address %s, port %d: %s\n", gtp_bind_addr.c_str(), GTPU_PORT, errbuf);
+    logger.error("Failed to bind on address %s, port %d: %s", gtp_bind_addr.c_str(), int(GTPU_PORT), errbuf);
-    srslte::console("Failed to bind on address %s, port %d: %s\n", gtp_bind_addr.c_str(), GTPU_PORT, errbuf);
+    srslte::console("Failed to bind on address %s, port %d: %s\n", gtp_bind_addr.c_str(), int(GTPU_PORT), errbuf);
     return SRSLTE_ERROR;
   }
 
@@ -91,21 +91,21 @@ void gtpu::stop()
 // gtpu_interface_pdcp
 void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu)
 {
-  gtpu_log->info_hex(pdu->msg, pdu->N_bytes, "TX PDU, RNTI: 0x%x, LCID: %d, n_bytes=%d", rnti, lcid, pdu->N_bytes);
+  logger.info(pdu->msg, pdu->N_bytes, "TX PDU, RNTI: 0x%x, LCID: %d, n_bytes=%d", rnti, lcid, pdu->N_bytes);
 
   // Check valid IP version
   struct iphdr* ip_pkt = (struct iphdr*)pdu->msg;
   if (ip_pkt->version != 4 && ip_pkt->version != 6) {
-    gtpu_log->error("Invalid IP version to SPGW\n");
+    logger.error("Invalid IP version to SPGW");
     return;
   }
   if (ip_pkt->version == 4) {
     if (ntohs(ip_pkt->tot_len) != pdu->N_bytes) {
-      gtpu_log->error("IP Len and PDU N_bytes mismatch\n");
+      logger.error("IP Len and PDU N_bytes mismatch");
     }
-    gtpu_log->debug("Tx S1-U PDU -- IP version %d, Total length %d\n", ip_pkt->version, ntohs(ip_pkt->tot_len));
+    logger.debug("Tx S1-U PDU -- IP version %d, Total length %d", int(ip_pkt->version), ntohs(ip_pkt->tot_len));
-    gtpu_log->debug("Tx S1-U PDU -- IP src addr %s\n", srslte::gtpu_ntoa(ip_pkt->saddr).c_str());
+    logger.debug("Tx S1-U PDU -- IP src addr %s", srslte::gtpu_ntoa(ip_pkt->saddr).c_str());
-    gtpu_log->debug("Tx S1-U PDU -- IP dst addr %s\n", srslte::gtpu_ntoa(ip_pkt->daddr).c_str());
+    logger.debug("Tx S1-U PDU -- IP dst addr %s", srslte::gtpu_ntoa(ip_pkt->daddr).c_str());
   }
 
   gtpu_header_t header;
@@ -120,7 +120,7 @@ void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t
   servaddr.sin_port        = htons(GTPU_PORT);
 
   if (!gtpu_write_header(&header, pdu.get(), gtpu_log)) {
-    gtpu_log->error("Error writing GTP-U Header. Flags 0x%x, Message Type 0x%x\n", header.flags, header.message_type);
+    logger.error("Error writing GTP-U Header. Flags 0x%x, Message Type 0x%x", header.flags, header.message_type);
     return;
   }
   if (sendto(fd, pdu->msg, pdu->N_bytes, MSG_EOR, (struct sockaddr*)&servaddr, sizeof(struct sockaddr_in)) < 0) {
@@ -129,21 +129,17 @@ void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t
 }
 
 /* Warning: This function is called before calling gtpu::init() during MCCH initialization.
- * If access to any element created in init (such as gtpu_log) is required, it must be considered
- * the case of it being NULL.
  */
 uint32_t gtpu::add_bearer(uint16_t rnti, uint32_t lcid, uint32_t addr, uint32_t teid_out)
 {
   // Allocate a TEID for the incoming tunnel
   uint32_t teid_in = allocate_teidin(rnti, lcid);
-  if (gtpu_log) {
+  logger.info("Adding bearer for rnti: 0x%x, lcid: %d, addr: 0x%x, teid_out: 0x%x, teid_in: 0x%x",
-    gtpu_log->info("Adding bearer for rnti: 0x%x, lcid: %d, addr: 0x%x, teid_out: 0x%x, teid_in: 0x%x\n",
+              rnti,
-                   rnti,
+              lcid,
-                   lcid,
+              addr,
-                   addr,
+              teid_out,
-                   teid_out,
+              teid_in);
-                   teid_in);
-  }
 
   // Initialize maps if it's a new RNTI
   if (rnti_bearers.count(rnti) == 0) {
@@ -163,7 +159,7 @@ uint32_t gtpu::add_bearer(uint16_t rnti, uint32_t lcid, uint32_t addr, uint32_t
 
 void gtpu::rem_bearer(uint16_t rnti, uint32_t lcid)
 {
-  gtpu_log->info("Removing bearer for rnti: 0x%x, lcid: %d\n", rnti, lcid);
+  logger.info("Removing bearer for rnti: 0x%x, lcid: %d", rnti, lcid);
 
   // Remove from TEID from map
   free_teidin(rnti, lcid);
@@ -186,14 +182,14 @@ void gtpu::rem_bearer(uint16_t rnti, uint32_t lcid)
 
 void gtpu::mod_bearer_rnti(uint16_t old_rnti, uint16_t new_rnti)
 {
-  gtpu_log->info("Modifying bearer rnti. Old rnti: 0x%x, new rnti: 0x%x\n", old_rnti, new_rnti);
+  logger.info("Modifying bearer rnti. Old rnti: 0x%x, new rnti: 0x%x", old_rnti, new_rnti);
 
   if (rnti_bearers.count(new_rnti) != 0) {
-    gtpu_log->error("New rnti already exists, aborting.\n");
+    logger.error("New rnti already exists, aborting.");
     return;
   }
   if (rnti_bearers.count(old_rnti) == 0) {
-    gtpu_log->error("Old rnti does not exist, aborting.\n");
+    logger.error("Old rnti does not exist, aborting.");
     return;
   }
 
@@ -226,7 +222,7 @@ void gtpu::rem_user(uint16_t rnti)
 
 void gtpu::handle_gtpu_s1u_rx_packet(srslte::unique_byte_buffer_t pdu, const sockaddr_in& addr)
 {
-  gtpu_log->debug("Received %d bytes from S1-U interface\n", pdu->N_bytes);
+  logger.debug("Received %d bytes from S1-U interface", pdu->N_bytes);
   pdu->set_timestamp();
 
   gtpu_header_t header;
@@ -254,38 +250,37 @@ void gtpu::handle_gtpu_s1u_rx_packet(srslte::unique_byte_buffer_t pdu, const soc
       bool user_exists = (rnti_bearers.count(rnti) > 0);
 
       if (not user_exists) {
-        gtpu_log->error("Unrecognized TEID In=%d for DL PDU. Dropping packet\n", header.teid);
+        logger.error("Unrecognized TEID In=%d for DL PDU. Dropping packet", header.teid);
         return;
       }
 
       if (lcid < SRSENB_N_SRB || lcid >= SRSENB_N_RADIO_BEARERS) {
-        gtpu_log->error("Invalid LCID for DL PDU: %d - dropping packet\n", lcid);
+        logger.error("Invalid LCID for DL PDU: %d - dropping packet", lcid);
         return;
       }
 
-      gtpu_log->info_hex(
+      logger.info(pdu->msg, pdu->N_bytes, "RX GTPU PDU rnti=0x%x, lcid=%d, n_bytes=%d", rnti, lcid, pdu->N_bytes);
-          pdu->msg, pdu->N_bytes, "RX GTPU PDU rnti=0x%x, lcid=%d, n_bytes=%d", rnti, lcid, pdu->N_bytes);
 
       struct iphdr* ip_pkt = (struct iphdr*)pdu->msg;
       if (ip_pkt->version != 4 && ip_pkt->version != 6) {
-        gtpu_log->error("Invalid IP version to SPGW\n");
+        logger.error("Invalid IP version to SPGW");
         return;
       }
 
       if (ip_pkt->version == 4) {
         if (ntohs(ip_pkt->tot_len) != pdu->N_bytes) {
-          gtpu_log->error("IP Len and PDU N_bytes mismatch\n");
+          logger.error("IP Len and PDU N_bytes mismatch");
         }
-        gtpu_log->debug("Rx S1-U PDU -- IP version %d, Total length %d\n", ip_pkt->version, ntohs(ip_pkt->tot_len));
+        logger.debug("Rx S1-U PDU -- IP version %d, Total length %d", int(ip_pkt->version), ntohs(ip_pkt->tot_len));
-        gtpu_log->debug("Rx S1-U PDU -- IP src addr %s\n", srslte::gtpu_ntoa(ip_pkt->saddr).c_str());
+        logger.debug("Rx S1-U PDU -- IP src addr %s", srslte::gtpu_ntoa(ip_pkt->saddr).c_str());
-        gtpu_log->debug("Rx S1-U PDU -- IP dst addr %s\n", srslte::gtpu_ntoa(ip_pkt->daddr).c_str());
+        logger.debug("Rx S1-U PDU -- IP dst addr %s", srslte::gtpu_ntoa(ip_pkt->daddr).c_str());
       }
       pdcp->write_sdu(rnti, lcid, std::move(pdu));
     } break;
     case GTPU_MSG_END_MARKER: {
       rnti_lcid_t rnti_lcid = teidin_to_rntilcid(header.teid);
       uint16_t    rnti      = rnti_lcid.rnti;
-      gtpu_log->info("Received GTPU End Marker for rnti=0x%x.\n", rnti);
+      logger.info("Received GTPU End Marker for rnti=0x%x.", rnti);
       break;
     }
     default:
@@ -303,7 +298,7 @@ void gtpu::handle_gtpu_m1u_rx_packet(srslte::unique_byte_buffer_t pdu, const soc
  ***************************************************************************/
 void gtpu::error_indication(in_addr_t addr, in_port_t port, uint32_t err_teid)
 {
-  gtpu_log->info("TX GTPU Error Indication. Seq: %d, Error TEID: %d\n", tx_seq, err_teid);
+  logger.info("TX GTPU Error Indication. Seq: %d, Error TEID: %d", tx_seq, err_teid);
 
   gtpu_header_t        header = {};
   unique_byte_buffer_t pdu    = allocate_unique_buffer(*pool);
@@ -333,7 +328,7 @@ void gtpu::error_indication(in_addr_t addr, in_port_t port, uint32_t err_teid)
  ***************************************************************************/
 void gtpu::echo_response(in_addr_t addr, in_port_t port, uint16_t seq)
 {
-  gtpu_log->info("TX GTPU Echo Response, Seq: %d\n", seq);
+  logger.info("TX GTPU Echo Response, Seq: %d", seq);
 
   gtpu_header_t        header = {};
   unique_byte_buffer_t pdu    = allocate_unique_buffer(*pool);
@@ -364,12 +359,12 @@ uint32_t gtpu::allocate_teidin(uint16_t rnti, uint16_t lcid)
 {
   uint32_t teid_in = ++next_teid_in;
   if (teidin_to_rntilcid_map.count(teid_in) != 0) {
-    gtpu_log->error("TEID In already exists\n");
+    logger.error("TEID In already exists");
     return 0;
   }
   rnti_lcid_t rnti_lcid           = {rnti, lcid};
   teidin_to_rntilcid_map[teid_in] = rnti_lcid;
-  gtpu_log->debug("TEID In=%d added\n", teid_in);
+  logger.debug("TEID In=%d added", teid_in);
   return teid_in;
 }
 
@@ -378,7 +373,7 @@ void gtpu::free_teidin(uint16_t rnti, uint16_t lcid)
   for (std::map<uint32_t, rnti_lcid_t>::iterator it = teidin_to_rntilcid_map.begin();
        it != teidin_to_rntilcid_map.end();) {
     if (it->second.rnti == rnti && it->second.lcid == lcid) {
-      gtpu_log->debug("TEID In=%d erased\n", it->first);
+      logger.debug("TEID In=%d erased", it->first);
       it = teidin_to_rntilcid_map.erase(it);
     } else {
       it++;
@@ -391,7 +386,7 @@ void gtpu::free_teidin(uint16_t rnti)
   for (std::map<uint32_t, rnti_lcid_t>::iterator it = teidin_to_rntilcid_map.begin();
        it != teidin_to_rntilcid_map.end();) {
     if (it->second.rnti == rnti) {
-      gtpu_log->debug("TEID In=%d erased\n", it->first);
+      logger.debug("TEID In=%d erased", it->first);
       it = teidin_to_rntilcid_map.erase(it);
     } else {
       it++;
@@ -403,7 +398,7 @@ gtpu::rnti_lcid_t gtpu::teidin_to_rntilcid(uint32_t teidin)
 {
   rnti_lcid_t rnti_lcid = {};
   if (teidin_to_rntilcid_map.count(teidin) == 0) {
-    gtpu_log->error("TEID=%d In does not exist.\n", teidin);
+    logger.error("TEID=%d In does not exist.", teidin);
     return rnti_lcid;
   }
   rnti_lcid.rnti = teidin_to_rntilcid_map[teidin].rnti;
@@ -420,7 +415,7 @@ uint32_t gtpu::rntilcid_to_teidin(uint16_t rnti, uint16_t lcid)
     }
   }
   if (teidin == 0) {
-    gtpu_log->error("Could not find TEID. RNTI=0x%x, LCID=%d.\n", rnti, lcid);
+    logger.error("Could not find TEID. RNTI=0x%x, LCID=%d.", rnti, lcid);
   }
   return teidin;
 }
@@ -448,7 +443,7 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr
   struct sockaddr_in bindaddr = {};
   m1u_sd                      = socket(AF_INET, SOCK_DGRAM, 0);
   if (m1u_sd < 0) {
-    gtpu_log->error("Failed to create M1-U sink socket\n");
+    logger.error("Failed to create M1-U sink socket");
     return false;
   }
 
@@ -457,7 +452,7 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr
   bindaddr.sin_addr.s_addr = htonl(INADDR_ANY); // Multicast sockets require bind to INADDR_ANY
   bindaddr.sin_port        = htons(GTPU_PORT + 1);
   if (bind(m1u_sd, (struct sockaddr*)&bindaddr, sizeof(bindaddr)) < 0) {
-    gtpu_log->error("Failed to bind multicast socket\n");
+    logger.error("Failed to bind multicast socket");
     return false;
   }
 
@@ -466,11 +461,11 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr
   mreq.imr_multiaddr.s_addr = inet_addr(m1u_multiaddr.c_str()); // Multicast address of the service
   mreq.imr_interface.s_addr = inet_addr(m1u_if_addr.c_str());   // Address of the IF the socket will listen to.
   if (setsockopt(m1u_sd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
-    gtpu_log->error("Register musticast group for M1-U\n");
+    logger.error("Register musticast group for M1-U");
-    gtpu_log->error("M1-U infterface IP: %s, M1-U Multicast Address %s\n", m1u_if_addr.c_str(), m1u_multiaddr.c_str());
+    logger.error("M1-U infterface IP: %s, M1-U Multicast Address %s", m1u_if_addr.c_str(), m1u_multiaddr.c_str());
     return false;
   }
-  gtpu_log->info("M1-U initialized\n");
+  logger.info("M1-U initialized");
 
   initiated    = true;
   lcid_counter = 1;
@@ -483,7 +478,7 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr
 
 void gtpu::m1u_handler::handle_rx_packet(srslte::unique_byte_buffer_t pdu, const sockaddr_in& addr)
 {
-  gtpu_log->debug("Received %d bytes from M1-U interface\n", pdu->N_bytes);
+  logger.debug("Received %d bytes from M1-U interface", pdu->N_bytes);
 
   gtpu_header_t header;
   gtpu_read_header(pdu.get(), &header, gtpu_log);

srsenb/src/stack/upper/pdcp.cc

@@ -15,10 +15,8 @@
 
 namespace srsenb {
 
-pdcp::pdcp(srslte::task_sched_handle task_sched_, const char* logname) :
+pdcp::pdcp(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger) :
-  task_sched(task_sched_),
+  task_sched(task_sched_), logger(logger), pool(srslte::byte_buffer_pool::get_instance())
-  log_h(logname),
-  pool(srslte::byte_buffer_pool::get_instance())
 {}
 
 void pdcp::init(rlc_interface_pdcp* rlc_, rrc_interface_pdcp* rrc_, gtpu_interface_pdcp* gtpu_)
@@ -39,7 +37,7 @@ void pdcp::stop()
 void pdcp::add_user(uint16_t rnti)
 {
   if (users.count(rnti) == 0) {
-    srslte::pdcp* obj = new srslte::pdcp(task_sched, log_h->get_service_name().c_str());
+    srslte::pdcp* obj = new srslte::pdcp(task_sched, logger.id().c_str());
     obj->init(&users[rnti].rlc_itf, &users[rnti].rrc_itf, &users[rnti].gtpu_itf);
     users[rnti].rlc_itf.rnti  = rnti;
     users[rnti].gtpu_itf.rnti = rnti;
@@ -184,17 +182,17 @@ void pdcp::user_interface_rrc::write_pdu(uint32_t lcid, srslte::unique_byte_buff
 
 void pdcp::user_interface_rrc::write_pdu_bcch_bch(srslte::unique_byte_buffer_t pdu)
 {
-  ERROR("Error: Received BCCH from ue=%d\n", rnti);
+  ERROR("Error: Received BCCH from ue=%d", rnti);
 }
 
 void pdcp::user_interface_rrc::write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t pdu)
 {
-  ERROR("Error: Received BCCH from ue=%d\n", rnti);
+  ERROR("Error: Received BCCH from ue=%d", rnti);
 }
 
 void pdcp::user_interface_rrc::write_pdu_pcch(srslte::unique_byte_buffer_t pdu)
 {
-  ERROR("Error: Received PCCH from ue=%d\n", rnti);
+  ERROR("Error: Received PCCH from ue=%d", rnti);
 }
 
 std::string pdcp::user_interface_rrc::get_rb_name(uint32_t lcid)

srsenb/src/stack/upper/rlc.cc

@@ -18,12 +18,10 @@ namespace srsenb {
 void rlc::init(pdcp_interface_rlc*    pdcp_,
                rrc_interface_rlc*     rrc_,
                mac_interface_rlc*     mac_,
-               srslte::timer_handler* timers_,
+               srslte::timer_handler* timers_)
-               srslte::log_ref        log_h_)
 {
   pdcp   = pdcp_;
   rrc    = rrc_;
-  log_h  = log_h_;
   mac    = mac_;
   timers = timers_;
 
@@ -57,7 +55,7 @@ void rlc::add_user(uint16_t rnti)
 {
   pthread_rwlock_rdlock(&rwlock);
   if (users.count(rnti) == 0) {
-    std::unique_ptr<srslte::rlc> obj(new srslte::rlc(log_h->get_service_name().c_str()));
+    std::unique_ptr<srslte::rlc> obj(new srslte::rlc(logger.id().c_str()));
     obj->init(&users[rnti],
               &users[rnti],
               timers,
@@ -81,7 +79,7 @@ void rlc::rem_user(uint16_t rnti)
     users[rnti].rlc->stop();
     users.erase(rnti);
   } else {
-    log_h->error("Removing rnti=0x%x. Already removed\n", rnti);
+    logger.error("Removing rnti=0x%x. Already removed", rnti);
   }
   pthread_rwlock_unlock(&rwlock);
 }
@@ -96,7 +94,7 @@ void rlc::clear_buffer(uint16_t rnti)
         mac->rlc_buffer_state(rnti, i, 0, 0);
       }
     }
-    log_h->info("Cleared buffer rnti=0x%x\n", rnti);
+    logger.info("Cleared buffer rnti=0x%x", rnti);
   }
   pthread_rwlock_unlock(&rwlock);
 }
@@ -176,7 +174,7 @@ void rlc::reestablish(uint16_t rnti)
 // This function is called by UE RLC instance every time the tx/retx buffers are updated
 void rlc::update_bsr(uint32_t rnti, uint32_t lcid, uint32_t tx_queue, uint32_t retx_queue)
 {
-  log_h->debug("Buffer state: rnti=0x%x, lcid=%d, tx_queue=%d\n", rnti, lcid, tx_queue);
+  logger.debug("Buffer state: rnti=0x%x, lcid=%d, tx_queue=%d", rnti, lcid, tx_queue);
   mac->rlc_buffer_state(rnti, lcid, tx_queue, retx_queue);
 }
 
@@ -272,17 +270,17 @@ void rlc::user_interface::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t
 
 void rlc::user_interface::write_pdu_bcch_bch(srslte::unique_byte_buffer_t sdu)
 {
-  ERROR("Error: Received BCCH from ue=%d\n", rnti);
+  ERROR("Error: Received BCCH from ue=%d", rnti);
 }
 
 void rlc::user_interface::write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t sdu)
 {
-  ERROR("Error: Received BCCH from ue=%d\n", rnti);
+  ERROR("Error: Received BCCH from ue=%d", rnti);
 }
 
 void rlc::user_interface::write_pdu_pcch(srslte::unique_byte_buffer_t sdu)
 {
-  ERROR("Error: Received PCCH from ue=%d\n", rnti);
+  ERROR("Error: Received PCCH from ue=%d", rnti);
 }
 
 std::string rlc::user_interface::get_rb_name(uint32_t lcid)

srsenb/src/stack/upper/s1ap.cc

@@ -31,9 +31,9 @@
 using srslte::s1ap_mccmnc_to_plmn;
 using srslte::uint32_to_uint8;
 
-#define procError(fmt, ...) s1ap_ptr->s1ap_log->error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procError(fmt, ...) s1ap_ptr->logger.error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
-#define procWarning(fmt, ...) s1ap_ptr->s1ap_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procWarning(fmt, ...) s1ap_ptr->logger.warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
-#define procInfo(fmt, ...) s1ap_ptr->s1ap_log->info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
+#define procInfo(fmt, ...) s1ap_ptr->logger.info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
 
 using namespace asn1::s1ap;
 
@@ -62,9 +62,9 @@ srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::init(uint32_t
   target_eci  = target_eci_;
   target_plmn = target_plmn_;
 
-  procInfo("Sending HandoverRequired to MME id=%d\n", ue_ptr->ctxt.mme_ue_s1ap_id);
+  procInfo("Sending HandoverRequired to MME id=%d", ue_ptr->ctxt.mme_ue_s1ap_id);
   if (not ue_ptr->send_ho_required(target_eci, target_plmn, std::move(rrc_container_))) {
-    procError("Failed to send HORequired to cell 0x%x\n", target_eci);
+    procError("Failed to send HORequired to cell 0x%x", target_eci);
     return srslte::proc_outcome_t::error;
   }
 
@@ -76,7 +76,7 @@ srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::init(uint32_t
 srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::react(ts1_reloc_prep_expired e)
 {
   // do nothing for now
-  procError("timer TS1Relocprep has expired.\n");
+  procError("timer TS1Relocprep has expired.");
   return srslte::proc_outcome_t::error;
 }
 srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::react(const ho_prep_fail_s& msg)
@@ -84,7 +84,7 @@ srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::react(const ho_prep_fail_s& msg
   ue_ptr->ts1_reloc_prep.stop();
 
   std::string cause = s1ap_ptr->get_cause(msg.protocol_ies.cause.value);
-  procError("HO preparation Failure. Cause: %s\n", cause.c_str());
+  procError("HO preparation Failure. Cause: %s", cause.c_str());
   srslte::console("HO preparation Failure. Cause: %s\n", cause.c_str());
 
   return srslte::proc_outcome_t::error;
@@ -104,18 +104,18 @@ srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::react(const asn1::s1ap::ho_cmd_
   if (msg.ext or msg.protocol_ies.target_to_source_transparent_container_secondary_present or
       msg.protocol_ies.handov_type.value.value != handov_type_opts::intralte or
       msg.protocol_ies.crit_diagnostics_present or msg.protocol_ies.nas_security_paramsfrom_e_utran_present) {
-    procWarning("Not handling HandoverCommand extensions and non-intraLTE params\n");
+    procWarning("Not handling HandoverCommand extensions and non-intraLTE params");
   }
 
   // Check for E-RABs that could not be admitted in the target
   if (msg.protocol_ies.erab_to_release_list_ho_cmd_present) {
-    procWarning("Not handling E-RABtoReleaseList\n");
+    procWarning("Not handling E-RABtoReleaseList");
     // TODO
   }
 
   // Check for E-RABs subject to being forwarded
   if (msg.protocol_ies.erab_subjectto_data_forwarding_list_present) {
-    procWarning("Not handling E-RABSubjecttoDataForwardingList\n");
+    procWarning("Not handling E-RABSubjecttoDataForwardingList");
     // TODO
   }
 
@@ -125,17 +125,17 @@ srslte::proc_outcome_t s1ap::ue::ho_prep_proc_t::react(const asn1::s1ap::ho_cmd_
                       msg.protocol_ies.target_to_source_transparent_container.value.size());
   asn1::s1ap::targetenb_to_sourceenb_transparent_container_s container;
   if (container.unpack(bref) != asn1::SRSASN_SUCCESS) {
-    procError("Failed to decode TargeteNBToSourceeNBTransparentContainer\n");
+    procError("Failed to decode TargeteNBToSourceeNBTransparentContainer");
     return srslte::proc_outcome_t::error;
   }
   if (container.ie_exts_present or container.ext) {
-    procWarning("Not handling extensions\n");
+    procWarning("Not handling extensions");
   }
 
   // Create a unique buffer out of transparent container to pass to RRC
   rrc_container = srslte::allocate_unique_buffer(*s1ap_ptr->pool, false);
   if (rrc_container == nullptr) {
-    procError("Fatal Error: Couldn't allocate buffer.\n");
+    procError("Fatal Error: Couldn't allocate buffer.");
     return srslte::proc_outcome_t::error;
   }
   memcpy(rrc_container->msg, container.rrc_container.data(), container.rrc_container.size());
@@ -150,7 +150,7 @@ void s1ap::ue::ho_prep_proc_t::then(const srslte::proc_state_t& result)
     s1ap_ptr->rrc->ho_preparation_complete(ue_ptr->ctxt.rnti, false, {});
   } else {
     s1ap_ptr->rrc->ho_preparation_complete(ue_ptr->ctxt.rnti, true, std::move(rrc_container));
-    procInfo("Completed with success\n");
+    procInfo("Completed with success");
   }
 }
 
@@ -160,23 +160,23 @@ void s1ap::ue::ho_prep_proc_t::then(const srslte::proc_state_t& result)
 
 srslte::proc_outcome_t s1ap::s1_setup_proc_t::init()
 {
-  procInfo("Starting new MME connection.\n");
+  procInfo("Starting new MME connection.");
   return start_mme_connection();
 }
 
 srslte::proc_outcome_t s1ap::s1_setup_proc_t::start_mme_connection()
 {
   if (not s1ap_ptr->running) {
-    procInfo("S1AP is not running anymore.\n");
+    procInfo("S1AP is not running anymore.");
     return srslte::proc_outcome_t::error;
   }
   if (s1ap_ptr->mme_connected) {
-    procInfo("eNB S1AP is already connected to MME\n");
+    procInfo("eNB S1AP is already connected to MME");
     return srslte::proc_outcome_t::success;
   }
 
   if (not s1ap_ptr->connect_mme()) {
-    procInfo("Failed to initiate SCTP socket. Attempting reconnection in %d seconds\n",
+    procInfo("Failed to initiate SCTP socket. Attempting reconnection in %d seconds",
              s1ap_ptr->mme_connect_timer.duration() / 1000);
     srslte::console("Failed to initiate SCTP socket. Attempting reconnection in %d seconds\n",
                     s1ap_ptr->mme_connect_timer.duration() / 1000);
@@ -185,14 +185,14 @@ srslte::proc_outcome_t s1ap::s1_setup_proc_t::start_mme_connection()
   }
 
   if (not s1ap_ptr->setup_s1()) {
-    procError("S1 setup failed. Exiting...\n");
+    procError("S1 setup failed. Exiting...");
     srslte::console("S1 setup failed\n");
     s1ap_ptr->running = false;
     return srslte::proc_outcome_t::error;
   }
 
   s1ap_ptr->s1setup_timeout.run();
-  procInfo("S1SetupRequest sent. Waiting for response...\n");
+  procInfo("S1SetupRequest sent. Waiting for response...");
   return srslte::proc_outcome_t::yield;
 }
 
@@ -202,10 +202,10 @@ srslte::proc_outcome_t s1ap::s1_setup_proc_t::react(const srsenb::s1ap::s1_setup
     s1ap_ptr->s1setup_timeout.stop();
   }
   if (event.success) {
-    procInfo("S1Setup procedure completed successfully\n");
+    procInfo("S1Setup procedure completed successfully");
     return srslte::proc_outcome_t::success;
   }
-  procError("S1Setup failed. Exiting...\n");
+  procError("S1Setup failed. Exiting...");
   srslte::console("S1setup failed\n");
   return srslte::proc_outcome_t::error;
 }
@@ -214,7 +214,7 @@ void s1ap::s1_setup_proc_t::then(const srslte::proc_state_t& result) const
 {
   if (result.is_error()) {
     s1ap_ptr->s1ap_socket.reset();
-    procInfo("S1AP socket closed.\n");
+    procInfo("S1AP socket closed.");
   }
 }
 
@@ -222,15 +222,16 @@ void s1ap::s1_setup_proc_t::then(const srslte::proc_state_t& result) const
  *                     S1AP class
  *********************************************************/
 
-s1ap::s1ap(srslte::task_sched_handle task_sched_) : s1setup_proc(this), task_sched(task_sched_) {}
+s1ap::s1ap(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger) :
+  s1setup_proc(this), logger(logger), task_sched(task_sched_)
+{}
 
 int s1ap::init(s1ap_args_t args_, rrc_interface_s1ap* rrc_, srsenb::stack_interface_s1ap_lte* stack_)
 {
-  rrc      = rrc_;
+  rrc   = rrc_;
-  args     = args_;
+  args  = args_;
-  s1ap_log = srslte::logmap::get("S1AP");
+  stack = stack_;
-  stack    = stack_;
+  pool  = srslte::byte_buffer_pool::get_instance();
-  pool     = srslte::byte_buffer_pool::get_instance();
 
   build_tai_cgi();
 
@@ -238,7 +239,7 @@ int s1ap::init(s1ap_args_t args_, rrc_interface_s1ap* rrc_, srsenb::stack_interf
   mme_connect_timer    = task_sched.get_unique_timer();
   auto mme_connect_run = [this](uint32_t tid) {
     if (not s1setup_proc.launch()) {
-      s1ap_log->error("Failed to initiate S1Setup procedure.\n");
+      logger.error("Failed to initiate S1Setup procedure.");
     }
   };
   mme_connect_timer.set(10000, mme_connect_run);
@@ -255,7 +256,7 @@ int s1ap::init(s1ap_args_t args_, rrc_interface_s1ap* rrc_, srsenb::stack_interf
   running = true;
   // starting MME connection
   if (not s1setup_proc.launch()) {
-    s1ap_log->error("Failed to initiate S1Setup procedure.\n");
+    logger.error("Failed to initiate S1Setup procedure.");
   }
 
   return SRSLTE_SUCCESS;
@@ -306,7 +307,7 @@ void s1ap::initial_ue(uint16_t rnti, asn1::s1ap::rrc_establishment_cause_e cause
   ue_ptr->ctxt.rnti = rnti;
   ue* u             = users.add_user(std::move(ue_ptr));
   if (u == nullptr) {
-    s1ap_log->error("Failed to add rnti=0x%x\n", rnti);
+    logger.error("Failed to add rnti=0x%x", rnti);
     return;
   }
   u->send_initialuemessage(cause, std::move(pdu), false);
@@ -322,7 +323,7 @@ void s1ap::initial_ue(uint16_t                              rnti,
   ue_ptr->ctxt.rnti = rnti;
   ue* u             = users.add_user(std::move(ue_ptr));
   if (u == nullptr) {
-    s1ap_log->error("Failed to add rnti=0x%x\n", rnti);
+    logger.error("Failed to add rnti=0x%x", rnti);
     return;
   }
   u->send_initialuemessage(cause, std::move(pdu), true, m_tmsi, mmec);
@@ -330,11 +331,11 @@ void s1ap::initial_ue(uint16_t                              rnti,
 
 void s1ap::write_pdu(uint16_t rnti, srslte::unique_byte_buffer_t pdu)
 {
-  s1ap_log->info_hex(pdu->msg, pdu->N_bytes, "Received RRC SDU");
+  logger.info(pdu->msg, pdu->N_bytes, "Received RRC SDU");
 
   ue* u = users.find_ue_rnti(rnti);
   if (u == nullptr) {
-    s1ap_log->info("The rnti=0x%x does not exist\n", rnti);
+    logger.info("The rnti=0x%x does not exist", rnti);
     return;
   }
   u->send_ulnastransport(std::move(pdu));
@@ -342,7 +343,7 @@ void s1ap::write_pdu(uint16_t rnti, srslte::unique_byte_buffer_t pdu)
 
 bool s1ap::user_release(uint16_t rnti, asn1::s1ap::cause_radio_network_e cause_radio)
 {
-  s1ap_log->info("User inactivity - RNTI:0x%x\n", rnti);
+  logger.info("User inactivity - RNTI:0x%x", rnti);
 
   ue* u = users.find_ue_rnti(rnti);
   if (u == nullptr) {
@@ -350,7 +351,7 @@ bool s1ap::user_release(uint16_t rnti, asn1::s1ap::cause_radio_network_e cause_r
   }
 
   if (u->was_uectxtrelease_requested()) {
-    s1ap_log->warning("UE context for RNTI:0x%x is in zombie state. Releasing...\n", rnti);
+    logger.warning("UE context for RNTI:0x%x is in zombie state. Releasing...", rnti);
     users.erase(u);
     rrc->release_complete(rnti);
     return false;
@@ -372,13 +373,13 @@ bool s1ap::user_exists(uint16_t rnti)
 
 void s1ap::user_mod(uint16_t old_rnti, uint16_t new_rnti)
 {
-  s1ap_log->info("Modifying user context. Old rnti: 0x%x, new rnti: 0x%x\n", old_rnti, new_rnti);
+  logger.info("Modifying user context. Old rnti: 0x%x, new rnti: 0x%x", old_rnti, new_rnti);
   if (not user_exists(old_rnti)) {
-    s1ap_log->error("Old rnti does not exist, aborting.\n");
+    logger.error("Old rnti does not exist, aborting.");
     return;
   }
   if (user_exists(new_rnti)) {
-    s1ap_log->error("New rnti already exists, aborting.\n");
+    logger.error("New rnti already exists, aborting.");
     return;
   }
   users.find_ue_rnti(old_rnti)->ctxt.rnti = new_rnti;
@@ -401,7 +402,7 @@ void s1ap::ue_erab_setup_complete(uint16_t rnti, const asn1::s1ap::erab_setup_re
 {
   ue* u = users.find_ue_rnti(rnti);
   if (u == nullptr) {
-    s1ap_log->error("rnti 0x%x not found\n", rnti);
+    logger.error("rnti 0x%x not found", rnti);
     return;
   }
   u->send_erab_setup_response(res);
@@ -423,7 +424,7 @@ bool s1ap::is_mme_connected()
 
 bool s1ap::connect_mme()
 {
-  s1ap_log->info("Connecting to MME %s:%d\n", args.mme_addr.c_str(), MME_PORT);
+  logger.info("Connecting to MME %s:%d", args.mme_addr.c_str(), int(MME_PORT));
 
   // Init SCTP socket and bind it
   if (not srslte::net_utils::sctp_init_client(
@@ -439,7 +440,7 @@ bool s1ap::connect_mme()
   // Assign a handler to rx MME packets (going to run in a different thread)
   stack->add_mme_socket(s1ap_socket.fd());
 
-  s1ap_log->info("SCTP socket established with MME\n");
+  logger.info("SCTP socket established with MME");
   return true;
 }
 
@@ -492,21 +493,21 @@ bool s1ap::handle_mme_rx_msg(srslte::unique_byte_buffer_t pdu,
   if (flags & MSG_NOTIFICATION) {
     // Received notification
     union sctp_notification* notification = (union sctp_notification*)pdu->msg;
-    s1ap_log->debug("SCTP Notification %d\n", notification->sn_header.sn_type);
+    logger.debug("SCTP Notification %d", notification->sn_header.sn_type);
     if (notification->sn_header.sn_type == SCTP_SHUTDOWN_EVENT) {
-      s1ap_log->info("SCTP Association Shutdown. Association: %d\n", sri.sinfo_assoc_id);
+      logger.info("SCTP Association Shutdown. Association: %d", sri.sinfo_assoc_id);
       srslte::console("SCTP Association Shutdown. Association: %d\n", sri.sinfo_assoc_id);
       stack->remove_mme_socket(s1ap_socket.get_socket());
       s1ap_socket.reset();
     } else if (notification->sn_header.sn_type == SCTP_PEER_ADDR_CHANGE &&
                notification->sn_paddr_change.spc_state == SCTP_ADDR_UNREACHABLE) {
-      s1ap_log->info("SCTP peer addres unreachable. Association: %d\n", sri.sinfo_assoc_id);
+      logger.info("SCTP peer addres unreachable. Association: %d", sri.sinfo_assoc_id);
       srslte::console("SCTP peer address unreachable. Association: %d\n", sri.sinfo_assoc_id);
       stack->remove_mme_socket(s1ap_socket.get_socket());
       s1ap_socket.reset();
     }
   } else if (pdu->N_bytes == 0) {
-    s1ap_log->error("SCTP return 0 bytes. Closing socket\n");
+    logger.error("SCTP return 0 bytes. Closing socket");
     s1ap_socket.reset();
   }
 
@@ -514,12 +515,12 @@ bool s1ap::handle_mme_rx_msg(srslte::unique_byte_buffer_t pdu,
   if (not s1ap_socket.is_init()) {
     mme_connected = false;
     if (not s1setup_proc.launch()) {
-      s1ap_log->error("Failed to initiate MME connection procedure.\n");
+      logger.error("Failed to initiate MME connection procedure.");
     }
     return false;
   }
 
-  s1ap_log->info_hex(pdu->msg, pdu->N_bytes, "Received S1AP PDU");
+  logger.info(pdu->msg, pdu->N_bytes, "Received S1AP PDU");
   handle_s1ap_rx_pdu(pdu.get());
   return true;
 }
@@ -535,7 +536,7 @@ bool s1ap::handle_s1ap_rx_pdu(srslte::byte_buffer_t* pdu)
   asn1::cbit_ref bref(pdu->msg, pdu->N_bytes);
 
   if (rx_pdu.unpack(bref) != asn1::SRSASN_SUCCESS) {
-    s1ap_log->error("Failed to unpack received PDU\n");
+    logger.error("Failed to unpack received PDU");
     return false;
   }
 
@@ -547,7 +548,7 @@ bool s1ap::handle_s1ap_rx_pdu(srslte::byte_buffer_t* pdu)
     case s1ap_pdu_c::types_opts::unsuccessful_outcome:
       return handle_unsuccessfuloutcome(rx_pdu.unsuccessful_outcome());
     default:
-      s1ap_log->error("Unhandled PDU type %d\n", rx_pdu.type().value);
+      logger.error("Unhandled PDU type %d", rx_pdu.type().value);
       return false;
   }
 
@@ -578,7 +579,7 @@ bool s1ap::handle_initiatingmessage(const init_msg_s& msg)
     case s1ap_elem_procs_o::init_msg_c::types_opts::mme_status_transfer:
       return handle_mme_status_transfer(msg.value.mme_status_transfer());
     default:
-      s1ap_log->error("Unhandled initiating message: %s\n", msg.value.type().to_string().c_str());
+      logger.error("Unhandled initiating message: %s", msg.value.type().to_string().c_str());
   }
   return true;
 }
@@ -591,10 +592,10 @@ bool s1ap::handle_successfuloutcome(const successful_outcome_s& msg)
     case s1ap_elem_procs_o::successful_outcome_c::types_opts::ho_cmd:
       return handle_s1hocommand(msg.value.ho_cmd());
     case s1ap_elem_procs_o::successful_outcome_c::types_opts::ho_cancel_ack:
-      s1ap_log->info("Received %s\n", msg.value.type().to_string().c_str());
+      logger.info("Received %s", msg.value.type().to_string().c_str());
       return true;
     default:
-      s1ap_log->error("Unhandled successful outcome message: %s\n", msg.value.type().to_string().c_str());
+      logger.error("Unhandled successful outcome message: %s", msg.value.type().to_string().c_str());
   }
   return true;
 }
@@ -607,14 +608,14 @@ bool s1ap::handle_unsuccessfuloutcome(const unsuccessful_outcome_s& msg)
     case s1ap_elem_procs_o::unsuccessful_outcome_c::types_opts::ho_prep_fail:
       return handle_hopreparationfailure(msg.value.ho_prep_fail());
     default:
-      s1ap_log->error("Unhandled unsuccessful outcome message: %s\n", msg.value.type().to_string().c_str());
+      logger.error("Unhandled unsuccessful outcome message: %s", msg.value.type().to_string().c_str());
   }
   return true;
 }
 
 bool s1ap::handle_s1setupresponse(const asn1::s1ap::s1_setup_resp_s& msg)
 {
-  s1ap_log->info("Received S1SetupResponse\n");
+  logger.info("Received S1SetupResponse");
   s1setupresponse = msg;
   mme_connected   = true;
   s1_setup_proc_t::s1setupresult res;
@@ -625,9 +626,9 @@ bool s1ap::handle_s1setupresponse(const asn1::s1ap::s1_setup_resp_s& msg)
 
 bool s1ap::handle_dlnastransport(const dl_nas_transport_s& msg)
 {
-  s1ap_log->info("Received DownlinkNASTransport\n");
+  logger.info("Received DownlinkNASTransport");
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
@@ -635,15 +636,15 @@ bool s1ap::handle_dlnastransport(const dl_nas_transport_s& msg)
   }
 
   if (msg.protocol_ies.ho_restrict_list_present) {
-    s1ap_log->warning("Not handling HandoverRestrictionList\n");
+    logger.warning("Not handling HandoverRestrictionList");
   }
   if (msg.protocol_ies.subscriber_profile_idfor_rfp_present) {
-    s1ap_log->warning("Not handling SubscriberProfileIDforRFP\n");
+    logger.warning("Not handling SubscriberProfileIDforRFP");
   }
 
   srslte::unique_byte_buffer_t pdu = srslte::allocate_unique_buffer(*pool);
   if (pdu == nullptr) {
-    s1ap_log->error("Fatal Error: Couldn't allocate buffer in s1ap::run_thread().\n");
+    logger.error("Fatal Error: Couldn't allocate buffer in s1ap::run_thread().");
     return false;
   }
   memcpy(pdu->msg, msg.protocol_ies.nas_pdu.value.data(), msg.protocol_ies.nas_pdu.value.size());
@@ -654,9 +655,9 @@ bool s1ap::handle_dlnastransport(const dl_nas_transport_s& msg)
 
 bool s1ap::handle_initialctxtsetuprequest(const init_context_setup_request_s& msg)
 {
-  s1ap_log->info("Received InitialContextSetupRequest\n");
+  logger.info("Received InitialContextSetupRequest");
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
@@ -687,7 +688,7 @@ bool s1ap::handle_initialctxtsetuprequest(const init_context_setup_request_s& ms
 bool s1ap::handle_paging(const asn1::s1ap::paging_s& msg)
 {
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   uint32_t ueid = msg.protocol_ies.ue_id_idx_value.value.to_number();
   rrc->add_paging_id(ueid, msg.protocol_ies.ue_paging_id.value);
@@ -696,9 +697,9 @@ bool s1ap::handle_paging(const asn1::s1ap::paging_s& msg)
 
 bool s1ap::handle_erabsetuprequest(const erab_setup_request_s& msg)
 {
-  s1ap_log->info("Received ERABSetupRequest\n");
+  logger.info("Received ERABSetupRequest");
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
@@ -711,12 +712,12 @@ bool s1ap::handle_erabsetuprequest(const erab_setup_request_s& msg)
 
 bool s1ap::handle_erabmodifyrequest(const erab_modify_request_s& msg)
 {
-  s1ap_log->info("Received ERABModifyRequest\n");
+  logger.info("Received ERABModifyRequest");
   std::vector<uint16_t> erab_successful_modified = {};
   std::vector<uint16_t> erab_failed_to_modify    = {};
 
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
@@ -728,7 +729,7 @@ bool s1ap::handle_erabmodifyrequest(const erab_modify_request_s& msg)
 
   // Send E-RAB modify response back to the MME
   if (not u->send_erab_modify_response(erab_successful_modified, erab_failed_to_modify)) {
-    s1ap_log->info("Failed to send ERABReleaseResponse\n");
+    logger.info("Failed to send ERABReleaseResponse");
     return false;
   }
 
@@ -737,12 +738,12 @@ bool s1ap::handle_erabmodifyrequest(const erab_modify_request_s& msg)
 
 bool s1ap::handle_erabreleasecommand(const erab_release_cmd_s& msg)
 {
-  s1ap_log->info("Received ERABReleaseCommand\n");
+  logger.info("Received ERABReleaseCommand");
   std::vector<uint16_t> erab_successful_release = {};
   std::vector<uint16_t> erab_failed_to_release  = {};
 
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
@@ -754,7 +755,7 @@ bool s1ap::handle_erabreleasecommand(const erab_release_cmd_s& msg)
 
   // Send E-RAB release response back to the MME
   if (not u->send_erab_release_response(erab_successful_release, erab_failed_to_release)) {
-    s1ap_log->info("Failed to send ERABReleaseResponse\n");
+    logger.info("Failed to send ERABReleaseResponse");
     return false;
   }
 
@@ -763,7 +764,7 @@ bool s1ap::handle_erabreleasecommand(const erab_release_cmd_s& msg)
 
 bool s1ap::handle_uecontextmodifyrequest(const ue_context_mod_request_s& msg)
 {
-  s1ap_log->info("Received UeContextModificationRequest\n");
+  logger.info("Received UeContextModificationRequest");
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
     return false;
@@ -796,9 +797,9 @@ bool s1ap::handle_uecontextmodifyrequest(const ue_context_mod_request_s& msg)
 
 bool s1ap::handle_uectxtreleasecommand(const ue_context_release_cmd_s& msg)
 {
-  s1ap_log->info("Received UEContextReleaseCommand\n");
+  logger.info("Received UEContextReleaseCommand");
   if (msg.ext) {
-    s1ap_log->warning("Not handling S1AP message extension\n");
+    logger.warning("Not handling S1AP message extension");
   }
 
   ue* u = nullptr;
@@ -806,10 +807,10 @@ bool s1ap::handle_uectxtreleasecommand(const ue_context_release_cmd_s& msg)
     auto& idpair = msg.protocol_ies.ue_s1ap_ids.value.ue_s1ap_id_pair();
 
     if (idpair.ext) {
-      s1ap_log->warning("Not handling S1AP message extension\n");
+      logger.warning("Not handling S1AP message extension");
     }
     if (idpair.ie_exts_present) {
-      s1ap_log->warning("Not handling S1AP message iE_Extensions\n");
+      logger.warning("Not handling S1AP message iE_Extensions");
     }
     u = find_s1apmsg_user(idpair.enb_ue_s1ap_id, idpair.mme_ue_s1ap_id);
     if (u == nullptr) {
@@ -819,7 +820,7 @@ bool s1ap::handle_uectxtreleasecommand(const ue_context_release_cmd_s& msg)
     uint32_t mme_ue_id = msg.protocol_ies.ue_s1ap_ids.value.mme_ue_s1ap_id();
     u                  = users.find_ue_mmeid(mme_ue_id);
     if (u == nullptr) {
-      s1ap_log->warning("UE for mme_ue_s1ap_id:%d not found - discarding message\n", mme_ue_id);
+      logger.warning("UE for mme_ue_s1ap_id:%d not found - discarding message", mme_ue_id);
       return false;
     }
   }
@@ -828,7 +829,7 @@ bool s1ap::handle_uectxtreleasecommand(const ue_context_release_cmd_s& msg)
   rrc->release_erabs(rnti);
   u->send_uectxtreleasecomplete();
   users.erase(u);
-  s1ap_log->info("UE context for RNTI:0x%x released\n", rnti);
+  logger.info("UE context for RNTI:0x%x released", rnti);
   rrc->release_complete(rnti);
   return true;
 }
@@ -836,14 +837,14 @@ bool s1ap::handle_uectxtreleasecommand(const ue_context_release_cmd_s& msg)
 bool s1ap::handle_s1setupfailure(const asn1::s1ap::s1_setup_fail_s& msg)
 {
   std::string cause = get_cause(msg.protocol_ies.cause.value);
-  s1ap_log->error("S1 Setup Failure. Cause: %s\n", cause.c_str());
+  logger.error("S1 Setup Failure. Cause: %s", cause.c_str());
   srslte::console("S1 Setup Failure. Cause: %s\n", cause.c_str());
   return true;
 }
 
 bool s1ap::handle_hopreparationfailure(const ho_prep_fail_s& msg)
 {
-  s1ap_log->info("Received HO Preparation Failure\n");
+  logger.info("Received HO Preparation Failure");
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
     return false;
@@ -854,7 +855,7 @@ bool s1ap::handle_hopreparationfailure(const ho_prep_fail_s& msg)
 
 bool s1ap::handle_s1hocommand(const asn1::s1ap::ho_cmd_s& msg)
 {
-  s1ap_log->info("Received S1 HO Command\n");
+  logger.info("Received S1 HO Command");
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
   if (u == nullptr) {
     return false;
@@ -871,7 +872,7 @@ bool s1ap::handle_ho_request(const asn1::s1ap::ho_request_s& msg)
 {
   uint16_t rnti = SRSLTE_INVALID_RNTI;
 
-  s1ap_log->info("Received S1 HO Request\n");
+  logger.info("Received S1 HO Request");
   srslte::console("Received S1 HO Request\n");
 
   auto on_scope_exit = srslte::make_scope_exit([this, &rnti, msg]() {
@@ -883,14 +884,14 @@ bool s1ap::handle_ho_request(const asn1::s1ap::ho_request_s& msg)
 
   if (msg.ext or msg.protocol_ies.ho_restrict_list_present or
       msg.protocol_ies.handov_type.value.value != handov_type_opts::intralte) {
-    s1ap_log->error("Not handling S1AP non-intra LTE handovers and extensions\n");
+    logger.error("Not handling S1AP non-intra LTE handovers and extensions");
     return false;
   }
 
   // Confirm the UE does not exist in TeNB
   if (users.find_ue_mmeid(msg.protocol_ies.mme_ue_s1ap_id.value.value) != nullptr) {
-    s1ap_log->error("The provided MME_UE_S1AP_ID=%" PRIu64 " is already connected to the cell\n",
+    logger.error("The provided MME_UE_S1AP_ID=%" PRIu64 " is already connected to the cell",
-                    msg.protocol_ies.mme_ue_s1ap_id.value.value);
+                 msg.protocol_ies.mme_ue_s1ap_id.value.value);
     return false;
   }
 
@@ -907,7 +908,7 @@ bool s1ap::handle_ho_request(const asn1::s1ap::ho_request_s& msg)
   asn1::cbit_ref bref{msg.protocol_ies.source_to_target_transparent_container.value.data(),
                       msg.protocol_ies.source_to_target_transparent_container.value.size()};
   if (container.unpack(bref) != asn1::SRSASN_SUCCESS) {
-    s1ap_log->error("Failed to unpack SourceToTargetTransparentContainer\n");
+    logger.error("Failed to unpack SourceToTargetTransparentContainer");
     return false;
   }
 
@@ -972,7 +973,7 @@ bool s1ap::send_ho_req_ack(const asn1::s1ap::ho_request_s&               msg,
   auto&         pdu = ho_cmd; // reuse pdu
   asn1::bit_ref bref{pdu->msg, pdu->get_tailroom()};
   if (transparent_container.pack(bref) != asn1::SRSASN_SUCCESS) {
-    s1ap_log->error("Failed to pack TargeteNBToSourceeNBTransparentContainer\n");
+    logger.error("Failed to pack TargeteNBToSourceeNBTransparentContainer");
     return false;
   }
   container.target_to_source_transparent_container.value.resize(bref.distance_bytes());
@@ -983,7 +984,7 @@ bool s1ap::send_ho_req_ack(const asn1::s1ap::ho_request_s&               msg,
 
 bool s1ap::handle_mme_status_transfer(const asn1::s1ap::mme_status_transfer_s& msg)
 {
-  s1ap_log->info("Received S1 MMEStatusTransfer\n");
+  logger.info("Received S1 MMEStatusTransfer");
   srslte::console("Received S1 MMEStatusTransfer\n");
 
   ue* u = find_s1apmsg_user(msg.protocol_ies.enb_ue_s1ap_id.value.value, msg.protocol_ies.mme_ue_s1ap_id.value.value);
@@ -1114,7 +1115,7 @@ bool s1ap::ue::send_uectxtreleaserequest(const cause_c& cause)
   }
 
   if (!ctxt.mme_ue_s1ap_id_present) {
-    s1ap_log->error("Cannot send UE context release request without a MME-UE-S1AP-Id allocated.\n");
+    logger.error("Cannot send UE context release request without a MME-UE-S1AP-Id allocated.");
     return false;
   }
 
@@ -1367,7 +1368,7 @@ bool s1ap::send_ho_required(uint16_t                     rnti,
 
   // launch procedure
   if (not u->ho_prep_proc.launch(target_eci, target_plmn, std::move(rrc_container))) {
-    s1ap_log->error("Failed to initiate an HandoverPreparation procedure for user rnti=0x%x\n", u->ctxt.rnti);
+    logger.error("Failed to initiate an HandoverPreparation procedure for user rnti=0x%x", u->ctxt.rnti);
     return false;
   }
   return true;
@@ -1405,13 +1406,13 @@ bool s1ap::send_enb_status_transfer_proc(uint16_t rnti, std::vector<bearer_statu
 //  // TODO: caps->UERadioCapability.
 
 //  liblte_s1ap_pack_s1ap_pdu(&tx_pdu, (LIBLTE_BYTE_MSG_STRUCT*)&msg);
-//  s1ap_log->info_hex(msg.msg, msg.N_bytes, "Sending UERadioCapabilityInfo for RNTI:0x%x", rnti);
+//  logger.info_hex(msg.msg, msg.N_bytes, "Sending UERadioCapabilityInfo for RNTI:0x%x", rnti);
 
 //  ssize_t n_sent = sctp_sendmsg(socket_fd, msg.msg, msg.N_bytes,
 //                                (struct sockaddr*)&mme_addr, sizeof(struct sockaddr_in),
 //                                htonl(PPID), 0, ue_ctxt_map[rnti]->stream_id, 0, 0);
 //  if(n_sent == -1) {
-//    s1ap_log->error("Failed to send UplinkNASTransport for RNTI:0x%x\n", rnti);
+//    logger.error("Failed to send UplinkNASTransport for RNTI:0x%x", rnti);
 //    return false;
 //  }
 
@@ -1455,17 +1456,15 @@ s1ap::ue* s1ap::user_list::add_user(std::unique_ptr<s1ap::ue> user)
 {
   // Check for ID repetitions
   if (find_ue_rnti(user->ctxt.rnti) != nullptr) {
-    srslte::logmap::get("S1AP")->error("The user to be added with rnti=0x%x already exists\n", user->ctxt.rnti);
+    srslte::logmap::get("S1AP")->error("The user to be added with rnti=0x%x already exists", user->ctxt.rnti);
     return nullptr;
   }
   if (find_ue_enbid(user->ctxt.enb_ue_s1ap_id) != nullptr) {
-    srslte::logmap::get("S1AP")->error("The user to be added with enb id=%d already exists\n",
+    srslte::logmap::get("S1AP")->error("The user to be added with enb id=%d already exists", user->ctxt.enb_ue_s1ap_id);
-                                       user->ctxt.enb_ue_s1ap_id);
     return nullptr;
   }
   if (find_ue_mmeid(user->ctxt.mme_ue_s1ap_id) != nullptr) {
-    srslte::logmap::get("S1AP")->error("The user to be added with mme id=%d already exists\n",
+    srslte::logmap::get("S1AP")->error("The user to be added with mme id=%d already exists", user->ctxt.mme_ue_s1ap_id);
-                                       user->ctxt.mme_ue_s1ap_id);
     return nullptr;
   }
   auto p = users.insert(std::make_pair(user->ctxt.enb_ue_s1ap_id, std::move(user)));
@@ -1476,7 +1475,7 @@ void s1ap::user_list::erase(ue* ue_ptr)
 {
   auto it = users.find(ue_ptr->ctxt.enb_ue_s1ap_id);
   if (it == users.end()) {
-    srslte::logmap::get("S1AP")->error("User to be erased does not exist\n");
+    srslte::logmap::get("S1AP")->error("User to be erased does not exist");
     return;
   }
   users.erase(it);
@@ -1490,7 +1489,7 @@ bool s1ap::sctp_send_s1ap_pdu(const asn1::s1ap::s1ap_pdu_c& tx_pdu, uint32_t rnt
 {
   srslte::unique_byte_buffer_t buf = srslte::allocate_unique_buffer(*pool, false);
   if (buf == nullptr) {
-    s1ap_log->error("Fatal Error: Couldn't allocate buffer for %s.\n", procedure_name);
+    logger.error("Fatal Error: Couldn't allocate buffer for %s.", procedure_name);
     return false;
   }
   asn1::bit_ref bref(buf->msg, buf->get_tailroom());
@@ -1503,9 +1502,9 @@ bool s1ap::sctp_send_s1ap_pdu(const asn1::s1ap::s1ap_pdu_c& tx_pdu, uint32_t rnt
   }
 
   if (rnti != SRSLTE_INVALID_RNTI) {
-    s1ap_log->info_hex(buf->msg, buf->N_bytes, "Sending %s for rnti=0x%x", procedure_name, rnti);
+    logger.info(buf->msg, buf->N_bytes, "Sending %s for rnti=0x%x", procedure_name, rnti);
   } else {
-    s1ap_log->info_hex(buf->msg, buf->N_bytes, "Sending %s to MME", procedure_name);
+    logger.info(buf->msg, buf->N_bytes, "Sending %s to MME", procedure_name);
   }
   uint16_t streamid = rnti == SRSLTE_INVALID_RNTI ? NONUE_STREAM_ID : users.find_ue_rnti(rnti)->stream_id;
 
@@ -1521,9 +1520,9 @@ bool s1ap::sctp_send_s1ap_pdu(const asn1::s1ap::s1ap_pdu_c& tx_pdu, uint32_t rnt
                                 0);
   if (n_sent == -1) {
     if (rnti > 0) {
-      s1ap_log->error("Failed to send %s for rnti=0x%x\n", procedure_name, rnti);
+      logger.error("Failed to send %s for rnti=0x%x", procedure_name, rnti);
     } else {
-      s1ap_log->error("Failed to send %s\n", procedure_name);
+      logger.error("Failed to send %s", procedure_name);
     }
     return false;
   }
@@ -1540,11 +1539,11 @@ s1ap::ue* s1ap::find_s1apmsg_user(uint32_t enb_id, uint32_t mme_id)
 {
   ue* user_ptr = users.find_ue_enbid(enb_id);
   if (user_ptr == nullptr) {
-    s1ap_log->warning("enb_ue_s1ap_id=%d not found - discarding message\n", enb_id);
+    logger.warning("enb_ue_s1ap_id=%d not found - discarding message", enb_id);
     return nullptr;
   }
   if (user_ptr->ctxt.mme_ue_s1ap_id_present and user_ptr->ctxt.mme_ue_s1ap_id != mme_id) {
-    s1ap_log->warning("MME_UE_S1AP_ID has changed - old:%d, new:%d\n", user_ptr->ctxt.mme_ue_s1ap_id, mme_id);
+    logger.warning("MME_UE_S1AP_ID has changed - old:%d, new:%d", user_ptr->ctxt.mme_ue_s1ap_id, mme_id);
   }
   user_ptr->ctxt.mme_ue_s1ap_id_present = true;
   user_ptr->ctxt.mme_ue_s1ap_id         = mme_id;
@@ -1586,7 +1585,7 @@ void s1ap::start_pcap(srslte::s1ap_pcap* pcap_)
 /*               s1ap::ue Class
 ********************************************************************************/
 
-s1ap::ue::ue(s1ap* s1ap_ptr_) : s1ap_ptr(s1ap_ptr_), s1ap_log(s1ap_ptr_->s1ap_log), ho_prep_proc(this)
+s1ap::ue::ue(s1ap* s1ap_ptr_) : s1ap_ptr(s1ap_ptr_), ho_prep_proc(this), logger(s1ap_ptr->logger)
 {
   ctxt.enb_ue_s1ap_id = s1ap_ptr->next_enb_ue_s1ap_id++;
   gettimeofday(&ctxt.init_timestamp, nullptr);
@@ -1665,7 +1664,7 @@ bool s1ap::ue::send_ho_required(uint32_t                     target_eci,
   uint8_t       buffer[4096];
   asn1::bit_ref bref(buffer, sizeof(buffer));
   if (transparent_cntr.pack(bref) != asn1::SRSASN_SUCCESS) {
-    s1ap_log->error("Failed to pack transparent container of HO Required message\n");
+    logger.error("Failed to pack transparent container of HO Required message");
     return false;
   }
   container.source_to_target_transparent_container.value.resize(bref.distance_bytes());
@@ -1704,7 +1703,7 @@ bool s1ap::ue::send_enb_status_transfer_proc(std::vector<bearer_status_info>& be
 
     //    asn1::json_writer jw;
     //    asn1bearer.to_json(jw);
-    //    printf("Bearer to add %s\n", jw.to_string().c_str());
+    //    printf("Bearer to add %s", jw.to_string().c_str());
   }
 
   return s1ap_ptr->sctp_send_s1ap_pdu(tx_pdu, ctxt.rnti, "ENBStatusTransfer");

srsenb/src/stack/upper/sdap.cc

@@ -14,7 +14,7 @@
 
 namespace srsenb {
 
-sdap::sdap() : m_log("SDAP") {}
+sdap::sdap() {}
 
 bool sdap::init(pdcp_interface_sdap_nr* pdcp_, gtpu_interface_sdap_nr* gtpu_, srsue::gw_interface_pdcp* gw_)
 {

srsenb/test/mac/sched_ca_test.cc

@@ -23,20 +23,24 @@ uint32_t const seed = std::chrono::system_clock::now().time_since_epoch().count(
  *     Logging     *
  *******************/
 
-class sched_test_log final : public srslte::test_log_filter
+/// RAII style class that prints the test diagnostic info on destruction.
+class sched_diagnostic_printer
 {
 public:
-  sched_test_log() : srslte::test_log_filter("TEST") { exit_on_error = true; }
+  explicit sched_diagnostic_printer(srslte::log_sink_spy& s) : s(s) {}
-  ~sched_test_log() override { log_diagnostics(); }
 
-  void log_diagnostics() override
+  ~sched_diagnostic_printer()
   {
-    info("[TESTER] Number of assertion warnings: %u\n", warn_counter);
+    auto& logger = srslog::fetch_basic_logger("TEST");
-    info("[TESTER] Number of assertion errors: %u\n", error_counter);
+    logger.info("[TESTER] Number of assertion warnings: %u", s.get_warning_counter());
-    info("[TESTER] This was the seed: %u\n", seed);
+    logger.info("[TESTER] Number of assertion errors: %u", s.get_error_counter());
+    logger.info("[TESTER] This was the seed: %u", seed);
+    srslog::flush();
   }
+
+private:
+  srslte::log_sink_spy& s;
 };
-srslte::scoped_log<sched_test_log> log_global{};
 
 /******************************
  *      Scheduler Tests
@@ -100,7 +104,6 @@ int test_scell_activation(test_scell_activation_params params)
 
   /* Setup simulation arguments struct */
   sim_sched_args sim_args = generate_default_sim_args(nof_prb, nof_ccs);
-  sim_args.sim_log        = log_global.get();
   sim_args.start_tti      = start_tti;
   sim_args.default_ue_sim_cfg.ue_cfg.supported_cc_list.resize(1);
   sim_args.default_ue_sim_cfg.ue_cfg.supported_cc_list[0].active                                = true;
@@ -226,7 +229,7 @@ int test_scell_activation(test_scell_activation_params params)
   TESTASSERT(tot_dl_sched_data > 0);
   TESTASSERT(tot_ul_sched_data > 0);
 
-  log_global->info("[TESTER] Sim1 finished successfully\n");
+  srslog::fetch_basic_logger("TEST").info("[TESTER] Sim1 finished successfully");
   return SRSLTE_SUCCESS;
 }
 
@@ -235,6 +238,28 @@ int main()
   // Setup rand seed
   set_randseed(seed);
 
+  // Setup the log spy to intercept error and warning log entries.
+  if (!srslog::install_custom_sink(
+          srslte::log_sink_spy::name(),
+          std::unique_ptr<srslte::log_sink_spy>(new srslte::log_sink_spy(srslog::get_default_log_formatter())))) {
+    return SRSLTE_ERROR;
+  }
+
+  auto* spy = static_cast<srslte::log_sink_spy*>(srslog::find_sink(srslte::log_sink_spy::name()));
+  if (!spy) {
+    return SRSLTE_ERROR;
+  }
+
+  auto& mac_log = srslog::fetch_basic_logger("MAC");
+  mac_log.set_level(srslog::basic_levels::info);
+  auto& test_log = srslog::fetch_basic_logger("TEST", *spy, false);
+  test_log.set_level(srslog::basic_levels::info);
+
+  // Start the log backend.
+  srslog::init();
+
+  sched_diagnostic_printer printer(*spy);
+
   srslte::logmap::set_default_log_level(srslte::LOG_LEVEL_INFO);
   printf("[TESTER] This is the chosen seed: %u\n", seed);
   uint32_t N_runs = 20;
@@ -250,5 +275,7 @@ int main()
     TESTASSERT(test_scell_activation(p) == SRSLTE_SUCCESS);
   }
 
+  srslog::flush();
+
   return 0;
 }

srsenb/test/mac/sched_common_test_suite.cc

@@ -27,10 +27,10 @@ int test_pusch_collisions(const sf_output_res_t& sf_out, uint32_t enb_cc_idx, co
   prbmask_t ul_allocs(nof_prb);
 
   auto try_ul_fill = [&](prb_interval alloc, const char* ch_str, bool strict = true) {
-    CONDERROR(alloc.stop() > nof_prb, "Allocated RBs %s out-of-bounds\n", alloc.to_string().c_str());
+    CONDERROR(alloc.stop() > nof_prb, "Allocated RBs %s out-of-bounds", alloc.to_string().c_str());
-    CONDERROR(alloc.empty(), "Allocations must have at least one PRB\n");
+    CONDERROR(alloc.empty(), "Allocations must have at least one PRB");
     if (strict and ul_allocs.any(alloc.start(), alloc.stop())) {
-      TESTERROR("Collision Detected of %s alloc=%s and cumulative_mask=0x%s\n",
+      TESTERROR("Collision Detected of %s alloc=%s and cumulative_mask=0x%s",
                 ch_str,
                 alloc.to_string().c_str(),
                 ul_allocs.to_hex().c_str());
@@ -62,7 +62,7 @@ int test_pusch_collisions(const sf_output_res_t& sf_out, uint32_t enb_cc_idx, co
   }
 
   CONDERROR(expected_ul_mask != nullptr and *expected_ul_mask != ul_allocs,
-            "The derived UL PRB mask %s does not match the expected one %s\n",
+            "The derived UL PRB mask %s does not match the expected one %s",
             ul_allocs.to_string().c_str(),
             expected_ul_mask->to_string().c_str());
 
@@ -80,7 +80,7 @@ int extract_dl_prbmask(const srslte_cell_t&               cell,
   alloc_mask.reset();
 
   CONDERROR(srslte_ra_dl_dci_to_grant(&cell, &dl_sf, SRSLTE_TM1, false, &dci, &grant) == SRSLTE_ERROR,
-            "Failed to decode PDSCH grant\n");
+            "Failed to decode PDSCH grant");
   for (uint32_t j = 0; j < alloc_mask.size(); ++j) {
     if (grant.prb_idx[0][j]) {
       alloc_mask.set(j);
@@ -100,9 +100,9 @@ int test_pdsch_collisions(const sf_output_res_t& sf_out, uint32_t enb_cc_idx, co
     if (extract_dl_prbmask(cell_params.cfg.cell, dci, alloc_mask) != SRSLTE_SUCCESS) {
       return SRSLTE_ERROR;
     }
-    CONDERROR(alloc_mask.none(), "DL allocation must occupy at least one RBG.\n");
+    CONDERROR(alloc_mask.none(), "DL allocation must occupy at least one RBG.");
     if ((dl_allocs & alloc_mask).any()) {
-      TESTERROR("Detected collision in the DL %s allocation (%s intersects %s)\n",
+      TESTERROR("Detected collision in the DL %s allocation (%s intersects %s)",
                 channel,
                 dl_allocs.to_string().c_str(),
                 alloc_mask.to_string().c_str());
@@ -141,14 +141,14 @@ int test_pdsch_collisions(const sf_output_res_t& sf_out, uint32_t enb_cc_idx, co
   for (uint32_t i = 0; i < cell_params.nof_rbgs; ++i) {
     uint32_t lim = SRSLTE_MIN((i + 1) * cell_params.P, dl_allocs.size());
     bool     val = dl_allocs.any(i * cell_params.P, lim);
-    CONDERROR(rev_alloc.any(i * cell_params.P, lim) and val, "No holes can be left in an RBG\n");
+    CONDERROR(rev_alloc.any(i * cell_params.P, lim) and val, "No holes can be left in an RBG");
     if (val) {
       rbgmask.set(i);
     }
   }
 
   CONDERROR(expected_rbgmask != nullptr and *expected_rbgmask != rbgmask,
-            "The derived DL RBG mask %s does not match the expected one %s\n",
+            "The derived DL RBG mask %s does not match the expected one %s",
             rbgmask.to_string().c_str(),
             expected_rbgmask->to_string().c_str());
 
@@ -174,17 +174,17 @@ int test_sib_scheduling(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
 
   /* Test if SIB1 was correctly scheduled */
   auto it = std::find_if(bc_begin, bc_end, [](bc_elem& elem) { return elem.index == 0; });
-  CONDERROR(sib1_expected and it == bc_end, "Failed to allocate SIB1 in even sfn, sf_idx==5\n");
+  CONDERROR(sib1_expected and it == bc_end, "Failed to allocate SIB1 in even sfn, sf_idx==5");
-  CONDERROR(not sib1_expected and it != bc_end, "SIB1 allocated in wrong TTI.\n");
+  CONDERROR(not sib1_expected and it != bc_end, "SIB1 allocated in wrong TTI.");
 
   /* Test if any SIB was scheduled with wrong index, tbs, or outside of its window */
   for (bc_elem* bc = bc_begin; bc != bc_end; ++bc) {
     if (bc->index == 0) {
       continue;
     }
-    CONDERROR(bc->index >= sched_interface::MAX_SIBS, "Invalid SIB idx=%d\n", bc->index + 1);
+    CONDERROR(bc->index >= sched_interface::MAX_SIBS, "Invalid SIB idx=%d", bc->index + 1);
     CONDERROR(bc->tbs < cell_params.cfg.sibs[bc->index].len,
-              "Allocated BC process with TBS=%d < sib_len=%d\n",
+              "Allocated BC process with TBS=%d < sib_len=%d",
               bc->tbs,
               cell_params.cfg.sibs[bc->index].len);
     uint32_t x         = (bc->index - 1) * cell_params.cfg.si_window_ms;
@@ -195,7 +195,7 @@ int test_sib_scheduling(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
     }
     srslte::tti_point    win_start{sfn_start * 10 + sf};
     srslte::tti_interval window{win_start, win_start + cell_params.cfg.si_window_ms};
-    CONDERROR(not window.contains(to_tx_dl(sf_out.tti_rx)), "Scheduled SIB is outside of its SIB window\n");
+    CONDERROR(not window.contains(to_tx_dl(sf_out.tti_rx)), "Scheduled SIB is outside of its SIB window");
   }
   return SRSLTE_SUCCESS;
 }
@@ -215,14 +215,11 @@ int test_pdcch_collisions(const sf_output_res_t&                   sf_out,
   // Helper Function: checks if there is any collision. If not, fills the PDCCH mask
   auto try_cce_fill = [&](const srslte_dci_location_t& dci_loc, const char* ch) {
     uint32_t cce_start = dci_loc.ncce, cce_stop = dci_loc.ncce + (1u << dci_loc.L);
-    CONDERROR(dci_loc.L == 0, "The aggregation level %d is not valid\n", dci_loc.L);
+    CONDERROR(dci_loc.L == 0, "The aggregation level %d is not valid", dci_loc.L);
     CONDERROR(
-        cce_start >= ncce or cce_stop > ncce, "The CCE positions (%u, %u) do not fit in PDCCH\n", cce_start, cce_stop);
+        cce_start >= ncce or cce_stop > ncce, "The CCE positions (%u, %u) do not fit in PDCCH", cce_start, cce_stop);
-    CONDERROR(used_cce.any(cce_start, cce_stop),
+    CONDERROR(
-              "%s DCI collision between CCE positions (%u, %u)\n",
+        used_cce.any(cce_start, cce_stop), "%s DCI collision between CCE positions (%u, %u)", ch, cce_start, cce_stop);
-              ch,
-              cce_start,
-              cce_stop);
     used_cce.fill(cce_start, cce_stop);
     return SRSLTE_SUCCESS;
   };
@@ -247,7 +244,7 @@ int test_pdcch_collisions(const sf_output_res_t&                   sf_out,
   }
 
   CONDERROR(expected_cce_mask != nullptr and *expected_cce_mask != used_cce,
-            "The derived PDCCH mask %s does not match the expected one %s\n",
+            "The derived PDCCH mask %s does not match the expected one %s",
             used_cce.to_string().c_str(),
             expected_cce_mask->to_string().c_str());
 
@@ -264,18 +261,18 @@ int test_dci_content_common(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
   for (uint32_t i = 0; i < ul_result.nof_dci_elems; ++i) {
     const auto& pusch = ul_result.pusch[i];
     uint16_t    rnti  = pusch.dci.rnti;
-    CONDERROR(pusch.tbs == 0, "Allocated PUSCH with invalid TBS=%d\n", pusch.tbs);
+    CONDERROR(pusch.tbs == 0, "Allocated PUSCH with invalid TBS=%d", pusch.tbs);
-    CONDERROR(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in UL\n", rnti);
+    CONDERROR(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in UL", rnti);
     alloc_rntis.insert(pusch.dci.rnti);
-    CONDERROR(not((pusch.current_tx_nb == 0) xor (pusch.dci.tb.rv != 0)), "Number of txs incorrectly set\n");
+    CONDERROR(not((pusch.current_tx_nb == 0) xor (pusch.dci.tb.rv != 0)), "Number of txs incorrectly set");
     if (not pusch.needs_pdcch) {
       // In case of non-adaptive retx or Msg3
       continue;
     }
     if (pusch.dci.tb.rv == 0) {
       // newTx
-      CONDERROR(pusch.dci.format != SRSLTE_DCI_FORMAT0, "Incorrect UL DCI format\n");
+      CONDERROR(pusch.dci.format != SRSLTE_DCI_FORMAT0, "Incorrect UL DCI format");
-      CONDERROR(pusch.dci.tb.mcs_idx > 28, "Incorrect UL MCS index\n");
+      CONDERROR(pusch.dci.tb.mcs_idx > 28, "Incorrect UL MCS index");
     }
   }
 
@@ -283,8 +280,8 @@ int test_dci_content_common(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
   for (uint32_t i = 0; i < dl_result.nof_data_elems; ++i) {
     auto&    data = dl_result.data[i];
     uint16_t rnti = data.dci.rnti;
-    CONDERROR(data.tbs[0] == 0 and data.tbs[1] == 0, "Allocated DL data has empty TBS\n");
+    CONDERROR(data.tbs[0] == 0 and data.tbs[1] == 0, "Allocated DL data has empty TBS");
-    CONDERROR(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in DL\n", rnti);
+    CONDERROR(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in DL", rnti);
     alloc_rntis.insert(data.dci.rnti);
     for (uint32_t tb = 0; tb < 2; ++tb) {
       if (data.tbs[tb] == 0) {
@@ -292,15 +289,15 @@ int test_dci_content_common(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
       }
       if (data.dci.tb[tb].rv == 0) {
         // newTx
-        CONDERROR(data.nof_pdu_elems[tb] == 0, "Allocated DL grant does not have MAC SDUs\n");
+        CONDERROR(data.nof_pdu_elems[tb] == 0, "Allocated DL grant does not have MAC SDUs");
         CONDERROR(data.nof_pdu_elems[tb] > sched_interface::MAX_RLC_PDU_LIST,
-                  "Number of SDUs in DL grant exceeds limit\n");
+                  "Number of SDUs in DL grant exceeds limit");
         uint32_t alloc_bytes = 0;
         for (uint32_t pdu = 0; pdu < data.nof_pdu_elems[tb]; ++pdu) {
           alloc_bytes += data.pdu[tb][pdu].nbytes;
         }
-        CONDERROR(alloc_bytes > data.tbs[tb], "The bytes allocated to individual MAC SDUs is larger than total TBS\n");
+        CONDERROR(alloc_bytes > data.tbs[tb], "The bytes allocated to individual MAC SDUs is larger than total TBS");
-        CONDERROR(data.dci.tb[tb].mcs_idx > 28, "Incorrect DL MCS index\n");
+        CONDERROR(data.dci.tb[tb].mcs_idx > 28, "Incorrect DL MCS index");
       }
     }
   }
@@ -308,18 +305,18 @@ int test_dci_content_common(const sf_output_res_t& sf_out, uint32_t enb_cc_idx)
     auto& bc = dl_result.bc[i];
     if (bc.type == sched_interface::dl_sched_bc_t::BCCH) {
       CONDERROR(bc.tbs < cell_params.cfg.sibs[bc.index].len,
-                "Allocated BC process with TBS=%d < sib_len=%d\n",
+                "Allocated BC process with TBS=%d < sib_len=%d",
                 bc.tbs,
                 cell_params.cfg.sibs[bc.index].len);
     } else if (bc.type == sched_interface::dl_sched_bc_t::PCCH) {
-      CONDERROR(bc.tbs == 0, "Allocated paging process with invalid TBS=%d\n", bc.tbs);
+      CONDERROR(bc.tbs == 0, "Allocated paging process with invalid TBS=%d", bc.tbs);
     } else {
-      TESTERROR("Invalid broadcast process id=%d\n", (int)bc.type);
+      TESTERROR("Invalid broadcast process id=%d", (int)bc.type);
     }
   }
   for (uint32_t i = 0; i < dl_result.nof_rar_elems; ++i) {
     const auto& rar = dl_result.rar[i];
-    CONDERROR(rar.tbs == 0, "Allocated RAR process with invalid TBS=%d\n", rar.tbs);
+    CONDERROR(rar.tbs == 0, "Allocated RAR process with invalid TBS=%d", rar.tbs);
   }
 
   return SRSLTE_SUCCESS;

srsenb/test/mac/sched_grid_test.cc

@@ -128,7 +128,7 @@ int test_pdcch_one_ue()
     TESTASSERT(pdcch_result[1]->total_mask == (pdcch_result[0]->current_mask | pdcch_result[1]->current_mask));
     TESTASSERT(std::count(dci_locs, dci_locs + nof_dci_locs, pdcch_result[0]->dci_pos.ncce) > 0);
 
-    srslte::logmap::get("TEST")->info("PDCCH alloc result: %s\n", pdcch.result_to_string(true).c_str());
+    srslog::fetch_basic_logger("TEST").info("PDCCH alloc result: %s", pdcch.result_to_string(true).c_str());
   }
   TESTASSERT(tti_counter == nof_ttis);
 
@@ -139,8 +139,16 @@ int main()
 {
   srsenb::set_randseed(seed);
   printf("This is the chosen seed: %u\n", seed);
-  srslte::logmap::get("TEST")->set_level(srslte::LOG_LEVEL_INFO);
+
+  auto& test_log = srslog::fetch_basic_logger("TEST", false);
+  test_log.set_level(srslog::basic_levels::info);
+
+  // Start the log backend.
+  srslog::init();
 
   TESTASSERT(test_pdcch_one_ue() == SRSLTE_SUCCESS);
+
+  srslog::flush();
+
   printf("Success\n");
 }

srsenb/test/mac/sched_lc_ch_test.cc

@@ -17,10 +17,12 @@
 
 using namespace srsenb;
 const uint32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
-uint32_t       rlc_overhead(uint32_t lcid)
+
+uint32_t rlc_overhead(uint32_t lcid)
 {
   return lcid == 0 ? 0 : 3;
 }
+
 uint32_t add_rlc_overhead(uint32_t lcid, uint32_t rlc_payload_size)
 {
   return rlc_payload_size + (rlc_payload_size == 0 ? 0 : rlc_overhead(lcid));
@@ -190,9 +192,17 @@ int main()
 {
   srsenb::set_randseed(seed);
   srslte::console("This is the chosen seed: %u\n", seed);
-  srslte::logmap::get("TEST")->set_level(srslte::LOG_LEVEL_INFO);
+
+  auto& test_log = srslog::fetch_basic_logger("TEST", false);
+  test_log.set_level(srslog::basic_levels::info);
+
+  // Start the log backend.
+  srslog::init();
 
   TESTASSERT(test_lc_ch_pbr_infinity() == SRSLTE_SUCCESS);
   TESTASSERT(test_lc_ch_pbr_finite() == SRSLTE_SUCCESS);
+
+  srslog::flush();
+
   srslte::console("Success\n");
 }

srsenb/test/mac/sched_sim_ue.cc

@@ -40,7 +40,8 @@ bool sim_ue_ctxt_t::is_last_dl_retx(uint32_t ue_cc_idx, uint32_t pid) const
 ue_sim::ue_sim(uint16_t                         rnti_,
                const sched_interface::ue_cfg_t& ue_cfg_,
                srslte::tti_point                prach_tti_rx_,
-               uint32_t                         preamble_idx)
+               uint32_t                         preamble_idx) :
+  logger(srslog::fetch_basic_logger("MAC"))
 {
   ctxt.rnti         = rnti_;
   ctxt.prach_tti_rx = prach_tti_rx_;
@@ -214,14 +215,14 @@ int sched_sim_base::add_user(uint16_t rnti, const sched_interface::ue_cfg_t& ue_
 {
   CONDERROR(!srslte_prach_tti_opportunity_config_fdd(
                 (*cell_params)[ue_cfg_.supported_cc_list[0].enb_cc_idx].prach_config, current_tti_rx.to_uint(), -1),
-            "New user added in a non-PRACH TTI\n");
+            "New user added in a non-PRACH TTI");
   TESTASSERT(ue_db.count(rnti) == 0);
 
   final_ue_cfg[rnti] = ue_cfg_;
   auto rach_cfg      = generate_rach_ue_cfg(ue_cfg_);
   ue_db.insert(std::make_pair(rnti, ue_sim(rnti, rach_cfg, current_tti_rx, preamble_idx)));
 
-  CONDERROR(sched_ptr->ue_cfg(rnti, rach_cfg) != SRSLTE_SUCCESS, "Configuring new user rnti=0x%x to sched\n", rnti);
+  CONDERROR(sched_ptr->ue_cfg(rnti, rach_cfg) != SRSLTE_SUCCESS, "Configuring new user rnti=0x%x to sched", rnti);
 
   sched_interface::dl_sched_rar_info_t rar_info = {};
   rar_info.prach_tti                            = current_tti_rx.to_uint();
@@ -236,9 +237,9 @@ int sched_sim_base::add_user(uint16_t rnti, const sched_interface::ue_cfg_t& ue_
 
 int sched_sim_base::ue_recfg(uint16_t rnti, const sched_interface::ue_cfg_t& ue_cfg_)
 {
-  CONDERROR(ue_db.count(rnti) == 0, "User must already exist to be configured\n");
+  CONDERROR(ue_db.count(rnti) == 0, "User must already exist to be configured");
   ue_db.at(rnti).set_cfg(ue_cfg_);
-  CONDERROR(sched_ptr->ue_cfg(rnti, ue_cfg_) != SRSLTE_SUCCESS, "Configuring new user rnti=0x%x to sched\n", rnti);
+  CONDERROR(sched_ptr->ue_cfg(rnti, ue_cfg_) != SRSLTE_SUCCESS, "Configuring new user rnti=0x%x to sched", rnti);
 
   return SRSLTE_SUCCESS;
 }
@@ -330,7 +331,7 @@ int sched_sim_base::apply_tti_events(sim_ue_ctxt_t& ue_ctxt, const ue_tti_events
       auto& h = ue_ctxt.cc_list[cc_feedback.ue_cc_idx].dl_harqs[cc_feedback.dl_pid];
 
       if (cc_feedback.dl_ack) {
-        log_h->info("DL ACK rnti=0x%x tti_dl_tx=%u pid=%d\n",
+        logger.info("DL ACK rnti=0x%x tti_dl_tx=%u pid=%d",
                     ue_ctxt.rnti,
                     to_tx_dl(h.last_tti_rx).to_uint(),
                     cc_feedback.dl_pid);
@@ -339,7 +340,7 @@ int sched_sim_base::apply_tti_events(sim_ue_ctxt_t& ue_ctxt, const ue_tti_events
       // update scheduler
       if (sched_ptr->dl_ack_info(
               events.tti_rx.to_uint(), ue_ctxt.rnti, enb_cc_idx, cc_feedback.tb, cc_feedback.dl_ack) < 0) {
-        log_h->error("The ACKed DL Harq pid=%d does not exist.\n", cc_feedback.dl_pid);
+        logger.error("The ACKed DL Harq pid=%d does not exist.", cc_feedback.dl_pid);
         error_counter++;
       }
 
@@ -353,7 +354,7 @@ int sched_sim_base::apply_tti_events(sim_ue_ctxt_t& ue_ctxt, const ue_tti_events
       auto& h = ue_ctxt.cc_list[cc_feedback.ue_cc_idx].ul_harqs[cc_feedback.dl_pid];
 
       if (cc_feedback.ul_ack) {
-        log_h->info("UL ACK rnti=0x%x tti_ul_tx=%u pid=%d\n",
+        logger.info("UL ACK rnti=0x%x tti_ul_tx=%u pid=%d",
                     ue_ctxt.rnti,
                     to_tx_ul(h.last_tti_rx).to_uint(),
                     cc_feedback.ul_pid);
@@ -361,7 +362,7 @@ int sched_sim_base::apply_tti_events(sim_ue_ctxt_t& ue_ctxt, const ue_tti_events
 
       // update scheduler
       if (sched_ptr->ul_crc_info(events.tti_rx.to_uint(), ue_ctxt.rnti, enb_cc_idx, cc_feedback.ul_ack) < 0) {
-        log_h->error("The ACKed UL Harq pid=%d does not exist.\n", cc_feedback.ul_pid);
+        logger.error("The ACKed UL Harq pid=%d does not exist.", cc_feedback.ul_pid);
         error_counter++;
       }
     }

srsenb/test/mac/sched_sim_ue.h

@@ -15,6 +15,7 @@
 
 #include "sched_common_test_suite.h"
 #include "srslte/interfaces/sched_interface.h"
+#include "srslte/srslog/srslog.h"
 #include <bitset>
 
 namespace srsenb {
@@ -90,15 +91,15 @@ private:
   void update_dl_harqs(const sf_output_res_t& sf_out);
   void update_ul_harqs(const sf_output_res_t& sf_out);
 
-  srslte::log_ref log_h{"MAC"};
+  srslog::basic_logger& logger;
-  sim_ue_ctxt_t   ctxt;
+  sim_ue_ctxt_t         ctxt;
 };
 
 class sched_sim_base
 {
 public:
   sched_sim_base(sched_interface* sched_ptr_, const std::vector<sched_interface::cell_cfg_t>& cell_params_) :
-    sched_ptr(sched_ptr_), cell_params(&cell_params_)
+    logger(srslog::fetch_basic_logger("MAC")), sched_ptr(sched_ptr_), cell_params(&cell_params_)
   {
     sched_ptr->cell_cfg(cell_params_); // call parent cfg
   }
@@ -142,7 +143,7 @@ private:
   int set_default_tti_events(const sim_ue_ctxt_t& ue_ctxt, ue_tti_events& pending_events);
   int apply_tti_events(sim_ue_ctxt_t& ue_ctxt, const ue_tti_events& events);
 
-  srslte::log_ref                                 log_h{"MAC"};
+  srslog::basic_logger&                           logger;
   sched_interface*                                sched_ptr;
   const std::vector<sched_interface::cell_cfg_t>* cell_params;
 

srsenb/test/mac/sched_test_common.cc

@@ -130,14 +130,12 @@ int common_sched_tester::sim_cfg(sim_sched_args args)
   sched_sim.reset(new sched_sim_random{this, sim_args0.cell_cfg});
   sched_stats.reset(new sched_result_stats{sim_args0.cell_cfg});
 
-  tester_log = sim_args0.sim_log;
-
   return SRSLTE_SUCCESS;
 }
 
 int common_sched_tester::add_user(uint16_t rnti, const ue_ctxt_test_cfg& ue_cfg_)
 {
-  tester_log->info("Adding user rnti=0x%x\n", rnti);
+  logger.info("Adding user rnti=0x%x", rnti);
   sched_sim->ue_sim_cfg_map[rnti] = ue_cfg_;
   return sched_sim->add_user(rnti, ue_cfg_.ue_cfg, tti_info.nof_prachs++);
 }
@@ -149,7 +147,7 @@ int common_sched_tester::reconf_user(uint16_t rnti, const sched_interface::ue_cf
 
 int common_sched_tester::rem_user(uint16_t rnti)
 {
-  tester_log->info("Removing user rnti=0x%x\n", rnti);
+  logger.info("Removing user rnti=0x%x", rnti);
   sched_sim->ue_sim_cfg_map.erase(rnti);
   return sched_sim->rem_user(rnti);
 }
@@ -168,7 +166,7 @@ void common_sched_tester::new_test_tti()
   tti_info.dl_sched_result.resize(sched_cell_params.size());
   tti_info.ul_sched_result.resize(sched_cell_params.size());
 
-  tester_log->step(tti_rx.to_uint());
+  logger.set_context(tti_rx.to_uint());
 }
 
 int common_sched_tester::run_ue_ded_tests_and_update_ctxt(const sf_output_res_t& sf_out)
@@ -215,7 +213,7 @@ int common_sched_tester::process_tti_events(const tti_ev& tti_ev)
 
     // configure bearers
     if (ue_ev.bearer_cfg != nullptr) {
-      CONDERROR(not sched_sim->user_exists(ue_ev.rnti), "User rnti=0x%x does not exist\n", ue_ev.rnti);
+      CONDERROR(not sched_sim->user_exists(ue_ev.rnti), "User rnti=0x%x does not exist", ue_ev.rnti);
       // TODO: Instantiate more bearers
       TESTASSERT(sched_sim->bearer_cfg(ue_ev.rnti, 0, *ue_ev.bearer_cfg) == SRSLTE_SUCCESS);
     }
@@ -224,7 +222,7 @@ int common_sched_tester::process_tti_events(const tti_ev& tti_ev)
 
     // push UL SRs and DL packets
     if (ue_ev.buffer_ev != nullptr) {
-      CONDERROR(user == nullptr, "TESTER ERROR: Trying to schedule data for user that does not exist\n");
+      CONDERROR(user == nullptr, "TESTER ERROR: Trying to schedule data for user that does not exist");
       const auto& ue_sim_ctxt = user->get_ctxt();
       if (ue_ev.buffer_ev->dl_data > 0 and ue_sim_ctxt.conres_rx) {
         // If Msg4 has already been tx and there DL data to transmit
@@ -249,7 +247,7 @@ int common_sched_tester::process_tti_events(const tti_ev& tti_ev)
 int common_sched_tester::run_tti(const tti_ev& tti_events)
 {
   new_test_tti();
-  tester_log->info("---- tti=%u | nof_ues=%zd ----\n", tti_rx.to_uint(), ue_db.size());
+  logger.info("---- tti=%u | nof_ues=%zd ----", tti_rx.to_uint(), ue_db.size());
 
   sched_sim->new_tti(tti_rx);
   process_tti_events(tti_events);

srsenb/test/mac/sched_test_common.h

@@ -16,6 +16,7 @@
 #include "sched_sim_ue.h"
 #include "sched_test_utils.h"
 #include "srsenb/hdr/stack/mac/sched.h"
+#include "srslte/srslog/srslog.h"
 #include <random>
 
 namespace srsenb {
@@ -78,6 +79,7 @@ public:
     std::vector<sched_interface::ul_sched_res_t> ul_sched_result;
   };
 
+  common_sched_tester() : logger(srslog::fetch_basic_logger("TEST")) {}
   ~common_sched_tester() override = default;
 
   const ue_cfg_t* get_current_ue_cfg(uint16_t rnti) const;
@@ -95,8 +97,8 @@ public:
   int run_ue_ded_tests_and_update_ctxt(const sf_output_res_t& sf_out);
 
   // args
-  sim_sched_args sim_args0; ///< arguments used to generate TTI events
+  sim_sched_args        sim_args0; ///< arguments used to generate TTI events
-  srslte::log*   tester_log = nullptr;
+  srslog::basic_logger& logger;
 
   // tti specific params
   tti_info_t tti_info;

srsenb/test/mac/sched_test_rand.cc

@@ -48,34 +48,38 @@ ue_stats_t                     ue_tot_stats;
  *     Logging     *
  *******************/
 
-class sched_test_log final : public srslte::test_log_filter
+/// RAII style class that prints the test diagnostic info on destruction.
+class sched_diagnostic_printer
 {
 public:
-  sched_test_log() : srslte::test_log_filter("TEST") { exit_on_error = true; }
+  explicit sched_diagnostic_printer(srslte::log_sink_spy& s) : s(s) {}
-  ~sched_test_log() override { log_diagnostics(); }
 
-  void log_diagnostics() override
+  ~sched_diagnostic_printer()
   {
-    info("UE stats:\n");
+    auto& logger = srslog::fetch_basic_logger("TEST");
-    info("all: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}\n",
+    logger.info("UE stats:");
-         ue_tot_stats.nof_dl_rbs,
+    logger.info("all: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}",
-         ue_tot_stats.nof_ul_rbs,
+                ue_tot_stats.nof_dl_rbs,
-         ue_tot_stats.nof_dl_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis,
+                ue_tot_stats.nof_ul_rbs,
-         ue_tot_stats.nof_ul_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis);
+                ue_tot_stats.nof_dl_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis,
-    for (auto& e : ue_stats) {
+                ue_tot_stats.nof_ul_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis);
-      info("0x%x: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}\n",
+    for (const auto& e : ue_stats) {
-           e.first,
+      logger.info("0x%x: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}",
-           e.second.nof_dl_rbs,
+                  e.first,
-           e.second.nof_ul_rbs,
+                  e.second.nof_dl_rbs,
-           e.second.nof_dl_bytes * 8 * 0.001 / e.second.nof_ttis,
+                  e.second.nof_ul_rbs,
-           e.second.nof_ul_bytes * 8 * 0.001 / e.second.nof_ttis);
+                  e.second.nof_dl_bytes * 8 * 0.001 / e.second.nof_ttis,
+                  e.second.nof_ul_bytes * 8 * 0.001 / e.second.nof_ttis);
     }
-    info("Number of assertion warnings: %u\n", warn_counter);
+    logger.info("Number of assertion warnings: %u", s.get_warning_counter());
-    info("Number of assertion errors: %u\n", error_counter);
+    logger.info("Number of assertion errors: %u", s.get_error_counter());
-    info("This was the seed: %u\n", seed);
+    logger.info("This was the seed: %u", seed);
+    srslog::flush();
   }
+
+private:
+  srslte::log_sink_spy& s;
 };
-srslte::scoped_log<sched_test_log> log_global{};
 
 /*******************
  *     Dummies     *
@@ -164,10 +168,10 @@ int sched_tester::test_harqs()
     uint16_t                    rnti = data.dci.rnti;
     const srsenb::dl_harq_proc& h    = ue_db[rnti].get_dl_harq(h_id, CARRIER_IDX);
     CONDERROR(h.get_tti() != srsenb::to_tx_dl(tti_rx),
-              "The scheduled DL harq pid=%d does not a valid tti=%u\n",
+              "The scheduled DL harq pid=%d does not a valid tti=%u",
               h_id,
               srsenb::to_tx_dl(tti_rx).to_uint());
-    CONDERROR(h.get_n_cce() != data.dci.location.ncce, "Harq DCI location does not match with result\n");
+    CONDERROR(h.get_n_cce() != data.dci.location.ncce, "Harq DCI location does not match with result");
   }
 
   /* Check PHICH allocations */
@@ -175,20 +179,20 @@ int sched_tester::test_harqs()
     const auto& phich = tti_info.ul_sched_result[CARRIER_IDX].phich[i];
     const auto& hprev = tti_data.ue_data[phich.rnti].ul_harq;
     const auto* h     = ue_db[phich.rnti].get_ul_harq(srsenb::to_tx_ul(tti_rx), CARRIER_IDX);
-    CONDERROR(not hprev.has_pending_phich(), "Alloc PHICH did not have any pending ack\n");
+    CONDERROR(not hprev.has_pending_phich(), "Alloc PHICH did not have any pending ack");
     bool maxretx_flag = hprev.nof_retx(0) + 1 >= hprev.max_nof_retx();
     if (phich.phich == sched_interface::ul_sched_phich_t::ACK) {
       // The harq can be either ACKed or Resumed
       if (not hprev.is_empty()) {
         // In case it was resumed
-        CONDERROR(h == nullptr or h->is_empty(), "Cannot resume empty UL harq\n");
+        CONDERROR(h == nullptr or h->is_empty(), "Cannot resume empty UL harq");
         for (uint32_t j = 0; j < tti_info.ul_sched_result[CARRIER_IDX].nof_dci_elems; ++j) {
           auto& pusch = tti_info.ul_sched_result[CARRIER_IDX].pusch[j];
-          CONDERROR(pusch.dci.rnti == phich.rnti, "Cannot send PHICH::ACK for same harq that got UL grant.\n");
+          CONDERROR(pusch.dci.rnti == phich.rnti, "Cannot send PHICH::ACK for same harq that got UL grant.");
         }
       }
     } else {
-      CONDERROR(h->get_pending_data() == 0 and !maxretx_flag, "NACKed harq has no pending data\n");
+      CONDERROR(h->get_pending_data() == 0 and !maxretx_flag, "NACKed harq has no pending data");
     }
   }
 
@@ -285,7 +289,6 @@ sched_sim_events rand_sim_params(uint32_t nof_ttis)
   sim_gen.sim_args.default_ue_sim_cfg.ue_cfg.measgap_offset   = std::uniform_int_distribution<uint32_t>{
       0, sim_gen.sim_args.default_ue_sim_cfg.ue_cfg.measgap_period}(srsenb::get_rand_gen());
   sim_gen.sim_args.start_tti = 0;
-  sim_gen.sim_args.sim_log   = log_global.get();
   sim_gen.sim_args.sched_args.pdsch_mcs =
       boolean_dist() ? -1 : std::uniform_int_distribution<>{0, 24}(srsenb::get_rand_gen());
   sim_gen.sim_args.sched_args.pusch_mcs =
@@ -326,9 +329,29 @@ int main()
   srsenb::set_randseed(seed);
   printf("This is the chosen seed: %u\n", seed);
 
-  srslte::logmap::set_default_log_level(srslte::LOG_LEVEL_INFO);
+  // Setup the log spy to intercept error and warning log entries.
+  if (!srslog::install_custom_sink(
+          srslte::log_sink_spy::name(),
+          std::unique_ptr<srslte::log_sink_spy>(new srslte::log_sink_spy(srslog::get_default_log_formatter())))) {
+    return SRSLTE_ERROR;
+  }
+
+  auto* spy = static_cast<srslte::log_sink_spy*>(srslog::find_sink(srslte::log_sink_spy::name()));
+  if (!spy) {
+    return SRSLTE_ERROR;
+  }
+
+  auto& mac_log = srslog::fetch_basic_logger("MAC");
+  mac_log.set_level(srslog::basic_levels::info);
+  auto& test_log = srslog::fetch_basic_logger("TEST", *spy, false);
+  test_log.set_level(srslog::basic_levels::info);
+
+  // Start the log backend.
+  srslog::init();
+
   uint32_t N_runs = 1, nof_ttis = 10240 + 10;
 
+  sched_diagnostic_printer printer(*spy);
   for (uint32_t n = 0; n < N_runs; ++n) {
     printf("Sim run number: %u\n", n + 1);
     sched_sim_events sim = rand_sim_params(nof_ttis);

srsenb/test/mac/sched_test_utils.h

@@ -154,7 +154,6 @@ struct tti_ev {
 struct sim_sched_args {
   uint32_t                                         start_tti = 0;
   std::vector<srsenb::sched_interface::cell_cfg_t> cell_cfg;
-  srslte::log*                                     sim_log = nullptr;
   ue_ctxt_test_cfg                                 default_ue_sim_cfg{};
   srsenb::sched_interface::sched_args_t            sched_args = {};
 };

srsenb/test/mac/sched_ue_ded_test_suite.cc

@@ -67,28 +67,28 @@ int test_pdsch_grant(const sim_enb_ctxt_t&                   enb_ctxt,
   const sched_interface::cell_cfg_t&         cell_params = (*enb_ctxt.cell_params)[enb_cc_idx];
 
   // TEST: Check if CC is configured and active
-  CONDERROR(cc_cfg == nullptr or not cc_cfg->active, "PDSCH allocation for disabled or unavailable cc\n");
+  CONDERROR(cc_cfg == nullptr or not cc_cfg->active, "PDSCH allocation for disabled or unavailable cc");
   CONDERROR(pdsch.dci.ue_cc_idx != std::distance(&ue_ctxt.ue_cfg.supported_cc_list.front(), cc_cfg),
-            "Inconsistent enb_cc_idx -> ue_cc_idx mapping\n");
+            "Inconsistent enb_cc_idx -> ue_cc_idx mapping");
 
   // TEST: DCI is consistent with current UE DL harq state
   auto&    h        = ue_ctxt.cc_list[pdsch.dci.ue_cc_idx].dl_harqs[pdsch.dci.pid];
   uint32_t nof_retx = get_nof_retx(pdsch.dci.tb[0].rv); // 0..3
   if (h.nof_txs == 0 or h.ndi != pdsch.dci.tb[0].ndi) {
     // It is newtx
-    CONDERROR(nof_retx != 0, "Invalid rv index for new tx\n");
+    CONDERROR(nof_retx != 0, "Invalid rv index for new tx");
-    CONDERROR(h.active, "DL newtx for already active DL harq pid=%d\n", h.pid);
+    CONDERROR(h.active, "DL newtx for already active DL harq pid=%d", h.pid);
   } else {
     // it is retx
-    CONDERROR(get_rvidx(h.nof_retxs + 1) != (uint32_t)pdsch.dci.tb[0].rv, "Invalid rv index for retx\n");
+    CONDERROR(get_rvidx(h.nof_retxs + 1) != (uint32_t)pdsch.dci.tb[0].rv, "Invalid rv index for retx");
-    CONDERROR(not h.active, "retx for inactive dl harq pid=%d\n", h.pid);
+    CONDERROR(not h.active, "retx for inactive dl harq pid=%d", h.pid);
-    CONDERROR(to_tx_dl_ack(h.last_tti_rx) > tti_rx, "harq pid=%d reused too soon\n", h.pid);
+    CONDERROR(to_tx_dl_ack(h.last_tti_rx) > tti_rx, "harq pid=%d reused too soon", h.pid);
     CONDERROR(h.nof_retxs + 1 > ue_ctxt.ue_cfg.maxharq_tx,
-              "The number of retx=%d exceeded its max=%d\n",
+              "The number of retx=%d exceeded its max=%d",
               h.nof_retxs + 1,
               ue_ctxt.ue_cfg.maxharq_tx);
-    //    CONDERROR(h.dci_loc.L != pdsch.dci.location.L, "Harq DCI aggregation level changed.\n");
+    //    CONDERROR(h.dci_loc.L != pdsch.dci.location.L, "Harq DCI aggregation level changed.");
-    CONDERROR(h.tbs != pdsch.tbs[0], "TBS changed during HARQ retx\n");
+    CONDERROR(h.tbs != pdsch.tbs[0], "TBS changed during HARQ retx");
   }
 
   // TEST: max coderate is not exceeded
@@ -104,7 +104,7 @@ int test_pdsch_grant(const sim_enb_ctxt_t&                   enb_ctxt,
     srslte_mod_t mod      = srslte_ra_dl_mod_from_mcs(pdsch.dci.tb[0].mcs_idx, ue_ctxt.ue_cfg.use_tbs_index_alt);
     uint32_t     max_Qm   = ue_ctxt.ue_cfg.use_tbs_index_alt ? 8 : 6;
     uint32_t     Qm       = std::min(max_Qm, srslte_mod_bits_x_symbol(mod));
-    CONDERROR(coderate > 0.930f * Qm, "Max coderate was exceeded\n");
+    CONDERROR(coderate > 0.930f * Qm, "Max coderate was exceeded");
   }
 
   return SRSLTE_SUCCESS;
@@ -116,7 +116,7 @@ int test_dl_sched_result(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t&
     for (uint32_t i = 0; i < sf_out.dl_cc_result[cc].nof_data_elems; ++i) {
       const sched_interface::dl_sched_data_t& data = sf_out.dl_cc_result[cc].data[i];
       CONDERROR(
-          enb_ctxt.ue_db.count(data.dci.rnti) == 0, "Allocated DL grant for non-existent rnti=0x%x\n", data.dci.rnti);
+          enb_ctxt.ue_db.count(data.dci.rnti) == 0, "Allocated DL grant for non-existent rnti=0x%x", data.dci.rnti);
       TESTASSERT(test_pdsch_grant(enb_ctxt, sf_out, cc, data) == SRSLTE_SUCCESS);
     }
   }
@@ -137,7 +137,7 @@ int test_ul_sched_result(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t&
     CONDERROR(std::any_of(phich_begin,
                           phich_end,
                           [&enb_ctxt](const phich_t& phich) { return enb_ctxt.ue_db.count(phich.rnti) == 0; }),
-              "Scheduled PHICH does not have associated rnti\n");
+              "Scheduled PHICH does not have associated rnti");
 
     // TEST: rnti must exist for all PUSCH
     CONDERROR(std::any_of(pusch_begin,
@@ -157,8 +157,8 @@ int test_ul_sched_result(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t&
 
       // TEST: Check that idle CCs do not receive PUSCH grants or PHICH
       if (ue_cc_idx < 0 or not ue.ue_cfg.supported_cc_list[ue_cc_idx].active) {
-        CONDERROR(phich_ptr != nullptr, "PHICH cannot be allocated in idle cells\n");
+        CONDERROR(phich_ptr != nullptr, "PHICH cannot be allocated in idle cells");
-        CONDERROR(pusch_ptr != nullptr, "PUSCH cannot be allocated in idle cells\n");
+        CONDERROR(pusch_ptr != nullptr, "PUSCH cannot be allocated in idle cells");
         continue;
       }
 
@@ -170,44 +170,44 @@ int test_ul_sched_result(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t&
 
       // TEST: Already active UL HARQs have to receive PHICH
       CONDERROR(
-          h.active and phich_ptr == nullptr, "PHICH not received for rnti=0x%x active UL HARQ pid=%d\n", rnti, pid);
+          h.active and phich_ptr == nullptr, "PHICH not received for rnti=0x%x active UL HARQ pid=%d", rnti, pid);
       CONDERROR(not h.active and phich_ptr != nullptr,
-                "PHICH for rnti=0x%x corresponds to inactive UL HARQ pid=%d\n",
+                "PHICH for rnti=0x%x corresponds to inactive UL HARQ pid=%d",
                 rnti,
                 pid);
 
       // TEST: absent PUSCH grants for active UL HARQs must be either ACKs, last retx, or interrupted HARQs
       if ((phich_ptr != nullptr) and (pusch_ptr == nullptr)) {
-        CONDERROR(not h_inactive, "PHICH NACK received for rnti=0x%x but no PUSCH retx reallocated\n", rnti);
+        CONDERROR(not h_inactive, "PHICH NACK received for rnti=0x%x but no PUSCH retx reallocated", rnti);
       }
 
       if (pusch_ptr != nullptr) {
-        CONDERROR(pusch_ptr->dci.ue_cc_idx != (uint32_t)ue_cc_idx, "Inconsistent enb_cc_idx -> ue_cc_idx mapping\n");
+        CONDERROR(pusch_ptr->dci.ue_cc_idx != (uint32_t)ue_cc_idx, "Inconsistent enb_cc_idx -> ue_cc_idx mapping");
 
         // TEST: DCI is consistent with current UE UL harq state
         uint32_t nof_retx = get_nof_retx(pusch_ptr->dci.tb.rv); // 0..3
 
         if (h.nof_txs == 0 or h.ndi != pusch_ptr->dci.tb.ndi) {
           // newtx
-          CONDERROR(nof_retx != 0, "Invalid rv index for new tx\n");
+          CONDERROR(nof_retx != 0, "Invalid rv index for new tx");
-          CONDERROR(pusch_ptr->current_tx_nb != 0, "UL HARQ retxs need to have been previously transmitted\n");
+          CONDERROR(pusch_ptr->current_tx_nb != 0, "UL HARQ retxs need to have been previously transmitted");
-          CONDERROR(not h_inactive, "New tx for already active UL HARQ\n");
+          CONDERROR(not h_inactive, "New tx for already active UL HARQ");
         } else {
-          CONDERROR(pusch_ptr->current_tx_nb == 0, "UL retx has to have nof tx > 0\n");
+          CONDERROR(pusch_ptr->current_tx_nb == 0, "UL retx has to have nof tx > 0");
           if (not h.active) {
             // the HARQ is being resumed
-            CONDERROR(not pusch_ptr->needs_pdcch, "Resumed UL HARQs need to be signalled in PDCCH\n");
+            CONDERROR(not pusch_ptr->needs_pdcch, "Resumed UL HARQs need to be signalled in PDCCH");
           } else {
             if (pusch_ptr->needs_pdcch) {
-              CONDERROR(pusch_ptr->dci.type2_alloc.riv == h.riv, "Adaptive retx must change riv\n");
+              CONDERROR(pusch_ptr->dci.type2_alloc.riv == h.riv, "Adaptive retx must change riv");
             } else {
               // non-adaptive retx
-              CONDERROR(pusch_ptr->dci.type2_alloc.riv != h.riv, "Non-adaptive retx must keep the same riv\n");
+              CONDERROR(pusch_ptr->dci.type2_alloc.riv != h.riv, "Non-adaptive retx must keep the same riv");
             }
           }
-          CONDERROR(get_rvidx(h.nof_retxs + 1) != (uint32_t)pusch_ptr->dci.tb.rv, "Invalid rv index for retx\n");
+          CONDERROR(get_rvidx(h.nof_retxs + 1) != (uint32_t)pusch_ptr->dci.tb.rv, "Invalid rv index for retx");
-          CONDERROR(h.tbs != pusch_ptr->tbs, "TBS changed during HARQ retx\n");
+          CONDERROR(h.tbs != pusch_ptr->tbs, "TBS changed during HARQ retx");
-          CONDERROR(to_tx_ul(h.last_tti_rx) > sf_out.tti_rx, "UL harq pid=%d was reused too soon\n", h.pid);
+          CONDERROR(to_tx_ul(h.last_tti_rx) > sf_out.tti_rx, "UL harq pid=%d was reused too soon", h.pid);
         }
       }
     }
@@ -238,11 +238,11 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
 
       if (not rar_window.contains(tti_tx_dl)) {
         CONDERROR(not ue.rar_tti_rx.is_valid() and tti_tx_dl > rar_window.stop(),
-                  "rnti=0x%x RAR not scheduled within the RAR Window\n",
+                  "rnti=0x%x RAR not scheduled within the RAR Window",
                   rnti);
         for (uint32_t i = 0; i < sf_out.dl_cc_result[cc].nof_rar_elems; ++i) {
           CONDERROR(sf_out.dl_cc_result[cc].rar[i].dci.rnti == rnti,
-                    "No RAR allocations allowed outside of user RAR window\n");
+                    "No RAR allocations allowed outside of user RAR window");
         }
       } else {
         // Inside RAR window
@@ -251,19 +251,19 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
           for (const auto& grant : dl_cc_res.rar[i].msg3_grant) {
             const auto& data = grant.data;
             if (data.prach_tti == (uint32_t)ue.prach_tti_rx.to_uint() and data.preamble_idx == ue.preamble_idx) {
-              CONDERROR(rnti != data.temp_crnti, "RAR grant C-RNTI does not match the expected.\n");
+              CONDERROR(rnti != data.temp_crnti, "RAR grant C-RNTI does not match the expected.");
               nof_rars++;
             }
           }
         }
-        CONDERROR(nof_rars > 1, "There was more than one RAR for the same user\n");
+        CONDERROR(nof_rars > 1, "There was more than one RAR for the same user");
       }
 
       // TEST: Msg3 was allocated
       if (ue.rar_tti_rx.is_valid() and not ue.msg3_tti_rx.is_valid()) {
         // RAR scheduled, Msg3 not yet scheduled
         srslte::tti_point expected_msg3_tti_rx = ue.rar_tti_rx + MSG3_DELAY_MS;
-        CONDERROR(expected_msg3_tti_rx < sf_out.tti_rx, "No UL msg3 alloc was made\n");
+        CONDERROR(expected_msg3_tti_rx < sf_out.tti_rx, "No UL msg3 alloc was made");
 
         if (expected_msg3_tti_rx == sf_out.tti_rx) {
           // Msg3 should exist
@@ -271,13 +271,13 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
           for (uint32_t i = 0; i < ul_cc_res.nof_dci_elems; ++i) {
             if (ul_cc_res.pusch[i].dci.rnti == rnti) {
               msg3_count++;
-              CONDERROR(ul_cc_res.pusch[i].needs_pdcch, "Msg3 allocations do not require PDCCH\n");
+              CONDERROR(ul_cc_res.pusch[i].needs_pdcch, "Msg3 allocations do not require PDCCH");
               CONDERROR(ue.msg3_riv != ul_cc_res.pusch[i].dci.type2_alloc.riv,
-                        "The Msg3 was not allocated in the expected PRBs.\n");
+                        "The Msg3 was not allocated in the expected PRBs.");
             }
           }
-          CONDERROR(msg3_count == 0, "Msg3 was not transmitted.\n");
+          CONDERROR(msg3_count == 0, "Msg3 was not transmitted.");
-          CONDERROR(msg3_count > 1, "Only one Msg3 allower per user.\n");
+          CONDERROR(msg3_count > 1, "Only one Msg3 allower per user.");
         }
       }
 
@@ -288,33 +288,33 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
         for (uint32_t i = 0; i < dl_cc_res.nof_data_elems; ++i) {
           if (dl_cc_res.data[i].dci.rnti == rnti) {
             CONDERROR(to_tx_dl(sf_out.tti_rx) < to_tx_ul(ue.msg3_tti_rx),
-                      "Msg4 cannot be scheduled without Msg3 being tx\n");
+                      "Msg4 cannot be scheduled without Msg3 being tx");
             for (uint32_t j = 0; j < dl_cc_res.data[i].nof_pdu_elems[0]; ++j) {
               if (dl_cc_res.data[i].pdu[0][j].lcid == (uint32_t)srslte::dl_sch_lcid::CON_RES_ID) {
                 // ConRes found
                 CONDERROR(dl_cc_res.data[i].dci.format != SRSLTE_DCI_FORMAT1 and
                               dl_cc_res.data[i].dci.format != SRSLTE_DCI_FORMAT1A,
-                          "ConRes must be format1/1a\n");
+                          "ConRes must be format1/1a");
                 msg4_count++;
               }
             }
-            CONDERROR(msg4_count == 0, "No ConRes CE was scheduled in Msg4\n");
+            CONDERROR(msg4_count == 0, "No ConRes CE was scheduled in Msg4");
           }
         }
-        CONDERROR(msg4_count > 1, "Duplicate ConRes CE for the same rnti\n");
+        CONDERROR(msg4_count > 1, "Duplicate ConRes CE for the same rnti");
       }
 
       if (not ue.msg4_tti_rx.is_valid()) {
         // TEST: No UL allocs except for Msg3 before Msg4
         for (uint32_t i = 0; i < ul_cc_res.nof_dci_elems; ++i) {
           if (ul_cc_res.pusch[i].dci.rnti == rnti) {
-            CONDERROR(not ue.rar_tti_rx.is_valid(), "No UL allocs before RAR allowed\n");
+            CONDERROR(not ue.rar_tti_rx.is_valid(), "No UL allocs before RAR allowed");
             srslte::tti_point expected_msg3_tti = ue.rar_tti_rx + MSG3_DELAY_MS;
-            CONDERROR(expected_msg3_tti > sf_out.tti_rx, "No UL allocs before Msg3 is scheduled\n");
+            CONDERROR(expected_msg3_tti > sf_out.tti_rx, "No UL allocs before Msg3 is scheduled");
             if (expected_msg3_tti < sf_out.tti_rx) {
               bool msg3_retx =
                   ((ue.msg3_tti_rx - expected_msg3_tti) % (FDD_HARQ_DELAY_UL_MS + FDD_HARQ_DELAY_DL_MS)) == 0;
-              CONDERROR(not msg3_retx, "No UL txs allowed except for Msg3 before user received Msg4\n");
+              CONDERROR(not msg3_retx, "No UL txs allowed except for Msg3 before user received Msg4");
             }
           }
         }
@@ -322,7 +322,7 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
         // TEST: No DL allocs before Msg3
         if (not ue.msg3_tti_rx.is_valid()) {
           for (uint32_t i = 0; i < dl_cc_res.nof_data_elems; ++i) {
-            CONDERROR(dl_cc_res.data[i].dci.rnti == rnti, "No DL data allocs allowed before Msg3 is scheduled\n");
+            CONDERROR(dl_cc_res.data[i].dci.rnti == rnti, "No DL data allocs allowed before Msg3 is scheduled");
           }
         }
       }
@@ -339,7 +339,7 @@ int test_ra(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out)
               return ctxt.preamble_idx == preamble_idx and ((uint32_t)ctxt.prach_tti_rx.to_uint() == prach_tti);
             });
         CONDERROR(it == enb_ctxt.ue_db.end(), "There was a RAR allocation with no associated user");
-        CONDERROR(it->second->ue_cfg.supported_cc_list[0].enb_cc_idx != cc, "The allocated RAR is in the wrong cc\n");
+        CONDERROR(it->second->ue_cfg.supported_cc_list[0].enb_cc_idx != cc, "The allocated RAR is in the wrong cc");
       }
     }
   }
@@ -372,12 +372,12 @@ int test_meas_gaps(const sim_enb_ctxt_t& enb_ctxt, const sf_output_res_t& sf_out
       if (is_in_measgap(tti_tx_ul, ue.ue_cfg.measgap_period, ue.ue_cfg.measgap_offset) or
           is_in_measgap(tti_tx_phich, ue.ue_cfg.measgap_period, ue.ue_cfg.measgap_offset)) {
         const pusch_t* pusch_ptr = find_pusch_grant(rnti, ul_cc_res);
-        CONDERROR(pusch_ptr != nullptr, "PUSCH grants and PHICH cannot fall in UE measGap\n");
+        CONDERROR(pusch_ptr != nullptr, "PUSCH grants and PHICH cannot fall in UE measGap");
       }
       if (is_in_measgap(tti_tx_dl, ue.ue_cfg.measgap_period, ue.ue_cfg.measgap_offset) or
           is_in_measgap(tti_tx_dl_ack, ue.ue_cfg.measgap_period, ue.ue_cfg.measgap_offset)) {
         const pdsch_t* pdsch_ptr = find_pdsch_grant(rnti, dl_cc_res);
-        CONDERROR(pdsch_ptr != nullptr, "PDSCH grants and respective ACKs cannot fall in UE measGap\n");
+        CONDERROR(pdsch_ptr != nullptr, "PDSCH grants and respective ACKs cannot fall in UE measGap");
       }
     }
   }

srsenb/test/phy/enb_phy_test.cc

@@ -9,6 +9,7 @@
  * the distribution.
  *
  */
+
 #include <boost/program_options.hpp>
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/parsers.hpp>
@@ -49,7 +50,7 @@ public:
       expired = (cvar.wait_until(lock, expire_time) == std::cv_status::timeout);                                       \
     }                                                                                                                  \
     if (expired) {                                                                                                     \
-      log_h.warning("Expired " #NAME " waiting\n");                                                                    \
+      logger.warning("Expired " #NAME " waiting");                                                                     \
     }                                                                                                                  \
     return received_##NAME;                                                                                            \
   }                                                                                                                    \
@@ -62,7 +63,7 @@ private:
   {                                                                                                                    \
     std::unique_lock<std::mutex> lock(mutex);                                                                          \
     cvar.notify_all();                                                                                                 \
-    log_h.debug(#NAME " received\n");                                                                                  \
+    logger.debug(#NAME " received");                                                                                   \
     received_##NAME = true;                                                                                            \
   }
 
@@ -71,7 +72,7 @@ class dummy_radio final : public srslte::radio_interface_phy
 private:
   std::mutex                        mutex;
   std::condition_variable           cvar;
-  srslte::log_filter                log_h;
+  srslog::basic_logger&             logger;
   std::vector<srslte_ringbuffer_t*> ringbuffers_tx;
   std::vector<srslte_ringbuffer_t*> ringbuffers_rx;
   srslte::rf_timestamp_t            ts_rx    = {};
@@ -102,19 +103,20 @@ private:
   CALLBACK(get_info);
 
 public:
-  explicit dummy_radio(uint32_t nof_channels, uint32_t nof_prb, const std::string& log_level) : log_h("RADIO")
+  explicit dummy_radio(uint32_t nof_channels, uint32_t nof_prb, const std::string& log_level) :
+    logger(srslog::fetch_basic_logger("RADIO", false))
   {
-    log_h.set_level(log_level);
+    logger.set_level(srslog::str_to_basic_level(log_level));
 
     // Allocate receive ring buffer
     for (uint32_t i = 0; i < nof_channels; i++) {
       auto* rb = (srslte_ringbuffer_t*)srslte_vec_malloc(sizeof(srslte_ringbuffer_t));
       if (not rb) {
-        ERROR("Allocating ring buffer\n");
+        ERROR("Allocating ring buffer");
       }
 
       if (srslte_ringbuffer_init(rb, SRSLTE_SF_LEN_PRB(nof_prb) * SRSLTE_NOF_SF_X_FRAME * (uint32_t)sizeof(cf_t))) {
-        ERROR("Initiating ring buffer\n");
+        ERROR("Initiating ring buffer");
       }
 
       ringbuffers_tx.push_back(rb);
@@ -124,11 +126,11 @@ public:
     for (uint32_t i = 0; i < nof_channels; i++) {
       auto* rb = (srslte_ringbuffer_t*)srslte_vec_malloc(sizeof(srslte_ringbuffer_t));
       if (not rb) {
-        ERROR("Allocating ring buffer\n");
+        ERROR("Allocating ring buffer");
       }
 
       if (srslte_ringbuffer_init(rb, SRSLTE_SF_LEN_PRB(nof_prb) * SRSLTE_NOF_SF_X_FRAME * (uint32_t)sizeof(cf_t))) {
-        ERROR("Initiating ring buffer\n");
+        ERROR("Initiating ring buffer");
       }
 
       ringbuffers_rx.push_back(rb);
@@ -158,7 +160,7 @@ public:
     int      err    = SRSLTE_SUCCESS;
     uint32_t nbytes = static_cast<uint32_t>(sizeof(cf_t)) * nof_samples;
 
-    log_h.debug("read_tx %d\n", nof_samples);
+    logger.debug("read_tx %d", nof_samples);
 
     for (uint32_t i = 0; i < ringbuffers_tx.size() and i < buffers.size(); i++) {
       do {
@@ -173,7 +175,7 @@ public:
   {
     uint32_t nbytes = static_cast<uint32_t>(sizeof(cf_t)) * nof_samples;
 
-    log_h.debug("write_rx %d\n", nof_samples);
+    logger.debug("write_rx %d", nof_samples);
 
     for (uint32_t i = 0; i < ringbuffers_rx.size() and i < buffers.size(); i++) {
       srslte_ringbuffer_write(ringbuffers_rx[i], buffers[i], nbytes);
@@ -191,7 +193,7 @@ public:
     // Get number of bytes to write
     uint32_t nbytes = static_cast<uint32_t>(sizeof(cf_t)) * buffer.get_nof_samples();
 
-    log_h.debug("tx %d\n", buffer.get_nof_samples());
+    logger.debug("tx %d", buffer.get_nof_samples());
 
     // Write ring buffer
     for (uint32_t i = 0; i < ringbuffers_tx.size() and err >= SRSLTE_SUCCESS; i++) {
@@ -216,7 +218,7 @@ public:
       return true;
     }
 
-    log_h.info("rx_now %d\n", buffer.get_nof_samples());
+    logger.info("rx_now %d", buffer.get_nof_samples());
 
     // Get number of bytes to read
     uint32_t nbytes = static_cast<uint32_t>(sizeof(cf_t)) * buffer.get_nof_samples();
@@ -265,15 +267,15 @@ typedef std::unique_ptr<dummy_radio> unique_dummy_radio_t;
 class dummy_stack final : public srsenb::stack_interface_phy_lte
 {
 private:
-  static constexpr float prob_dl_grant = 0.50f;
+  static constexpr float    prob_dl_grant = 0.50f;
-  static constexpr float prob_ul_grant = 0.10f;
+  static constexpr float    prob_ul_grant = 0.10f;
-  static constexpr uint32_t cfi        = 2;
+  static constexpr uint32_t cfi           = 2;
 
   srsenb::phy_cell_cfg_list_t                       phy_cell_cfg;
   srsenb::phy_interface_rrc_lte::phy_rrc_cfg_list_t phy_rrc;
   std::mutex                                        mutex;
   std::condition_variable                           cvar;
-  srslte::log_filter                                log_h;
+  srslog::basic_logger&                             logger;
   srslte_softbuffer_tx_t                            softbuffer_tx                                           = {};
   srslte_softbuffer_rx_t                            softbuffer_rx[SRSLTE_MAX_CARRIERS][SRSLTE_FDD_NOF_HARQ] = {};
   uint8_t*                                          data                                                    = nullptr;
@@ -327,22 +329,22 @@ private:
   std::queue<tti_cqi_info_t> tti_cqi_info_queue;
   std::vector<uint32_t>      active_cell_list;
 
-  uint32_t              nof_locations[SRSLTE_NOF_SF_X_FRAME]                    = {};
+  uint32_t              nof_locations[SRSLTE_NOF_SF_X_FRAME]                           = {};
   srslte_dci_location_t dci_locations[SRSLTE_NOF_SF_X_FRAME][SRSLTE_MAX_CANDIDATES_UE] = {};
-  uint32_t              ul_riv                                                  = 0;
+  uint32_t              ul_riv                                                         = 0;
 
 public:
   explicit dummy_stack(const srsenb::phy_cfg_t&                                 phy_cfg_,
                        const srsenb::phy_interface_rrc_lte::phy_rrc_cfg_list_t& phy_rrc_,
                        const std::string&                                       log_level,
                        uint16_t                                                 rnti_) :
-    log_h("STACK"),
+    logger(srslog::fetch_basic_logger("STACK", false)),
     ue_rnti(rnti_),
     random_gen(srslte_random_init(rnti_)),
     phy_cell_cfg(phy_cfg_.phy_cell_cfg),
     phy_rrc(phy_rrc_)
   {
-    log_h.set_level(log_level);
+    logger.set_level(srslog::str_to_basic_level(log_level));
     srslte_softbuffer_tx_init(&softbuffer_tx, SRSLTE_MAX_PRB);
     for (uint32_t i = 0; i < phy_rrc.size(); i++) {
       for (auto& sb : softbuffer_rx[i]) {
@@ -362,7 +364,7 @@ public:
       sf_cfg_dl.cfi     = cfi;
       sf_cfg_dl.sf_type = SRSLTE_SF_NORM;
 
-      uint32_t              _nof_locations                    = {};
+      uint32_t              _nof_locations                           = {};
       srslte_dci_location_t _dci_locations[SRSLTE_MAX_CANDIDATES_UE] = {};
       _nof_locations = srslte_pdcch_ue_locations(&pdcch, &sf_cfg_dl, _dci_locations, SRSLTE_MAX_CANDIDATES_UE, ue_rnti);
 
@@ -416,7 +418,7 @@ public:
 
     notify_sr_detected();
 
-    log_h.info("Received SR tti=%d; rnti=0x%x\n", tti, rnti);
+    logger.info("Received SR tti=%d; rnti=0x%x", tti, rnti);
 
     return SRSLTE_SUCCESS;
   }
@@ -428,7 +430,7 @@ public:
   {
     notify_ri_info();
 
-    log_h.info("Received RI tti=%d; rnti=0x%x; cc_idx=%d; ri=%d;\n", tti, rnti, cc_idx, ri_value);
+    logger.info("Received RI tti=%d; rnti=0x%x; cc_idx=%d; ri=%d;", tti, rnti, cc_idx, ri_value);
 
     return 0;
   }
@@ -436,7 +438,7 @@ public:
   {
     notify_pmi_info();
 
-    log_h.info("Received PMI tti=%d; rnti=0x%x; cc_idx=%d; pmi=%d;\n", tti, rnti, cc_idx, pmi_value);
+    logger.info("Received PMI tti=%d; rnti=0x%x; cc_idx=%d; pmi=%d;", tti, rnti, cc_idx, pmi_value);
 
     return 0;
   }
@@ -450,7 +452,7 @@ public:
 
     notify_cqi_info();
 
-    log_h.info("Received CQI tti=%d; rnti=0x%x; cc_idx=%d; cqi=%d;\n", tti, rnti, cc_idx, cqi_value);
+    logger.info("Received CQI tti=%d; rnti=0x%x; cc_idx=%d; cqi=%d;", tti, rnti, cc_idx, cqi_value);
 
     return SRSLTE_SUCCESS;
   }
@@ -461,7 +463,7 @@ public:
   }
   int ta_info(uint32_t tti, uint16_t rnti, float ta_us) override
   {
-    log_h.info("Received TA INFO tti=%d; rnti=0x%x; ta=%.1f us\n", tti, rnti, ta_us);
+    logger.info("Received TA INFO tti=%d; rnti=0x%x; ta=%.1f us", tti, rnti, ta_us);
     notify_ta_info();
     return 0;
   }
@@ -475,7 +477,7 @@ public:
     tti_dl_info.ack           = ack;
     tti_dl_info_ack_queue.push(tti_dl_info);
 
-    log_h.info("Received DL ACK tti=%d; rnti=0x%x; cc=%d; tb=%d; ack=%d;\n", tti, rnti, cc_idx, tb_idx, ack);
+    logger.info("Received DL ACK tti=%d; rnti=0x%x; cc=%d; tb=%d; ack=%d;", tti, rnti, cc_idx, tb_idx, ack);
     notify_ack_info();
     return 0;
   }
@@ -488,14 +490,14 @@ public:
     tti_ul_info.crc           = crc_res;
     tti_ul_info_ack_queue.push(tti_ul_info);
 
-    log_h.info("Received UL ACK tti=%d; rnti=0x%x; cc=%d; ack=%d;\n", tti, rnti, cc_idx, crc_res);
+    logger.info("Received UL ACK tti=%d; rnti=0x%x; cc=%d; ack=%d;", tti, rnti, cc_idx, crc_res);
     notify_crc_info();
 
     return 0;
   }
   int push_pdu(uint32_t tti, uint16_t rnti, uint32_t cc_idx, uint32_t nof_bytes, bool crc_res) override
   {
-    log_h.info("Received push_pdu tti=%d; rnti=0x%x; ack=%d;\n", tti, rnti, crc_res);
+    logger.info("Received push_pdu tti=%d; rnti=0x%x; ack=%d;", tti, rnti, crc_res);
     notify_push_pdu();
 
     return 0;
@@ -577,7 +579,7 @@ public:
         uint32_t cw_count = 0;
         for (uint32_t tb = 0; tb < SRSLTE_MAX_TB; tb++) {
           if (sched_tb[tb]) {
-            log_h.debug("Transmitted DL grant tti=%d; rnti=0x%x; cc=%d; tb=%d;\n", tti, ue_rnti, cc_idx, tb);
+            logger.debug("Transmitted DL grant tti=%d; rnti=0x%x; cc=%d; tb=%d;", tti, ue_rnti, cc_idx, tb);
 
             // Create Grant with maximum safe MCS
             dl_sched.pdsch[0].dci.tb[tb].cw_idx  = cw_count++;
@@ -742,7 +744,7 @@ public:
         uint32_t elapsed_tti = TTI_SUB(tti_sr_info2.tti, tti_sr_info1.tti);
 
         // Log SR info
-        log_h.info("SR: tti1=%d; tti2=%d; elapsed %d;\n", tti_sr_info1.tti, tti_sr_info2.tti, elapsed_tti);
+        logger.info("SR: tti1=%d; tti2=%d; elapsed %d;", tti_sr_info1.tti, tti_sr_info2.tti, elapsed_tti);
 
         // Check first TTI
         TESTASSERT(tti_sr_info1.tti % 20 == 0);
@@ -773,27 +775,26 @@ private:
   srslte_softbuffer_tx_t                            softbuffer_tx = {};
   uint8_t*                                          tx_data       = nullptr;
   srsenb::phy_interface_rrc_lte::phy_rrc_cfg_list_t phy_rrc_cfg   = {};
-  srslte::log_filter                                log_h;
+  srslog::basic_logger&                             logger;
   std::map<uint32_t, uint32_t>                      last_ri = {};
 
 public:
   dummy_ue(dummy_radio* _radio, const srsenb::phy_cell_cfg_list_t& cell_list, std::string log_level, uint16_t rnti_) :
-    radio(_radio),
+    radio(_radio), logger(srslog::fetch_basic_logger("UPHY"))
-    log_h("UPHY", nullptr, true)
   {
     // Calculate subframe length
     nof_ports = cell_list[0].cell.nof_ports;
     sf_len    = static_cast<uint32_t>(SRSLTE_SF_LEN_PRB(cell_list[0].cell.nof_prb));
     rnti      = rnti_;
 
-    log_h.set_level(std::move(log_level));
+    logger.set_level(srslog::str_to_basic_level(log_level));
 
     // Initialise one buffer per eNb
     for (uint32_t i = 0; i < cell_list.size() * nof_ports; i++) {
       // Allocate buffers
       cf_t* buffer = srslte_vec_cf_malloc(sf_len);
       if (not buffer) {
-        ERROR("Allocating UE DL buffer\n");
+        ERROR("Allocating UE DL buffer");
       }
       buffers.push_back(buffer);
 
@@ -808,18 +809,18 @@ public:
       // Allocate UE DL
       auto* ue_dl = (srslte_ue_dl_t*)srslte_vec_malloc(sizeof(srslte_ue_dl_t));
       if (not ue_dl) {
-        ERROR("Allocatin UE DL\n");
+        ERROR("Allocatin UE DL");
       }
       ue_dl_v.push_back(ue_dl);
 
       // Initialise UE DL
       if (srslte_ue_dl_init(ue_dl, &buffers[cc_idx * nof_ports], cell.nof_prb, cell.nof_ports)) {
-        ERROR("Initiating UE DL\n");
+        ERROR("Initiating UE DL");
       }
 
       // Set Cell
       if (srslte_ue_dl_set_cell(ue_dl, cell)) {
-        ERROR("Setting UE DL cell\n");
+        ERROR("Setting UE DL cell");
       }
 
       // Set RNTI
@@ -828,18 +829,18 @@ public:
       // Allocate UE UL
       auto* ue_ul = (srslte_ue_ul_t*)srslte_vec_malloc(sizeof(srslte_ue_ul_t));
       if (not ue_ul) {
-        ERROR("Allocatin UE UL\n");
+        ERROR("Allocatin UE UL");
       }
       ue_ul_v.push_back(ue_ul);
 
       // Initialise UE UL
       if (srslte_ue_ul_init(ue_ul, buffers[cc_idx * nof_ports], cell.nof_prb)) {
-        ERROR("Setting UE UL cell\n");
+        ERROR("Setting UE UL cell");
       }
 
       // Set cell
       if (srslte_ue_ul_set_cell(ue_ul, cell)) {
-        ERROR("Setting UE DL cell\n");
+        ERROR("Setting UE DL cell");
       }
 
       // Set RNTI
@@ -848,13 +849,13 @@ public:
 
     // Initialise softbuffer
     if (srslte_softbuffer_tx_init(&softbuffer_tx, cell_list[0].cell.nof_prb)) {
-      ERROR("Initialising Tx softbuffer\n");
+      ERROR("Initialising Tx softbuffer");
     }
 
     // Initialise dummy tx data
     tx_data = srslte_vec_u8_malloc(SRSENB_MAX_BUFFER_SIZE_BYTES);
     if (not tx_data) {
-      ERROR("Allocating Tx data\n");
+      ERROR("Allocating Tx data");
     }
 
     for (uint32_t i = 0; i < SRSENB_MAX_BUFFER_SIZE_BYTES; i++) {
@@ -948,17 +949,17 @@ public:
       if (nof_dl_grants) {
         char str[256] = {};
         srslte_dci_dl_info(dci_dl, str, sizeof(str));
-        log_h.info("[DL DCI] %s\n", str);
+        logger.info("[DL DCI] %s", str);
 
         if (srslte_ue_dl_dci_to_pdsch_grant(
                 ue_dl_v[cc_idx], &sf_dl_cfg, &ue_dl_cfg, dci_dl, &ue_dl_cfg.cfg.pdsch.grant)) {
-          log_h.error("Converting DCI message to DL dci\n");
+          logger.error("Converting DCI message to DL dci");
           return SRSLTE_ERROR;
         }
 
         srslte_pdsch_tx_info(&ue_dl_cfg.cfg.pdsch, str, 512);
 
-        log_h.info("[DL PDSCH %d] cc=%d, %s\n", sf_dl_cfg.tti, cc_idx, str);
+        logger.info("[DL PDSCH %d] cc=%d, %s", sf_dl_cfg.tti, cc_idx, str);
 
         pdsch_ack.cc[ue_cc_idx].M                           = 1;
         pdsch_ack.cc[ue_cc_idx].m[0].present                = true;
@@ -1071,7 +1072,7 @@ public:
       char str[256] = {};
       srslte_ue_ul_info(&ue_ul_cfg, &sf_ul_cfg, &pusch_data.uci, str, sizeof(str));
       if (str[0]) {
-        log_h.info("[UL INFO %d] %s\n", i, str);
+        logger.info("[UL INFO %d] %s", i, str);
       }
     }
 
@@ -1096,7 +1097,7 @@ public:
       char str[256] = {};
       srslte_ue_ul_info(&ue_ul_cfg, &sf_ul_cfg, &pusch_data.uci, str, sizeof(str));
       if (str[0]) {
-        log_h.info("[UL INFO %d] %s\n", 0, str);
+        logger.info("[UL INFO %d] %s", 0, str);
       }
     }
 
@@ -1112,7 +1113,7 @@ public:
     srslte_pdsch_ack_t pdsch_ack = {};
 
     // Set logging TTI
-    log_h.step(sf_dl_cfg.tti);
+    logger.set_context(sf_dl_cfg.tti);
 
     // Work DL
     TESTASSERT(work_dl(pdsch_ack, uci_data) == SRSLTE_SUCCESS);
@@ -1187,7 +1188,7 @@ private:
   unique_dummy_stack_t  stack;
   unique_srsenb_phy_t   enb_phy;
   unique_dummy_ue_phy_t ue_phy;
-  srslte::log_filter    log_h;
+  srslog::basic_logger& logger;
 
   args_t                                            args = {};   ///< Test arguments
   srsenb::phy_args_t                                phy_args;    ///< PHY arguments
@@ -1203,13 +1204,14 @@ private:
   change_state_t change_state = change_state_assert;
 
 public:
-  phy_test_bench(args_t& args_, srslte::logger& logger_) : log_h("TEST BENCH")
+  phy_test_bench(args_t& args_, srslog::sink& log_sink) :
+    logger(srslog::fetch_basic_logger("TEST BENCH", log_sink, false))
   {
     // Copy test arguments
     args = args_;
 
     // Configure logger
-    log_h.set_level(args.log_level);
+    logger.set_level(srslog::str_to_basic_level(args.log_level));
 
     // PHY arguments
     phy_args.log.phy_level   = args.log_level;
@@ -1301,7 +1303,7 @@ public:
     stack->set_active_cell_list(args.ue_cell_list);
 
     /// eNb PHY initialisation instance
-    enb_phy = unique_srsenb_phy_t(new srsenb::phy(&logger_));
+    enb_phy = unique_srsenb_phy_t(new srsenb::phy(log_sink));
 
     /// Initiate eNb PHY with the given RNTI
     enb_phy->init(phy_args, phy_cfg, radio.get(), stack.get());
@@ -1335,7 +1337,7 @@ public:
     switch (change_state) {
       case change_state_assert:
         if (args.period_pcell_rotate > 0 and tti_counter >= args.period_pcell_rotate) {
-          log_h.warning("******* Cell rotation: Disable scheduling *******\n");
+          logger.warning("******* Cell rotation: Disable scheduling *******");
           // Disable all cells
           std::vector<uint32_t> active_cells;
           stack->set_active_cell_list(active_cells);
@@ -1346,7 +1348,7 @@ public:
         break;
       case change_state_flush:
         if (tti_counter >= 2 * FDD_HARQ_DELAY_DL_MS + FDD_HARQ_DELAY_UL_MS) {
-          log_h.warning("******* Cell rotation: Reconfigure *******\n");
+          logger.warning("******* Cell rotation: Reconfigure *******");
 
           std::array<bool, SRSLTE_MAX_CARRIERS> activation = {}; ///< Activation/Deactivation vector
 
@@ -1373,7 +1375,7 @@ public:
         break;
       case change_state_wait_steady:
         if (tti_counter >= FDD_HARQ_DELAY_DL_MS + FDD_HARQ_DELAY_UL_MS) {
-          log_h.warning("******* Cell rotation: Enable scheduling *******\n");
+          logger.warning("******* Cell rotation: Enable scheduling *******");
 
           std::vector<uint32_t> active_cell_list;
 
@@ -1460,21 +1462,10 @@ int main(int argc, char** argv)
   test_args.init();
 
   // Setup logging.
-  srslog::sink* log_sink = srslog::create_stdout_sink();
-  if (!log_sink) {
-    return SRSLTE_ERROR;
-  }
-
-  srslog::log_channel* chan = srslog::create_log_channel("main_channel", *log_sink);
-  if (!chan) {
-    return SRSLTE_ERROR;
-  }
-  srslte::srslog_wrapper log_wrapper(*chan);
-
   srslog::init();
 
   // Create Test Bench
-  unique_phy_test_bench test_bench = unique_phy_test_bench(new phy_test_bench(test_args, log_wrapper));
+  unique_phy_test_bench test_bench = unique_phy_test_bench(new phy_test_bench(test_args, srslog::get_default_sink()));
 
   // Run Simulation
   for (uint32_t i = 0; i < test_args.duration; i++) {
@@ -1483,6 +1474,8 @@ int main(int argc, char** argv)
 
   test_bench->stop();
 
+  srslog::flush();
+
   std::cout << "Passed" << std::endl;
 
   return SRSLTE_SUCCESS;