PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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.
This commit is contained in:
faluco 2021-01-28 12:17:18 +01:00 committed by GitHub
parent 4709bacefd
commit 711438f756
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
105 changed files with 1672 additions and 1413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/include/srslte/common/signal_handler.h
View File

@ -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 bool running = true;
static srslog::sink* log_sink = nullptr;
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();

61
lib/include/srslte/common/test_common.h
View File

@ -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
{

5
lib/include/srslte/srslog/detail/log_backend.h
View File

@ -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.
virtual void push(log_entry&& entry) = 0;
/// Pushes a log entry into the backend. Returns true on success, otherwise
/// false.
virtual bool push(log_entry&& entry) = 0;
/// Returns true when the backend has been started, otherwise false.
virtual bool is_running() const = 0;

18
lib/include/srslte/srslog/detail/support/work_queue.h
View File

@ -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.
void push(const T& value)
/// Inserts a new element into the back of the queue. Returns false when the
/// 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.
void push(T&& value)
/// Inserts a new element into the back of the queue. Returns false when the
/// 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.

51
lib/include/srslte/srslog/logger.h
View File

@ -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)...},
logger_id(std::move(id)),
channels{&args...}
T{std::forward<Args>(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
/// element should be called LAST as it is a sentinel value.
/// Order the elements from highest to lowest logging level. First element
/// 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

1
lib/include/srslte/srslog/srslog_c.h
View File

@ -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 */

2
lib/src/srslog/formatters/text_formatter.cpp
View File

@ -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);

4
lib/src/srslog/log_backend_impl.h
View File

@ -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(); }

5
lib/src/srslog/srslog.cpp
View File

@ -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) {

4
lib/src/srslog/srslog_c.cpp
View File

@ -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)

6
lib/test/srslog/event_trace_test.cpp
View File

@ -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; }

3
lib/test/srslog/log_channel_test.cpp
View File

@ -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; }

21
lib/test/srslog/logger_test.cpp
View File

@ -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;
}

2
lib/test/srslog/srslog_test.cpp
View File

@ -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;
};

2
lib/test/srslog/test_dummies.h
View File

@ -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; }
};

8
srsenb/hdr/enb.h
View File

@ -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::log_ref log; // Own logger for eNB
srslte::logger* logger = nullptr;
srslog::sink& log_sink;
srslog::basic_logger& enb_log;
srslte::log_filter pool_log;

11
srsenb/hdr/phy/lte/cc_worker.h
View File

@ -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;
phy_common* phy = nullptr;
bool initiated = false;
srslog::basic_logger& logger;
phy_common* phy = nullptr;
bool initiated = false;
cf_t* signal_buffer_rx[SRSLTE_MAX_PORTS] = {};
cf_t* signal_buffer_tx[SRSLTE_MAX_PORTS] = {};

15
srsenb/hdr/phy/lte/sf_worker.h
View File

@ -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;
phy_common* phy = nullptr;
bool initiated = false;
bool running = false;
std::mutex work_mutex;
srslog::basic_logger& logger;
phy_common* phy = nullptr;
bool initiated = false;
bool running = false;
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;

6
srsenb/hdr/phy/lte/worker_pool.h
View File

@ -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);

5
srsenb/hdr/phy/nr/cc_worker.h
View File

@ -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

9
srsenb/hdr/phy/nr/sf_worker.h
View File

@ -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_nr_state* phy_state = nullptr;
srslte::log* log_h = nullptr;
phy_common* phy = nullptr;
phy_nr_state* phy_state = nullptr;
srslog::basic_logger& logger;
// Temporal attributes
srslte_softbuffer_tx_t softbuffer_tx = {};

6
srsenb/hdr/phy/nr/worker_pool.h
View File

@ -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);

13
srsenb/hdr/phy/phy.h
View File

@ -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;
std::unique_ptr<srslte::log_filter> log_h = nullptr;
std::unique_ptr<srslte::log_filter> log_phy_lib_h = nullptr;
srslog::sink& log_sink;
srslog::basic_logger& phy_log;
srslog::basic_logger& phy_lib_log;
lte::worker_pool lte_workers;
nr::worker_pool nr_workers;

17
srsenb/hdr/phy/prach_worker.h
View File

@ -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)

9
srsenb/hdr/phy/txrx.h
View File

@ -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;
srslte::radio_interface_phy* radio_h = nullptr;
srslte::log* log_h = nullptr;
stack_interface_phy_lte* stack = nullptr;
srslte::radio_interface_phy* radio_h = nullptr;
srslog::basic_logger& logger;
lte::worker_pool* lte_workers = nullptr;
nr::worker_pool* nr_workers = nullptr;
prach_worker_pool* prach = nullptr;

11
srsenb/hdr/stack/enb_stack_lte.h
View File

@ -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;

5
srsenb/hdr/stack/mac/mac.h
View File

@ -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 = {};

1
srsenb/hdr/stack/mac/sched.h
View File

@ -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;

5
srsenb/hdr/stack/mac/sched_carrier.h
View File

@ -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;

11
srsenb/hdr/stack/mac/sched_grid.h
View File

@ -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;

9
srsenb/hdr/stack/mac/sched_helpers.h
View File

@ -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);

3
srsenb/hdr/stack/mac/sched_ue.h
View File

@ -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 */

7
srsenb/hdr/stack/mac/sched_ue_ctrl/sched_harq.h
View File

@ -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;

4
srsenb/hdr/stack/mac/sched_ue_ctrl/sched_lch.h
View File

@ -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 = {};
};

2
srsenb/hdr/stack/mac/sched_ue_ctrl/sched_ue_cell.h
View File

@ -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;

3
srsenb/hdr/stack/mac/sched_ue_ctrl/tpc.h
View File

@ -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;
}
}

2
srsenb/hdr/stack/mac/schedulers/sched_base.h
View File

@ -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 ****************/

3
srsenb/hdr/stack/mac/ue.h
View File

@ -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

2
srsenb/hdr/stack/rrc/mac_controller.h
View File

@ -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;

16
srsenb/hdr/stack/rrc/rrc.h
View File

@ -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) {
rrc_log->info("%s - %s %s (%zd B)\n", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
} else if (rrc_log->get_level() >= srslte::LOG_LEVEL_DEBUG) {
if (logger.info.enabled()) {
logger.info("%s - %s %s (%zd B)", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
} else if (logger.debug.enabled()) {
asn1::json_writer json_writer;
msg.to_json(json_writer);
rrc_log->debug_hex(
pdu.data(), pdu.size(), "%s - %s %s (%zd B)\n", 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(
pdu.data(), pdu.size(), "%s - %s %s (%zd B)", source.c_str(), dir_str[dir], msg_type.c_str(), pdu.size());
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;

21
srsenb/hdr/stack/rrc/rrc_bearer_cfg.h
View File

@ -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"};
uint16_t rnti = 0;
const rrc_cfg_t* cfg = nullptr;
srslog::basic_logger& logger;
uint16_t rnti = 0;
const rrc_cfg_t* cfg = nullptr;
// last cfg
asn1::rrc::drb_to_add_mod_list_l current_drbs;

3
srsenb/hdr/stack/rrc/rrc_cell_cfg.h
View File

@ -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;

12
srsenb/hdr/stack/rrc/rrc_mobility.h
View File

@ -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);
};

17
srsenb/hdr/stack/upper/gtpu.h
View File

@ -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;
pdcp_interface_gtpu* pdcp = nullptr;
srslte::log_ref gtpu_log;
std::string m1u_multiaddr;
std::string m1u_if_addr;
gtpu* parent = nullptr;
pdcp_interface_gtpu* pdcp = nullptr;
srslte::log_ref gtpu_log;
srslog::basic_logger& logger;
std::string m1u_multiaddr;
std::string m1u_if_addr;
bool initiated = false;
int m1u_sd = -1;

5
srsenb/hdr/stack/upper/pdcp.h
View File

@ -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;
};

11
srsenb/hdr/stack/upper/rlc.h
View File

@ -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_,
rrc_interface_rlc* rrc_,
mac_interface_rlc* mac_,
srslte::timer_handler* timers_,
srslte::log_ref log_h);
explicit rlc(srslog::basic_logger& logger) : logger(logger) {}
void
init(pdcp_interface_rlc* pdcp_, rrc_interface_rlc* rrc_, mac_interface_rlc* mac_, srslte::timer_handler* timers_);
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;
};

15
srsenb/hdr/stack/upper/s1ap.h
View File

@ -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;
srslte::log_ref s1ap_log;
s1ap* s1ap_ptr;
srslog::basic_logger& logger;
// state
bool release_requested = false;

1
srsenb/hdr/stack/upper/sdap.h
View File

@ -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;

22
srsenb/src/enb.cc
View File

@ -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");
log->set_level(srslte::LOG_LEVEL_INFO);
log->info("%s", get_build_string().c_str());
enb_log.set_level(srslog::basic_levels::info);
enb_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();
}

66
srsenb/src/enb_cfg_parser.cc
View File

@ -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);

20
srsenb/src/main.cc
View File

@ -480,19 +480,13 @@ int main(int argc, char* argv[])
srslte_debug_handle_crash(argc, argv);
parse_args(&args, argc, argv);
// Setup logging.
log_sink = (args.log.filename == "stdout")
? srslog::create_stdout_sink()
: srslog::create_file_sink(args.log.filename, fixup_log_file_maxsize(args.log.file_max_size));
if (!log_sink) {
return SRSLTE_ERROR;
}
// Setup the default log sink.
srslog::set_default_sink(
(args.log.filename == "stdout")
? srslog::fetch_stdout_sink()
: srslog::fetch_file_sink(args.log.filename, fixup_log_file_maxsize(args.log.file_max_size)));
srslog::log_channel* chan = srslog::create_log_channel("main_channel", *log_sink);
if (!chan) {
return SRSLTE_ERROR;
}
srslte::srslog_wrapper log_wrapper(*chan);
srslte::srslog_wrapper log_wrapper(srslog::fetch_log_channel("main_channel"));
// 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;

77
srsenb/src/phy/lte/cc_worker.cc
View File

@ -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);
}
}

33
srsenb/src/phy/lte/sf_worker.cc
View File

@ -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_;
log_h = log_h_;
phy = phy_;
// 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);

23
srsenb/src/phy/lte/worker_pool.cc
View File

@ -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
// Create array of pointers to phy_logs
// 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* 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));
}
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);
// Add workers to workers pool and start threads
for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
auto w = std::unique_ptr<lte::sf_worker>(new sf_worker());
w->init(common, (srslte::log*)log_vec[i].get());
auto w = std::unique_ptr<lte::sf_worker>(new sf_worker(log));
w->init(common);
pool.init_worker(i, w.get(), prio);
workers.push_back(std::move(w));
}

26
srsenb/src/phy/nr/cc_worker.cc
View File

@ -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_idx(cc_idx_), phy_state(phy_state_), log_h(log)
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_), 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) {
log_h->info("PDCCH: cc=%d, ...\n", cc_idx);
if (logger.info.enabled()) {
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;
}

10
srsenb/src/phy/nr/sf_worker.cc
View File

@ -23,17 +23,17 @@
namespace srsenb {
namespace nr {
sf_worker::sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslte::log* log) :
phy(phy_), phy_state(phy_state_), log_h(log)
sf_worker::sf_worker(phy_common* phy_, phy_nr_state* phy_state_, srslog::basic_logger& logger) :
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);
}

21
srsenb/src/phy/nr/worker_pool.cc
View File

@ -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));

92
srsenb/src/phy/phy.cc
View File

@ -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) {
case LOG_LEVEL_INFO_S:
log_phy_lib_h->info(" %s", str);
break;
case LOG_LEVEL_DEBUG_S:
log_phy_lib_h->debug(" %s", str);
break;
case LOG_LEVEL_ERROR_S:
log_phy_lib_h->error(" %s", str);
break;
default:
break;
}
} else {
printf("[PHY_LIB]: %s\n", str);
switch (log_level) {
case LOG_LEVEL_INFO_S:
phy_lib_log.info(" %s", str);
break;
case LOG_LEVEL_DEBUG_S:
phy_lib_log.debug(" %s", str);
break;
case LOG_LEVEL_ERROR_S:
phy_lib_log.error(" %s", str);
break;
default:
break;
}
}
phy::phy(srslte::logger* logger_) :
logger(logger_), lte_workers(MAX_WORKERS), nr_workers(MAX_WORKERS), workers_common(), nof_workers(0)
phy::phy(srslog::sink& log_sink) :
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
if (srslte::log::get_level_from_string(args.log.phy_lib_level) != srslte::LOG_LEVEL_NONE) {
log_phy_lib_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter);
log_phy_lib_h->init("PHY_LIB", logger, true);
log_phy_lib_h->set_level(args.log.phy_lib_level);
log_phy_lib_h->set_hex_limit(args.log.phy_hex_limit);
// Add PHY lib log.
srslog::basic_levels log_lvl = srslog::str_to_basic_level(args.log.phy_lib_level);
phy_lib_log.set_level(log_lvl);
phy_lib_log.set_hex_dump_max_size(args.log.phy_hex_limit);
if (log_lvl != srslog::basic_levels::none) {
srslte_phy_log_register_handler(this, srslte_phy_handler);
}
// Create default log
{
log_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter);
log_h->init("PHY", logger, true);
log_h->set_level(args.log.phy_level);
log_h->set_hex_limit(args.log.phy_hex_limit);
}
// Create default log.
phy_log.set_level(log_lvl);
phy_log.set_hex_dump_max_size(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);
nr_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, 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,
cfg.phy_cell_cfg[cc].cell,
prach_cfg,
stack_,
log_h.get(),
PRACH_WORKER_THREAD_PRIO,
args.nof_prach_threads);
prach.init(
cc, cfg.phy_cell_cfg[cc].cell, prach_cfg, stack_, phy_log, 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];
}

13
srsenb/src/phy/phy_common.cc
View File

@ -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;

8
srsenb/src/phy/phy_ue_db.cc
View File

@ -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);

14
srsenb/src/phy/prach_worker.cc
View File

@ -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,

21
srsenb/src/phy/txrx.cc
View File

@ -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);
if (log_h) {
log_h->step(tti);
}
logger.set_context(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,

43
srsenb/src/stack/enb_stack_lte.cc
View File

@ -20,14 +20,23 @@ using namespace srslte;
namespace srsenb {
enb_stack_lte::enb_stack_lte(srslte::logger* logger_) :
task_sched(512, 0, 128),
logger(logger_),
pdcp(&task_sched, "PDCP"),
enb_stack_lte::enb_stack_lte(srslte::logger* logger_, srslog::sink& log_sink) :
thread("STACK"),
mac(&task_sched),
s1ap(&task_sched),
rrc(&task_sched)
mac_logger(srslog::fetch_basic_logger("MAC", log_sink)),
rlc_logger(srslog::fetch_basic_logger("RLC", log_sink, false)),
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;
}

103
srsenb/src/stack/mac/mac.cc
View File

@ -27,10 +27,8 @@ using namespace asn1::rrc;
namespace srsenb {
mac::mac(srslte::ext_task_sched_handle task_sched_) :
rar_payload(),
common_buffers(SRSLTE_MAX_CARRIERS),
task_sched(task_sched_)
mac::mac(srslte::ext_task_sched_handle task_sched_, srslog::basic_logger& logger) :
logger(logger), rar_payload(), 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",
tti,
enb_cc_idx,
preamble_idx,
time_adv,
rnti);
logger.info(
"RACH: tti=%d, cc=%d, preamble=%d, offset=%d, temp_crnti=0x%x", tti, 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",
mch.mtch_sched[0].lcid,
mch.mtch_sched[mch.num_mtch_sched - 1].stop,
tti);
logger.info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d ",
mch.mtch_sched[0].lcid,
mch.mtch_sched[mch.num_mtch_sched - 1].stop,
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",
rar_idx,
pdu_len,
rar_payload_len,
nof_grants);
logger.error("Assembling RAR: rar_idx=%d, pdu_len=%d, rar_payload_len=%d, nof_grants=%d",
rar_idx,
pdu_len,
int(rar_payload_len),
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] =
std::unique_ptr<ue>{new ue(SRSLTE_MRNTI, args.nof_prb, &scheduler, rrc_h, rlc_h, phy_h, log_h, cells.size())};
ue_db[SRSLTE_MRNTI] = std::unique_ptr<ue>{
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;
}

11
srsenb/src/stack/mac/sched.cc
View File

@ -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;
}

29
srsenb/src/stack/mac/sched_carrier.cc
View File

@ -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);
log_h->error("%s", error_msg);
srslte::console("%s\n", 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",
crnti,
sf_msg3_sched->get_tti_tx_ul().to_uint());
logger.error(
"SCHED: Failed to allocate Msg3 for rnti=0x%x at tti=%d", crnti, 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_phich_cc_results(log_h, enb_cc_idx, cc_result->ul_sched_result);
log_dl_cc_results(logger, enb_cc_idx, cc_result->dl_sched_result);
log_phich_cc_results(logger, enb_cc_idx, cc_result->ul_sched_result);
return *cc_result;
}

96
srsenb/src/stack/mac/sched_grid.cc
View File

@ -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) {
log_h->debug("No space in PDCCH for rnti=0x%x DL tx. Current PDCCH allocation: %s\n",
if (logger.debug.enabled()) {
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) {
log_h->debug("No space in PDCCH for rnti=0x%x UL tx. Current PDCCH allocation: %s\n",
if (logger.debug.enabled()) {
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",
sib_idx + 1,
aggr_lvl,
sib_len,
ret.first.to_string());
logger.warning("SCHED: Could not allocate SIB=%d, L=%d, len=%d, cause=%s",
sib_idx + 1,
aggr_lvl,
sib_len,
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(
"SCHED: Could not allocate Paging with payload length=%d, cause=%s\n", paging_payload, ret.first.to_string());
logger.warning(
"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, "
"rar_grant_mcs=%d\n",
logger.info("SCHED: RAR, temp_crnti=0x%x, ra-rnti=%d, rbgs=%s, dci=(%d,%d), rar_grant_rba=%d, "
"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",
srslte_ra_tbs_from_idx(mcs, 2),
srslte_ra_tbs_from_idx(mcs, 3),
tbs_bytes,
tbs,
mcs);
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, 3),
tbs_bytes,
tbs,
mcs);
dci->alloc_type = SRSLTE_RA_ALLOC_TYPE2;
dci->type2_alloc.mode = srslte_ra_type2_t::SRSLTE_RA_TYPE2_LOC;

61
srsenb/src/stack/mac/sched_helpers.cc
View File

@ -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 Info(fmt, ...) srslte::logmap::get("MAC")->info(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) srslte::logmap::get("MAC")->warning(fmt, ##__VA_ARGS__)
#define Error(fmt, ...) srslte::logmap::get("MAC")->error(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) srslog::fetch_basic_logger("MAC").debug(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) srslog::fetch_basic_logger("MAC").info(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) srslog::fetch_basic_logger("MAC").warning(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) {
log_h->debug("SCHED: DL MAC PDU payload cc=%d:\n%s", enb_cc_idx, fmt::to_string(strbuf).c_str());
if (logger.debug.enabled()) {
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",
dl_cqi,
l,
nof_bits,
coderate,
max_coderate);
Debug("SCHED: CQI=%d, l=%d, nof_bits=%d, coderate=%.2f, max_coderate=%.2f",
dl_cqi,
l,
nof_bits,
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(
"SCHED: The provided CQI configurations for UE scells %d and %d collide in time resources.\n", i, j);
Warning("SCHED: The provided CQI configurations for UE scells %d and %d collide in time resources.", i, j);
ret = SRSLTE_ERROR;
}
}

77
srsenb/src/stack/mac/sched_ue.cc
View File

@ -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(
"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());
logger.debug(
"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",
tb,
rem_tbs,
h->get_id(),
pending_bytes);
logger.warning("SCHED: Failed to allocate DL TB with tb_idx=%d, tbs=%d, pid=%d. Pending DL buffer data=%d",
tb,
rem_tbs,
h->get_id(),
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. "
"Consider increasing initial CQI value.\n",
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.",
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",
pending_data,
pending_ul_data,
lch_handler.get_bsr_text().c_str());
logger.debug("SCHED: pending_data=%d, in_harq_data=%d, bsr=%s",
pending_data,
pending_ul_data,
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];
}
}

22
srsenb/src/stack/mac/sched_ue_ctrl/sched_harq.cc
View File

@ -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",
tb_idx,
id,
tti.to_uint(),
max_retx);
srslog::fetch_basic_logger("MAC").info(
"SCHED: discarding TB=%d pid=%d, tti=%d, maximum number of retx exceeded (%d)",
tb_idx,
id,
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) :
dl_harqs(nof_dl_harqs), ul_harqs(nof_ul_harqs), log_h(srslte::logmap::get("MAC "))
harq_entity::harq_entity(size_t nof_dl_harqs, size_t nof_ul_harqs) : dl_harqs(nof_dl_harqs), ul_harqs(nof_ul_harqs)
{
for (uint32_t i = 0; i < dl_harqs.size(); ++i) {
dl_harqs[i].init(i);

24
srsenb/src/stack/mac/sched_ue_ctrl/sched_lch.cc
View File

@ -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",
lc_id,
to_string(lch[lc_id].cfg.direction),
lch[lc_id].cfg.priority);
logger.info("SCHED: bearer configured: lc_id=%d, mode=%s, prio=%d",
lc_id,
to_string(lch[lc_id].cfg.direction),
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

9
srsenb/src/stack/mac/sched_ue_ctrl/sched_ue_cell.cc
View File

@ -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);

4
srsenb/src/stack/mac/schedulers/sched_time_pf.cc
View File

@ -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;
}

8
srsenb/src/stack/mac/schedulers/sched_time_rr.cc
View File

@ -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());
}
}
}

92
srsenb/src/stack/mac/ue.cc
View File

@ -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",
it->first,
rnti,
tti,
srslte_tti_interval(tti, it->first));
logger.warning("UE buffers: Removing old buffer tti=%d, rnti=%d, now is %d, interval=%d",
it->first,
rnti,
tti,
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",
rnti,
tti % nof_rx_harq_proc,
ue_cc_idx);
logger.warning("UE buffers: Null RX PDU pointer in deallocate_pdu for rnti=0x%x pid=%d cc_idx=%d",
rnti,
tti % nof_rx_harq_proc,
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",
rnti,
tti % nof_rx_harq_proc,
ue_cc_idx);
logger.warning("UE buffers: Null RX PDU pointer in push_pdu for rnti=0x%x pid=%d cc_idx=%d",
rnti,
tti % nof_rx_harq_proc,
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(
"Invalid parameters calling generate_pdu: cc_idx=%d, harq_pid=%d, tb_idx=%d\n", ue_cc_idx, harq_pid, tb_idx);
logger.error(
"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;

12
srsenb/src/stack/rrc/mac_controller.cc
View File

@ -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;
}

109
srsenb/src/stack/rrc/rrc.cc
View File

@ -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 "
"re-establishment procedure.\n");
logger.warning("Inactivity timeout is smaller than the sum of t310, t311 and n310. This may break the UE's "
"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",
paging_rec->paging_record_list.size(),
byte_buf_paging.N_bytes,
N_bits);
logger.info("Assembling PCCH payload with %d UE identities, payload_len=%d bytes, nbits=%d",
paging_rec->paging_record_list.size(),
byte_buf_paging.N_bytes,
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;
}
}

72
srsenb/src/stack/rrc/rrc_bearer_cfg.cc
View File

@ -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)");
log_h->info_hex(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)");
log_h->info_hex(sec_cfg.k_up_enc.data(), 32, "UP Encryption Key (k_up_enc)");
logger.info(k_enb, 32, "K_eNB (k_enb)");
logger.info(sec_cfg.k_rrc_enc.data(), 32, "RRC Encryption Key (k_rrc_enc)");
logger.info(sec_cfg.k_rrc_int.data(), 32, "RRC Integrity Key (k_rrc_int)");
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);
log_h->info_hex(k_enb, 32, "Old K_eNB (k_enb)");
logger.info("Regenerating KeNB with PCI=0x%02x, DL-EARFCN=%d", new_pci, new_dl_earfcn);
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++;
}

64
srsenb/src/stack/rrc/rrc_cell_cfg.cc
View File

@ -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(
"Removing CQI resources: no users in time-frequency slot (%d, %d)\n", c->cqi_res.prb_idx, c->cqi_res.sf_idx);
logger.warning(
"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(
"Deallocated SR resources for time-frequency slot (%d, %d)\n", 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.info(
"Deallocated SR resources for time-frequency slot (%d, %d)", sr_res.sr_sched_prb_idx, sr_res.sr_sched_sf_idx);
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;

140
srsenb/src/stack/rrc/rrc_mobility.cc
View File

@ -26,14 +26,14 @@
namespace srsenb {
#define Info(fmt, ...) rrc_log->info("Mobility: " fmt, ##__VA_ARGS__)
#define Error(fmt, ...) rrc_log->error("Mobility: " fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) rrc_log->warning("Mobility: " fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) rrc_log->debug("Mobility: " fmt, ##__VA_ARGS__)
#define Info(fmt, ...) logger.info("Mobility: " fmt, ##__VA_ARGS__)
#define Error(fmt, ...) logger.error("Mobility: " fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) logger.warning("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 procWarning(fmt, ...) parent->rrc_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procError(fmt, ...) parent->rrc_log->error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procInfo(fmt, ...) parent->logger.info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procWarning(fmt, ...) parent->logger.warning("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 meas_it = std::find_if(meas_list_cfg.begin(), meas_list_cfg.end(), same_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);
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 enb_cell_common* src_cell_cfg = src_cell_ded->cell_common;
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;
/*** 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_hex(container->msg, container->N_bytes, "Received container:\n");
get_log()->warning("Unpacking of RRC HOCommand was unsuccessful");
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",
rrc_ue->rnti,
target_cell->cell_common->cell_cfg.cell_id);
logger.info("User rnti=0x%x successfully handovered to cell_id=0x%x",
rrc_ue->rnti,
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",
drb_it->lc_ch_id,
drb_state.next_pdcp_tx_sn,
drb_state.next_pdcp_rx_sn);
logger.info("Setting lcid=%d PDCP state to {Tx SN: %d, Rx SN: %d}",
drb_it->lc_ch_id,
drb_state.next_pdcp_tx_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(
"User rnti=0x%x successfully handovered to cell_id=0x%x\n", rrc_ue->rnti, s.target_cell->cell_cfg.cell_id);
logger.info(
"User rnti=0x%x successfully handovered to cell_id=0x%x", rrc_ue->rnti, s.target_cell->cell_cfg.cell_id);
}
} // namespace srsenb

167
srsenb/src/stack/rrc/rrc_ue.cc
View File

@ -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) {
parent->rrc_log->debug("Activity registered for rnti=0x%x (timeout_value=%dms)\n", rnti, activity_timer.duration());
if (parent) {
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->rrc_log->info("Activity timer for rnti=0x%x expired after %d ms\n", rnti, activity_timer.time_elapsed());
}
parent->logger.info("Activity timer for rnti=0x%x expired after %d ms", 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",
(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,
(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());
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(),
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(),
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",
old_rnti);
parent->logger.info("ConnectionReestablishmentRequest for rnti=0x%x. Sending Connection Reestablishment",
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->rrc_log->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",
old_reest_pdcp_state[lcid].tx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
old_reest_pdcp_state[lcid].rx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
parent->logger.debug("Getting PDCP state for E-RAB with LCID %d", lcid);
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",
old_reest_pdcp_state[lcid].tx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
old_reest_pdcp_state[lcid].rx_hfn,
old_reest_pdcp_state[lcid].next_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",
transaction_id,
msg->rrc_transaction_id);
parent->logger.error(
"Expected RRCReconfigurationComplete with transaction ID: %d, got %d", 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",
msg_r8->ue_cap_rat_container_list[i].rat_type.to_string().c_str());
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());
} 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, "
"LAST_SUBMITTED_PDCP_RX_SN %d\n",
old_reest_pdcp_state[lcid].tx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
old_reest_pdcp_state[lcid].rx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_rx_sn,
old_reest_pdcp_state[lcid].last_submitted_pdcp_rx_sn);
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",
old_reest_pdcp_state[lcid].tx_hfn,
old_reest_pdcp_state[lcid].next_pdcp_tx_sn,
old_reest_pdcp_state[lcid].rx_hfn,
old_reest_pdcp_state[lcid].next_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

27
srsenb/src/stack/rrc/ue_meas_cfg.cc
View File

@ -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",
target_offset.type().to_string().c_str());
srslog::fetch_basic_logger("RRC").warning("MeasGap of type %s not supported",
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(),
sorted_ue_cells.end(),
[](const ue_cell_ded* cc1, const ue_cell_ded* cc2) {
return cc1->get_dl_earfcn() < cc2->get_dl_earfcn();
});
std::sort(sorted_ue_cells.begin(), sorted_ue_cells.end(), [](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,
meas_cfg_s& current_meascfg,
bool apply_meascfg_updates(meas_cfg_s& meascfg,
meas_cfg_s& current_meascfg,
const ue_cell_ded_list& ue_cell_list,
int prev_earfcn,
int prev_pci)
int prev_earfcn,
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

8
srsenb/src/stack/rrc/ue_rr_cfg.cc
View File

@ -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.");
}
}
}

99
srsenb/src/stack/upper/gtpu.cc
View File

@ -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);
srslte::console("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(), 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));
gtpu_log->debug("Tx S1-U PDU -- IP src addr %s\n", 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 version %d, Total length %d", int(ip_pkt->version), ntohs(ip_pkt->tot_len));
logger.debug("Tx S1-U PDU -- IP src addr %s", srslte::gtpu_ntoa(ip_pkt->saddr).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) {
gtpu_log->info("Adding bearer for rnti: 0x%x, lcid: %d, addr: 0x%x, teid_out: 0x%x, teid_in: 0x%x\n",
rnti,
lcid,
addr,
teid_out,
teid_in);
}
logger.info("Adding bearer for rnti: 0x%x, lcid: %d, addr: 0x%x, teid_out: 0x%x, teid_in: 0x%x",
rnti,
lcid,
addr,
teid_out,
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(
pdu->msg, pdu->N_bytes, "RX GTPU PDU rnti=0x%x, lcid=%d, n_bytes=%d", rnti, lcid, pdu->N_bytes);
logger.info(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));
gtpu_log->debug("Rx S1-U PDU -- IP src addr %s\n", 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 version %d, Total length %d", int(ip_pkt->version), ntohs(ip_pkt->tot_len));
logger.debug("Rx S1-U PDU -- IP src addr %s", srslte::gtpu_ntoa(ip_pkt->saddr).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");
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("Register musticast group for M1-U");
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);

14
srsenb/src/stack/upper/pdcp.cc
View File

@ -15,10 +15,8 @@
namespace srsenb {
pdcp::pdcp(srslte::task_sched_handle task_sched_, const char* logname) :
task_sched(task_sched_),
log_h(logname),
pool(srslte::byte_buffer_pool::get_instance())
pdcp::pdcp(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger) :
task_sched(task_sched_), logger(logger), 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)

18
srsenb/src/stack/upper/rlc.cc
View File

@ -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::log_ref log_h_)
srslte::timer_handler* timers_)
{
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)

217
srsenb/src/stack/upper/s1ap.cc
View File

@ -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 procWarning(fmt, ...) s1ap_ptr->s1ap_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procInfo(fmt, ...) s1ap_ptr->s1ap_log->info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procError(fmt, ...) s1ap_ptr->logger.error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define procWarning(fmt, ...) s1ap_ptr->logger.warning("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_;
args = args_;
s1ap_log = srslte::logmap::get("S1AP");
stack = stack_;
pool = srslte::byte_buffer_pool::get_instance();
rrc = rrc_;
args = args_;
stack = stack_;
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",
msg.protocol_ies.mme_ue_s1ap_id.value.value);
logger.error("The provided MME_UE_S1AP_ID=%" PRIu64 " is already connected to the cell",
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",
user->ctxt.enb_ue_s1ap_id);
srslte::logmap::get("S1AP")->error("The user to be added with enb id=%d already exists", 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",
user->ctxt.mme_ue_s1ap_id);
srslte::logmap::get("S1AP")->error("The user to be added with mme id=%d already exists", 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");

2
srsenb/src/stack/upper/sdap.cc
View File

@ -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_)
{

47
srsenb/test/mac/sched_ca_test.cc
View File

@ -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; }
~sched_test_log() override { log_diagnostics(); }
explicit sched_diagnostic_printer(srslte::log_sink_spy& s) : s(s) {}
void log_diagnostics() override
~sched_diagnostic_printer()
{
info("[TESTER] Number of assertion warnings: %u\n", warn_counter);
info("[TESTER] Number of assertion errors: %u\n", error_counter);
info("[TESTER] This was the seed: %u\n", seed);
auto& logger = srslog::fetch_basic_logger("TEST");
logger.info("[TESTER] Number of assertion warnings: %u", s.get_warning_counter());
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;
}

71
srsenb/test/mac/sched_common_test_suite.cc
View File

@ -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.empty(), "Allocations must have at least one PRB\n");
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");
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(not sib1_expected and it != bc_end, "SIB1 allocated in wrong TTI.\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.");
/* 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);
CONDERROR(used_cce.any(cce_start, cce_stop),
"%s DCI collision between CCE positions (%u, %u)\n",
ch,
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), "%s DCI collision between CCE positions (%u, %u)", 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(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in UL\n", rnti);
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", 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.tb.mcs_idx > 28, "Incorrect UL MCS index\n");
CONDERROR(pusch.dci.format != SRSLTE_DCI_FORMAT0, "Incorrect UL DCI format");
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(alloc_rntis.count(rnti) > 0, "The user rnti=0x%x got allocated multiple times in DL\n", rnti);
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", 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(data.dci.tb[tb].mcs_idx > 28, "Incorrect DL MCS index\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");
}
}
}
@ -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;

12
srsenb/test/mac/sched_grid_test.cc
View File

@ -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");
}

14
srsenb/test/mac/sched_lc_ch_test.cc
View File

@ -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");
}

19
srsenb/test/mac/sched_sim_ue.cc
View File

@ -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++;
}
}

9
srsenb/test/mac/sched_sim_ue.h
View File

@ -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"};
sim_ue_ctxt_t ctxt;
srslog::basic_logger& logger;
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;

14
srsenb/test/mac/sched_test_common.cc
View File

@ -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);

6
srsenb/test/mac/sched_test_common.h
View File

@ -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
srslte::log* tester_log = nullptr;
sim_sched_args sim_args0; ///< arguments used to generate TTI events
srslog::basic_logger& logger;
// tti specific params
tti_info_t tti_info;

81
srsenb/test/mac/sched_test_rand.cc
View File

@ -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; }
~sched_test_log() override { log_diagnostics(); }
explicit sched_diagnostic_printer(srslte::log_sink_spy& s) : s(s) {}
void log_diagnostics() override
~sched_diagnostic_printer()
{
info("UE stats:\n");
info("all: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}\n",
ue_tot_stats.nof_dl_rbs,
ue_tot_stats.nof_ul_rbs,
ue_tot_stats.nof_dl_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis,
ue_tot_stats.nof_ul_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis);
for (auto& e : ue_stats) {
info("0x%x: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}\n",
e.first,
e.second.nof_dl_rbs,
e.second.nof_ul_rbs,
e.second.nof_dl_bytes * 8 * 0.001 / e.second.nof_ttis,
e.second.nof_ul_bytes * 8 * 0.001 / e.second.nof_ttis);
auto& logger = srslog::fetch_basic_logger("TEST");
logger.info("UE stats:");
logger.info("all: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}",
ue_tot_stats.nof_dl_rbs,
ue_tot_stats.nof_ul_rbs,
ue_tot_stats.nof_dl_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis,
ue_tot_stats.nof_ul_bytes * 8 * 0.001 / ue_tot_stats.nof_ttis);
for (const auto& e : ue_stats) {
logger.info("0x%x: {DL/UL RBs: %" PRIu32 "/%" PRIu32 ", DL/UL bitrates: %0.2f/%0.2f Mbps}",
e.first,
e.second.nof_dl_rbs,
e.second.nof_ul_rbs,
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);
info("Number of assertion errors: %u\n", error_counter);
info("This was the seed: %u\n", seed);
logger.info("Number of assertion warnings: %u", s.get_warning_counter());
logger.info("Number of assertion errors: %u", s.get_error_counter());
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);

1
srsenb/test/mac/sched_test_utils.h
View File

@ -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 = {};
};

98
srsenb/test/mac/sched_ue_ded_test_suite.cc
View File

@ -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(h.active, "DL newtx for already active DL harq pid=%d\n", h.pid);
CONDERROR(nof_retx != 0, "Invalid rv index for new tx");
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(not h.active, "retx for inactive dl harq pid=%d\n", h.pid);
CONDERROR(to_tx_dl_ack(h.last_tti_rx) > tti_rx, "harq pid=%d reused too soon\n", h.pid);
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", 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.tbs != pdsch.tbs[0], "TBS changed during HARQ retx\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");
}
// 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(pusch_ptr != nullptr, "PUSCH 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");
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(pusch_ptr->current_tx_nb != 0, "UL HARQ retxs need to have been previously transmitted\n");
CONDERROR(not h_inactive, "New tx for already active UL HARQ\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");
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(h.tbs != pusch_ptr->tbs, "TBS changed during HARQ retx\n");
CONDERROR(to_tx_ul(h.last_tti_rx) > sf_out.tti_rx, "UL harq pid=%d was reused too soon\n", h.pid);
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");
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 > 1, "Only one Msg3 allower per user.\n");
CONDERROR(msg3_count == 0, "Msg3 was not transmitted.");
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");
}
}
}

133
srsenb/test/phy/enb_phy_test.cc
View File

@ -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_ul_grant = 0.10f;
static constexpr uint32_t cfi = 2;
static constexpr float prob_dl_grant = 0.50f;
static constexpr float prob_ul_grant = 0.10f;
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),
log_h("UPHY", nullptr, true)
radio(_radio), logger(srslog::fetch_basic_logger("UPHY"))
{
// 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;

Some files were not shown because too many files have changed in this diff Show More