5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Upgrade loggers in srsue (#2163)

Browse Source 
* Replaced UE logger in the ue class.

* Replaced loggers in the main phy class and prach.

* Replaced loggers in phy common and ta_control.

* Replace loggers in cc and sf workers.

* Replaced loggers in intra_measure, scell_recv, search, sfn_sync, sync.

* Remove last uses of the old loggers in the main phy class.

* Remove stray newline in logs.

* Replaced loggers in ue gw.

* - Started to replace loggers in the ue stack.
- Replaced loggers in usim and pcsc.
- Adapted nas and usim tests.

* Replace loggers in nas.

* Added missing log init calls in two previously modified tests.

* Replaced logger in nas idle procs.

* Replaced loggers in nas emm state.

* Replaced loggers in tft packet filter and adapted tft test.

* Replaced loggers in main RRC class.

* Replaced loggers in RRC cell.

* Replaced loggers in RRC meas.

* Replaced loggers in rrc procedures.

* Started logger replacement in MAC layer, more precisely in demux and dl_harq classes.
Been unable to inject loggers in construction for dl_tb_process due to very weird static assertions in the std::vector code being the type not constructible which is not true, so instead use the main MAC logger directly.

* Replaced loggers in mac mux class.

* Replaced loggers in mac pro_bsr.

* Replaced loggers in mac proc phr.

* Replaced loggers in mac proc SR and RA.

* Replace loggers in mac UL HARQ.

* Replaced loggers in main ue stack class.

* Fixed nas test crashing due to a null string.

* Ported mac_test to use the new loggers.

* Removed TTI reporting for the PHY log as the old logger did.

* Replaced loggers in UE phy tests.

* Configure loggers in nas_test.

* Replaced loggers in rrc_meas_test.

* Replaced loggers in rrc_reconfig_test.

* Added missing newline in tft_test.

* Fix compilation errors in TTCN3 tests.

* Fix linker error detected in CI and warning.

* Replaced loggers in TTCN3 tests.

* Fix a text replace error in some log messages.

* Remove trailing newlines from log entries.

* Remove old logger from rrc.

* Flush backend before printing the test status.

* - Fix compilation error from previous rebase.
- Remove trailing newlines from some missing log entries.
master
faluco 4 years ago committed by GitHub
parent 42aa5c4499
commit 5981469f9f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
100 changed files with 2790 additions and 2780 deletions
Show Stats Download Patch File Download Diff File

4
srsue/hdr/phy/lte/cc_worker.h
Unescape Escape View File

@ -23,7 +23,7 @@ namespace lte {
class cc_worker class cc_worker
{ {
public: public:
cc_worker(uint32_t cc_idx, uint32_t max_prb, phy_common* phy, srslte::log* log); cc_worker(uint32_t cc_idx, uint32_t max_prb, phy_common* phy, srslog::basic_logger& logger);
~cc_worker(); ~cc_worker();
/* Functions used by main PHY thread */ /* Functions used by main PHY thread */
@ -87,7 +87,7 @@ private:
/* Common objects */ /* Common objects */
phy_common* phy = nullptr; phy_common* phy = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte_cell_t cell = {}; srslte_cell_t cell = {};
srslte_dl_sf_cfg_t sf_cfg_dl = {}; srslte_dl_sf_cfg_t sf_cfg_dl = {};

4
srsue/hdr/phy/lte/sf_worker.h
Unescape Escape View File

@ -33,7 +33,7 @@ namespace lte {
class sf_worker : public srslte::thread_pool::worker class sf_worker : public srslte::thread_pool::worker
{ {
public: public:
sf_worker(uint32_t max_prb, phy_common* phy, srslte::log* log); sf_worker(uint32_t max_prb, phy_common* phy_, srslog::basic_logger& logger);
virtual ~sf_worker(); virtual ~sf_worker();
void reset_cell_unlocked(uint32_t cc_idx); void reset_cell_unlocked(uint32_t cc_idx);
@ -79,7 +79,7 @@ private:
phy_common* phy = nullptr; phy_common* phy = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte_cell_t cell = {}; srslte_cell_t cell = {};
std::mutex cell_mutex; std::mutex cell_mutex;

6
srsue/hdr/phy/lte/worker_pool.h
Unescape Escape View File

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

19
srsue/hdr/phy/phy.h
Unescape Escape View File

@ -23,6 +23,7 @@
#include "srslte/interfaces/radio_interfaces.h" #include "srslte/interfaces/radio_interfaces.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include "srsue/hdr/phy/lte/worker_pool.h" #include "srsue/hdr/phy/lte/worker_pool.h"
#include "srsue/hdr/phy/nr/worker_pool.h" #include "srsue/hdr/phy/nr/worker_pool.h"
@ -67,8 +68,17 @@ private:
class phy final : public ue_lte_phy_base, public srslte::thread class phy final : public ue_lte_phy_base, public srslte::thread
{ {
public: public:
explicit phy(srslte::logger* logger_) : explicit phy(srslte::logger* logger_, srslog::sink& log_sink) :
logger(logger_), lte_workers(MAX_WORKERS), nr_workers(MAX_WORKERS), common(), thread("PHY"){}; logger(logger_),
log_sink(log_sink),
logger_phy(srslog::fetch_basic_logger("PHY", log_sink)),
logger_phy_lib(srslog::fetch_basic_logger("PHY_LIB", log_sink)),
lte_workers(MAX_WORKERS),
nr_workers(MAX_WORKERS),
common(logger_phy),
sfsync(logger_phy, logger_phy_lib),
prach_buffer(logger_phy),
thread("PHY"){};
~phy() final { stop(); } ~phy() final { stop(); }
// Init defined in base class // Init defined in base class
@ -173,9 +183,10 @@ private:
srslte::radio_interface_phy* radio = nullptr; srslte::radio_interface_phy* radio = nullptr;
srslte::logger* logger = nullptr; srslte::logger* logger = nullptr;
srslog::sink& log_sink;
std::unique_ptr<srslte::log_filter> log_h = nullptr; srslog::basic_logger& logger_phy;
std::unique_ptr<srslte::log_filter> log_phy_lib_h = nullptr; srslog::basic_logger& logger_phy_lib;
srsue::stack_interface_phy_lte* stack = nullptr; srsue::stack_interface_phy_lte* stack = nullptr;
lte::worker_pool lte_workers; lte::worker_pool lte_workers;

6
srsue/hdr/phy/phy_common.h
Unescape Escape View File

@ -21,6 +21,7 @@
#include "srslte/interfaces/radio_interfaces.h" #include "srslte/interfaces/radio_interfaces.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include "srsue/hdr/phy/scell/scell_state.h" #include "srsue/hdr/phy/scell/scell_state.h"
#include "ta_control.h" #include "ta_control.h"
@ -65,12 +66,11 @@ public:
// Time Aligment Controller, internal thread safe // Time Aligment Controller, internal thread safe
ta_control ta; ta_control ta;
phy_common(); phy_common(srslog::basic_logger& logger);
~phy_common(); ~phy_common();
void init(phy_args_t* args, void init(phy_args_t* args,
srslte::log* _log,
srslte::radio_interface_phy* _radio, srslte::radio_interface_phy* _radio,
stack_interface_phy_lte* _stack, stack_interface_phy_lte* _stack,
rsrp_insync_itf* rsrp_insync); rsrp_insync_itf* rsrp_insync);
@ -248,7 +248,7 @@ private:
bool is_pending_tx_end = false; bool is_pending_tx_end = false;
srslte::radio_interface_phy* radio_h = nullptr; srslte::radio_interface_phy* radio_h = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte::channel_ptr ul_channel = nullptr; srslte::channel_ptr ul_channel = nullptr;
int rar_grant_tti = -1; int rar_grant_tti = -1;

7
srsue/hdr/phy/prach.h
Unescape Escape View File

@ -16,6 +16,7 @@
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include <bitset> #include <bitset>
@ -24,10 +25,10 @@ namespace srsue {
class prach class prach
{ {
public: public:
prach() = default; prach(srslog::basic_logger& logger) : logger(logger) {}
~prach() { stop(); } ~prach() { stop(); }
void init(uint32_t max_prb, srslte::log* log_h); void init(uint32_t max_prb);
void stop(); void stop();
bool set_cell(srslte_cell_t cell, srslte_prach_cfg_t prach_cfg); bool set_cell(srslte_cell_t cell, srslte_prach_cfg_t prach_cfg);
bool prepare_to_send(uint32_t preamble_idx, int allowed_subframe = -1, float target_power_dbm = -1); bool prepare_to_send(uint32_t preamble_idx, int allowed_subframe = -1, float target_power_dbm = -1);
@ -55,7 +56,7 @@ private:
static constexpr unsigned max_fs = 12; static constexpr unsigned max_fs = 12;
static constexpr unsigned max_preambles = 64; static constexpr unsigned max_preambles = 64;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte_prach_t prach_obj = {}; srslte_prach_t prach_obj = {};
srslte_cell_t cell = {}; srslte_cell_t cell = {};
srslte_cfo_t cfo_h = {}; srslte_cfo_t cfo_h = {};

9
srsue/hdr/phy/scell/intra_measure.h
Unescape Escape View File

@ -58,7 +58,7 @@ public:
/** /**
* Constructor * Constructor
*/ */
intra_measure(); intra_measure(srslog::basic_logger& logger);
/** /**
* Destructor * Destructor
@ -69,9 +69,8 @@ public:
* Initiation function, necessary to configure main parameters * Initiation function, necessary to configure main parameters
* @param common SRSUE phy_common instance pointer for providing intra_freq_meas_len_ms and intra_freq_meas_period_ms * @param common SRSUE phy_common instance pointer for providing intra_freq_meas_len_ms and intra_freq_meas_period_ms
* @param rrc SRSUE PHY->RRC interface for supplying the RRC with the measurements * @param rrc SRSUE PHY->RRC interface for supplying the RRC with the measurements
* @param log_h Physical layer Logging filter pointer
*/ */
void init(uint32_t cc_idx, phy_common* common, meas_itf* new_cell_itf, srslte::log* log_h); void init(uint32_t cc_idx, phy_common* common, meas_itf* new_cell_itf);
/** /**
* Stops the operation of this component * Stops the operation of this component
@ -193,9 +192,9 @@ private:
///< Internal Thread priority, low by default ///< Internal Thread priority, low by default
const static int INTRA_FREQ_MEAS_PRIO = DEFAULT_PRIORITY + 5; const static int INTRA_FREQ_MEAS_PRIO = DEFAULT_PRIORITY + 5;
scell_recv scell = {}; scell_recv scell;
meas_itf* new_cell_itf = nullptr; meas_itf* new_cell_itf = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
uint32_t cc_idx = 0; uint32_t cc_idx = 0;
uint32_t current_earfcn = 0; uint32_t current_earfcn = 0;
uint32_t current_sflen = 0; uint32_t current_sflen = 0;

6
srsue/hdr/phy/scell/scell_recv.h
Unescape Escape View File

@ -24,7 +24,9 @@ namespace scell {
class scell_recv class scell_recv
{ {
public: public:
void init(srslte::log* log_h, uint32_t max_sf_window); explicit scell_recv(srslog::basic_logger& logger) : logger(logger) {}
void init(uint32_t max_sf_window);
void deinit(); void deinit();
void reset(); void reset();
std::set<uint32_t> find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cell, const uint32_t nof_sf); std::set<uint32_t> find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cell, const uint32_t nof_sf);
@ -34,7 +36,7 @@ private:
constexpr static float ABSOLUTE_RSRP_THRESHOLD_DBM = -125; constexpr static float ABSOLUTE_RSRP_THRESHOLD_DBM = -125;
cf_t* sf_buffer[SRSLTE_MAX_PORTS]; cf_t* sf_buffer[SRSLTE_MAX_PORTS];
srslte::log* log_h; srslog::basic_logger& logger;
srslte_sync_t sync_find; srslte_sync_t sync_find;
uint32_t current_fft_sz; uint32_t current_fft_sz;

6
srsue/hdr/phy/scell/scell_state.h
Unescape Escape View File

@ -138,7 +138,7 @@ public:
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) { if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
ERROR("CC IDX %d out-of-range\n", cc_idx); ERROR("CC IDX %d out-of-range", cc_idx);
return; return;
} }
@ -203,7 +203,7 @@ public:
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) { if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
ERROR("CC IDX %d out-of-range\n", cc_idx); ERROR("CC IDX %d out-of-range", cc_idx);
return 0; return 0;
} }
@ -215,7 +215,7 @@ public:
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) { if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
ERROR("CC IDX %d out-of-range\n", cc_idx); ERROR("CC IDX %d out-of-range", cc_idx);
return 0; return 0;
} }

8
srsue/hdr/phy/scell/scell_sync.h
Unescape Escape View File

@ -87,13 +87,13 @@ private:
state = STATE_IN_SYNCH; state = STATE_IN_SYNCH;
break; break;
case SRSLTE_SYNC_FOUND_NOSPACE: case SRSLTE_SYNC_FOUND_NOSPACE:
ERROR("No space error\n"); ERROR("No space error");
break; break;
case SRSLTE_SYNC_NOFOUND: case SRSLTE_SYNC_NOFOUND:
// Ignore // Ignore
break; break;
case SRSLTE_SYNC_ERROR: case SRSLTE_SYNC_ERROR:
ERROR("Error finding PSS\n"); ERROR("Error finding PSS");
break; break;
} }
@ -117,7 +117,7 @@ public:
// Initialise Find PSS object // Initialise Find PSS object
if (srslte_sync_init(&find_pss, 2 * SRSLTE_SF_LEN_MAX, 2 * SRSLTE_SF_LEN_MAX, SRSLTE_SYMBOL_SZ_MAX) != if (srslte_sync_init(&find_pss, 2 * SRSLTE_SF_LEN_MAX, 2 * SRSLTE_SF_LEN_MAX, SRSLTE_SYMBOL_SZ_MAX) !=
SRSLTE_SUCCESS) { SRSLTE_SUCCESS) {
ERROR("Initiating Synchronizer\n"); ERROR("Initiating Synchronizer");
} }
} }
@ -136,7 +136,7 @@ public:
// Resize Sync object // Resize Sync object
if (srslte_sync_resize(&find_pss, 2 * sf_len, 2 * sf_len, symbol_sz) != SRSLTE_SUCCESS) { if (srslte_sync_resize(&find_pss, 2 * sf_len, 2 * sf_len, symbol_sz) != SRSLTE_SUCCESS) {
ERROR("Error setting cell sync find\n"); ERROR("Error setting cell sync find");
} }
// Configure // Configure

6
srsue/hdr/phy/search.h
Unescape Escape View File

@ -15,6 +15,7 @@
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "srslte/srslte.h" #include "srslte/srslte.h"
namespace srsue { namespace srsue {
@ -34,8 +35,9 @@ class search
public: public:
typedef enum { CELL_NOT_FOUND, CELL_FOUND, ERROR, TIMEOUT } ret_code; typedef enum { CELL_NOT_FOUND, CELL_FOUND, ERROR, TIMEOUT } ret_code;
explicit search(srslog::basic_logger& logger) : logger(logger) {}
~search(); ~search();
void init(srslte::rf_buffer_t& buffer_, srslte::log* log_h, uint32_t nof_rx_channels, search_callback* parent); void init(srslte::rf_buffer_t& buffer_, uint32_t nof_rx_channels, search_callback* parent);
void reset(); void reset();
float get_last_cfo(); float get_last_cfo();
void set_agc_enable(bool enable); void set_agc_enable(bool enable);
@ -43,7 +45,7 @@ public:
private: private:
search_callback* p = nullptr; search_callback* p = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte::rf_buffer_t buffer = {}; srslte::rf_buffer_t buffer = {};
srslte_ue_cellsearch_t cs = {}; srslte_ue_cellsearch_t cs = {};
srslte_ue_mib_sync_t ue_mib_sync = {}; srslte_ue_mib_sync_t ue_mib_sync = {};

6
srsue/hdr/phy/sfn_sync.h
Unescape Escape View File

@ -15,6 +15,7 @@
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "srslte/srslte.h" #include "srslte/srslte.h"
namespace srsue { namespace srsue {
@ -24,13 +25,12 @@ class sfn_sync
{ {
public: public:
typedef enum { IDLE, SFN_FOUND, SFX0_FOUND, SFN_NOFOUND, ERROR } ret_code; typedef enum { IDLE, SFN_FOUND, SFX0_FOUND, SFN_NOFOUND, ERROR } ret_code;
sfn_sync() = default; explicit sfn_sync(srslog::basic_logger& logger) : logger(logger) {}
~sfn_sync(); ~sfn_sync();
void init(srslte_ue_sync_t* ue_sync, void init(srslte_ue_sync_t* ue_sync,
const phy_args_t* phy_args_, const phy_args_t* phy_args_,
srslte::rf_buffer_t& buffer, srslte::rf_buffer_t& buffer,
uint32_t buffer_max_samples_, uint32_t buffer_max_samples_,
srslte::log* log_h,
uint32_t nof_subframes = SFN_SYNC_NOF_SUBFRAMES); uint32_t nof_subframes = SFN_SYNC_NOF_SUBFRAMES);
void reset(); void reset();
bool set_cell(srslte_cell_t cell); bool set_cell(srslte_cell_t cell);
@ -50,7 +50,7 @@ private:
const phy_args_t* phy_args = nullptr; const phy_args_t* phy_args = nullptr;
uint32_t cnt = 0; uint32_t cnt = 0;
uint32_t timeout = 0; uint32_t timeout = 0;
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
srslte_ue_sync_t* ue_sync = nullptr; srslte_ue_sync_t* ue_sync = nullptr;
srslte::rf_buffer_t mib_buffer = {}; srslte::rf_buffer_t mib_buffer = {};
uint32_t buffer_max_samples = 0; uint32_t buffer_max_samples = 0;

15
srsue/hdr/phy/sync.h
Unescape Escape View File

@ -47,7 +47,14 @@ class sync : public srslte::thread,
public scell::intra_measure::meas_itf public scell::intra_measure::meas_itf
{ {
public: public:
sync() : thread("SYNC"), sf_buffer(sync_nof_rx_subframes), dummy_buffer(sync_nof_rx_subframes){}; sync(srslog::basic_logger& phy_logger, srslog::basic_logger& phy_lib_logger) :
thread("SYNC"),
search_p(phy_logger),
sfn_p(phy_logger),
phy_logger(phy_logger),
phy_lib_logger(phy_lib_logger),
sf_buffer(sync_nof_rx_subframes),
dummy_buffer(sync_nof_rx_subframes){};
~sync(); ~sync();
void init(srslte::radio_interface_phy* radio_, void init(srslte::radio_interface_phy* radio_,
@ -56,8 +63,6 @@ public:
lte::worker_pool* _lte_workers_pool, lte::worker_pool* _lte_workers_pool,
nr::worker_pool* _nr_workers_pool, nr::worker_pool* _nr_workers_pool,
phy_common* _worker_com, phy_common* _worker_com,
srslte::log* _log_h,
srslte::log* _log_phy_lib_h,
uint32_t prio, uint32_t prio,
int sync_cpu_affinity = -1); int sync_cpu_affinity = -1);
void stop(); void stop();
@ -199,8 +204,8 @@ private:
// Pointers to other classes // Pointers to other classes
stack_interface_phy_lte* stack = nullptr; stack_interface_phy_lte* stack = nullptr;
srslte::log* log_h = nullptr; srslog::basic_logger& phy_logger;
srslte::log* log_phy_lib_h = nullptr; srslog::basic_logger& phy_lib_logger;
lte::worker_pool* lte_worker_pool = nullptr; lte::worker_pool* lte_worker_pool = nullptr;
nr::worker_pool* nr_worker_pool = nullptr; nr::worker_pool* nr_worker_pool = nullptr;
srslte::radio_interface_phy* radio_h = nullptr; srslte::radio_interface_phy* radio_h = nullptr;

30
srsue/hdr/phy/ta_control.h
Unescape Escape View File

@ -22,18 +22,13 @@ namespace srsue {
class ta_control class ta_control
{ {
private: private:
srslte::log* log_h = nullptr; srslog::basic_logger& logger;
mutable std::mutex mutex; mutable std::mutex mutex;
uint32_t next_base_nta = 0; uint32_t next_base_nta = 0;
float next_base_sec = 0.0f; float next_base_sec = 0.0f;
public: public:
/** ta_control(srslog::basic_logger& logger) : logger(logger) {}
* Sets the logging instance
*
* @param loh_h_ logging instance pointer
*/
void set_logger(srslte::log* log_h_) { log_h = log_h_; }
/** /**
* Sets the next base time in seconds, discarding previous changes. * Sets the next base time in seconds, discarding previous changes.
@ -50,10 +45,7 @@ public:
// Update base in nta // Update base in nta
next_base_nta = static_cast<uint32_t>(roundf(next_base_sec / SRSLTE_LTE_TS)); next_base_nta = static_cast<uint32_t>(roundf(next_base_sec / SRSLTE_LTE_TS));
// Log information information if available logger.info("PHY: Set TA base: n_ta: %d, ta_usec: %.1f", next_base_nta, next_base_sec * 1e6f);
if (log_h) {
log_h->info("PHY: Set TA base: n_ta: %d, ta_usec: %.1f\n", next_base_nta, next_base_sec * 1e6f);
}
} }
/** /**
@ -71,14 +63,11 @@ public:
// Update base in nta // Update base in nta
next_base_nta = static_cast<uint32_t>(roundf(next_base_sec / SRSLTE_LTE_TS)); next_base_nta = static_cast<uint32_t>(roundf(next_base_sec / SRSLTE_LTE_TS));
// Log information information if available logger.info("PHY: Set TA: ta_delta_usec: %.1f, n_ta: %d, ta_usec: %.1f",
if (log_h) {
log_h->info("PHY: Set TA: ta_delta_usec: %.1f, n_ta: %d, ta_usec: %.1f\n",
ta_delta_sec * 1e6f, ta_delta_sec * 1e6f,
next_base_nta, next_base_nta,
next_base_sec * 1e6f); next_base_sec * 1e6f);
} }
}
/** /**
* Increments (delta) the next base time according to time alignment command from a Random Access Response (RAR). * Increments (delta) the next base time according to time alignment command from a Random Access Response (RAR).
@ -95,11 +84,7 @@ public:
// Update base in seconds // Update base in seconds
next_base_sec = static_cast<float>(next_base_nta) * SRSLTE_LTE_TS; next_base_sec = static_cast<float>(next_base_nta) * SRSLTE_LTE_TS;
// Log information information if available logger.info("PHY: Set TA RAR: ta_cmd: %d, n_ta: %d, ta_usec: %.1f", ta_cmd, next_base_nta, next_base_sec * 1e6f);
if (log_h) {
log_h->info(
"PHY: Set TA RAR: ta_cmd: %d, n_ta: %d, ta_usec: %.1f\n", ta_cmd, next_base_nta, next_base_sec * 1e6f);
}
} }
/** /**
@ -117,10 +102,7 @@ public:
// Update base in seconds // Update base in seconds
next_base_sec = static_cast<float>(next_base_nta) * SRSLTE_LTE_TS; next_base_sec = static_cast<float>(next_base_nta) * SRSLTE_LTE_TS;
// Log information information if available logger.info("PHY: Set TA: ta_cmd: %d, n_ta: %d, ta_usec: %.1f", ta_cmd, next_base_nta, next_base_sec * 1e6f);
if (log_h) {
log_h->info("PHY: Set TA: ta_cmd: %d, n_ta: %d, ta_usec: %.1f\n", ta_cmd, next_base_nta, next_base_sec * 1e6f);
}
} }
/** /**

4
srsue/hdr/stack/mac/demux.h
Unescape Escape View File

@ -18,6 +18,7 @@
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/mac/pdu.h" #include "srslte/mac/pdu.h"
#include "srslte/mac/pdu_queue.h" #include "srslte/mac/pdu_queue.h"
#include "srslte/srslog/srslog.h"
/* Logical Channel Demultiplexing and MAC CE dissassemble */ /* Logical Channel Demultiplexing and MAC CE dissassemble */
@ -33,7 +34,7 @@ public:
class demux : public srslte::pdu_queue::process_callback class demux : public srslte::pdu_queue::process_callback
{ {
public: public:
demux(srslte::log_ref log_h_); demux(srslte::log_ref log_h_, srslog::basic_logger& logger);
void init(phy_interface_mac_common* phy_h_, void init(phy_interface_mac_common* phy_h_,
rlc_interface_mac* rlc, rlc_interface_mac* rlc,
mac_interface_demux* mac, mac_interface_demux* mac,
@ -62,6 +63,7 @@ private:
// args // args
srslte::log_ref log_h; srslte::log_ref log_h;
srslog::basic_logger& logger;
phy_interface_mac_common* phy_h = nullptr; phy_interface_mac_common* phy_h = nullptr;
rlc_interface_mac* rlc = nullptr; rlc_interface_mac* rlc = nullptr;
mac_interface_demux* mac = nullptr; mac_interface_demux* mac = nullptr;

6
srsue/hdr/stack/mac/dl_harq.h
Unescape Escape View File

@ -30,7 +30,7 @@ class dl_harq_entity
public: public:
dl_harq_entity(uint8_t cc_idx_); dl_harq_entity(uint8_t cc_idx_);
bool init(srslte::log_ref log_h, mac_interface_rrc::ue_rnti_t* rntis, demux* demux_unit); bool init(mac_interface_rrc::ue_rnti_t* rntis, demux* demux_unit);
void reset(); void reset();
void start_pcap(srslte::mac_pcap* pcap_); void start_pcap(srslte::mac_pcap* pcap_);
@ -80,7 +80,7 @@ private:
bool is_initiated; bool is_initiated;
dl_harq_entity* harq_entity; dl_harq_entity* harq_entity;
srslte::log_ref log_h; srslog::basic_logger& logger;
bool is_first_tb; bool is_first_tb;
bool is_new_transmission; bool is_new_transmission;
@ -110,7 +110,7 @@ private:
std::vector<dl_harq_process> proc; std::vector<dl_harq_process> proc;
dl_harq_process bcch_proc; dl_harq_process bcch_proc;
demux* demux_unit = nullptr; demux* demux_unit = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
srslte::mac_pcap* pcap = nullptr; srslte::mac_pcap* pcap = nullptr;
mac_interface_rrc::ue_rnti_t* rntis = nullptr; mac_interface_rrc::ue_rnti_t* rntis = nullptr;
uint16_t last_temporal_crnti = 0; uint16_t last_temporal_crnti = 0;

2
srsue/hdr/stack/mac/mac.h
Unescape Escape View File

@ -27,6 +27,7 @@
#include "srslte/common/timers.h" #include "srslte/common/timers.h"
#include "srslte/common/tti_sync_cv.h" #include "srslte/common/tti_sync_cv.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include "ul_harq.h" #include "ul_harq.h"
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
@ -108,6 +109,7 @@ private:
rrc_interface_mac* rrc_h = nullptr; rrc_interface_mac* rrc_h = nullptr;
srslte::ext_task_sched_handle task_sched; srslte::ext_task_sched_handle task_sched;
srslte::log_ref log_h; srslte::log_ref log_h;
srslog::basic_logger& logger;
mac_interface_phy_lte::mac_phy_cfg_mbsfn_t phy_mbsfn_cfg = {}; mac_interface_phy_lte::mac_phy_cfg_mbsfn_t phy_mbsfn_cfg = {};
// RNTI search window scheduling // RNTI search window scheduling

4
srsue/hdr/stack/mac/mux.h
Unescape Escape View File

@ -24,6 +24,7 @@
#include "srslte/interfaces/mac_interface_types.h" #include "srslte/interfaces/mac_interface_types.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/mac/pdu.h" #include "srslte/mac/pdu.h"
#include "srslte/srslog/srslog.h"
#include <mutex> #include <mutex>
namespace srsue { namespace srsue {
@ -31,7 +32,7 @@ namespace srsue {
class mux class mux
{ {
public: public:
mux(srslte::log_ref log_); mux(srslte::log_ref log_, srslog::basic_logger& logger);
~mux(){}; ~mux(){};
void reset(); void reset();
void init(rlc_interface_mac* rlc, bsr_interface_mux* bsr_procedure, phr_proc* phr_procedure_); void init(rlc_interface_mac* rlc, bsr_interface_mux* bsr_procedure, phr_proc* phr_procedure_);
@ -70,6 +71,7 @@ private:
std::mutex mutex; std::mutex mutex;
srslte::log_ref log_h; srslte::log_ref log_h;
srslog::basic_logger& logger;
rlc_interface_mac* rlc = nullptr; rlc_interface_mac* rlc = nullptr;
bsr_interface_mux* bsr_procedure = nullptr; bsr_interface_mux* bsr_procedure = nullptr;
phr_proc* phr_procedure = nullptr; phr_proc* phr_procedure = nullptr;

8
srsue/hdr/stack/mac/proc_bsr.h
Unescape Escape View File

@ -20,6 +20,7 @@
#include "srslte/common/logmap.h" #include "srslte/common/logmap.h"
#include "srslte/common/timers.h" #include "srslte/common/timers.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
/* Buffer status report procedure */ /* Buffer status report procedure */
@ -49,9 +50,8 @@ public:
class bsr_proc : public srslte::timer_callback, public bsr_interface_mux class bsr_proc : public srslte::timer_callback, public bsr_interface_mux
{ {
public: public:
bsr_proc(); explicit bsr_proc(srslog::basic_logger& logger) : logger(logger) {}
void void init(sr_proc* sr_proc, rlc_interface_mac* rlc, srslte::ext_task_sched_handle* task_sched_);
init(sr_proc* sr_proc, rlc_interface_mac* rlc, srslte::log_ref log_h, srslte::ext_task_sched_handle* task_sched_);
void step(uint32_t tti); void step(uint32_t tti);
void reset(); void reset();
void set_config(srslte::bsr_cfg_t& bsr_cfg); void set_config(srslte::bsr_cfg_t& bsr_cfg);
@ -69,7 +69,7 @@ private:
std::mutex mutex; std::mutex mutex;
srslte::ext_task_sched_handle* task_sched = nullptr; srslte::ext_task_sched_handle* task_sched = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
rlc_interface_mac* rlc = nullptr; rlc_interface_mac* rlc = nullptr;
sr_proc* sr = nullptr; sr_proc* sr = nullptr;

7
srsue/hdr/stack/mac/proc_phr.h
Unescape Escape View File

@ -16,6 +16,7 @@
#include "srslte/common/logmap.h" #include "srslte/common/logmap.h"
#include "srslte/common/timers.h" #include "srslte/common/timers.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include <stdint.h> #include <stdint.h>
/* Power headroom report procedure */ /* Power headroom report procedure */
@ -25,8 +26,8 @@ namespace srsue {
class phr_proc : public srslte::timer_callback class phr_proc : public srslte::timer_callback
{ {
public: public:
phr_proc(); explicit phr_proc(srslog::basic_logger& logger);
void init(phy_interface_mac_lte* phy_h, srslte::log_ref log_h_, srslte::ext_task_sched_handle* task_sched_); void init(phy_interface_mac_lte* phy_h, srslte::ext_task_sched_handle* task_sched_);
void set_config(srslte::phr_cfg_t& cfg); void set_config(srslte::phr_cfg_t& cfg);
void step(); void step();
void reset(); void reset();
@ -40,7 +41,7 @@ public:
private: private:
bool pathloss_changed(); bool pathloss_changed();
srslte::log_ref log_h; srslog::basic_logger& logger;
phy_interface_mac_lte* phy_h; phy_interface_mac_lte* phy_h;
srslte::ext_task_sched_handle* task_sched; srslte::ext_task_sched_handle* task_sched;
srslte::phr_cfg_t phr_cfg; srslte::phr_cfg_t phr_cfg;

5
srsue/hdr/stack/mac/proc_ra.h
Unescape Escape View File

@ -31,13 +31,12 @@ namespace srsue {
class ra_proc : public srslte::timer_callback class ra_proc : public srslte::timer_callback
{ {
public: public:
ra_proc() : rar_pdu_msg(20){}; explicit ra_proc(srslog::basic_logger& logger) : rar_pdu_msg(20), logger(logger) {}
~ra_proc(); ~ra_proc();
void init(phy_interface_mac_lte* phy_h, void init(phy_interface_mac_lte* phy_h,
rrc_interface_mac* rrc_, rrc_interface_mac* rrc_,
srslte::log_ref log_h,
mac_interface_rrc::ue_rnti_t* rntis, mac_interface_rrc::ue_rnti_t* rntis,
srslte::timer_handler::unique_timer* time_alignment_timer_, srslte::timer_handler::unique_timer* time_alignment_timer_,
mux* mux_unit, mux* mux_unit,
@ -137,7 +136,7 @@ private:
void read_params(); void read_params();
phy_interface_mac_lte* phy_h = nullptr; phy_interface_mac_lte* phy_h = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
mux* mux_unit = nullptr; mux* mux_unit = nullptr;
srslte::mac_pcap* pcap = nullptr; srslte::mac_pcap* pcap = nullptr;
rrc_interface_mac* rrc = nullptr; rrc_interface_mac* rrc = nullptr;

7
srsue/hdr/stack/mac/proc_sr.h
Unescape Escape View File

@ -15,6 +15,7 @@
#include "srslte/common/logmap.h" #include "srslte/common/logmap.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include <stdint.h> #include <stdint.h>
/* Scheduling Request procedure as defined in 5.4.4 of 36.321 */ /* Scheduling Request procedure as defined in 5.4.4 of 36.321 */
@ -27,8 +28,8 @@ class ra_proc;
class sr_proc class sr_proc
{ {
public: public:
sr_proc(); explicit sr_proc(srslog::basic_logger& logger);
void init(ra_proc* ra, phy_interface_mac_lte* phy_h, rrc_interface_mac* rrc, srslte::log_ref log_h); void init(ra_proc* ra, phy_interface_mac_lte* phy_h, rrc_interface_mac* rrc);
void step(uint32_t tti); void step(uint32_t tti);
void set_config(srslte::sr_cfg_t& cfg); void set_config(srslte::sr_cfg_t& cfg);
void reset(); void reset();
@ -45,7 +46,7 @@ private:
ra_proc* ra; ra_proc* ra;
rrc_interface_mac* rrc; rrc_interface_mac* rrc;
phy_interface_mac_lte* phy_h; phy_interface_mac_lte* phy_h;
srslte::log_ref log_h; srslog::basic_logger& logger;
bool initiated; bool initiated;
}; };

6
srsue/hdr/stack/mac/ul_harq.h
Unescape Escape View File

@ -31,7 +31,7 @@ class ul_harq_entity
public: public:
ul_harq_entity(const uint8_t cc_idx_); ul_harq_entity(const uint8_t cc_idx_);
bool init(srslte::log_ref log_h_, mac_interface_rrc_common::ue_rnti_t* rntis_, ra_proc* ra_proc_h_, mux* mux_unit_); bool init(mac_interface_rrc_common::ue_rnti_t* rntis_, ra_proc* ra_proc_h_, mux* mux_unit_);
void reset(); void reset();
void reset_ndi(); void reset_ndi();
@ -77,7 +77,7 @@ private:
bool is_grant_configured; bool is_grant_configured;
bool is_initiated; bool is_initiated;
srslte::log_ref log_h; srslog::basic_logger& logger;
ul_harq_entity* harq_entity; ul_harq_entity* harq_entity;
srslte_softbuffer_tx_t softbuffer; srslte_softbuffer_tx_t softbuffer;
@ -96,7 +96,7 @@ private:
mux* mux_unit = nullptr; mux* mux_unit = nullptr;
srslte::mac_pcap* pcap = nullptr; srslte::mac_pcap* pcap = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
mac_interface_rrc_common::ue_rnti_t* rntis = nullptr; mac_interface_rrc_common::ue_rnti_t* rntis = nullptr;
srslte::ul_harq_cfg_t harq_cfg = {}; srslte::ul_harq_cfg_t harq_cfg = {};

3
srsue/hdr/stack/rrc/rrc.h
Unescape Escape View File

@ -25,6 +25,7 @@
#include "srslte/common/security.h" #include "srslte/common/security.h"
#include "srslte/common/stack_procedure.h" #include "srslte/common/stack_procedure.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include <map> #include <map>
#include <math.h> #include <math.h>
@ -175,7 +176,7 @@ private:
stack_interface_rrc* stack = nullptr; stack_interface_rrc* stack = nullptr;
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;
srslte::byte_buffer_pool* pool = nullptr; srslte::byte_buffer_pool* pool = nullptr;
srslte::log_ref rrc_log; srslog::basic_logger& logger;
phy_interface_rrc_lte* phy = nullptr; phy_interface_rrc_lte* phy = nullptr;
mac_interface_rrc* mac = nullptr; mac_interface_rrc* mac = nullptr;
rlc_interface_rrc* rlc = nullptr; rlc_interface_rrc* rlc = nullptr;

3
srsue/hdr/stack/rrc/rrc_cell.h
Unescape Escape View File

@ -20,6 +20,7 @@
#include "srslte/asn1/rrc_nr_utils.h" #include "srslte/asn1/rrc_nr_utils.h"
#endif #endif
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
namespace srsue { namespace srsue {
@ -268,7 +269,7 @@ private:
bool add_neighbour_cell_unsorted(unique_meas_cell cell); bool add_neighbour_cell_unsorted(unique_meas_cell cell);
// args // args
srslte::log_ref log_h{"RRC"}; srslog::basic_logger& logger = srslog::fetch_basic_logger("RRC");
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;
unique_meas_cell serv_cell; unique_meas_cell serv_cell;

15
srsue/hdr/stack/rrc/rrc_meas.h
Unescape Escape View File

@ -35,7 +35,7 @@ meas_obj_to_add_mod_s* find_meas_obj_map(std::map<uint32_t, meas_obj_to_add_mod_
class rrc::rrc_meas class rrc::rrc_meas
{ {
public: public:
rrc_meas() : meas_cfg(&meas_report_list), meas_report_list(&meas_cfg), log_h(srslte::logmap::get("RRC")) {} rrc_meas() : meas_cfg(&meas_report_list), meas_report_list(&meas_cfg), logger(srslog::fetch_basic_logger("RRC")) {}
void init(rrc* rrc_ptr); void init(rrc* rrc_ptr);
void reset(); void reset();
bool parse_meas_config(const rrc_conn_recfg_r8_ies_s* meas_config, bool is_ho_reest = false, uint32_t src_earfcn = 0); bool parse_meas_config(const rrc_conn_recfg_r8_ies_s* meas_config, bool is_ho_reest = false, uint32_t src_earfcn = 0);
@ -58,7 +58,7 @@ private:
class var_meas_report_list class var_meas_report_list
{ {
public: public:
var_meas_report_list(var_meas_cfg* meas_cfg_) : meas_cfg(meas_cfg_), log_h(srslte::logmap::get("RRC")) {} var_meas_report_list(var_meas_cfg* meas_cfg_) : meas_cfg(meas_cfg_), logger(srslog::fetch_basic_logger("RRC")) {}
void init(rrc* rrc); void init(rrc* rrc);
void generate_report(const uint32_t measId); void generate_report(const uint32_t measId);
void remove_all_varmeas_reports(); void remove_all_varmeas_reports();
@ -94,7 +94,7 @@ private:
srslte::timer_handler::unique_timer periodic_timer = {}; srslte::timer_handler::unique_timer periodic_timer = {};
}; };
var_meas_cfg* meas_cfg = nullptr; var_meas_cfg* meas_cfg = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
rrc* rrc_ptr = nullptr; rrc* rrc_ptr = nullptr;
std::map<uint32_t, var_meas_report> varMeasReportList; std::map<uint32_t, var_meas_report> varMeasReportList;
}; };
@ -104,7 +104,9 @@ private:
class var_meas_cfg class var_meas_cfg
{ {
public: public:
var_meas_cfg(var_meas_report_list* meas_report_) : meas_report(meas_report_), log_h(srslte::logmap::get("RRC")) {} var_meas_cfg(var_meas_report_list* meas_report_) :
meas_report(meas_report_), logger(srslog::fetch_basic_logger("RRC"))
{}
void init(rrc* rrc); void init(rrc* rrc);
void reset(); void reset();
phy_quant_t get_filter_a(); phy_quant_t get_filter_a();
@ -114,6 +116,7 @@ private:
bool parse_meas_config(const meas_cfg_s* meas_config, bool is_ho_reest, uint32_t src_earfcn); bool parse_meas_config(const meas_cfg_s* meas_config, bool is_ho_reest, uint32_t src_earfcn);
void eval_triggers(); void eval_triggers();
void report_triggers(); void report_triggers();
private: private:
void remove_varmeas_report(const uint32_t meas_id); void remove_varmeas_report(const uint32_t meas_id);
@ -185,14 +188,14 @@ private:
#endif #endif
var_meas_report_list* meas_report = nullptr; var_meas_report_list* meas_report = nullptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
rrc* rrc_ptr = nullptr; rrc* rrc_ptr = nullptr;
}; };
std::mutex meas_cfg_mutex; std::mutex meas_cfg_mutex;
var_meas_cfg meas_cfg; var_meas_cfg meas_cfg;
var_meas_report_list meas_report_list; var_meas_report_list meas_report_list;
srslte::log_ref log_h; srslog::basic_logger& logger;
rrc* rrc_ptr = nullptr; rrc* rrc_ptr = nullptr;
// Static functions // Static functions

11
srsue/hdr/stack/rrc/rrc_procedures.h
Unescape Escape View File

@ -12,6 +12,7 @@
#include "phy_controller.h" #include "phy_controller.h"
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "srslte/srslog/srslog.h"
#include "srsue/hdr/stack/rrc/rrc.h" #include "srsue/hdr/stack/rrc/rrc.h"
#include <map> #include <map>
#include <string> #include <string>
@ -78,7 +79,7 @@ private:
// conts // conts
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
// state // state
srslte::timer_handler::unique_timer si_acq_timeout, si_acq_retry_timer; srslte::timer_handler::unique_timer si_acq_timeout, si_acq_retry_timer;
@ -96,7 +97,7 @@ public:
private: private:
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
srslte::proc_outcome_t launch_sib_acquire(); srslte::proc_outcome_t launch_sib_acquire();
@ -160,7 +161,7 @@ public:
private: private:
// consts // consts
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
// state variables // state variables
found_plmn_t found_plmns[MAX_FOUND_PLMNS]; found_plmn_t found_plmns[MAX_FOUND_PLMNS];
@ -181,7 +182,7 @@ public:
private: private:
// const // const
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
// args // args
srslte::establishment_cause_t cause; srslte::establishment_cause_t cause;
srslte::unique_byte_buffer_t dedicated_info_nas; srslte::unique_byte_buffer_t dedicated_info_nas;
@ -226,7 +227,7 @@ public:
private: private:
// args // args
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log_ref log_h; srslog::basic_logger& logger;
asn1::rrc::paging_s paging; asn1::rrc::paging_s paging;
// vars // vars

10
srsue/hdr/stack/ue_stack_lte.h
Unescape Escape View File

@ -51,7 +51,7 @@ class ue_stack_lte final : public ue_stack_base,
public srslte::thread public srslte::thread
{ {
public: public:
ue_stack_lte(); explicit ue_stack_lte(srslog::sink& log_sink);
~ue_stack_lte(); ~ue_stack_lte();
std::string get_type() final; std::string get_type() final;
@ -139,7 +139,6 @@ private:
// UE stack logging // UE stack logging
srslte::logger* logger = nullptr; srslte::logger* logger = nullptr;
srslte::log_ref stack_log{"STCK"}; ///< our own log filter
srslte::log_ref mac_log{"MAC"}; srslte::log_ref mac_log{"MAC"};
srslte::log_ref rlc_log{"RLC"}; srslte::log_ref rlc_log{"RLC"};
srslte::log_ref pdcp_log{"PDCP"}; srslte::log_ref pdcp_log{"PDCP"};
@ -147,6 +146,13 @@ private:
srslte::log_ref usim_log{"USIM"}; srslte::log_ref usim_log{"USIM"};
srslte::log_ref nas_log{"NAS"}; srslte::log_ref nas_log{"NAS"};
srslte::log_ref pool_log{"POOL"}; srslte::log_ref pool_log{"POOL"};
srslog::basic_logger& stack_logger;
srslog::basic_logger& mac_logger;
srslog::basic_logger& rlc_logger;
srslog::basic_logger& pdcp_logger;
srslog::basic_logger& rrc_logger;
srslog::basic_logger& usim_logger;
srslog::basic_logger& nas_logger;
// RAT-specific interfaces // RAT-specific interfaces
phy_interface_stack_lte* phy = nullptr; phy_interface_stack_lte* phy = nullptr;

5
srsue/hdr/stack/upper/gw.h
Unescape Escape View File

@ -21,6 +21,7 @@
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/threads.h" #include "srslte/common/threads.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include "tft_packet_filter.h" #include "tft_packet_filter.h"
#include <net/if.h> #include <net/if.h>
@ -64,7 +65,7 @@ private:
stack_interface_gw* stack = nullptr; stack_interface_gw* stack = nullptr;
srslte::byte_buffer_pool* pool = nullptr; srslte::byte_buffer_pool* pool = nullptr;
srslte::logger* logger = nullptr; srslte::logger* old_logger = nullptr;
gw_args_t args = {}; gw_args_t args = {};
@ -77,7 +78,7 @@ private:
bool if_up = false; bool if_up = false;
uint32_t default_lcid = 0; uint32_t default_lcid = 0;
srslte::log_filter log; srslog::basic_logger& logger;
uint32_t current_ip_addr = 0; uint32_t current_ip_addr = 0;
uint8_t current_if_id[8]; uint8_t current_if_id[8];

3
srsue/hdr/stack/upper/nas.h
Unescape Escape View File

@ -22,6 +22,7 @@
#include "srslte/common/stack_procedure.h" #include "srslte/common/stack_procedure.h"
#include "srslte/common/task_scheduler.h" #include "srslte/common/task_scheduler.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include "srsue/hdr/stack/upper/nas_config.h" #include "srsue/hdr/stack/upper/nas_config.h"
#include "srsue/hdr/stack/upper/nas_emm_state.h" #include "srsue/hdr/stack/upper/nas_emm_state.h"
#include "srsue/hdr/stack/upper/nas_metrics.h" #include "srsue/hdr/stack/upper/nas_metrics.h"
@ -73,7 +74,7 @@ public:
private: private:
srslte::byte_buffer_pool* pool = nullptr; srslte::byte_buffer_pool* pool = nullptr;
srslte::log_ref nas_log; srslog::basic_logger& logger;
rrc_interface_nas* rrc = nullptr; rrc_interface_nas* rrc = nullptr;
usim_interface_nas* usim = nullptr; usim_interface_nas* usim = nullptr;
gw_interface_nas* gw = nullptr; gw_interface_nas* gw = nullptr;

3
srsue/hdr/stack/upper/nas_emm_state.h
Unescape Escape View File

@ -14,6 +14,7 @@
#define SRSUE_NAS_EMM_STATE_H #define SRSUE_NAS_EMM_STATE_H
#include "srslte/common/logmap.h" #include "srslte/common/logmap.h"
#include "srslte/srslog/srslog.h"
#include <atomic> #include <atomic>
#include <string> #include <string>
@ -80,7 +81,7 @@ private:
std::atomic<state_t> state{state_t::null}; // The GW might require to know the NAS state from another thread std::atomic<state_t> state{state_t::null}; // The GW might require to know the NAS state from another thread
deregistered_substate_t deregistered_substate = deregistered_substate_t::null; deregistered_substate_t deregistered_substate = deregistered_substate_t::null;
registered_substate_t registered_substate = registered_substate_t::null; registered_substate_t registered_substate = registered_substate_t::null;
srslte::log_ref nas_log{"NAS"}; srslog::basic_logger& logger = srslog::fetch_basic_logger("NAS");
}; };
const char* emm_state_text(emm_state_t::state_t type); const char* emm_state_text(emm_state_t::state_t type);

8
srsue/hdr/stack/upper/pcsc_usim.h
Unescape Escape View File

@ -33,7 +33,7 @@ static inline uint16_t to_uint16(const uint8_t* a)
class pcsc_usim : public usim_base class pcsc_usim : public usim_base
{ {
public: public:
pcsc_usim(srslte::log* log_); explicit pcsc_usim(srslog::basic_logger& logger);
~pcsc_usim(); ~pcsc_usim();
int init(usim_args_t* args); int init(usim_args_t* args);
void stop(); void stop();
@ -57,10 +57,10 @@ private:
class scard class scard
{ {
public: public:
scard() : log(NULL){}; explicit scard(srslog::basic_logger& logger) : logger(logger) {}
~scard(){}; ~scard(){};
int init(usim_args_t* args, srslte::log* log_); int init(usim_args_t* args);
void deinit(); void deinit();
int select_file(unsigned short file_id, unsigned char* buf, size_t* buf_len); int select_file(unsigned short file_id, unsigned char* buf, size_t* buf_len);
@ -176,7 +176,7 @@ private:
long unsigned scard_protocol; long unsigned scard_protocol;
sim_types_t sim_type; sim_types_t sim_type;
bool pin1_needed; bool pin1_needed;
srslte::log* log; srslog::basic_logger& logger;
}; };
scard sc; scard sc;

9
srsue/hdr/stack/upper/tft_packet_filter.h
Unescape Escape View File

@ -17,6 +17,7 @@
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/srslog/srslog.h"
#include <mutex> #include <mutex>
namespace srsue { namespace srsue {
@ -62,7 +63,7 @@ public:
tft_packet_filter_t(uint8_t eps_bearer_id_, tft_packet_filter_t(uint8_t eps_bearer_id_,
uint8_t lcid_, uint8_t lcid_,
const LIBLTE_MME_PACKET_FILTER_STRUCT& tft_, const LIBLTE_MME_PACKET_FILTER_STRUCT& tft_,
srslte::log* log_); srslog::basic_logger& logger);
bool match(const srslte::unique_byte_buffer_t& pdu); bool match(const srslte::unique_byte_buffer_t& pdu);
bool filter_contains(uint16_t filtertype); bool filter_contains(uint16_t filtertype);
@ -91,7 +92,7 @@ public:
uint8_t type_of_service_mask = {}; uint8_t type_of_service_mask = {};
uint8_t flow_label[3] = {}; uint8_t flow_label[3] = {};
srslte::log* log; srslog::basic_logger& logger;
bool match_ip(const srslte::unique_byte_buffer_t& pdu); bool match_ip(const srslte::unique_byte_buffer_t& pdu);
bool match_protocol(const srslte::unique_byte_buffer_t& pdu); bool match_protocol(const srslte::unique_byte_buffer_t& pdu);
@ -106,7 +107,7 @@ public:
class tft_pdu_matcher class tft_pdu_matcher
{ {
public: public:
tft_pdu_matcher(srslte::log_filter* log_) : log(log_){}; explicit tft_pdu_matcher(srslog::basic_logger& logger) : logger(logger) {}
~tft_pdu_matcher(){}; ~tft_pdu_matcher(){};
void set_default_lcid(const uint8_t lcid); void set_default_lcid(const uint8_t lcid);
@ -116,7 +117,7 @@ public:
const LIBLTE_MME_TRAFFIC_FLOW_TEMPLATE_STRUCT* tft); const LIBLTE_MME_TRAFFIC_FLOW_TEMPLATE_STRUCT* tft);
private: private:
srslte::log_filter* log = nullptr; srslog::basic_logger& logger;
uint8_t default_lcid = 0; uint8_t default_lcid = 0;
std::mutex tft_mutex; std::mutex tft_mutex;
typedef std::map<uint16_t, tft_packet_filter_t> tft_filter_map_t; typedef std::map<uint16_t, tft_packet_filter_t> tft_filter_map_t;

2
srsue/hdr/stack/upper/usim.h
Unescape Escape View File

@ -25,7 +25,7 @@ namespace srsue {
class usim : public usim_base class usim : public usim_base
{ {
public: public:
usim(srslte::log* log_); explicit usim(srslog::basic_logger& logger);
int init(usim_args_t* args); int init(usim_args_t* args);
void stop(); void stop();

7
srsue/hdr/stack/upper/usim_base.h
Unescape Escape View File

@ -17,6 +17,7 @@
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "srslte/common/security.h" #include "srslte/common/security.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include <string> #include <string>
namespace srsue { namespace srsue {
@ -57,9 +58,9 @@ public:
class usim_base : public usim_interface_nas, public usim_interface_rrc, public usim_interface_rrc_nr class usim_base : public usim_interface_nas, public usim_interface_rrc, public usim_interface_rrc_nr
{ {
public: public:
usim_base(srslte::log* log_); explicit usim_base(srslog::basic_logger& logger);
virtual ~usim_base(); virtual ~usim_base();
static std::unique_ptr<usim_base> get_instance(usim_args_t* args, srslte::log* log_); static std::unique_ptr<usim_base> get_instance(usim_args_t* args, srslog::basic_logger& logger);
virtual int init(usim_args_t* args) = 0; virtual int init(usim_args_t* args) = 0;
virtual void stop() = 0; virtual void stop() = 0;
@ -104,7 +105,7 @@ protected:
bool initiated = false; bool initiated = false;
// Logging // Logging
srslte::log* log = nullptr; srslog::basic_logger& logger;
// User data // User data
// 3GPP 33.102 v10.0.0 Annex H // 3GPP 33.102 v10.0.0 Annex H

8
srsue/hdr/ue.h
Unescape Escape View File

@ -28,6 +28,7 @@
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/srslog/srslog.h"
#include "stack/ue_stack_base.h" #include "stack/ue_stack_base.h"
#include "ue_metrics_interface.h" #include "ue_metrics_interface.h"
@ -83,7 +84,7 @@ typedef struct {
class ue : public ue_metrics_interface class ue : public ue_metrics_interface
{ {
public: public:
ue(); ue(srslog::sink& log_sink);
~ue(); ~ue();
int init(const all_args_t& args_, srslte::logger* logger_); int init(const all_args_t& args_, srslte::logger* logger_);
@ -105,8 +106,9 @@ private:
std::unique_ptr<gw> gw_inst; std::unique_ptr<gw> gw_inst;
// Generic logger members // Generic logger members
srslte::logger* logger = nullptr; srslte::logger* old_logger = nullptr;
srslte::log_filter log; // Own logger for UE srslog::sink& log_sink;
srslog::basic_logger& logger;
all_args_t args; all_args_t args;
srslte::byte_buffer_pool* pool = nullptr; srslte::byte_buffer_pool* pool = nullptr;

3
srsue/src/main.cc
Unescape Escape View File

@ -641,6 +641,7 @@ int main(int argc, char* argv[])
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
srslte::srslog_wrapper log_wrapper(*chan); srslte::srslog_wrapper log_wrapper(*chan);
srslog::set_default_sink(*log_sink);
// Start the log backend. // Start the log backend.
srslog::init(); srslog::init();
@ -651,7 +652,7 @@ int main(int argc, char* argv[])
srslte::check_scaling_governor(args.rf.device_name); srslte::check_scaling_governor(args.rf.device_name);
// Create UE instance // Create UE instance
srsue::ue ue; srsue::ue ue(*log_sink);
if (ue.init(args, &log_wrapper)) { if (ue.init(args, &log_wrapper)) {
ue.stop(); ue.stop();
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;

90
srsue/src/phy/lte/cc_worker.cc
Unescape Escape View File

@ -16,16 +16,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
#define CURRENT_TTI (sf_cfg_dl.tti) #define CURRENT_TTI (sf_cfg_dl.tti)
#define CURRENT_SFIDX (sf_cfg_dl.tti % 10) #define CURRENT_SFIDX (sf_cfg_dl.tti % 10)
@ -40,34 +40,34 @@ namespace lte {
* *
*/ */
cc_worker::cc_worker(uint32_t cc_idx_, uint32_t max_prb, srsue::phy_common* phy_, srslte::log* log_h_) cc_worker::cc_worker(uint32_t cc_idx_, uint32_t max_prb, srsue::phy_common* phy_, srslog::basic_logger& logger) :
logger(logger)
{ {
cc_idx = cc_idx_; cc_idx = cc_idx_;
phy = phy_; phy = phy_;
log_h = log_h_;
signal_buffer_max_samples = 3 * SRSLTE_SF_LEN_PRB(max_prb); signal_buffer_max_samples = 3 * SRSLTE_SF_LEN_PRB(max_prb);
for (uint32_t i = 0; i < phy->args->nof_rx_ant; i++) { for (uint32_t i = 0; i < phy->args->nof_rx_ant; i++) {
signal_buffer_rx[i] = srslte_vec_cf_malloc(signal_buffer_max_samples); signal_buffer_rx[i] = srslte_vec_cf_malloc(signal_buffer_max_samples);
if (!signal_buffer_rx[i]) { if (!signal_buffer_rx[i]) {
Error("Allocating memory\n"); Error("Allocating memory");
return; return;
} }
signal_buffer_tx[i] = srslte_vec_cf_malloc(signal_buffer_max_samples); signal_buffer_tx[i] = srslte_vec_cf_malloc(signal_buffer_max_samples);
if (!signal_buffer_tx[i]) { if (!signal_buffer_tx[i]) {
Error("Allocating memory\n"); Error("Allocating memory");
return; return;
} }
} }
if (srslte_ue_dl_init(&ue_dl, signal_buffer_rx, max_prb, phy->args->nof_rx_ant)) { if (srslte_ue_dl_init(&ue_dl, signal_buffer_rx, max_prb, phy->args->nof_rx_ant)) {
Error("Initiating UE DL\n"); Error("Initiating UE DL");
return; return;
} }
if (srslte_ue_ul_init(&ue_ul, signal_buffer_tx[0], max_prb)) { if (srslte_ue_ul_init(&ue_ul, signal_buffer_tx[0], max_prb)) {
Error("Initiating UE UL\n"); Error("Initiating UE UL");
return; return;
} }
@ -125,16 +125,16 @@ bool cc_worker::set_cell_unlocked(srslte_cell_t cell_)
cell = cell_; cell = cell_;
if (srslte_ue_dl_set_cell(&ue_dl, cell)) { if (srslte_ue_dl_set_cell(&ue_dl, cell)) {
Error("Setting ue_dl cell\n"); Error("Setting ue_dl cell");
return false; return false;
} }
if (srslte_ue_dl_set_mbsfn_area_id(&ue_dl, 1)) { if (srslte_ue_dl_set_mbsfn_area_id(&ue_dl, 1)) {
Error("Setting mbsfn id\n"); Error("Setting mbsfn id");
} }
if (srslte_ue_ul_set_cell(&ue_ul, cell)) { if (srslte_ue_ul_set_cell(&ue_ul, cell)) {
Error("Initiating UE UL\n"); Error("Initiating UE UL");
return false; return false;
} }
@ -212,7 +212,7 @@ bool cc_worker::work_dl_regular()
bool found_dl_grant = false; bool found_dl_grant = false;
if (!cell_initiated) { if (!cell_initiated) {
log_h->warning("Trying to access cc_worker=%d while cell not initialized (DL)\n", cc_idx); logger.warning("Trying to access cc_worker=%d while cell not initialized (DL)", cc_idx);
return false; return false;
} }
@ -242,7 +242,7 @@ bool cc_worker::work_dl_regular()
/* Do FFT and extract PDCCH LLR, or quit if no actions are required in this subframe */ /* Do FFT and extract PDCCH LLR, or quit if no actions are required in this subframe */
if (srslte_ue_dl_decode_fft_estimate(&ue_dl, &sf_cfg_dl, &ue_dl_cfg) < 0) { if (srslte_ue_dl_decode_fft_estimate(&ue_dl, &sf_cfg_dl, &ue_dl_cfg) < 0) {
Error("Getting PDCCH FFT estimate\n"); Error("Getting PDCCH FFT estimate");
return false; return false;
} }
@ -267,7 +267,7 @@ bool cc_worker::work_dl_regular()
} }
// Generate PHY grant // Generate PHY grant
if (srslte_ue_dl_dci_to_pdsch_grant(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, &dci_dl, &ue_dl_cfg.cfg.pdsch.grant)) { if (srslte_ue_dl_dci_to_pdsch_grant(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, &dci_dl, &ue_dl_cfg.cfg.pdsch.grant)) {
Info("Converting DCI message to DL dci\n"); Info("Converting DCI message to DL dci");
return false; return false;
} }
@ -307,7 +307,7 @@ bool cc_worker::work_dl_mbsfn(srslte_mbsfn_cfg_t mbsfn_cfg)
mac_interface_phy_lte::tb_action_dl_t dl_action = {}; mac_interface_phy_lte::tb_action_dl_t dl_action = {};
if (!cell_initiated) { if (!cell_initiated) {
log_h->warning("Trying to access cc_worker=%d while cell not initialized (MBSFN)\n", cc_idx); logger.warning("Trying to access cc_worker=%d while cell not initialized (MBSFN)", cc_idx);
return false; return false;
} }
@ -323,7 +323,7 @@ bool cc_worker::work_dl_mbsfn(srslte_mbsfn_cfg_t mbsfn_cfg)
/* Do FFT and extract PDCCH LLR, or quit if no actions are required in this subframe */ /* Do FFT and extract PDCCH LLR, or quit if no actions are required in this subframe */
if (srslte_ue_dl_decode_fft_estimate(&ue_dl, &sf_cfg_dl, &ue_dl_cfg) < 0) { if (srslte_ue_dl_decode_fft_estimate(&ue_dl, &sf_cfg_dl, &ue_dl_cfg) < 0) {
Error("Getting PDCCH FFT estimate\n"); Error("Getting PDCCH FFT estimate");
return false; return false;
} }
@ -383,12 +383,12 @@ int cc_worker::decode_pdcch_dl()
/* Blind search first without cross scheduling then with it if enabled */ /* Blind search first without cross scheduling then with it if enabled */
for (int i = 0; i < (ue_dl_cfg.cfg.dci.cif_present ? 2 : 1) && !nof_grants; i++) { for (int i = 0; i < (ue_dl_cfg.cfg.dci.cif_present ? 2 : 1) && !nof_grants; i++) {
Debug("PDCCH looking for rnti=0x%x\n", dl_rnti); Debug("PDCCH looking for rnti=0x%x", dl_rnti);
ue_dl_cfg.cfg.dci.cif_enabled = i > 0; ue_dl_cfg.cfg.dci.cif_enabled = i > 0;
ue_dl_cfg.cfg.dci_common_ss = (cc_idx == 0); ue_dl_cfg.cfg.dci_common_ss = (cc_idx == 0);
nof_grants = srslte_ue_dl_find_dl_dci(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, dl_rnti, dci); nof_grants = srslte_ue_dl_find_dl_dci(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, dl_rnti, dci);
if (nof_grants < 0) { if (nof_grants < 0) {
Error("Looking for DL grants\n"); Error("Looking for DL grants");
return -1; return -1;
} }
} }
@ -403,10 +403,10 @@ int cc_worker::decode_pdcch_dl()
phy->set_dl_pending_grant(CURRENT_TTI, dci[k].cif_present ? dci[k].cif : cc_idx, cc_idx, &dci[k]); phy->set_dl_pending_grant(CURRENT_TTI, dci[k].cif_present ? dci[k].cif : cc_idx, cc_idx, &dci[k]);
// Logging // Logging
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
char str[512]; char str[512];
srslte_dci_dl_info(&dci[k], str, 512); srslte_dci_dl_info(&dci[k], str, 512);
log_h->info("PDCCH: cc=%d, %s, snr=%.1f dB\n", cc_idx, str, ue_dl.chest_res.snr_db); logger.info("PDCCH: cc=%d, %s, snr=%.1f dB", cc_idx, str, ue_dl.chest_res.snr_db);
} }
} }
} }
@ -444,7 +444,7 @@ int cc_worker::decode_pdsch(srslte_pdsch_ack_resource_t ack_resource,
// Run PDSCH decoder // Run PDSCH decoder
if (decode_enable) { if (decode_enable) {
if (srslte_ue_dl_decode_pdsch(&ue_dl, &sf_cfg_dl, &ue_dl_cfg.cfg.pdsch, pdsch_dec)) { if (srslte_ue_dl_decode_pdsch(&ue_dl, &sf_cfg_dl, &ue_dl_cfg.cfg.pdsch, pdsch_dec)) {
Error("ERROR: Decoding PDSCH\n"); Error("ERROR: Decoding PDSCH");
} }
} }
@ -480,10 +480,10 @@ int cc_worker::decode_pdsch(srslte_pdsch_ack_resource_t ack_resource,
phy->set_dl_metrics(cc_idx, dl_metrics); phy->set_dl_metrics(cc_idx, dl_metrics);
// Logging // Logging
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
char str[512]; char str[512];
srslte_pdsch_rx_info(&ue_dl_cfg.cfg.pdsch, pdsch_dec, str, 512); srslte_pdsch_rx_info(&ue_dl_cfg.cfg.pdsch, pdsch_dec, str, 512);
log_h->info("PDSCH: cc=%d, %s, snr=%.1f dB\n", cc_idx, str, ue_dl.chest_res.snr_db); logger.info("PDSCH: cc=%d, %s, snr=%.1f dB", cc_idx, str, ue_dl.chest_res.snr_db);
} }
} }
@ -503,7 +503,7 @@ int cc_worker::decode_pmch(mac_interface_phy_lte::tb_action_dl_t* action, srslte
srslte_softbuffer_rx_reset_tbs(pmch_cfg.pdsch_cfg.softbuffers.rx[0], pmch_cfg.pdsch_cfg.grant.tb[0].tbs); srslte_softbuffer_rx_reset_tbs(pmch_cfg.pdsch_cfg.softbuffers.rx[0], pmch_cfg.pdsch_cfg.grant.tb[0].tbs);
if (srslte_ue_dl_decode_pmch(&ue_dl, &sf_cfg_dl, &pmch_cfg, &pmch_dec)) { if (srslte_ue_dl_decode_pmch(&ue_dl, &sf_cfg_dl, &pmch_cfg, &pmch_dec)) {
Error("Decoding PMCH\n"); Error("Decoding PMCH");
return -1; return -1;
} }
@ -514,7 +514,7 @@ int cc_worker::decode_pmch(mac_interface_phy_lte::tb_action_dl_t* action, srslte
dl_metrics.turbo_iters = pmch_dec.avg_iterations_block / 2; dl_metrics.turbo_iters = pmch_dec.avg_iterations_block / 2;
phy->set_dl_metrics(cc_idx, dl_metrics); phy->set_dl_metrics(cc_idx, dl_metrics);
Info("PMCH: l_crb=%2d, tbs=%d, mcs=%d, crc=%s, snr=%.1f dB, n_iter=%.1f\n", Info("PMCH: l_crb=%2d, tbs=%d, mcs=%d, crc=%s, snr=%.1f dB, n_iter=%.1f",
pmch_cfg.pdsch_cfg.grant.nof_prb, pmch_cfg.pdsch_cfg.grant.nof_prb,
pmch_cfg.pdsch_cfg.grant.tb[0].tbs / 8, pmch_cfg.pdsch_cfg.grant.tb[0].tbs / 8,
pmch_cfg.pdsch_cfg.grant.tb[0].mcs_idx, pmch_cfg.pdsch_cfg.grant.tb[0].mcs_idx,
@ -527,7 +527,7 @@ int cc_worker::decode_pmch(mac_interface_phy_lte::tb_action_dl_t* action, srslte
} }
} else { } else {
Warning("Received dci for TBS=0\n"); Warning("Received dci for TBS=0");
} }
return 0; return 0;
} }
@ -543,10 +543,10 @@ void cc_worker::decode_phich()
phich_grant.I_phich = I_phich; phich_grant.I_phich = I_phich;
if (phy->get_ul_pending_ack(&sf_cfg_dl, cc_idx, &phich_grant, &dci_ul)) { if (phy->get_ul_pending_ack(&sf_cfg_dl, cc_idx, &phich_grant, &dci_ul)) {
if (srslte_ue_dl_decode_phich(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, &phich_grant, &phich_res)) { if (srslte_ue_dl_decode_phich(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, &phich_grant, &phich_res)) {
Error("Decoding PHICH\n"); Error("Decoding PHICH");
} }
phy->set_ul_received_ack(&sf_cfg_dl, cc_idx, phich_res.ack_value, I_phich, &dci_ul); phy->set_ul_received_ack(&sf_cfg_dl, cc_idx, phich_res.ack_value, I_phich, &dci_ul);
Info("PHICH: hi=%d, corr=%.1f, I_lowest=%d, n_dmrs=%d, I_phich=%d\n", Info("PHICH: hi=%d, corr=%.1f, I_lowest=%d, n_dmrs=%d, I_phich=%d",
phich_res.ack_value, phich_res.ack_value,
phich_res.distance, phich_res.distance,
phich_grant.n_prb_lowest, phich_grant.n_prb_lowest,
@ -578,7 +578,7 @@ bool cc_worker::work_ul(srslte_uci_data_t* uci_data)
uint32_t pid = 0; uint32_t pid = 0;
if (!cell_initiated) { if (!cell_initiated) {
log_h->warning("Trying to access cc_worker=%d while cell not initialized (UL)\n", cc_idx); logger.warning("Trying to access cc_worker=%d while cell not initialized (UL)", cc_idx);
return false; return false;
} }
@ -607,14 +607,14 @@ bool cc_worker::work_ul(srslte_uci_data_t* uci_data)
// Generate PHY grant // Generate PHY grant
if (srslte_ue_ul_dci_to_pusch_grant(&ue_ul, &sf_cfg_ul, &ue_ul_cfg, &dci_ul, &ue_ul_cfg.ul_cfg.pusch.grant)) { if (srslte_ue_ul_dci_to_pusch_grant(&ue_ul, &sf_cfg_ul, &ue_ul_cfg, &dci_ul, &ue_ul_cfg.ul_cfg.pusch.grant)) {
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
char str[128]; char str[128];
srslte_dci_ul_info(&dci_ul, str, sizeof(str)); srslte_dci_ul_info(&dci_ul, str, sizeof(str));
Info("Converting DCI message to UL grant %s\n", str); Info("Converting DCI message to UL grant %s", str);
} }
ul_grant_available = false; ul_grant_available = false;
} else if (ue_ul_cfg.ul_cfg.pusch.grant.tb.mod == SRSLTE_MOD_BPSK) { } else if (ue_ul_cfg.ul_cfg.pusch.grant.tb.mod == SRSLTE_MOD_BPSK) {
Error("UL retransmission without valid stored grant.\n"); Error("UL retransmission without valid stored grant.");
ul_grant_available = false; ul_grant_available = false;
} else { } else {
// Save TBS info for next retx // Save TBS info for next retx
@ -702,7 +702,7 @@ int cc_worker::decode_pdcch_ul()
ue_dl_cfg.cfg.dci_common_ss = (cc_idx == 0); ue_dl_cfg.cfg.dci_common_ss = (cc_idx == 0);
nof_grants = srslte_ue_dl_find_ul_dci(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, ul_rnti, dci); nof_grants = srslte_ue_dl_find_ul_dci(&ue_dl, &sf_cfg_dl, &ue_dl_cfg, ul_rnti, dci);
if (nof_grants < 0) { if (nof_grants < 0) {
Error("Looking for UL grants\n"); Error("Looking for UL grants");
return -1; return -1;
} }
} }
@ -717,10 +717,10 @@ int cc_worker::decode_pdcch_ul()
phy->set_ul_pending_grant(&sf_cfg_dl, cc_idx_grant, &dci[k]); phy->set_ul_pending_grant(&sf_cfg_dl, cc_idx_grant, &dci[k]);
// Logging // Logging
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
char str[512]; char str[512];
srslte_dci_ul_info(&dci[k], str, 512); srslte_dci_ul_info(&dci[k], str, 512);
log_h->info("PDCCH: cc=%d, %s, snr=%.1f dB\n", cc_idx_grant, str, ue_dl.chest_res.snr_db); logger.info("PDCCH: cc=%d, %s, snr=%.1f dB", cc_idx_grant, str, ue_dl.chest_res.snr_db);
} }
} }
} }
@ -761,7 +761,7 @@ bool cc_worker::encode_uplink(mac_interface_phy_lte::tb_action_ul_t* action, srs
// Encode signal // Encode signal
int ret = srslte_ue_ul_encode(&ue_ul, &sf_cfg_ul, &ue_ul_cfg, &data); int ret = srslte_ue_ul_encode(&ue_ul, &sf_cfg_ul, &ue_ul_cfg, &data);
if (ret < 0) { if (ret < 0) {
Error("Encoding UL cc=%d\n", cc_idx); Error("Encoding UL cc=%d", cc_idx);
} }
// Store metrics // Store metrics
@ -773,10 +773,10 @@ bool cc_worker::encode_uplink(mac_interface_phy_lte::tb_action_ul_t* action, srs
} }
// Logging // Logging
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
char str[512]; char str[512];
if (srslte_ue_ul_info(&ue_ul_cfg, &sf_cfg_ul, &data.uci, str, 512)) { if (srslte_ue_ul_info(&ue_ul_cfg, &sf_cfg_ul, &data.uci, str, 512)) {
log_h->info("%s\n", str); logger.info("%s", str);
} }
} }
@ -785,12 +785,12 @@ bool cc_worker::encode_uplink(mac_interface_phy_lte::tb_action_ul_t* action, srs
void cc_worker::set_uci_sr(srslte_uci_data_t* uci_data) void cc_worker::set_uci_sr(srslte_uci_data_t* uci_data)
{ {
Debug("set_uci_sr() query: sr_enabled=%d, last_tx_tti=%d\n", phy->sr_enabled, phy->sr_last_tx_tti); Debug("set_uci_sr() query: sr_enabled=%d, last_tx_tti=%d", phy->sr_enabled, phy->sr_last_tx_tti);
if (srslte_ue_ul_gen_sr(&ue_ul_cfg, &sf_cfg_ul, uci_data, phy->sr_enabled)) { if (srslte_ue_ul_gen_sr(&ue_ul_cfg, &sf_cfg_ul, uci_data, phy->sr_enabled)) {
if (phy->sr_enabled) { if (phy->sr_enabled) {
phy->sr_last_tx_tti = CURRENT_TTI_TX; phy->sr_last_tx_tti = CURRENT_TTI_TX;
phy->sr_enabled = false; phy->sr_enabled = false;
Debug("set_uci_sr() sending SR: sr_enabled=%d, last_tx_tti=%d\n", phy->sr_enabled, phy->sr_last_tx_tti); Debug("set_uci_sr() sending SR: sr_enabled=%d, last_tx_tti=%d", phy->sr_enabled, phy->sr_last_tx_tti);
} }
} }
} }
@ -824,7 +824,7 @@ void cc_worker::set_uci_aperiodic_cqi(srslte_uci_data_t* uci_data)
if (ue_dl_cfg.cfg.cqi_report.aperiodic_configured) { if (ue_dl_cfg.cfg.cqi_report.aperiodic_configured) {
srslte_ue_dl_gen_cqi_aperiodic(&ue_dl, &ue_dl_cfg, get_wideband_cqi(), uci_data); srslte_ue_dl_gen_cqi_aperiodic(&ue_dl, &ue_dl_cfg, get_wideband_cqi(), uci_data);
} else { } else {
Warning("Received CQI request but aperiodic mode is not configured\n"); Warning("Received CQI request but aperiodic mode is not configured");
} }
} }
@ -877,9 +877,9 @@ void cc_worker::set_config_unlocked(srslte::phy_cfg_t& phy_cfg)
// Update signals // Update signals
if (pregen_enabled) { if (pregen_enabled) {
Info("Pre-generating UL signals...\n"); Info("Pre-generating UL signals...");
srslte_ue_ul_pregen_signals(&ue_ul, &ue_ul_cfg); srslte_ue_ul_pregen_signals(&ue_ul, &ue_ul_cfg);
Info("Done pre-generating signals worker...\n"); Info("Done pre-generating signals worker...");
} }
} }

21
srsue/src/phy/lte/sf_worker.cc
Unescape Escape View File

@ -19,16 +19,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
/* This is to visualize the channel response */ /* This is to visualize the channel response */
#ifdef ENABLE_GUI #ifdef ENABLE_GUI
@ -48,14 +48,13 @@ static bool plot_nr_enable = false;
namespace srsue { namespace srsue {
namespace lte { namespace lte {
sf_worker::sf_worker(uint32_t max_prb, phy_common* phy_, srslte::log* log_h_) sf_worker::sf_worker(uint32_t max_prb, phy_common* phy_, srslog::basic_logger& logger) : logger(logger)
{ {
phy = phy_; phy = phy_;
log_h = log_h_;
// ue_sync in phy.cc requires a buffer for 3 subframes // ue_sync in phy.cc requires a buffer for 3 subframes
for (uint32_t r = 0; r < phy->args->nof_lte_carriers; r++) { for (uint32_t r = 0; r < phy->args->nof_lte_carriers; r++) {
cc_workers.push_back(new cc_worker(r, max_prb, phy, log_h)); cc_workers.push_back(new cc_worker(r, max_prb, phy, logger));
} }
} }
@ -75,11 +74,11 @@ bool sf_worker::set_cell_unlocked(uint32_t cc_idx, srslte_cell_t cell_)
{ {
if (cc_idx < cc_workers.size()) { if (cc_idx < cc_workers.size()) {
if (!cc_workers[cc_idx]->set_cell_unlocked(cell_)) { if (!cc_workers[cc_idx]->set_cell_unlocked(cell_)) {
Error("Setting cell for cc=%d\n", cc_idx); Error("Setting cell for cc=%d", cc_idx);
return false; return false;
} }
} else { } else {
Error("Setting cell for cc=%d; Not enough CC workers (%zd);\n", cc_idx, cc_workers.size()); Error("Setting cell for cc=%d; Not enough CC workers (%zd);", cc_idx, cc_workers.size());
} }
if (cc_idx == 0) { if (cc_idx == 0) {
@ -113,7 +112,7 @@ void sf_worker::set_tti(uint32_t tti_)
cc_worker->set_tti(tti); cc_worker->set_tti(tti);
} }
log_h->step(tti); logger.set_context(tti);
} }
void sf_worker::set_tx_time(const srslte::rf_timestamp_t& tx_time_) void sf_worker::set_tx_time(const srslte::rf_timestamp_t& tx_time_)
@ -163,7 +162,7 @@ void sf_worker::set_config_unlocked(uint32_t cc_idx, srslte::phy_cfg_t phy_cfg)
cc_workers[0]->upd_config_dci_unlocked(phy_cfg.dl_cfg.dci); cc_workers[0]->upd_config_dci_unlocked(phy_cfg.dl_cfg.dci);
} }
} else { } else {
Error("Setting config for cc=%d; Invalid cc_idx\n", cc_idx); Error("Setting config for cc=%d; Invalid cc_idx", cc_idx);
} }
} }

20
srsue/src/phy/lte/worker_pool.cc
Unescape Escape View File

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

18
srsue/src/phy/nr/cc_worker.cc
Unescape Escape View File

@ -38,13 +38,13 @@ cc_worker::cc_worker(uint32_t cc_idx_, srslte::log* log, phy_nr_state* phy_state
} }
if (srslte_ue_dl_nr_init(&ue_dl, buffer_c, &phy_state_->args.dl) < SRSLTE_SUCCESS) { if (srslte_ue_dl_nr_init(&ue_dl, buffer_c, &phy_state_->args.dl) < SRSLTE_SUCCESS) {
ERROR("Error initiating UE DL NR\n"); ERROR("Error initiating UE DL NR");
return; return;
} }
if (srslte_softbuffer_rx_init_guru(&softbuffer_rx, SRSLTE_SCH_NR_MAX_NOF_CB_LDPC, SRSLTE_LDPC_MAX_LEN_ENCODED_CB) < if (srslte_softbuffer_rx_init_guru(&softbuffer_rx, SRSLTE_SCH_NR_MAX_NOF_CB_LDPC, SRSLTE_LDPC_MAX_LEN_ENCODED_CB) <
SRSLTE_SUCCESS) { SRSLTE_SUCCESS) {
ERROR("Error init soft-buffer\n"); ERROR("Error init soft-buffer");
return; return;
} }
data.resize(SRSLTE_SCH_NR_MAX_NOF_CB_LDPC * SRSLTE_LDPC_MAX_LEN_ENCODED_CB / 8); data.resize(SRSLTE_SCH_NR_MAX_NOF_CB_LDPC * SRSLTE_LDPC_MAX_LEN_ENCODED_CB / 8);
@ -69,7 +69,7 @@ cc_worker::~cc_worker()
bool cc_worker::set_carrier(const srslte_carrier_nr_t* carrier) bool cc_worker::set_carrier(const srslte_carrier_nr_t* carrier)
{ {
if (srslte_ue_dl_nr_set_carrier(&ue_dl, carrier) < SRSLTE_SUCCESS) { if (srslte_ue_dl_nr_set_carrier(&ue_dl, carrier) < SRSLTE_SUCCESS) {
ERROR("Error setting carrier\n"); ERROR("Error setting carrier");
return false; return false;
} }
@ -77,7 +77,7 @@ bool cc_worker::set_carrier(const srslte_carrier_nr_t* carrier)
coreset.duration = 2; coreset.duration = 2;
if (srslte_ue_dl_nr_set_coreset(&ue_dl, &coreset) < SRSLTE_SUCCESS) { if (srslte_ue_dl_nr_set_coreset(&ue_dl, &coreset) < SRSLTE_SUCCESS) {
ERROR("Error setting carrier\n"); ERROR("Error setting carrier");
return false; return false;
} }
@ -128,12 +128,12 @@ bool cc_worker::work_dl()
srslte_dci_dl_nr_t dci_dl_rx = {}; srslte_dci_dl_nr_t dci_dl_rx = {};
int nof_found_dci = srslte_ue_dl_nr_find_dl_dci(&ue_dl, &search_space, &dl_slot_cfg, rnti, &dci_dl_rx, 1); int nof_found_dci = srslte_ue_dl_nr_find_dl_dci(&ue_dl, &search_space, &dl_slot_cfg, rnti, &dci_dl_rx, 1);
if (nof_found_dci < SRSLTE_SUCCESS) { if (nof_found_dci < SRSLTE_SUCCESS) {
ERROR("Error decoding\n"); ERROR("Error decoding");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (nof_found_dci < 1) { if (nof_found_dci < 1) {
ERROR("Error DCI not found\n"); ERROR("Error DCI not found");
} }
dci_dl.rnti = 0x1234; dci_dl.rnti = 0x1234;
@ -145,7 +145,7 @@ bool cc_worker::work_dl()
// Compute DL grant // Compute DL grant
if (srslte_ra_dl_dci_to_grant_nr(&ue_dl.carrier, &pdsch_cfg, &dci_dl, &pdsch_cfg.grant)) { if (srslte_ra_dl_dci_to_grant_nr(&ue_dl.carrier, &pdsch_cfg, &dci_dl, &pdsch_cfg.grant)) {
ERROR("Computing DL grant\n"); ERROR("Computing DL grant");
} }
pdsch_res[0].payload = data.data(); pdsch_res[0].payload = data.data();
@ -153,7 +153,7 @@ bool cc_worker::work_dl()
srslte_softbuffer_rx_reset(pdsch_cfg.grant.tb[0].softbuffer.rx); srslte_softbuffer_rx_reset(pdsch_cfg.grant.tb[0].softbuffer.rx);
if (srslte_ue_dl_nr_decode_pdsch(&ue_dl, &dl_slot_cfg, &pdsch_cfg, pdsch_res.data()) < SRSLTE_SUCCESS) { if (srslte_ue_dl_nr_decode_pdsch(&ue_dl, &dl_slot_cfg, &pdsch_cfg, pdsch_res.data()) < SRSLTE_SUCCESS) {
ERROR("Error decoding PDSCH\n"); ERROR("Error decoding PDSCH");
return false; return false;
} }
@ -161,7 +161,7 @@ bool cc_worker::work_dl()
if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) { if (log_h->get_level() >= srslte::LOG_LEVEL_INFO) {
char str[512]; char str[512];
srslte_ue_dl_nr_pdsch_info(&ue_dl, &pdsch_cfg, pdsch_res.data(), str, sizeof(str)); srslte_ue_dl_nr_pdsch_info(&ue_dl, &pdsch_cfg, pdsch_res.data(), str, sizeof(str));
log_h->info("PDSCH: cc=%d, %s\n", cc_idx, str); log_h->info("PDSCH: cc=%d, %s", cc_idx, str);
} }
return true; return true;

92
srsue/src/phy/phy.cc
Unescape Escape View File

@ -25,16 +25,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger_phy.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger_phy.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger_phy.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger_phy.debug(fmt, ##__VA_ARGS__)
using namespace std; using namespace std;
@ -48,23 +48,19 @@ 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) void phy::srslte_phy_logger(phy_logger_level_t log_level, char* str)
{ {
if (log_phy_lib_h) {
switch (log_level) { switch (log_level) {
case LOG_LEVEL_INFO_S: case LOG_LEVEL_INFO_S:
log_phy_lib_h->info(" %s", str); logger_phy_lib.info(" %s", str);
break; break;
case LOG_LEVEL_DEBUG_S: case LOG_LEVEL_DEBUG_S:
log_phy_lib_h->debug(" %s", str); logger_phy_lib.debug(" %s", str);
break; break;
case LOG_LEVEL_ERROR_S: case LOG_LEVEL_ERROR_S:
log_phy_lib_h->error(" %s", str); logger_phy_lib.error(" %s", str);
break; break;
default: default:
break; break;
} }
} else {
printf("[PHY_LIB]: %s\n", str);
}
} }
void phy::set_default_args(phy_args_t& args_) void phy::set_default_args(phy_args_t& args_)
@ -123,21 +119,16 @@ int phy::init(const phy_args_t& args_)
} }
// Add PHY lib log // Add PHY lib log
if (srslte::log::get_level_from_string(args.log.phy_lib_level) != srslte::LOG_LEVEL_NONE) { auto lib_log_level = srslog::str_to_basic_level(args.log.phy_lib_level);
log_phy_lib_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter); logger_phy_lib.set_level(lib_log_level);
log_phy_lib_h->init("PHY_LIB", logger, true); logger_phy_lib.set_hex_dump_max_size(args.log.phy_hex_limit);
log_phy_lib_h->set_level(args.log.phy_lib_level); if (lib_log_level != srslog::basic_levels::none) {
log_phy_lib_h->set_hex_limit(args.log.phy_hex_limit);
srslte_phy_log_register_handler(this, srslte_phy_handler); srslte_phy_log_register_handler(this, srslte_phy_handler);
} }
// set default logger // set default logger
{ logger_phy.set_level(srslog::str_to_basic_level(args.log.phy_level));
log_h = std::unique_ptr<srslte::log_filter>(new srslte::log_filter); logger_phy.set_hex_dump_max_size(args.log.phy_hex_limit);
log_h->init("PHY", logger, true);
log_h->set_level(args.log.phy_level);
log_h->set_hex_limit(args.log.phy_hex_limit);
}
if (!check_args(args)) { if (!check_args(args)) {
return false; return false;
@ -152,24 +143,16 @@ int phy::init(const phy_args_t& args_)
void phy::run_thread() void phy::run_thread()
{ {
std::unique_lock<std::mutex> lock(config_mutex); std::unique_lock<std::mutex> lock(config_mutex);
prach_buffer.init(SRSLTE_MAX_PRB, log_h.get()); prach_buffer.init(SRSLTE_MAX_PRB);
common.init(&args, log_h.get(), radio, stack, &sfsync); common.init(&args, radio, stack, &sfsync);
// Initialise workers // Initialise workers
lte_workers.init(&common, logger, WORKERS_THREAD_PRIO); lte_workers.init(&common, log_sink, WORKERS_THREAD_PRIO);
nr_workers.init(&common, logger, WORKERS_THREAD_PRIO); nr_workers.init(&common, logger, WORKERS_THREAD_PRIO);
// Warning this must be initialized after all workers have been added to the pool // Warning this must be initialized after all workers have been added to the pool
sfsync.init(radio, sfsync.init(
stack, radio, stack, &prach_buffer, &lte_workers, &nr_workers, &common, SF_RECV_THREAD_PRIO, args.sync_cpu_affinity);
&prach_buffer,
&lte_workers,
&nr_workers,
&common,
log_h.get(),
log_phy_lib_h.get(),
SF_RECV_THREAD_PRIO,
args.sync_cpu_affinity);
// Disable UL signal pregeneration until the attachment // Disable UL signal pregeneration until the attachment
enable_pregen_signals(false); enable_pregen_signals(false);
@ -250,12 +233,12 @@ void phy::set_activation_deactivation_scell(uint32_t cmd, uint32_t tti)
void phy::configure_prach_params() void phy::configure_prach_params()
{ {
Debug("Configuring PRACH parameters\n"); Debug("Configuring PRACH parameters");
prach_cfg.tdd_config = tdd_config; prach_cfg.tdd_config = tdd_config;
if (!prach_buffer.set_cell(selected_cell, prach_cfg)) { if (!prach_buffer.set_cell(selected_cell, prach_cfg)) {
Error("Configuring PRACH parameters\n"); Error("Configuring PRACH parameters");
} }
} }
@ -325,7 +308,7 @@ bool phy::cell_select(phy_cell_t cell)
}); });
return true; return true;
} else { } else {
log_h->warning("Could not start Cell Selection procedure\n"); logger_phy.warning("Could not start Cell Selection procedure");
return false; return false;
} }
} }
@ -344,7 +327,7 @@ bool phy::cell_search()
stack->cell_search_complete(ret, found_cell); stack->cell_search_complete(ret, found_cell);
}); });
} else { } else {
log_h->warning("Could not start Cell Search procedure\n"); logger_phy.warning("Could not start Cell Search procedure");
} }
return true; return true;
} }
@ -370,7 +353,7 @@ void phy::prach_send(uint32_t preamble_idx, int allowed_subframe, float target_p
common.ta.set_base_sec(ta_base_sec); common.ta.set_base_sec(ta_base_sec);
common.reset_radio(); common.reset_radio();
if (!prach_buffer.prepare_to_send(preamble_idx, allowed_subframe, target_power_dbm)) { if (!prach_buffer.prepare_to_send(preamble_idx, allowed_subframe, target_power_dbm)) {
Error("Preparing PRACH to send\n"); Error("Preparing PRACH to send");
} }
} }
@ -388,12 +371,12 @@ void phy::radio_overflow()
void phy::radio_failure() void phy::radio_failure()
{ {
// TODO: handle failure // TODO: handle failure
Error("Radio failure.\n"); Error("Radio failure.");
} }
void phy::reset() void phy::reset()
{ {
Info("Resetting PHY...\n"); Info("Resetting PHY...");
common.ta.set_base_sec(0); common.ta.set_base_sec(0);
common.reset(); common.reset();
} }
@ -407,7 +390,7 @@ void phy::sr_send()
{ {
common.sr_enabled = true; common.sr_enabled = true;
common.sr_last_tx_tti = -1; common.sr_last_tx_tti = -1;
Debug("sr_send(): sr_enabled=%d, last_tx_tti=%d\n", common.sr_enabled, common.sr_last_tx_tti); Debug("sr_send(): sr_enabled=%d, last_tx_tti=%d", common.sr_enabled, common.sr_last_tx_tti);
} }
int phy::sr_last_tx_tti() int phy::sr_last_tx_tti()
@ -424,7 +407,7 @@ void phy::set_crnti(uint16_t rnti)
{ {
// set_crnti() is an operation that takes time, run in background worker // set_crnti() is an operation that takes time, run in background worker
cmd_worker.add_cmd([this, rnti]() { cmd_worker.add_cmd([this, rnti]() {
log_h->info("Configuring sequences for C-RNTI=0x%x...\n", rnti); logger_phy.info("Configuring sequences for C-RNTI=0x%x...", rnti);
for (uint32_t i = 0; i < args.nof_phy_threads; i++) { for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
// set_crnti is not protected so run when worker is finished // set_crnti is not protected so run when worker is finished
lte::sf_worker* w = lte_workers.wait_worker_id(i); lte::sf_worker* w = lte_workers.wait_worker_id(i);
@ -433,7 +416,7 @@ void phy::set_crnti(uint16_t rnti)
w->release(); w->release();
} }
} }
log_h->info("Finished configuring sequences for C-RNTI=0x%x.\n", rnti); logger_phy.info("Finished configuring sequences for C-RNTI=0x%x.", rnti);
}); });
} }
@ -467,7 +450,7 @@ bool phy::set_config(srslte::phy_cfg_t config_, uint32_t cc_idx)
return false; return false;
} }
Info("Setting configuration\n"); Info("Setting configuration");
// The PRACH configuration shall be updated only if: // The PRACH configuration shall be updated only if:
// - The new configuration belongs to the primary cell // - The new configuration belongs to the primary cell
@ -478,7 +461,7 @@ bool phy::set_config(srslte::phy_cfg_t config_, uint32_t cc_idx)
// Apply configuration after the worker is finished to avoid race conditions // Apply configuration after the worker is finished to avoid race conditions
cmd_worker.add_cmd([this, config_, cc_idx]() { cmd_worker.add_cmd([this, config_, cc_idx]() {
log_h->info("Setting new PHY configuration cc_idx=%d...\n", cc_idx); logger_phy.info("Setting new PHY configuration cc_idx=%d...", cc_idx);
for (uint32_t i = 0; i < args.nof_phy_threads; i++) { for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
// set_cell is not protected so run when worker is finished // set_cell is not protected so run when worker is finished
lte::sf_worker* w = lte_workers.wait_worker_id(i); lte::sf_worker* w = lte_workers.wait_worker_id(i);
@ -487,11 +470,10 @@ bool phy::set_config(srslte::phy_cfg_t config_, uint32_t cc_idx)
w->release(); w->release();
} }
} }
log_h->info("Finished setting new PHY configuration cc_idx=%d\n", cc_idx); logger_phy.info("Finished setting new PHY configuration cc_idx=%d", cc_idx);
// It is up to the PRACH component to detect whether the cell or the configuration have changed to reconfigure // It is up to the PRACH component to detect whether the cell or the configuration have changed to reconfigure
configure_prach_params(); configure_prach_params();
stack->set_config_complete(true); stack->set_config_complete(true);
}); });
return true; return true;
@ -505,7 +487,7 @@ bool phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn)
} }
if (cc_idx == 0) { if (cc_idx == 0) {
log_h->error("Received SCell configuration for invalid cc_idx=0\n"); logger_phy.error("Received SCell configuration for invalid cc_idx=0");
return false; return false;
} }
@ -518,7 +500,7 @@ bool phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn)
// First of all check validity of parameters // First of all check validity of parameters
if (!srslte_cell_isvalid(&cell_info)) { if (!srslte_cell_isvalid(&cell_info)) {
log_h->error("Received SCell configuration for an invalid cell\n"); logger_phy.error("Received SCell configuration for an invalid cell");
return false; return false;
} }
@ -538,7 +520,7 @@ bool phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn)
// Component carrier index zero should be reserved for PCell // Component carrier index zero should be reserved for PCell
// Send configuration to workers // Send configuration to workers
cmd_worker.add_cmd([this, cell_info, cc_idx, earfcn, earfcn_is_different]() { cmd_worker.add_cmd([this, cell_info, cc_idx, earfcn, earfcn_is_different]() {
log_h->info("Setting new SCell configuration cc_idx=%d, earfcn=%d...\n", cc_idx, earfcn); logger_phy.info("Setting new SCell configuration cc_idx=%d, earfcn=%d...", cc_idx, earfcn);
for (uint32_t i = 0; i < args.nof_phy_threads; i++) { for (uint32_t i = 0; i < args.nof_phy_threads; i++) {
// set_cell is not protected so run when worker is finished // set_cell is not protected so run when worker is finished
lte::sf_worker* w = lte_workers.wait_worker_id(i); lte::sf_worker* w = lte_workers.wait_worker_id(i);
@ -559,7 +541,7 @@ bool phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn)
// Set secondary serving cell synchronization // Set secondary serving cell synchronization
sfsync.scell_sync_set(cc_idx, cell_info); sfsync.scell_sync_set(cc_idx, cell_info);
log_h->info("Finished setting new SCell configuration cc_idx=%d, earfcn=%d\n", cc_idx, earfcn); logger_phy.info("Finished setting new SCell configuration cc_idx=%d, earfcn=%d", cc_idx, earfcn);
stack->set_scell_complete(true); stack->set_scell_complete(true);
}); });
@ -591,7 +573,7 @@ void phy::set_config_tdd(srslte_tdd_config_t& tdd_config_)
void phy::set_config_mbsfn_sib2(srslte::mbsfn_sf_cfg_t* cfg_list, uint32_t nof_cfgs) void phy::set_config_mbsfn_sib2(srslte::mbsfn_sf_cfg_t* cfg_list, uint32_t nof_cfgs)
{ {
if (nof_cfgs > 1) { if (nof_cfgs > 1) {
Warning("SIB2 has %d MBSFN subframe configs - only 1 supported\n", nof_cfgs); Warning("SIB2 has %d MBSFN subframe configs - only 1 supported", nof_cfgs);
} }
if (nof_cfgs > 0) { if (nof_cfgs > 0) {
common.mbsfn_config.mbsfn_subfr_cnfg = cfg_list[0]; common.mbsfn_config.mbsfn_subfr_cnfg = cfg_list[0];
@ -603,7 +585,7 @@ void phy::set_config_mbsfn_sib13(const srslte::sib13_t& sib13)
{ {
common.mbsfn_config.mbsfn_notification_cnfg = sib13.notif_cfg; common.mbsfn_config.mbsfn_notification_cnfg = sib13.notif_cfg;
if (sib13.nof_mbsfn_area_info > 1) { 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);
} }
if (sib13.nof_mbsfn_area_info > 0) { if (sib13.nof_mbsfn_area_info > 0) {
common.mbsfn_config.mbsfn_area_info = sib13.mbsfn_area_info_list[0]; common.mbsfn_config.mbsfn_area_info = sib13.mbsfn_area_info_list[0];

67
srsue/src/phy/phy_common.cc
Unescape Escape View File

@ -18,22 +18,22 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
namespace srsue { namespace srsue {
static srslte::rf_buffer_t zeros_multi(1); static srslte::rf_buffer_t zeros_multi(1);
phy_common::phy_common() phy_common::phy_common(srslog::basic_logger& logger) : logger(logger), ta(logger)
{ {
reset(); reset();
} }
@ -41,20 +41,16 @@ phy_common::phy_common()
phy_common::~phy_common() = default; phy_common::~phy_common() = default;
void phy_common::init(phy_args_t* _args, void phy_common::init(phy_args_t* _args,
srslte::log* _log,
srslte::radio_interface_phy* _radio, srslte::radio_interface_phy* _radio,
stack_interface_phy_lte* _stack, stack_interface_phy_lte* _stack,
rsrp_insync_itf* _chest_loop) rsrp_insync_itf* _chest_loop)
{ {
log_h = _log;
radio_h = _radio; radio_h = _radio;
stack = _stack; stack = _stack;
args = _args; args = _args;
insync_itf = _chest_loop; insync_itf = _chest_loop;
sr_last_tx_tti = -1; sr_last_tx_tti = -1;
ta.set_logger(_log);
// Instantiate UL channel emulator // Instantiate UL channel emulator
if (args->ul_channel_args.enable) { if (args->ul_channel_args.enable) {
ul_channel = ul_channel =
@ -133,7 +129,7 @@ void phy_common::set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRAN
#endif /* MSG3_DELAY_MS < 0 */ #endif /* MSG3_DELAY_MS < 0 */
if (rar_grant_tti < 0) { if (rar_grant_tti < 0) {
Error("Must call set_rar_grant_tti before set_rar_grant\n"); Error("Must call set_rar_grant_tti before set_rar_grant");
} }
srslte_dci_ul_t dci_ul; srslte_dci_ul_t dci_ul;
@ -141,7 +137,7 @@ void phy_common::set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRAN
srslte_dci_rar_unpack(grant_payload, &rar_grant); srslte_dci_rar_unpack(grant_payload, &rar_grant);
if (srslte_dci_rar_to_ul_dci(&cell, &rar_grant, &dci_ul)) { if (srslte_dci_rar_to_ul_dci(&cell, &rar_grant, &dci_ul)) {
Error("Converting RAR message to UL dci\n"); Error("Converting RAR message to UL dci");
return; return;
} }
@ -165,12 +161,12 @@ void phy_common::set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRAN
std::lock_guard<std::mutex> lock(pending_ul_grant_mutex); std::lock_guard<std::mutex> lock(pending_ul_grant_mutex);
pending_ul_grant_t& pending_grant = pending_ul_grant[0][msg3_tx_tti]; pending_ul_grant_t& pending_grant = pending_ul_grant[0][msg3_tx_tti];
if (!pending_grant.enable) { if (!pending_grant.enable) {
Debug("RAR grant rar_grant=%d, msg3_tti=%d, stored in index=%d\n", rar_grant_tti, msg3_tx_tti, TTIMOD(msg3_tx_tti)); Debug("RAR grant rar_grant=%d, msg3_tti=%d, stored in index=%d", rar_grant_tti, msg3_tx_tti, TTIMOD(msg3_tx_tti));
pending_grant.pid = ul_pidof(msg3_tx_tti, &tdd_config); pending_grant.pid = ul_pidof(msg3_tx_tti, &tdd_config);
pending_grant.dci = dci_ul; pending_grant.dci = dci_ul;
pending_grant.enable = true; pending_grant.enable = true;
} else { } else {
Warning("set_rar_grant: sf->tti=%d, cc=%d already in use\n", msg3_tx_tti, 0); Warning("set_rar_grant: sf->tti=%d, cc=%d already in use", msg3_tx_tti, 0);
} }
rar_grant_tti = -1; rar_grant_tti = -1;
@ -237,7 +233,7 @@ uint32_t phy_common::ul_pidof(uint32_t tti, srslte_tdd_config_t* tdd_config)
return (cycle_idx + sf_idx - 4) % 6; return (cycle_idx + sf_idx - 4) % 6;
} }
default: default:
Error("Invalid SF configuration %d\n", tdd_config->sf_config); Error("Invalid SF configuration %d", tdd_config->sf_config);
} }
} else { } else {
return tti % SRSLTE_FDD_NOF_HARQ; return tti % SRSLTE_FDD_NOF_HARQ;
@ -264,13 +260,13 @@ void phy_common::set_ul_pending_ack(srslte_ul_sf_cfg_t* sf,
pending_ack.dci_ul = *dci_ul; pending_ack.dci_ul = *dci_ul;
pending_ack.phich_grant = phich_grant; pending_ack.phich_grant = phich_grant;
pending_ack.enable = true; pending_ack.enable = true;
Debug("Set pending ACK for sf->tti=%d n_dmrs=%d, I_phich=%d, cc_idx=%d\n", Debug("Set pending ACK for sf->tti=%d n_dmrs=%d, I_phich=%d, cc_idx=%d",
sf->tti, sf->tti,
phich_grant.n_dmrs, phich_grant.n_dmrs,
phich_grant.I_phich, phich_grant.I_phich,
cc_idx); cc_idx);
} else { } else {
Warning("set_ul_pending_ack: sf->tti=%d, cc=%d already in use\n", sf->tti, cc_idx); Warning("set_ul_pending_ack: sf->tti=%d, cc=%d already in use", sf->tti, cc_idx);
} }
} }
@ -288,7 +284,7 @@ bool phy_common::get_ul_pending_ack(srslte_dl_sf_cfg_t* sf,
*dci_ul = pending_ack.dci_ul; *dci_ul = pending_ack.dci_ul;
ret = true; ret = true;
pending_ack.enable = false; pending_ack.enable = false;
Debug("Get pending ACK for sf->tti=%d n_dmrs=%d, I_phich=%d\n", sf->tti, phich_grant->n_dmrs, phich_grant->I_phich); Debug("Get pending ACK for sf->tti=%d n_dmrs=%d, I_phich=%d", sf->tti, phich_grant->n_dmrs, phich_grant->I_phich);
} }
return ret; return ret;
} }
@ -333,9 +329,9 @@ void phy_common::set_ul_pending_grant(srslte_dl_sf_cfg_t* sf, uint32_t cc_idx, s
pending_grant.pid = pid; pending_grant.pid = pid;
pending_grant.dci = *dci; pending_grant.dci = *dci;
pending_grant.enable = true; pending_grant.enable = true;
Debug("Set ul pending grant for sf->tti=%d current_tti=%d, pid=%d\n", tti_pusch_gr(sf), sf->tti, pid); Debug("Set ul pending grant for sf->tti=%d current_tti=%d, pid=%d", tti_pusch_gr(sf), sf->tti, pid);
} else { } else {
Warning("set_ul_pending_grant: sf->tti=%d, cc=%d already in use\n", sf->tti, cc_idx); Warning("set_ul_pending_grant: sf->tti=%d, cc=%d already in use", sf->tti, cc_idx);
} }
} }
@ -347,7 +343,7 @@ bool phy_common::get_ul_pending_grant(srslte_ul_sf_cfg_t* sf, uint32_t cc_idx, u
pending_ul_grant_t& pending_grant = pending_ul_grant[cc_idx][sf->tti]; pending_ul_grant_t& pending_grant = pending_ul_grant[cc_idx][sf->tti];
if (pending_grant.enable) { if (pending_grant.enable) {
Debug("Reading grant sf->tti=%d idx=%d\n", sf->tti, TTIMOD(sf->tti)); Debug("Reading grant sf->tti=%d idx=%d", sf->tti, TTIMOD(sf->tti));
if (pid) { if (pid) {
*pid = pending_grant.pid; *pid = pending_grant.pid;
} }
@ -386,7 +382,7 @@ void phy_common::set_ul_received_ack(srslte_dl_sf_cfg_t* sf,
received_ack.hi_present = true; received_ack.hi_present = true;
received_ack.hi_value = ack_value; received_ack.hi_value = ack_value;
received_ack.dci_ul = *dci_ul; received_ack.dci_ul = *dci_ul;
Debug("Set ul received ack for sf->tti=%d, current_tti=%d\n", tti_pusch_hi(sf), sf->tti); Debug("Set ul received ack for sf->tti=%d, current_tti=%d", tti_pusch_hi(sf), sf->tti);
} }
// SF->TTI at which PUSCH will be transmitted // SF->TTI at which PUSCH will be transmitted
@ -403,7 +399,7 @@ bool phy_common::get_ul_received_ack(srslte_ul_sf_cfg_t* sf, uint32_t cc_idx, bo
if (dci_ul) { if (dci_ul) {
*dci_ul = received_ack.dci_ul; *dci_ul = received_ack.dci_ul;
} }
Debug("Get ul received ack for current_tti=%d\n", sf->tti); Debug("Get ul received ack for current_tti=%d", sf->tti);
received_ack.hi_present = false; received_ack.hi_present = false;
ret = true; ret = true;
} }
@ -424,9 +420,9 @@ void phy_common::set_dl_pending_ack(srslte_dl_sf_cfg_t* sf,
pending_ack.enable = true; pending_ack.enable = true;
pending_ack.resource = resource; pending_ack.resource = resource;
memcpy(pending_ack.value, value, SRSLTE_MAX_CODEWORDS * sizeof(uint8_t)); memcpy(pending_ack.value, value, SRSLTE_MAX_CODEWORDS * sizeof(uint8_t));
Debug("Set dl pending ack for sf->tti=%d, value=%d, ncce=%d\n", sf->tti, value[0], resource.n_cce); Debug("Set dl pending ack for sf->tti=%d, value=%d, ncce=%d", sf->tti, value[0], resource.n_cce);
} else { } else {
Warning("pending_dl_ack: sf->tti=%d, cc=%d already in use\n", sf->tti, cc_idx); Warning("pending_dl_ack: sf->tti=%d, cc=%d already in use", sf->tti, cc_idx);
} }
} }
@ -446,7 +442,7 @@ void phy_common::set_dl_pending_grant(uint32_t tti,
pending_dl_grant[tti % FDD_HARQ_DELAY_UL_MS][cc_idx].grant_cc_idx = grant_cc_idx; pending_dl_grant[tti % FDD_HARQ_DELAY_UL_MS][cc_idx].grant_cc_idx = grant_cc_idx;
pending_dl_grant[tti % FDD_HARQ_DELAY_UL_MS][cc_idx].enable = true; pending_dl_grant[tti % FDD_HARQ_DELAY_UL_MS][cc_idx].enable = true;
} else { } else {
Warning("set_dl_pending_grant: cc=%d already exists\n", cc_idx); Warning("set_dl_pending_grant: cc=%d already exists", cc_idx);
} }
} }
@ -515,7 +511,7 @@ bool phy_common::get_dl_pending_ack(srslte_ul_sf_cfg_t* sf, uint32_t cc_idx, srs
ack->m[i].k = k; ack->m[i].k = k;
ack->m[i].resource = pending_ack.resource; ack->m[i].resource = pending_ack.resource;
memcpy(ack->m[i].value, pending_ack.value, SRSLTE_MAX_CODEWORDS * sizeof(uint8_t)); memcpy(ack->m[i].value, pending_ack.value, SRSLTE_MAX_CODEWORDS * sizeof(uint8_t));
Debug("Get dl pending ack for sf->tti=%d, i=%d, k=%d, pdsch_tti=%d, value=%d, ncce=%d, v_dai=%d\n", Debug("Get dl pending ack for sf->tti=%d, i=%d, k=%d, pdsch_tti=%d, value=%d, ncce=%d, v_dai=%d",
sf->tti, sf->tti,
i, i,
k, k,
@ -749,11 +745,10 @@ void phy_common::update_measurements(uint32_t cc_idx,
// Check in-sync / out-sync conditions. Use SNR instead of SINR for RLF threshold // Check in-sync / out-sync conditions. Use SNR instead of SINR for RLF threshold
if (cc_idx == 0) { if (cc_idx == 0) {
if (avg_rsrp_dbm[0] > args->in_sync_rsrp_dbm_th && avg_snr_db[0] > args->in_sync_snr_db_th) { if (avg_rsrp_dbm[0] > args->in_sync_rsrp_dbm_th && avg_snr_db[0] > args->in_sync_snr_db_th) {
log_h->debug( logger.debug("SNR=%.1f dB, RSRP=%.1f dBm sync=in-sync from channel estimator", avg_snr_db[0], avg_rsrp_dbm[0]);
"SNR=%.1f dB, RSRP=%.1f dBm sync=in-sync from channel estimator\n", avg_snr_db[0], avg_rsrp_dbm[0]);
} else { } else {
log_h->warning( logger.warning(
"SNR=%.1f dB RSRP=%.1f dBm, sync=out-of-sync from channel estimator\n", avg_snr_db[0], avg_rsrp_dbm[0]); "SNR=%.1f dB RSRP=%.1f dBm, sync=out-of-sync from channel estimator", avg_snr_db[0], avg_rsrp_dbm[0]);
insync = false; insync = false;
} }
} }
@ -942,7 +937,7 @@ void phy_common::build_mch_table()
} else if (mbsfn_config.mbsfn_subfr_cnfg.nof_alloc_subfrs == srslte::mbsfn_sf_cfg_t::sf_alloc_type_t::four_frames) { } else if (mbsfn_config.mbsfn_subfr_cnfg.nof_alloc_subfrs == srslte::mbsfn_sf_cfg_t::sf_alloc_type_t::four_frames) {
generate_mch_table(&mch_table[0], (uint32_t)mbsfn_config.mbsfn_subfr_cnfg.sf_alloc, 4u); generate_mch_table(&mch_table[0], (uint32_t)mbsfn_config.mbsfn_subfr_cnfg.sf_alloc, 4u);
} else { } else {
log_h->error("The subframe config has not been set for MBSFN\n"); logger.error("The subframe config has not been set for MBSFN");
} }
// Debug // Debug
@ -951,7 +946,7 @@ void phy_common::build_mch_table()
for (uint32_t j = 0; j < 40; j++) { for (uint32_t j = 0; j < 40; j++) {
ss << (int)mch_table[j] << "|"; ss << (int)mch_table[j] << "|";
} }
Info("MCH table: %s\n", ss.str().c_str()); Info("MCH table: %s", ss.str().c_str());
} }
void phy_common::build_mcch_table() void phy_common::build_mcch_table()
@ -965,7 +960,7 @@ void phy_common::build_mcch_table()
for (uint32_t j = 0; j < 10; j++) { for (uint32_t j = 0; j < 10; j++) {
ss << (int)mcch_table[j] << "|"; ss << (int)mcch_table[j] << "|";
} }
Info("MCCH table: %s\n", ss.str().c_str()); Info("MCCH table: %s", ss.str().c_str());
sib13_configured = true; sib13_configured = true;
} }
@ -1056,7 +1051,7 @@ bool phy_common::is_mch_subframe(srslte_mbsfn_cfg_t* cfg, uint32_t phy_tti)
// have_mtch_stop = false; // have_mtch_stop = false;
} }
} }
Debug("MCH subframe TTI:%d\n", phy_tti); Debug("MCH subframe TTI:%d", phy_tti);
} }
return true; return true;
} }
@ -1071,7 +1066,7 @@ bool phy_common::is_mch_subframe(srslte_mbsfn_cfg_t* cfg, uint32_t phy_tti)
} }
} }
} else { } else {
log_h->error("The subframe allocation type is not yet configured\n"); logger.error("The subframe allocation type is not yet configured");
} }
} }
@ -1100,7 +1095,7 @@ bool phy_common::is_mcch_subframe(srslte_mbsfn_cfg_t* cfg, uint32_t phy_tti)
cfg->mbsfn_mcs = enum_to_number(area_info.mcch_cfg.sig_mcs); cfg->mbsfn_mcs = enum_to_number(area_info.mcch_cfg.sig_mcs);
cfg->enable = true; cfg->enable = true;
have_mtch_stop = false; have_mtch_stop = false;
Debug("MCCH subframe TTI:%d\n", phy_tti); Debug("MCCH subframe TTI:%d", phy_tti);
return true; return true;
} }
} }

42
srsue/src/phy/prach.cc
Unescape Escape View File

@ -18,23 +18,21 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
using namespace srsue; using namespace srsue;
void prach::init(uint32_t max_prb, srslte::log* log_h_) void prach::init(uint32_t max_prb)
{ {
log_h = log_h_;
for (auto& i : buffer) { for (auto& i : buffer) {
for (auto& j : i) { for (auto& j : i) {
j = srslte_vec_cf_malloc(SRSLTE_PRACH_MAX_LEN); j = srslte_vec_cf_malloc(SRSLTE_PRACH_MAX_LEN);
@ -46,7 +44,7 @@ void prach::init(uint32_t max_prb, srslte::log* log_h_)
} }
if (srslte_cfo_init(&cfo_h, SRSLTE_PRACH_MAX_LEN)) { if (srslte_cfo_init(&cfo_h, SRSLTE_PRACH_MAX_LEN)) {
ERROR("PRACH: Error initiating CFO\n"); ERROR("PRACH: Error initiating CFO");
return; return;
} }
@ -59,7 +57,7 @@ void prach::init(uint32_t max_prb, srslte::log* log_h_)
} }
if (srslte_prach_init(&prach_obj, srslte_symbol_sz(max_prb))) { if (srslte_prach_init(&prach_obj, srslte_symbol_sz(max_prb))) {
Error("Initiating PRACH library\n"); Error("Initiating PRACH library");
return; return;
} }
@ -87,7 +85,7 @@ void prach::stop()
bool prach::set_cell(srslte_cell_t cell_, srslte_prach_cfg_t prach_cfg) bool prach::set_cell(srslte_cell_t cell_, srslte_prach_cfg_t prach_cfg)
{ {
if (!mem_initiated) { if (!mem_initiated) {
ERROR("PRACH: Error must call init() first\n"); ERROR("PRACH: Error must call init() first");
return false; return false;
} }
@ -101,11 +99,11 @@ bool prach::set_cell(srslte_cell_t cell_, srslte_prach_cfg_t prach_cfg)
if (6 + prach_cfg.freq_offset > cell.nof_prb) { if (6 + prach_cfg.freq_offset > cell.nof_prb) {
srslte::console("Error no space for PRACH: frequency offset=%d, N_rb_ul=%d\n", prach_cfg.freq_offset, cell.nof_prb); srslte::console("Error no space for PRACH: frequency offset=%d, N_rb_ul=%d\n", prach_cfg.freq_offset, cell.nof_prb);
log_h->error("Error no space for PRACH: frequency offset=%d, N_rb_ul=%d\n", prach_cfg.freq_offset, cell.nof_prb); logger.error("Error no space for PRACH: frequency offset=%d, N_rb_ul=%d", prach_cfg.freq_offset, cell.nof_prb);
return false; return false;
} }
Info("PRACH: cell.id=%d, configIdx=%d, rootSequence=%d, zeroCorrelationConfig=%d, freqOffset=%d\n", Info("PRACH: cell.id=%d, configIdx=%d, rootSequence=%d, zeroCorrelationConfig=%d, freqOffset=%d",
cell.id, cell.id,
prach_cfg.config_idx, prach_cfg.config_idx,
prach_cfg.root_seq_idx, prach_cfg.root_seq_idx,
@ -113,7 +111,7 @@ bool prach::set_cell(srslte_cell_t cell_, srslte_prach_cfg_t prach_cfg)
prach_cfg.freq_offset); prach_cfg.freq_offset);
if (srslte_prach_set_cfg(&prach_obj, &prach_cfg, cell.nof_prb)) { if (srslte_prach_set_cfg(&prach_obj, &prach_cfg, cell.nof_prb)) {
Error("Initiating PRACH library\n"); Error("Initiating PRACH library");
return false; return false;
} }
@ -122,7 +120,7 @@ bool prach::set_cell(srslte_cell_t cell_, srslte_prach_cfg_t prach_cfg)
transmitted_tti = -1; transmitted_tti = -1;
cell_initiated = true; cell_initiated = true;
log_h->info("Finished setting new PRACH configuration.\n"); logger.info("Finished setting new PRACH configuration.");
return true; return true;
} }
@ -139,7 +137,7 @@ bool prach::generate_buffer(uint32_t f_idx)
cfg.config_idx, cfg.tdd_config.sf_config, (f_idx / 6) * 10, f_idx % 6, cfg.freq_offset, cell.nof_prb); cfg.config_idx, cfg.tdd_config.sf_config, (f_idx / 6) * 10, f_idx % 6, cfg.freq_offset, cell.nof_prb);
} }
if (srslte_prach_gen(&prach_obj, preamble_idx, freq_offset, buffer[f_idx][preamble_idx])) { if (srslte_prach_gen(&prach_obj, preamble_idx, freq_offset, buffer[f_idx][preamble_idx])) {
Error("Generating PRACH preamble %d\n", preamble_idx); Error("Generating PRACH preamble %d", preamble_idx);
return false; return false;
} }
@ -151,7 +149,7 @@ bool prach::generate_buffer(uint32_t f_idx)
bool prach::prepare_to_send(uint32_t preamble_idx_, int allowed_subframe_, float target_power_dbm_) bool prach::prepare_to_send(uint32_t preamble_idx_, int allowed_subframe_, float target_power_dbm_)
{ {
if (preamble_idx_ >= max_preambles) { if (preamble_idx_ >= max_preambles) {
Error("PRACH: Invalid preamble %d\n", preamble_idx_); Error("PRACH: Invalid preamble %d", preamble_idx_);
return false; return false;
} }
@ -159,7 +157,7 @@ bool prach::prepare_to_send(uint32_t preamble_idx_, int allowed_subframe_, float
target_power_dbm = target_power_dbm_; target_power_dbm = target_power_dbm_;
allowed_subframe = allowed_subframe_; allowed_subframe = allowed_subframe_;
transmitted_tti = -1; transmitted_tti = -1;
Debug("PRACH: prepare to send preamble %d\n", preamble_idx); Debug("PRACH: prepare to send preamble %d", preamble_idx);
return true; return true;
} }
@ -175,7 +173,7 @@ bool prach::is_ready_to_send(uint32_t current_tti_, uint32_t current_pci)
// consider the number of subframes the transmission must be anticipated // consider the number of subframes the transmission must be anticipated
uint32_t tti_tx = TTI_TX(current_tti_); uint32_t tti_tx = TTI_TX(current_tti_);
if (srslte_prach_tti_opportunity(&prach_obj, tti_tx, allowed_subframe)) { if (srslte_prach_tti_opportunity(&prach_obj, tti_tx, allowed_subframe)) {
Debug("PRACH Buffer: Ready to send at tti: %d (now is %d)\n", tti_tx, current_tti_); Debug("PRACH Buffer: Ready to send at tti: %d (now is %d)", tti_tx, current_tti_);
transmitted_tti = tti_tx; transmitted_tti = tti_tx;
return true; return true;
} }
@ -205,7 +203,7 @@ cf_t* prach::generate(float cfo, uint32_t* nof_sf, float* target_power)
{ {
if (!cell_initiated || preamble_idx < 0 || !nof_sf || unsigned(preamble_idx) >= max_preambles || if (!cell_initiated || preamble_idx < 0 || !nof_sf || unsigned(preamble_idx) >= max_preambles ||
!srslte_cell_isvalid(&cell) || len >= MAX_LEN_SF * 30720 || len == 0) { !srslte_cell_isvalid(&cell) || len >= MAX_LEN_SF * 30720 || len == 0) {
Error("PRACH: Invalid parameters: cell_initiated=%d, preamble_idx=%d, cell.nof_prb=%d, len=%d\n", Error("PRACH: Invalid parameters: cell_initiated=%d, preamble_idx=%d, cell.nof_prb=%d, len=%d",
cell_initiated, cell_initiated,
preamble_idx, preamble_idx,
cell.nof_prb, cell.nof_prb,
@ -221,7 +219,7 @@ cf_t* prach::generate(float cfo, uint32_t* nof_sf, float* target_power)
f_idx += 6; f_idx += 6;
} }
if (f_idx >= max_fs) { if (f_idx >= max_fs) {
Error("PRACH Buffer: Invalid f_idx=%d\n", f_idx); Error("PRACH Buffer: Invalid f_idx=%d", f_idx);
f_idx = 0; f_idx = 0;
} }
} }
@ -231,7 +229,7 @@ cf_t* prach::generate(float cfo, uint32_t* nof_sf, float* target_power)
} }
if (!is_buffer_generated(f_idx, preamble_idx)) { if (!is_buffer_generated(f_idx, preamble_idx)) {
Error("PRACH Buffer not generated: f_idx=%d preamble_idx=%d\n", f_idx, preamble_idx); Error("PRACH Buffer not generated: f_idx=%d preamble_idx=%d", f_idx, preamble_idx);
return nullptr; return nullptr;
} }
@ -248,7 +246,7 @@ cf_t* prach::generate(float cfo, uint32_t* nof_sf, float* target_power)
*target_power = target_power_dbm; *target_power = target_power_dbm;
} }
Info("PRACH: Transmitted preamble=%d, tti_tx=%d, CFO=%.2f KHz, nof_sf=%d, target_power=%.1f dBm\n", Info("PRACH: Transmitted preamble=%d, tti_tx=%d, CFO=%.2f KHz, nof_sf=%d, target_power=%.1f dBm",
preamble_idx, preamble_idx,
transmitted_tti, transmitted_tti,
cfo * 15, cfo * 15,

32
srsue/src/phy/scell/intra_measure.cc
Unescape Escape View File

@ -12,22 +12,23 @@
#include "srsue/hdr/phy/scell/intra_measure.h" #include "srsue/hdr/phy/scell/intra_measure.h"
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED and log_h != nullptr) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED and log_h != nullptr) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED and log_h != nullptr) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED and log_h != nullptr) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
namespace srsue { namespace srsue {
namespace scell { namespace scell {
intra_measure::intra_measure() : scell(), thread("SYNC_INTRA_MEASURE") {} intra_measure::intra_measure(srslog::basic_logger& logger) : scell(logger), logger(logger), thread("SYNC_INTRA_MEASURE")
{}
intra_measure::~intra_measure() intra_measure::~intra_measure()
{ {
@ -36,11 +37,10 @@ intra_measure::~intra_measure()
free(search_buffer); free(search_buffer);
} }
void intra_measure::init(uint32_t cc_idx_, phy_common* common, meas_itf* new_cell_itf_, srslte::log* log_h_) void intra_measure::init(uint32_t cc_idx_, phy_common* common, meas_itf* new_cell_itf_)
{ {
cc_idx = cc_idx_; cc_idx = cc_idx_;
new_cell_itf = new_cell_itf_; new_cell_itf = new_cell_itf_;
log_h = log_h_;
if (common) { if (common) {
intra_freq_meas_len_ms = common->args->intra_freq_meas_len_ms; intra_freq_meas_len_ms = common->args->intra_freq_meas_len_ms;
@ -52,7 +52,7 @@ void intra_measure::init(uint32_t cc_idx_, phy_common* common, meas_itf* new_cel
srslte_refsignal_dl_sync_init(&refsignal_dl_sync); srslte_refsignal_dl_sync_init(&refsignal_dl_sync);
// Start scell // Start scell
scell.init(log_h, intra_freq_meas_len_ms); scell.init(intra_freq_meas_len_ms);
search_buffer = srslte_vec_cf_malloc(intra_freq_meas_len_ms * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB)); search_buffer = srslte_vec_cf_malloc(intra_freq_meas_len_ms * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB));
@ -96,7 +96,7 @@ void intra_measure::meas_stop()
// Transition state to idle // Transition state to idle
// Ring-buffer shall not be reset, it will automatically be reset as soon as the FSM transitions to receive // Ring-buffer shall not be reset, it will automatically be reset as soon as the FSM transitions to receive
state.set_state(internal_state::idle); state.set_state(internal_state::idle);
Info("INTRA: Disabled neighbour cell search for EARFCN %d\n", get_earfcn()); Info("INTRA: Disabled neighbour cell search for EARFCN %d", get_earfcn());
} }
void intra_measure::set_cells_to_meas(const std::set<uint32_t>& pci) void intra_measure::set_cells_to_meas(const std::set<uint32_t>& pci)
@ -105,7 +105,7 @@ void intra_measure::set_cells_to_meas(const std::set<uint32_t>& pci)
active_pci = pci; active_pci = pci;
active_pci_mutex.unlock(); active_pci_mutex.unlock();
state.set_state(internal_state::receive); state.set_state(internal_state::receive);
log_h->info("INTRA: Received list of %zd neighbour cells to measure in EARFCN %d.\n", pci.size(), current_earfcn); logger.info("INTRA: Received list of %zd neighbour cells to measure in EARFCN %d.", pci.size(), current_earfcn);
} }
void intra_measure::write(uint32_t tti, cf_t* data, uint32_t nsamples) void intra_measure::write(uint32_t tti, cf_t* data, uint32_t nsamples)
@ -134,7 +134,7 @@ void intra_measure::write(uint32_t tti, cf_t* data, uint32_t nsamples)
// Try writing in the buffer // Try writing in the buffer
if (srslte_ringbuffer_write(&ring_buffer, data, nbytes) < nbytes) { if (srslte_ringbuffer_write(&ring_buffer, data, nbytes) < nbytes) {
Warning("INTRA: Error writing to ringbuffer (EARFCN=%d)\n", current_earfcn); Warning("INTRA: Error writing to ringbuffer (EARFCN=%d)", current_earfcn);
// Transition to wait, so it can keep receiving without stopping the component operation // Transition to wait, so it can keep receiving without stopping the component operation
state.set_state(internal_state::wait); state.set_state(internal_state::wait);
@ -201,7 +201,7 @@ void intra_measure::measure_proc()
neighbour_cells.push_back(m); neighbour_cells.push_back(m);
Info("INTRA: Found neighbour cell: EARFCN=%d, PCI=%03d, RSRP=%5.1f dBm, RSRQ=%5.1f, peak_idx=%5d, " Info("INTRA: Found neighbour cell: EARFCN=%d, PCI=%03d, RSRP=%5.1f dBm, RSRQ=%5.1f, peak_idx=%5d, "
"CFO=%+.1fHz\n", "CFO=%+.1fHz",
m.earfcn, m.earfcn,
m.pci, m.pci,
m.rsrp, m.rsrp,

18
srsue/src/phy/scell/scell_recv.cc
Unescape Escape View File

@ -19,10 +19,8 @@ namespace scell {
* Secondary cell receiver * Secondary cell receiver
*/ */
void scell_recv::init(srslte::log* _log_h, uint32_t max_sf_window) void scell_recv::init(uint32_t max_sf_window)
{ {
log_h = _log_h;
// and a separate ue_sync instance // and a separate ue_sync instance
uint32_t max_fft_sz = (uint32_t)srslte_symbol_sz(100); uint32_t max_fft_sz = (uint32_t)srslte_symbol_sz(100);
@ -30,13 +28,13 @@ void scell_recv::init(srslte::log* _log_h, uint32_t max_sf_window)
sf_buffer[0] = srslte_vec_cf_malloc(max_sf_size); sf_buffer[0] = srslte_vec_cf_malloc(max_sf_size);
if (!sf_buffer[0]) { if (!sf_buffer[0]) {
log_h->error("Error allocating %d samples for scell\n", max_sf_size); logger.error("Error allocating %d samples for scell", max_sf_size);
return; return;
} }
// do this different we don't need all this search window. // do this different we don't need all this search window.
if (srslte_sync_init(&sync_find, max_sf_window * max_sf_size, 5 * max_sf_size, max_fft_sz)) { if (srslte_sync_init(&sync_find, max_sf_window * max_sf_size, 5 * max_sf_size, max_fft_sz)) {
log_h->error("Error initiating sync_find\n"); logger.error("Error initiating sync_find");
return; return;
} }
srslte_sync_set_sss_algorithm(&sync_find, SSS_FULL); srslte_sync_set_sss_algorithm(&sync_find, SSS_FULL);
@ -80,7 +78,7 @@ scell_recv::find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cel
if (fft_sz != current_fft_sz) { if (fft_sz != current_fft_sz) {
if (srslte_sync_resize(&sync_find, nof_sf * sf_len, 5 * sf_len, fft_sz)) { if (srslte_sync_resize(&sync_find, nof_sf * sf_len, 5 * sf_len, fft_sz)) {
log_h->error("Error resizing sync nof_sf=%d, sf_len=%d, fft_sz=%d\n", nof_sf, sf_len, fft_sz); logger.error("Error resizing sync nof_sf=%d, sf_len=%d, fft_sz=%d", nof_sf, sf_len, fft_sz);
return found_cell_ids; return found_cell_ids;
} }
current_fft_sz = fft_sz; current_fft_sz = fft_sz;
@ -109,7 +107,7 @@ scell_recv::find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cel
for (uint32_t sf5_cnt = 0; sf5_cnt < nof_sf / 5; sf5_cnt++) { for (uint32_t sf5_cnt = 0; sf5_cnt < nof_sf / 5; sf5_cnt++) {
sync_res = srslte_sync_find(&sync_find, input_buffer, sf5_cnt * 5 * sf_len, &peak_idx); sync_res = srslte_sync_find(&sync_find, input_buffer, sf5_cnt * 5 * sf_len, &peak_idx);
if (sync_res == SRSLTE_SYNC_ERROR) { if (sync_res == SRSLTE_SYNC_ERROR) {
log_h->error("INTRA: Error calling sync_find()\n"); logger.error("INTRA: Error calling sync_find()");
return found_cell_ids; return found_cell_ids;
} }
@ -126,8 +124,8 @@ scell_recv::find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cel
sss_detected = true; sss_detected = true;
} }
log_h->debug("INTRA: n_id_2=%d, cnt=%d/%d, sync_res=%d, cell_id=%d, sf_idx=%d, peak_idx=%d, peak_value=%f, " logger.debug("INTRA: n_id_2=%d, cnt=%d/%d, sync_res=%d, cell_id=%d, sf_idx=%d, peak_idx=%d, peak_value=%f, "
"sss_detected=%d\n", "sss_detected=%d",
n_id_2, n_id_2,
sf5_cnt, sf5_cnt,
nof_sf / 5, nof_sf / 5,
@ -143,7 +141,7 @@ scell_recv::find_cells(const cf_t* input_buffer, const srslte_cell_t serving_cel
if (sync_res == SRSLTE_SYNC_FOUND && sss_detected && cell_id >= 0) { if (sync_res == SRSLTE_SYNC_FOUND && sss_detected && cell_id >= 0) {
// We have found a new cell, add to the list // We have found a new cell, add to the list
found_cell_ids.insert((uint32_t)cell_id); found_cell_ids.insert((uint32_t)cell_id);
log_h->debug("INTRA: Detected new cell_id=%d using PSS/SSS\n", cell_id); logger.debug("INTRA: Detected new cell_id=%d using PSS/SSS", cell_id);
} }
} }
} }

35
srsue/src/phy/search.cc
Unescape Escape View File

@ -14,16 +14,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
namespace srsue { namespace srsue {
@ -45,20 +45,19 @@ search::~search()
srslte_ue_cellsearch_free(&cs); srslte_ue_cellsearch_free(&cs);
} }
void search::init(srslte::rf_buffer_t& buffer_, srslte::log* log_h_, uint32_t nof_rx_channels, search_callback* parent) void search::init(srslte::rf_buffer_t& buffer_, uint32_t nof_rx_channels, search_callback* parent)
{ {
log_h = log_h_;
p = parent; p = parent;
buffer = buffer_; buffer = buffer_;
if (srslte_ue_cellsearch_init_multi(&cs, 8, radio_recv_callback, nof_rx_channels, parent)) { if (srslte_ue_cellsearch_init_multi(&cs, 8, radio_recv_callback, nof_rx_channels, parent)) {
Error("SYNC: Initiating UE cell search\n"); Error("SYNC: Initiating UE cell search");
} }
srslte_ue_cellsearch_set_nof_valid_frames(&cs, 4); srslte_ue_cellsearch_set_nof_valid_frames(&cs, 4);
if (srslte_ue_mib_sync_init_multi(&ue_mib_sync, radio_recv_callback, nof_rx_channels, parent)) { if (srslte_ue_mib_sync_init_multi(&ue_mib_sync, radio_recv_callback, nof_rx_channels, parent)) {
Error("SYNC: Initiating UE MIB synchronization\n"); Error("SYNC: Initiating UE MIB synchronization");
} }
// Set options defined in expert section // Set options defined in expert section
@ -87,7 +86,7 @@ void search::set_agc_enable(bool enable)
rf_info->max_rx_gain, rf_info->max_rx_gain,
p->get_radio()->get_rx_gain()); p->get_radio()->get_rx_gain());
} else { } else {
ERROR("Error stop AGC not implemented\n"); ERROR("Error stop AGC not implemented");
} }
} }
@ -103,7 +102,7 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
uint32_t max_peak_cell = 0; uint32_t max_peak_cell = 0;
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
Info("SYNC: Searching for cell...\n"); Info("SYNC: Searching for cell...");
srslte::console("."); srslte::console(".");
if (force_N_id_2 >= 0 && force_N_id_2 < 3) { if (force_N_id_2 >= 0 && force_N_id_2 < 3) {
@ -114,10 +113,10 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
} }
if (ret < 0) { if (ret < 0) {
Error("SYNC: Error decoding MIB: Error searching PSS\n"); Error("SYNC: Error decoding MIB: Error searching PSS");
return ERROR; return ERROR;
} else if (ret == 0) { } else if (ret == 0) {
Info("SYNC: Could not find any cell in this frequency\n"); Info("SYNC: Could not find any cell in this frequency");
return CELL_NOT_FOUND; return CELL_NOT_FOUND;
} }
// Save result // Save result
@ -127,14 +126,14 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
float cfo = found_cells[max_peak_cell].cfo; float cfo = found_cells[max_peak_cell].cfo;
srslte::console("\n"); srslte::console("\n");
Info("SYNC: PSS/SSS detected: Mode=%s, PCI=%d, CFO=%.1f KHz, CP=%s\n", Info("SYNC: PSS/SSS detected: Mode=%s, PCI=%d, CFO=%.1f KHz, CP=%s",
new_cell.frame_type ? "TDD" : "FDD", new_cell.frame_type ? "TDD" : "FDD",
new_cell.id, new_cell.id,
cfo / 1000, cfo / 1000,
srslte_cp_string(new_cell.cp)); srslte_cp_string(new_cell.cp));
if (srslte_ue_mib_sync_set_cell(&ue_mib_sync, new_cell)) { if (srslte_ue_mib_sync_set_cell(&ue_mib_sync, new_cell)) {
Error("SYNC: Setting UE MIB cell\n"); Error("SYNC: Setting UE MIB cell");
return ERROR; return ERROR;
} }
@ -161,7 +160,7 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
new_cell.nof_ports, new_cell.nof_ports,
cfo / 1000); cfo / 1000);
Info("SYNC: MIB Decoded: Mode=%s, PCI=%d, PRB=%d, Ports=%d, CFO=%.1f KHz\n", Info("SYNC: MIB Decoded: Mode=%s, PCI=%d, PRB=%d, Ports=%d, CFO=%.1f KHz",
new_cell.frame_type ? "TDD" : "FDD", new_cell.frame_type ? "TDD" : "FDD",
new_cell.id, new_cell.id,
new_cell.nof_prb, new_cell.nof_prb,
@ -169,7 +168,7 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
cfo / 1000); cfo / 1000);
if (!srslte_cell_isvalid(&new_cell)) { if (!srslte_cell_isvalid(&new_cell)) {
Error("SYNC: Detected invalid cell.\n"); Error("SYNC: Detected invalid cell.");
return CELL_NOT_FOUND; return CELL_NOT_FOUND;
} }
@ -180,10 +179,10 @@ search::ret_code search::run(srslte_cell_t* cell_, std::array<uint8_t, SRSLTE_BC
return CELL_FOUND; return CELL_FOUND;
} else if (ret == 0) { } else if (ret == 0) {
Warning("SYNC: Found PSS but could not decode PBCH\n"); Warning("SYNC: Found PSS but could not decode PBCH");
return CELL_NOT_FOUND; return CELL_NOT_FOUND;
} else { } else {
Error("SYNC: Receiving MIB\n"); Error("SYNC: Receiving MIB");
return ERROR; return ERROR;
} }
} }

24
srsue/src/phy/sfn_sync.cc
Unescape Escape View File

@ -14,16 +14,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) logger.debug(fmt, ##__VA_ARGS__)
namespace srsue { namespace srsue {
@ -36,10 +36,8 @@ void sfn_sync::init(srslte_ue_sync_t* ue_sync_,
const phy_args_t* phy_args_, const phy_args_t* phy_args_,
srslte::rf_buffer_t& buffer, srslte::rf_buffer_t& buffer,
uint32_t buffer_max_samples_, uint32_t buffer_max_samples_,
srslte::log* log_h_,
uint32_t nof_subframes) uint32_t nof_subframes)
{ {
log_h = log_h_;
ue_sync = ue_sync_; ue_sync = ue_sync_;
phy_args = phy_args_; phy_args = phy_args_;
timeout = nof_subframes; timeout = nof_subframes;
@ -49,14 +47,14 @@ void sfn_sync::init(srslte_ue_sync_t* ue_sync_,
// MIB decoder uses a single receiver antenna in logical channel 0 // MIB decoder uses a single receiver antenna in logical channel 0
if (srslte_ue_mib_init(&ue_mib, buffer.get(0), SRSLTE_MAX_PRB)) { if (srslte_ue_mib_init(&ue_mib, buffer.get(0), SRSLTE_MAX_PRB)) {
Error("SYNC: Initiating UE MIB decoder\n"); Error("SYNC: Initiating UE MIB decoder");
} }
} }
bool sfn_sync::set_cell(srslte_cell_t cell_) bool sfn_sync::set_cell(srslte_cell_t cell_)
{ {
if (srslte_ue_mib_set_cell(&ue_mib, cell_)) { if (srslte_ue_mib_set_cell(&ue_mib, cell_)) {
Error("SYNC: Setting cell: initiating ue_mib\n"); Error("SYNC: Setting cell: initiating ue_mib");
return false; return false;
} }
reset(); reset();
@ -76,7 +74,7 @@ sfn_sync::ret_code sfn_sync::run_subframe(srslte_cell_t*
{ {
int ret = srslte_ue_sync_zerocopy(ue_sync, mib_buffer.to_cf_t(), buffer_max_samples); int ret = srslte_ue_sync_zerocopy(ue_sync, mib_buffer.to_cf_t(), buffer_max_samples);
if (ret < 0) { if (ret < 0) {
Error("SYNC: Error calling ue_sync_get_buffer.\n"); Error("SYNC: Error calling ue_sync_get_buffer.");
return ERROR; return ERROR;
} }
@ -86,7 +84,7 @@ sfn_sync::ret_code sfn_sync::run_subframe(srslte_cell_t*
return ret2; return ret2;
} }
} else { } else {
Info("SYNC: Waiting for PSS while trying to decode MIB (%d/%d)\n", cnt, timeout); Info("SYNC: Waiting for PSS while trying to decode MIB (%d/%d)", cnt, timeout);
} }
cnt++; cnt++;
@ -135,19 +133,19 @@ sfn_sync::ret_code sfn_sync::decode_mib(srslte_cell_t*
// Check if SNR is below the minimum threshold // Check if SNR is below the minimum threshold
if (ue_mib.chest_res.snr_db < phy_args->in_sync_snr_db_th) { if (ue_mib.chest_res.snr_db < phy_args->in_sync_snr_db_th) {
Info("SYNC: MIB decoded, SNR is too low (%+.1f < %+.1f)\n", Info("SYNC: MIB decoded, SNR is too low (%+.1f < %+.1f)",
ue_mib.chest_res.snr_db, ue_mib.chest_res.snr_db,
phy_args->in_sync_snr_db_th); phy_args->in_sync_snr_db_th);
return SFN_NOFOUND; return SFN_NOFOUND;
} }
Info("SYNC: DONE, SNR=%.1f dB, TTI=%d, sfn_offset=%d\n", ue_mib.chest_res.snr_db, *tti_cnt, sfn_offset); Info("SYNC: DONE, SNR=%.1f dB, TTI=%d, sfn_offset=%d", ue_mib.chest_res.snr_db, *tti_cnt, sfn_offset);
} }
reset(); reset();
return SFN_FOUND; return SFN_FOUND;
case SRSLTE_UE_MIB_NOTFOUND: case SRSLTE_UE_MIB_NOTFOUND:
Info("SYNC: Found PSS but could not decode MIB. SNR=%.1f dB (%d/%d)\n", ue_mib.chest_res.snr_db, cnt, timeout); Info("SYNC: Found PSS but could not decode MIB. SNR=%.1f dB (%d/%d)", ue_mib.chest_res.snr_db, cnt, timeout);
return SFN_NOFOUND; return SFN_NOFOUND;
} }
} }

156
srsue/src/phy/sync.cc
Unescape Escape View File

@ -20,16 +20,16 @@
#define Error(fmt, ...) \ #define Error(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->error(fmt, ##__VA_ARGS__) phy_logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) \ #define Warning(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->warning(fmt, ##__VA_ARGS__) phy_logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) \ #define Info(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->info(fmt, ##__VA_ARGS__) phy_logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) \ #define Debug(fmt, ...) \
if (SRSLTE_DEBUG_ENABLED) \ if (SRSLTE_DEBUG_ENABLED) \
log_h->debug(fmt, ##__VA_ARGS__) phy_logger.debug(fmt, ##__VA_ARGS__)
namespace srsue { namespace srsue {
@ -51,14 +51,10 @@ void sync::init(srslte::radio_interface_phy* _radio,
lte::worker_pool* _lte_workers_pool, lte::worker_pool* _lte_workers_pool,
nr::worker_pool* _nr_workers_pool, nr::worker_pool* _nr_workers_pool,
phy_common* _worker_com, phy_common* _worker_com,
srslte::log* _log_h,
srslte::log* _log_phy_lib_h,
uint32_t prio, uint32_t prio,
int sync_cpu_affinity) int sync_cpu_affinity)
{ {
radio_h = _radio; radio_h = _radio;
log_h = _log_h;
log_phy_lib_h = _log_phy_lib_h;
stack = _stack; stack = _stack;
lte_worker_pool = _lte_workers_pool; lte_worker_pool = _lte_workers_pool;
nr_worker_pool = _nr_workers_pool; nr_worker_pool = _nr_workers_pool;
@ -68,13 +64,13 @@ void sync::init(srslte::radio_interface_phy* _radio,
nof_rf_channels = nof_rf_channels =
(worker_com->args->nof_lte_carriers + worker_com->args->nof_nr_carriers) * worker_com->args->nof_rx_ant; (worker_com->args->nof_lte_carriers + worker_com->args->nof_nr_carriers) * worker_com->args->nof_rx_ant;
if (nof_rf_channels == 0 || nof_rf_channels > SRSLTE_MAX_CHANNELS) { if (nof_rf_channels == 0 || nof_rf_channels > SRSLTE_MAX_CHANNELS) {
Error("SYNC: Invalid number of RF channels (%d)\n", nof_rf_channels); Error("SYNC: Invalid number of RF channels (%d)", nof_rf_channels);
return; return;
} }
if (srslte_ue_sync_init_multi(&ue_sync, SRSLTE_MAX_PRB, false, radio_recv_callback, nof_rf_channels, this) != if (srslte_ue_sync_init_multi(&ue_sync, SRSLTE_MAX_PRB, false, radio_recv_callback, nof_rf_channels, this) !=
SRSLTE_SUCCESS) { SRSLTE_SUCCESS) {
Error("SYNC: Initiating ue_sync\n"); Error("SYNC: Initiating ue_sync");
return; return;
} }
@ -83,15 +79,15 @@ void sync::init(srslte::radio_interface_phy* _radio,
} }
// Initialize cell searcher // Initialize cell searcher
search_p.init(sf_buffer, log_h, nof_rf_channels, this); search_p.init(sf_buffer, nof_rf_channels, this);
// Initialize SFN synchronizer, it uses only pcell buffer // Initialize SFN synchronizer, it uses only pcell buffer
sfn_p.init(&ue_sync, worker_com->args, sf_buffer, sf_buffer.size(), log_h); sfn_p.init(&ue_sync, worker_com->args, sf_buffer, sf_buffer.size());
// Start intra-frequency measurement // Start intra-frequency measurement
for (uint32_t i = 0; i < worker_com->args->nof_lte_carriers; i++) { for (uint32_t i = 0; i < worker_com->args->nof_lte_carriers; i++) {
scell::intra_measure* q = new scell::intra_measure; scell::intra_measure* q = new scell::intra_measure(phy_logger);
q->init(i, worker_com, this, log_h); q->init(i, worker_com, this);
intra_freq_meas.push_back(std::unique_ptr<scell::intra_measure>(q)); intra_freq_meas.push_back(std::unique_ptr<scell::intra_measure>(q));
} }
@ -181,12 +177,12 @@ bool sync::cell_search_init()
std::unique_lock<std::mutex> ul(rrc_mutex); std::unique_lock<std::mutex> ul(rrc_mutex);
if (rrc_proc_state != PROC_IDLE) { if (rrc_proc_state != PROC_IDLE) {
Error("Cell Search: Can't start procedure. SYNC already running a procedure (%d)\n", (uint32_t)rrc_proc_state); Error("Cell Search: Can't start procedure. SYNC already running a procedure (%d)", (uint32_t)rrc_proc_state);
return false; return false;
} }
// Move state to IDLE // Move state to IDLE
Info("Cell Search: Start EARFCN index=%u/%zd\n", cellsearch_earfcn_index, worker_com->args->dl_earfcn_list.size()); Info("Cell Search: Start EARFCN index=%u/%zd", cellsearch_earfcn_index, worker_com->args->dl_earfcn_list.size());
phy_state.go_idle(); phy_state.go_idle();
worker_com->reset(); worker_com->reset();
@ -207,7 +203,7 @@ rrc_interface_phy_lte::cell_search_ret_t sync::cell_search_start(phy_cell_t* fou
ret.last_freq = rrc_interface_phy_lte::cell_search_ret_t::NO_MORE_FREQS; ret.last_freq = rrc_interface_phy_lte::cell_search_ret_t::NO_MORE_FREQS;
if (rrc_proc_state != PROC_SEARCH_START) { if (rrc_proc_state != PROC_SEARCH_START) {
Error("Cell Search: Can't run procedure. Must call cell_search_init() first (%d)\n", (uint32_t)rrc_proc_state); Error("Cell Search: Can't run procedure. Must call cell_search_init() first (%d)", (uint32_t)rrc_proc_state);
return ret; return ret;
} }
@ -217,28 +213,28 @@ rrc_interface_phy_lte::cell_search_ret_t sync::cell_search_start(phy_cell_t* fou
srate_mode = SRATE_FIND; srate_mode = SRATE_FIND;
radio_h->set_rx_srate(1.92e6); radio_h->set_rx_srate(1.92e6);
radio_h->set_tx_srate(1.92e6); radio_h->set_tx_srate(1.92e6);
Info("SYNC: Setting Cell Search sampling rate\n"); Info("SYNC: Setting Cell Search sampling rate");
} }
try { try {
if (current_earfcn != (int)worker_com->args->dl_earfcn_list.at(cellsearch_earfcn_index)) { if (current_earfcn != (int)worker_com->args->dl_earfcn_list.at(cellsearch_earfcn_index)) {
current_earfcn = (int)worker_com->args->dl_earfcn_list[cellsearch_earfcn_index]; current_earfcn = (int)worker_com->args->dl_earfcn_list[cellsearch_earfcn_index];
Info("Cell Search: changing frequency to EARFCN=%d\n", current_earfcn); Info("Cell Search: changing frequency to EARFCN=%d", current_earfcn);
set_frequency(); set_frequency();
} }
} catch (const std::out_of_range& oor) { } catch (const std::out_of_range& oor) {
Error("Index %d is not a valid EARFCN element.\n", cellsearch_earfcn_index); Error("Index %d is not a valid EARFCN element.", cellsearch_earfcn_index);
return ret; return ret;
} }
// Move to CELL SEARCH and wait to finish // Move to CELL SEARCH and wait to finish
Info("Cell Search: Setting Cell search state\n"); Info("Cell Search: Setting Cell search state");
phy_state.run_cell_search(); phy_state.run_cell_search();
// Check return state // Check return state
switch (cell_search_ret) { switch (cell_search_ret) {
case search::CELL_FOUND: case search::CELL_FOUND:
log_h->info("Cell Search: Found cell with PCI=%d with %d PRB\n", cell.id, cell.nof_prb); phy_logger.info("Cell Search: Found cell with PCI=%d with %d PRB", cell.id, cell.nof_prb);
if (found_cell) { if (found_cell) {
found_cell->earfcn = current_earfcn; found_cell->earfcn = current_earfcn;
found_cell->pci = cell.id; found_cell->pci = cell.id;
@ -247,18 +243,18 @@ rrc_interface_phy_lte::cell_search_ret_t sync::cell_search_start(phy_cell_t* fou
ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_FOUND; ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_FOUND;
break; break;
case search::CELL_NOT_FOUND: case search::CELL_NOT_FOUND:
Info("Cell Search: No cell found in this frequency\n"); Info("Cell Search: No cell found in this frequency");
ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_NOT_FOUND; ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_NOT_FOUND;
break; break;
default: default:
Error("Cell Search: while receiving samples\n"); Error("Cell Search: while receiving samples");
radio_error(); radio_error();
break; break;
} }
cellsearch_earfcn_index++; cellsearch_earfcn_index++;
if (cellsearch_earfcn_index >= worker_com->args->dl_earfcn_list.size()) { if (cellsearch_earfcn_index >= worker_com->args->dl_earfcn_list.size()) {
Info("Cell Search: No more frequencies in the current EARFCN set\n"); Info("Cell Search: No more frequencies in the current EARFCN set");
cellsearch_earfcn_index = 0; cellsearch_earfcn_index = 0;
ret.last_freq = rrc_interface_phy_lte::cell_search_ret_t::NO_MORE_FREQS; ret.last_freq = rrc_interface_phy_lte::cell_search_ret_t::NO_MORE_FREQS;
} else { } else {
@ -282,17 +278,17 @@ bool sync::cell_select_init(phy_cell_t new_cell)
std::unique_lock<std::mutex> ul(rrc_mutex); std::unique_lock<std::mutex> ul(rrc_mutex);
if (rrc_proc_state != PROC_IDLE) { if (rrc_proc_state != PROC_IDLE) {
Error("Cell Select: Can't start procedure. SYNC already running a procedure (%d)\n", (uint32_t)rrc_proc_state); Error("Cell Select: Can't start procedure. SYNC already running a procedure (%d)", (uint32_t)rrc_proc_state);
return false; return false;
} }
// Move state to IDLE // Move state to IDLE
if (!srslte_cellid_isvalid(new_cell.pci)) { if (!srslte_cellid_isvalid(new_cell.pci)) {
Error("Cell Select: Invalid cell_id=%d\n", new_cell.pci); Error("Cell Select: Invalid cell_id=%d", new_cell.pci);
return false; return false;
} }
Info("Cell Select: Going to IDLE\n"); Info("Cell Select: Going to IDLE");
phy_state.go_idle(); phy_state.go_idle();
worker_com->reset(); worker_com->reset();
@ -312,7 +308,7 @@ bool sync::cell_select_start(phy_cell_t new_cell)
bool ret = false; bool ret = false;
if (rrc_proc_state != PROC_SELECT_START) { if (rrc_proc_state != PROC_SELECT_START) {
Error("Cell Select: Can't run procedure. Must call cell_select_init() first (%d)\n", (uint32_t)rrc_proc_state); Error("Cell Select: Can't run procedure. Must call cell_select_init() first (%d)", (uint32_t)rrc_proc_state);
goto clean_exit; goto clean_exit;
} }
@ -325,7 +321,7 @@ bool sync::cell_select_start(phy_cell_t new_cell)
/* Reconfigure cell if necessary */ /* Reconfigure cell if necessary */
cell.id = new_cell.pci; cell.id = new_cell.pci;
if (not set_cell(new_cell.cfo_hz)) { if (not set_cell(new_cell.cfo_hz)) {
Error("Cell Select: Reconfiguring cell\n"); Error("Cell Select: Reconfiguring cell");
goto clean_exit; goto clean_exit;
} }
@ -333,9 +329,9 @@ bool sync::cell_select_start(phy_cell_t new_cell)
if ((int)new_cell.earfcn != current_earfcn) { if ((int)new_cell.earfcn != current_earfcn) {
current_earfcn = new_cell.earfcn; current_earfcn = new_cell.earfcn;
Info("Cell Select: Setting new frequency EARFCN=%d\n", new_cell.earfcn); Info("Cell Select: Setting new frequency EARFCN=%d", new_cell.earfcn);
if (!set_frequency()) { if (!set_frequency()) {
Error("Cell Select: Setting new frequency EARFCN=%d\n", new_cell.earfcn); Error("Cell Select: Setting new frequency EARFCN=%d", new_cell.earfcn);
goto clean_exit; goto clean_exit;
} }
} }
@ -345,18 +341,18 @@ bool sync::cell_select_start(phy_cell_t new_cell)
// Change sampling rate if necessary // Change sampling rate if necessary
if (srate_mode != SRATE_CAMP) { if (srate_mode != SRATE_CAMP) {
log_h->info("Cell Select: Setting CAMPING sampling rate\n"); phy_logger.info("Cell Select: Setting CAMPING sampling rate");
set_sampling_rate(); set_sampling_rate();
} }
// SFN synchronization // SFN synchronization
phy_state.run_sfn_sync(); phy_state.run_sfn_sync();
if (phy_state.is_camping()) { if (phy_state.is_camping()) {
Info("Cell Select: SFN synchronized. CAMPING...\n"); Info("Cell Select: SFN synchronized. CAMPING...");
stack->in_sync(); stack->in_sync();
ret = true; ret = true;
} else { } else {
Info("Cell Select: Could not synchronize SFN\n"); Info("Cell Select: Could not synchronize SFN");
} }
clean_exit: clean_exit:
@ -386,8 +382,8 @@ void sync::run_sfn_sync_state()
if (memcmp(&cell, &temp_cell, sizeof(srslte_cell_t)) != 0) { if (memcmp(&cell, &temp_cell, sizeof(srslte_cell_t)) != 0) {
srslte_cell_fprint(stdout, &cell, 0); srslte_cell_fprint(stdout, &cell, 0);
srslte_cell_fprint(stdout, &temp_cell, 0); srslte_cell_fprint(stdout, &temp_cell, 0);
log_h->error("Detected cell during SFN synchronization differs from configured cell. Cell reselection to " phy_logger.error("Detected cell during SFN synchronization differs from configured cell. Cell reselection to "
"cells with different MIB is not supported\n"); "cells with different MIB is not supported");
srslte::console("Detected cell during SFN synchronization differs from configured cell. Cell reselection " srslte::console("Detected cell during SFN synchronization differs from configured cell. Cell reselection "
"to cells with different MIB is not supported\n"); "to cells with different MIB is not supported\n");
phy_state.state_exit(false); phy_state.state_exit(false);
@ -408,10 +404,8 @@ void sync::run_camping_in_sync_state(lte::sf_worker* lte_worker,
srslte::rf_buffer_t& sync_buffer) srslte::rf_buffer_t& sync_buffer)
{ {
// Update logging TTI // Update logging TTI
log_h->step(tti); phy_lib_logger.set_context(tti);
if (log_phy_lib_h != nullptr) { phy_logger.set_context(tti);
log_phy_lib_h->step(tti);
}
// Check tti is synched with ue_sync // Check tti is synched with ue_sync
if (srslte_ue_sync_get_sfidx(&ue_sync) != tti % 10) { if (srslte_ue_sync_get_sfidx(&ue_sync) != tti % 10) {
@ -430,7 +424,7 @@ void sync::run_camping_in_sync_state(lte::sf_worker* lte_worker,
if (is_overflow) { if (is_overflow) {
force_camping_sfn_sync = true; force_camping_sfn_sync = true;
is_overflow = false; is_overflow = false;
log_h->info("Detected overflow, trying to resync SFN\n"); phy_logger.info("Detected overflow, trying to resync SFN");
} }
// Force decode MIB if required // Force decode MIB if required
@ -447,19 +441,19 @@ void sync::run_camping_in_sync_state(lte::sf_worker* lte_worker,
force_camping_sfn_sync = false; force_camping_sfn_sync = false;
if (memcmp(&cell, &temp_cell, sizeof(srslte_cell_t)) != 0) { if (memcmp(&cell, &temp_cell, sizeof(srslte_cell_t)) != 0) {
log_h->error("Detected cell during SFN synchronization differs from configured cell. Cell " phy_logger.error("Detected cell during SFN synchronization differs from configured cell. Cell "
"reselection to cells with different MIB is not supported\n"); "reselection to cells with different MIB is not supported");
srslte::console("Detected cell during SFN synchronization differs from configured cell. Cell " srslte::console("Detected cell during SFN synchronization differs from configured cell. Cell "
"reselection to cells with different MIB is not supported\n"); "reselection to cells with different MIB is not supported\n");
} else { } else {
log_h->info("SFN resynchronized successfully\n"); phy_logger.info("SFN resynchronized successfully");
} }
} else { } else {
log_h->warning("SFN not yet synchronized, sending out-of-sync\n"); phy_logger.warning("SFN not yet synchronized, sending out-of-sync");
} }
} }
Debug("SYNC: Worker %d synchronized\n", lte_worker->get_id()); Debug("SYNC: Worker %d synchronized", lte_worker->get_id());
metrics.sfo = srslte_ue_sync_get_sfo(&ue_sync); metrics.sfo = srslte_ue_sync_get_sfo(&ue_sync);
metrics.cfo = srslte_ue_sync_get_cfo(&ue_sync); metrics.cfo = srslte_ue_sync_get_cfo(&ue_sync);
@ -472,7 +466,7 @@ void sync::run_camping_in_sync_state(lte::sf_worker* lte_worker,
if (prach_buffer->is_ready_to_send(tti, cell.id)) { if (prach_buffer->is_ready_to_send(tti, cell.id)) {
prach_ptr = prach_buffer->generate(get_tx_cfo(), &prach_nof_sf, &prach_power); prach_ptr = prach_buffer->generate(get_tx_cfo(), &prach_nof_sf, &prach_power);
if (prach_ptr == nullptr) { if (prach_ptr == nullptr) {
Error("Generating PRACH\n"); Error("Generating PRACH");
} }
} }
@ -551,7 +545,7 @@ void sync::run_camping_state()
run_camping_in_sync_state(lte_worker, nr_worker, sync_buffer); run_camping_in_sync_state(lte_worker, nr_worker, sync_buffer);
break; break;
case 0: case 0:
Warning("SYNC: Out-of-sync detected in PSS/SSS\n"); Warning("SYNC: Out-of-sync detected in PSS/SSS");
out_of_sync(); out_of_sync();
lte_worker->release(); lte_worker->release();
@ -568,7 +562,7 @@ void sync::run_camping_state()
} }
// Run stack // Run stack
Debug("run_stack_tti: from main\n"); Debug("run_stack_tti: from main");
run_stack_tti(); run_stack_tti();
} }
@ -579,7 +573,7 @@ void sync::run_idle_state()
if (std::isnormal(current_srate) and current_srate > 0.0f) { if (std::isnormal(current_srate) and current_srate > 0.0f) {
nsamples = current_srate / 1000; nsamples = current_srate / 1000;
} }
Debug("Discarding %d samples\n", nsamples); Debug("Discarding %d samples", nsamples);
srslte_timestamp_t rx_time = {}; srslte_timestamp_t rx_time = {};
dummy_buffer.set_nof_samples(nsamples); dummy_buffer.set_nof_samples(nsamples);
if (radio_recv_fnc(dummy_buffer, &rx_time) == SRSLTE_SUCCESS) { if (radio_recv_fnc(dummy_buffer, &rx_time) == SRSLTE_SUCCESS) {
@ -591,7 +585,7 @@ void sync::run_idle_state()
} }
radio_h->tx_end(); radio_h->tx_end();
} else { } else {
Debug("Sleeping\n"); Debug("Sleeping");
usleep(1000); usleep(1000);
} }
} }
@ -599,11 +593,9 @@ void sync::run_idle_state()
void sync::run_thread() void sync::run_thread()
{ {
while (running) { while (running) {
if (log_phy_lib_h) { phy_lib_logger.set_context(tti);
log_phy_lib_h->step(tti);
}
Debug("SYNC: state=%s, tti=%d\n", phy_state.to_string(), tti); Debug("SYNC: state=%s, tti=%d", phy_state.to_string(), tti);
// If not camping, clear SFN sync // If not camping, clear SFN sync
if (!phy_state.is_camping()) { if (!phy_state.is_camping()) {
@ -642,7 +634,7 @@ void sync::radio_overflow()
void sync::radio_error() void sync::radio_error()
{ {
log_h->error("SYNC: Receiving from radio.\n"); phy_logger.error("SYNC: Receiving from radio.");
// Need to find a method to effectively reset radio, reloading the driver does not work // Need to find a method to effectively reset radio, reloading the driver does not work
radio_h->reset(); radio_h->reset();
} }
@ -662,10 +654,10 @@ void sync::in_sync()
void sync::out_of_sync() void sync::out_of_sync()
{ {
// Send RRC out-of-sync signal after NOF_OUT_OF_SYNC_SF consecutive subframes // Send RRC out-of-sync signal after NOF_OUT_OF_SYNC_SF consecutive subframes
Info("Out-of-sync %d/%d\n", out_of_sync_cnt, worker_com->args->nof_out_of_sync_events); Info("Out-of-sync %d/%d", out_of_sync_cnt, worker_com->args->nof_out_of_sync_events);
out_of_sync_cnt++; out_of_sync_cnt++;
if (out_of_sync_cnt == worker_com->args->nof_out_of_sync_events) { if (out_of_sync_cnt == worker_com->args->nof_out_of_sync_events) {
Info("Sending to RRC\n"); Info("Sending to RRC");
stack->out_of_sync(); stack->out_of_sync();
out_of_sync_cnt = 0; out_of_sync_cnt = 0;
in_sync_cnt = 0; in_sync_cnt = 0;
@ -692,14 +684,14 @@ void sync::set_agc_enable(bool enable)
// PHY and radio must have been initialised // PHY and radio must have been initialised
if (not running or radio_h == nullptr) { if (not running or radio_h == nullptr) {
ERROR("Error setting AGC: PHY not initiated\n"); ERROR("Error setting AGC: PHY not initiated");
return; return;
} }
// Get radio info and check it is valid // Get radio info and check it is valid
srslte_rf_info_t* rf_info = radio_h->get_info(); srslte_rf_info_t* rf_info = radio_h->get_info();
if (rf_info == nullptr) { if (rf_info == nullptr) {
Error("Error: Radio does not provide RF information\n"); Error("Error: Radio does not provide RF information");
return; return;
} }
@ -765,7 +757,7 @@ void sync::set_ue_sync_opts(srslte_ue_sync_t* q, float cfo)
} else if (!worker_com->args->sss_algorithm.compare("full")) { } else if (!worker_com->args->sss_algorithm.compare("full")) {
sss_alg = SSS_FULL; sss_alg = SSS_FULL;
} else { } else {
Warning("SYNC: Invalid SSS algorithm %s. Using 'full'\n", worker_com->args->sss_algorithm.c_str()); Warning("SYNC: Invalid SSS algorithm %s. Using 'full'", worker_com->args->sss_algorithm.c_str());
} }
srslte_sync_set_sss_algorithm(&q->strack, (sss_alg_t)sss_alg); srslte_sync_set_sss_algorithm(&q->strack, (sss_alg_t)sss_alg);
srslte_sync_set_sss_algorithm(&q->sfind, (sss_alg_t)sss_alg); srslte_sync_set_sss_algorithm(&q->sfind, (sss_alg_t)sss_alg);
@ -776,23 +768,23 @@ bool sync::set_cell(float cfo)
// Wait for SYNC thread to transition to IDLE (max. 2000ms) // Wait for SYNC thread to transition to IDLE (max. 2000ms)
uint32_t cnt = 0; uint32_t cnt = 0;
while (!phy_state.is_idle() && cnt <= 4000) { while (!phy_state.is_idle() && cnt <= 4000) {
Info("SYNC: PHY state is_idle=%d, cnt=%d\n", phy_state.is_idle(), cnt); Info("SYNC: PHY state is_idle=%d, cnt=%d", phy_state.is_idle(), cnt);
usleep(500); usleep(500);
cnt++; cnt++;
} }
if (!phy_state.is_idle()) { if (!phy_state.is_idle()) {
Error("Can not change Cell while not in IDLE\n"); Error("Can not change Cell while not in IDLE");
return false; return false;
} }
if (!srslte_cell_isvalid(&cell)) { if (!srslte_cell_isvalid(&cell)) {
Error("SYNC: Setting cell: invalid cell (nof_prb=%d, pci=%d, ports=%d)\n", cell.nof_prb, cell.id, cell.nof_ports); Error("SYNC: Setting cell: invalid cell (nof_prb=%d, pci=%d, ports=%d)", cell.nof_prb, cell.id, cell.nof_ports);
return false; return false;
} }
// Set cell in all objects // Set cell in all objects
if (srslte_ue_sync_set_cell(&ue_sync, cell)) { if (srslte_ue_sync_set_cell(&ue_sync, cell)) {
Error("SYNC: Setting cell: initiating ue_sync\n"); Error("SYNC: Setting cell: initiating ue_sync");
return false; return false;
} }
sfn_p.set_cell(cell); sfn_p.set_cell(cell);
@ -812,7 +804,7 @@ bool sync::set_cell(float cfo)
} }
} }
if (!success) { if (!success) {
Error("SYNC: Setting cell: initiating PHCH worker\n"); Error("SYNC: Setting cell: initiating PHCH worker");
return false; return false;
} }
@ -848,10 +840,8 @@ bool sync::set_frequency()
} }
} }
if (set_dl_freq > 0 && set_ul_freq > 0) { if (set_dl_freq > 0 && set_ul_freq > 0) {
log_h->info("SYNC: Set DL EARFCN=%d, f_dl=%.1f MHz, f_ul=%.1f MHz\n", phy_logger.info(
current_earfcn, "SYNC: Set DL EARFCN=%d, f_dl=%.1f MHz, f_ul=%.1f MHz", current_earfcn, set_dl_freq / 1e6, set_ul_freq / 1e6);
set_dl_freq / 1e6,
set_ul_freq / 1e6);
// Logical channel is 0 // Logical channel is 0
radio_h->set_rx_freq(0, set_dl_freq); radio_h->set_rx_freq(0, set_dl_freq);
@ -868,7 +858,7 @@ bool sync::set_frequency()
return true; return true;
} else { } else {
log_h->error("SYNC: Cell Search: Invalid EARFCN=%d\n", current_earfcn); phy_logger.error("SYNC: Cell Search: Invalid EARFCN=%d", current_earfcn);
return false; return false;
} }
} }
@ -877,19 +867,19 @@ void sync::set_sampling_rate()
{ {
float new_srate = (float)srslte_sampling_freq_hz(cell.nof_prb); float new_srate = (float)srslte_sampling_freq_hz(cell.nof_prb);
if (new_srate < 0.0) { if (new_srate < 0.0) {
Error("Invalid sampling rate for %d PRBs. keeping same.\n", cell.nof_prb); Error("Invalid sampling rate for %d PRBs. keeping same.", cell.nof_prb);
return; return;
} }
if (current_srate != new_srate || srate_mode != SRATE_CAMP) { if (current_srate != new_srate || srate_mode != SRATE_CAMP) {
current_srate = new_srate; current_srate = new_srate;
Info("SYNC: Setting sampling rate %.2f MHz\n", current_srate / 1000000); Info("SYNC: Setting sampling rate %.2f MHz", current_srate / 1000000);
srate_mode = SRATE_CAMP; srate_mode = SRATE_CAMP;
radio_h->set_rx_srate(current_srate); radio_h->set_rx_srate(current_srate);
radio_h->set_tx_srate(current_srate); radio_h->set_tx_srate(current_srate);
} else { } else {
Error("Error setting sampling rate for cell with %d PRBs\n", cell.nof_prb); Error("Error setting sampling rate for cell with %d PRBs", cell.nof_prb);
} }
} }
@ -933,7 +923,7 @@ int sync::radio_recv_fnc(srslte::rf_buffer_t& data, srslte_timestamp_t* rx_time)
// Run stack if the sync state is not in camping // Run stack if the sync state is not in camping
if (not phy_state.is_camping()) { if (not phy_state.is_camping()) {
Debug("run_stack_tti: from recv\n"); Debug("run_stack_tti: from recv");
run_stack_tti(); run_stack_tti();
} }
@ -954,7 +944,7 @@ int sync::radio_recv_fnc(srslte::rf_buffer_t& data, srslte_timestamp_t* rx_time)
} }
} }
log_h->debug("SYNC: received %d samples from radio\n", data.get_nof_samples()); phy_logger.debug("SYNC: received %d samples from radio", data.get_nof_samples());
return data.get_nof_samples(); return data.get_nof_samples();
} }
@ -965,14 +955,14 @@ void sync::run_stack_tti()
if (forced_rx_time_init || srslte_timestamp_iszero(&stack_tti_ts) || if (forced_rx_time_init || srslte_timestamp_iszero(&stack_tti_ts) ||
srslte_timestamp_compare(&stack_tti_ts_new, &stack_tti_ts) < 0) { srslte_timestamp_compare(&stack_tti_ts_new, &stack_tti_ts) < 0) {
if (srslte_timestamp_compare(&stack_tti_ts_new, &stack_tti_ts) < 0) { if (srslte_timestamp_compare(&stack_tti_ts_new, &stack_tti_ts) < 0) {
log_h->warning("SYNC: radio time seems to be going backwards (rx_time=%f, tti_ts=%f)\n", phy_logger.warning("SYNC: radio time seems to be going backwards (rx_time=%f, tti_ts=%f)",
srslte_timestamp_real(&stack_tti_ts_new), srslte_timestamp_real(&stack_tti_ts_new),
srslte_timestamp_real(&stack_tti_ts)); srslte_timestamp_real(&stack_tti_ts));
// time-stamp will be set to rx time below and run_tti() will be called with MIN_TTI_JUMP // time-stamp will be set to rx time below and run_tti() will be called with MIN_TTI_JUMP
} }
// init tti_ts with last rx time // init tti_ts with last rx time
log_h->debug("SYNC: Setting initial TTI time to %f\n", srslte_timestamp_real(&stack_tti_ts_new)); phy_logger.debug("SYNC: Setting initial TTI time to %f", srslte_timestamp_real(&stack_tti_ts_new));
srslte_timestamp_copy(&stack_tti_ts, &stack_tti_ts_new); srslte_timestamp_copy(&stack_tti_ts, &stack_tti_ts_new);
forced_rx_time_init = false; forced_rx_time_init = false;
} }
@ -985,14 +975,14 @@ void sync::run_stack_tti()
int32_t tti_jump = static_cast<int32_t>(srslte_timestamp_uint64(&temp, 1e3)); int32_t tti_jump = static_cast<int32_t>(srslte_timestamp_uint64(&temp, 1e3));
tti_jump = SRSLTE_MAX(tti_jump, MIN_TTI_JUMP); tti_jump = SRSLTE_MAX(tti_jump, MIN_TTI_JUMP);
if (tti_jump > MAX_TTI_JUMP) { if (tti_jump > MAX_TTI_JUMP) {
log_h->warning("SYNC: TTI jump of %d limited to %d\n", tti_jump, MAX_TTI_JUMP); phy_logger.warning("SYNC: TTI jump of %d limited to %d", tti_jump, int(MAX_TTI_JUMP));
tti_jump = SRSLTE_MIN(tti_jump, MAX_TTI_JUMP); tti_jump = SRSLTE_MIN(tti_jump, MAX_TTI_JUMP);
} }
// Run stack // Run stack
Debug("run_stack_tti: calling stack tti=%d, tti_jump=%d\n", tti, tti_jump); Debug("run_stack_tti: calling stack tti=%d, tti_jump=%d", tti, tti_jump);
stack->run_tti(tti, tti_jump); stack->run_tti(tti, tti_jump);
Debug("run_stack_tti: stack called\n"); Debug("run_stack_tti: stack called");
} }
// update timestamp // update timestamp
@ -1025,7 +1015,7 @@ void sync::set_cells_to_meas(uint32_t earfcn_, const std::set<uint32_t>& pci)
} }
} }
if (!found) { if (!found) {
log_h->error("Neighbour cell measurement not supported in secondary carrier. EARFCN=%d\n", earfcn_); phy_logger.error("Neighbour cell measurement not supported in secondary carrier. EARFCN=%d", earfcn_);
} }
} }

48
srsue/src/stack/mac/demux.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/demux.h" #include "srsue/hdr/stack/mac/demux.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
@ -21,7 +21,8 @@
namespace srsue { namespace srsue {
demux::demux(log_ref log_h_) : log_h(log_h_), mac_msg(20, log_h_), mch_mac_msg(20, log_h_), pending_mac_msg(20, log_h_) demux::demux(log_ref log_h_, srslog::basic_logger& logger) :
log_h(log_h_), logger(logger), mac_msg(20, log_h_), mch_mac_msg(20, log_h_), pending_mac_msg(20, log_h_)
{} {}
void demux::init(phy_interface_mac_common* phy_, void demux::init(phy_interface_mac_common* phy_,
@ -89,7 +90,7 @@ void demux::push_pdu_temp_crnti(uint8_t* buff, uint32_t nof_bytes)
switch (pending_mac_msg.get()->dl_sch_ce_type()) { switch (pending_mac_msg.get()->dl_sch_ce_type()) {
case srslte::dl_sch_lcid::CON_RES_ID: case srslte::dl_sch_lcid::CON_RES_ID:
if (!is_uecrid_successful) { if (!is_uecrid_successful) {
Debug("Found Contention Resolution ID CE\n"); Debug("Found Contention Resolution ID CE");
is_uecrid_successful = mac->contention_resolution_id_rcv(pending_mac_msg.get()->get_con_res_id()); is_uecrid_successful = mac->contention_resolution_id_rcv(pending_mac_msg.get()->get_con_res_id());
} }
break; break;
@ -102,13 +103,13 @@ void demux::push_pdu_temp_crnti(uint8_t* buff, uint32_t nof_bytes)
} }
pending_mac_msg.reset(); pending_mac_msg.reset();
if (is_uecrid_successful) { if (is_uecrid_successful) {
Debug("Saved MAC PDU with Temporal C-RNTI in buffer\n"); Debug("Saved MAC PDU with Temporal C-RNTI in buffer");
pdus.push(buff, nof_bytes, srslte::pdu_queue::DCH); pdus.push(buff, nof_bytes, srslte::pdu_queue::DCH);
} else { } else {
pdus.deallocate(buff); pdus.deallocate(buff);
} }
} else { } else {
Warning("Trying to push PDU with payload size zero\n"); Warning("Trying to push PDU with payload size zero");
} }
} }
@ -148,13 +149,13 @@ bool demux::process_pdus()
void demux::process_pdu(uint8_t* mac_pdu, uint32_t nof_bytes, srslte::pdu_queue::channel_t channel) void demux::process_pdu(uint8_t* mac_pdu, uint32_t nof_bytes, srslte::pdu_queue::channel_t channel)
{ {
Debug("Processing MAC PDU channel %d\n", channel); Debug("Processing MAC PDU channel %d", channel);
switch (channel) { switch (channel) {
case srslte::pdu_queue::DCH: case srslte::pdu_queue::DCH:
// Unpack DLSCH MAC PDU // Unpack DLSCH MAC PDU
mac_msg.init_rx(nof_bytes); mac_msg.init_rx(nof_bytes);
mac_msg.parse_packet(mac_pdu); mac_msg.parse_packet(mac_pdu);
Info("%s\n", mac_msg.to_string().c_str()); Info("%s", mac_msg.to_string().c_str());
process_sch_pdu(&mac_msg); process_sch_pdu(&mac_msg);
pdus.deallocate(mac_pdu); pdus.deallocate(mac_pdu);
break; break;
@ -184,7 +185,7 @@ void demux::process_sch_pdu_rt(uint8_t* buff, uint32_t nof_bytes, uint32_t tti)
} else { } else {
// Process MAC Control Element // Process MAC Control Element
if (!process_ce(mac_msg_rt.get(), tti)) { if (!process_ce(mac_msg_rt.get(), tti)) {
Warning("Received Subheader with invalid or unknown LCID\n"); Warning("Received Subheader with invalid or unknown LCID");
} }
} }
} }
@ -203,21 +204,20 @@ void demux::process_sch_pdu(srslte::sch_pdu* pdu_msg)
} }
if (sum == 0) { if (sum == 0) {
route_pdu = false; route_pdu = false;
Warning("Received all zero PDU\n"); Warning("Received all zero PDU");
} }
} }
// Route logical channel // Route logical channel
if (route_pdu) { if (route_pdu) {
Debug("Delivering PDU for lcid=%d, %d bytes\n", Debug(
pdu_msg->get()->get_sdu_lcid(), "Delivering PDU for lcid=%d, %d bytes", pdu_msg->get()->get_sdu_lcid(), pdu_msg->get()->get_payload_size());
pdu_msg->get()->get_payload_size());
if (pdu_msg->get()->get_payload_size() < MAX_PDU_LEN) { if (pdu_msg->get()->get_payload_size() < MAX_PDU_LEN) {
rlc->write_pdu( rlc->write_pdu(
pdu_msg->get()->get_sdu_lcid(), pdu_msg->get()->get_sdu_ptr(), pdu_msg->get()->get_payload_size()); pdu_msg->get()->get_sdu_lcid(), pdu_msg->get()->get_sdu_ptr(), pdu_msg->get()->get_payload_size());
} else { } else {
char tmp[1024]; char tmp[1024];
srslte_vec_sprint_hex(tmp, sizeof(tmp), pdu_msg->get()->get_sdu_ptr(), 32); srslte_vec_sprint_hex(tmp, sizeof(tmp), pdu_msg->get()->get_sdu_ptr(), 32);
Error("PDU size %d exceeds maximum PDU buffer size, lcid=%d, hex=[%s]\n", Error("PDU size %d exceeds maximum PDU buffer size, lcid=%d, hex=[%s]",
pdu_msg->get()->get_payload_size(), pdu_msg->get()->get_payload_size(),
pdu_msg->get()->get_sdu_lcid(), pdu_msg->get()->get_sdu_lcid(),
tmp); tmp);
@ -237,17 +237,17 @@ void demux::process_mch_pdu(srslte::mch_pdu* mch_msg)
uint16_t stop; uint16_t stop;
uint8_t lcid; uint8_t lcid;
if (mch_msg->get()->get_next_mch_sched_info(&lcid, &stop)) { if (mch_msg->get()->get_next_mch_sched_info(&lcid, &stop)) {
Info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d \n", lcid, stop, phy_h->get_current_tti()); Info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d ", lcid, stop, phy_h->get_current_tti());
} }
} }
if (mch_msg->get()->is_sdu()) { if (mch_msg->get()->is_sdu()) {
uint32_t lcid = mch_msg->get()->get_sdu_lcid(); uint32_t lcid = mch_msg->get()->get_sdu_lcid();
if (lcid >= SRSLTE_N_MCH_LCIDS) { if (lcid >= SRSLTE_N_MCH_LCIDS) {
Error("Radio bearer id must be in [0:%d] - %d\n", SRSLTE_N_MCH_LCIDS, lcid); Error("Radio bearer id must be in [0:%d] - %d", SRSLTE_N_MCH_LCIDS, lcid);
return; return;
} }
Debug("Wrote MCH LCID=%d to RLC\n", lcid); Debug("Wrote MCH LCID=%d to RLC", lcid);
if (1 == mch_lcids[lcid]) { if (1 == mch_lcids[lcid]) {
rlc->write_pdu_mch(lcid, mch_msg->get()->get_sdu_ptr(), mch_msg->get()->get_payload_size()); rlc->write_pdu_mch(lcid, mch_msg->get()->get_sdu_ptr(), mch_msg->get()->get_payload_size());
} }
@ -258,10 +258,10 @@ void demux::process_mch_pdu(srslte::mch_pdu* mch_msg)
void demux::mch_start_rx(uint32_t lcid) void demux::mch_start_rx(uint32_t lcid)
{ {
if (lcid < 32) { if (lcid < 32) {
Info("MCH Channel Setup: LCID=%d\n", lcid); Info("MCH Channel Setup: LCID=%d", lcid);
mch_lcids[lcid] = 1; mch_lcids[lcid] = 1;
} else { } else {
Error("MCH Channel Setup: invalid LCID=%d\n", lcid); Error("MCH Channel Setup: invalid LCID=%d", lcid);
} }
} }
@ -277,14 +277,14 @@ bool demux::process_ce(srslte::sch_subh* subh, uint32_t tti)
case srslte::dl_sch_lcid::SCELL_ACTIVATION: { case srslte::dl_sch_lcid::SCELL_ACTIVATION: {
uint32_t cmd = (uint32_t)subh->get_activation_deactivation_cmd(); uint32_t cmd = (uint32_t)subh->get_activation_deactivation_cmd();
srslte::console("SCELL Activation / Deactivation CMD: %x\n", cmd); srslte::console("SCELL Activation / Deactivation CMD: %x\n", cmd);
log_h->info("SCELL Activation / Deactivation CMD: %x\n", cmd); logger.info("SCELL Activation / Deactivation CMD: %x", cmd);
phy_h->set_activation_deactivation_scell(cmd, tti); phy_h->set_activation_deactivation_scell(cmd, tti);
break; break;
} }
case srslte::dl_sch_lcid::PADDING: case srslte::dl_sch_lcid::PADDING:
break; break;
default: default:
Error("MAC CE 0x%x not supported\n", subh->lcid_value()); Error("MAC CE 0x%x not supported", subh->lcid_value());
break; break;
} }
return true; return true;
@ -293,7 +293,7 @@ bool demux::process_ce(srslte::sch_subh* subh, uint32_t tti)
void demux::parse_ta_cmd(srslte::sch_subh* subh) void demux::parse_ta_cmd(srslte::sch_subh* subh)
{ {
phy_h->set_timeadv(subh->get_ta_cmd()); phy_h->set_timeadv(subh->get_ta_cmd());
Info("Received TA=%d (%d/%d) \n", Info("Received TA=%d (%d/%d) ",
subh->get_ta_cmd(), subh->get_ta_cmd(),
time_alignment_timer->time_elapsed(), time_alignment_timer->time_elapsed(),
time_alignment_timer->duration()); time_alignment_timer->duration());

46
srsue/src/stack/mac/dl_harq.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/dl_harq.h" #include "srsue/hdr/stack/mac/dl_harq.h"
#include "srslte/common/log.h" #include "srslte/common/log.h"
@ -23,12 +23,13 @@
namespace srsue { namespace srsue {
dl_harq_entity::dl_harq_entity(uint8_t cc_idx_) : proc(SRSLTE_MAX_HARQ_PROC), cc_idx(cc_idx_) {} dl_harq_entity::dl_harq_entity(uint8_t cc_idx_) :
proc(SRSLTE_MAX_HARQ_PROC), logger(srslog::fetch_basic_logger("MAC")), cc_idx(cc_idx_)
{}
bool dl_harq_entity::init(srslte::log_ref log_h_, mac_interface_rrc::ue_rnti_t* rntis_, demux* demux_unit_) bool dl_harq_entity::init(mac_interface_rrc::ue_rnti_t* rntis_, demux* demux_unit_)
{ {
demux_unit = demux_unit_; demux_unit = demux_unit_;
log_h = log_h_;
rntis = rntis_; rntis = rntis_;
for (uint32_t i = 0; i < SRSLTE_MAX_HARQ_PROC; i++) { for (uint32_t i = 0; i < SRSLTE_MAX_HARQ_PROC; i++) {
@ -53,7 +54,7 @@ void dl_harq_entity::new_grant_dl(mac_interface_phy_lte::mac_grant_dl_t grant,
proc_ptr = &bcch_proc; proc_ptr = &bcch_proc;
} else { } else {
if (grant.pid >= SRSLTE_MAX_HARQ_PROC) { if (grant.pid >= SRSLTE_MAX_HARQ_PROC) {
Error("Invalid PID: %d\n", grant.pid); Error("Invalid PID: %d", grant.pid);
return; return;
} }
proc_ptr = &proc[grant.pid]; proc_ptr = &proc[grant.pid];
@ -62,11 +63,11 @@ void dl_harq_entity::new_grant_dl(mac_interface_phy_lte::mac_grant_dl_t grant,
if (grant.rnti == rntis->temp_rnti && last_temporal_crnti != rntis->temp_rnti) { if (grant.rnti == rntis->temp_rnti && last_temporal_crnti != rntis->temp_rnti) {
last_temporal_crnti = rntis->temp_rnti; last_temporal_crnti = rntis->temp_rnti;
proc_ptr->reset_ndi(); proc_ptr->reset_ndi();
Info("Considering NDI in pid=%d to be toggled for first Temporal C-RNTI\n", grant.pid); Info("Considering NDI in pid=%d to be toggled for first Temporal C-RNTI", grant.pid);
} }
proc_ptr->new_grant_dl(grant, action); proc_ptr->new_grant_dl(grant, action);
} else { } else {
Error("SPS not supported\n"); Error("SPS not supported");
} }
} }
@ -76,7 +77,7 @@ void dl_harq_entity::tb_decoded(mac_interface_phy_lte::mac_grant_dl_t grant, boo
bcch_proc.tb_decoded(grant, ack); bcch_proc.tb_decoded(grant, ack);
} else { } else {
if (grant.pid >= SRSLTE_MAX_HARQ_PROC) { if (grant.pid >= SRSLTE_MAX_HARQ_PROC) {
Error("Invalid PID: %d\n", grant.pid); Error("Invalid PID: %d", grant.pid);
return; return;
} }
proc[grant.pid].tb_decoded(grant, ack); proc[grant.pid].tb_decoded(grant, ack);
@ -159,7 +160,7 @@ bool dl_harq_entity::dl_harq_process::is_sps()
return false; return false;
} }
dl_harq_entity::dl_harq_process::dl_tb_process::dl_tb_process() dl_harq_entity::dl_harq_process::dl_tb_process::dl_tb_process() : logger(srslog::fetch_basic_logger("MAC"))
{ {
is_initiated = false; is_initiated = false;
ack = false; ack = false;
@ -178,7 +179,7 @@ dl_harq_entity::dl_harq_process::dl_tb_process::~dl_tb_process()
bool dl_harq_entity::dl_harq_process::dl_tb_process::init(int pid, dl_harq_entity* parent, uint32_t tb_idx) bool dl_harq_entity::dl_harq_process::dl_tb_process::init(int pid, dl_harq_entity* parent, uint32_t tb_idx)
{ {
if (srslte_softbuffer_rx_init(&softbuffer, 110)) { if (srslte_softbuffer_rx_init(&softbuffer, 110)) {
Error("Error initiating soft buffer\n"); Error("Error initiating soft buffer");
return false; return false;
} }
@ -194,7 +195,6 @@ bool dl_harq_entity::dl_harq_process::dl_tb_process::init(int pid, dl_harq_entit
is_first_tb = true; is_first_tb = true;
is_initiated = true; is_initiated = true;
harq_entity = parent; harq_entity = parent;
log_h = harq_entity->log_h;
return true; return true;
} }
@ -249,7 +249,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::new_grant_dl(mac_interface_
// If this is a new transmission or the size of the TB has changed // If this is a new transmission or the size of the TB has changed
if (is_new_transmission || (cur_grant.tb[tid].tbs != grant.tb[tid].tbs)) { if (is_new_transmission || (cur_grant.tb[tid].tbs != grant.tb[tid].tbs)) {
if (!is_new_transmission) { if (!is_new_transmission) {
Debug("DL PID %d: Size of dci changed during a retransmission %d!=%d\n", Debug("DL PID %d: Size of dci changed during a retransmission %d!=%d",
pid, pid,
cur_grant.tb[tid].tbs, cur_grant.tb[tid].tbs,
grant.tb[tid].tbs); grant.tb[tid].tbs);
@ -268,7 +268,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::new_grant_dl(mac_interface_
cur_grant = grant; cur_grant = grant;
if (payload_buffer_ptr) { if (payload_buffer_ptr) {
Warning("DL PID %d: Allocating buffer already allocated. Deallocating.\n", pid); Warning("DL PID %d: Allocating buffer already allocated. Deallocating.", pid);
if (!is_bcch) { if (!is_bcch) {
harq_entity->demux_unit->deallocate(payload_buffer_ptr); harq_entity->demux_unit->deallocate(payload_buffer_ptr);
} }
@ -283,7 +283,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::new_grant_dl(mac_interface_
action->tb[tid].payload = payload_buffer_ptr; action->tb[tid].payload = payload_buffer_ptr;
if (!action->tb[tid].payload) { if (!action->tb[tid].payload) {
Error("Can't get a buffer for TBS=%d\n", cur_grant.tb[tid].tbs); Error("Can't get a buffer for TBS=%d", cur_grant.tb[tid].tbs);
return; return;
} }
@ -291,7 +291,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::new_grant_dl(mac_interface_
action->tb[tid].rv = cur_grant.tb[tid].rv; action->tb[tid].rv = cur_grant.tb[tid].rv;
action->tb[tid].softbuffer.rx = &softbuffer; action->tb[tid].softbuffer.rx = &softbuffer;
} else { } else {
Info("DL PID %d: Received duplicate TB%d. Discarding and retransmitting ACK (n_retx=%d, reset=%s)\n", Info("DL PID %d: Received duplicate TB%d. Discarding and retransmitting ACK (n_retx=%d, reset=%s)",
pid, pid,
tid, tid,
n_retx, n_retx,
@ -316,7 +316,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::tb_decoded(mac_interface_ph
harq_entity->pcap->write_dl_sirnti( harq_entity->pcap->write_dl_sirnti(
payload_buffer_ptr, cur_grant.tb[tid].tbs, ack, cur_grant.tti, harq_entity->cc_idx); payload_buffer_ptr, cur_grant.tb[tid].tbs, ack, cur_grant.tti, harq_entity->cc_idx);
} }
Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit (BCCH)\n", cur_grant.tb[tid].tbs); Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit (BCCH)", cur_grant.tb[tid].tbs);
harq_entity->demux_unit->push_pdu_bcch(payload_buffer_ptr, cur_grant.tb[tid].tbs); harq_entity->demux_unit->push_pdu_bcch(payload_buffer_ptr, cur_grant.tb[tid].tbs);
} else { } else {
if (harq_entity->pcap) { if (harq_entity->pcap) {
@ -324,14 +324,14 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::tb_decoded(mac_interface_ph
payload_buffer_ptr, cur_grant.tb[tid].tbs, cur_grant.rnti, ack, cur_grant.tti, harq_entity->cc_idx); payload_buffer_ptr, cur_grant.tb[tid].tbs, cur_grant.rnti, ack, cur_grant.tti, harq_entity->cc_idx);
} }
if (cur_grant.rnti == harq_entity->rntis->temp_rnti) { if (cur_grant.rnti == harq_entity->rntis->temp_rnti) {
Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit (Temporal C-RNTI)\n", cur_grant.tb[tid].tbs); Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit (Temporal C-RNTI)", cur_grant.tb[tid].tbs);
harq_entity->demux_unit->push_pdu_temp_crnti(payload_buffer_ptr, cur_grant.tb[tid].tbs); harq_entity->demux_unit->push_pdu_temp_crnti(payload_buffer_ptr, cur_grant.tb[tid].tbs);
// If T-CRNTI, update ack value with result from contention resolution // If T-CRNTI, update ack value with result from contention resolution
*ack_ptr = harq_entity->demux_unit->get_uecrid_successful(); *ack_ptr = harq_entity->demux_unit->get_uecrid_successful();
} else { } else {
Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit\n", cur_grant.tb[tid].tbs); Debug("Delivering PDU=%d bytes to Dissassemble and Demux unit", cur_grant.tb[tid].tbs);
harq_entity->demux_unit->push_pdu(payload_buffer_ptr, cur_grant.tb[tid].tbs, grant.tti); harq_entity->demux_unit->push_pdu(payload_buffer_ptr, cur_grant.tb[tid].tbs, grant.tti);
// Compute average number of retransmissions per packet // Compute average number of retransmissions per packet
@ -345,7 +345,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::tb_decoded(mac_interface_ph
payload_buffer_ptr = NULL; payload_buffer_ptr = NULL;
Info("DL %d (TB %d): %s tbs=%d, rv=%d, ack=%s, ndi=%d\n", Info("DL %d (TB %d): %s tbs=%d, rv=%d, ack=%s, ndi=%d",
pid, pid,
tid, tid,
is_new_transmission ? "newTX" : "reTX ", is_new_transmission ? "newTX" : "reTX ",
@ -377,7 +377,7 @@ bool dl_harq_entity::dl_harq_process::dl_tb_process::calc_is_new_transmission(
is_new_transmission = false; is_new_transmission = false;
} }
Debug("Set HARQ for %stransmission\n", is_new_transmission ? "new " : "re"); Debug("Set HARQ for %stransmission", is_new_transmission ? "new " : "re");
return is_new_transmission; return is_new_transmission;
} }

84
srsue/src/stack/mac/mac.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include <pthread.h> #include <pthread.h>
#include <string.h> #include <string.h>
@ -28,9 +28,14 @@ namespace srsue {
mac::mac(const char* logname, ext_task_sched_handle task_sched_) : mac::mac(const char* logname, ext_task_sched_handle task_sched_) :
log_h(srslte::logmap::get(logname)), log_h(srslte::logmap::get(logname)),
logger(srslog::fetch_basic_logger(logname)),
mch_msg(10, log_h), mch_msg(10, log_h),
mux_unit(log_h), mux_unit(log_h, logger),
demux_unit(log_h), demux_unit(log_h, logger),
ra_procedure(logger),
sr_procedure(logger),
bsr_procedure(logger),
phr_procedure(logger),
pcap(nullptr), pcap(nullptr),
task_sched(task_sched_) task_sched(task_sched_)
{ {
@ -67,16 +72,16 @@ bool mac::init(phy_interface_mac_lte* phy, rlc_interface_mac* rlc, rrc_interface
// Create Stack task dispatch queue // Create Stack task dispatch queue
stack_task_dispatch_queue = task_sched.make_task_queue(); stack_task_dispatch_queue = task_sched.make_task_queue();
bsr_procedure.init(&sr_procedure, rlc_h, log_h, &task_sched); bsr_procedure.init(&sr_procedure, rlc_h, &task_sched);
phr_procedure.init(phy_h, log_h, &task_sched); phr_procedure.init(phy_h, &task_sched);
mux_unit.init(rlc_h, &bsr_procedure, &phr_procedure); mux_unit.init(rlc_h, &bsr_procedure, &phr_procedure);
demux_unit.init(phy_h, rlc_h, this, &timer_alignment); demux_unit.init(phy_h, rlc_h, this, &timer_alignment);
ra_procedure.init(phy_h, rrc, log_h, &uernti, &timer_alignment, &mux_unit, &task_sched); ra_procedure.init(phy_h, rrc, &uernti, &timer_alignment, &mux_unit, &task_sched);
sr_procedure.init(&ra_procedure, phy_h, rrc, log_h); sr_procedure.init(&ra_procedure, phy_h, rrc);
// Create UL/DL unique HARQ pointers // Create UL/DL unique HARQ pointers
ul_harq.at(PCELL_CC_IDX)->init(log_h, &uernti, &ra_procedure, &mux_unit); ul_harq.at(PCELL_CC_IDX)->init(&uernti, &ra_procedure, &mux_unit);
dl_harq.at(PCELL_CC_IDX)->init(log_h, &uernti, &demux_unit); dl_harq.at(PCELL_CC_IDX)->init(&uernti, &demux_unit);
reset(); reset();
@ -120,7 +125,7 @@ void mac::reconfiguration(const uint32_t& cc_idx, const bool& enable)
if (cc_idx < SRSLTE_MAX_CARRIERS) { if (cc_idx < SRSLTE_MAX_CARRIERS) {
if (enable and ul_harq.at(cc_idx) == nullptr) { if (enable and ul_harq.at(cc_idx) == nullptr) {
ul_harq_entity_ptr ul = ul_harq_entity_ptr(new ul_harq_entity(cc_idx)); ul_harq_entity_ptr ul = ul_harq_entity_ptr(new ul_harq_entity(cc_idx));
ul->init(log_h, &uernti, &ra_procedure, &mux_unit); ul->init(&uernti, &ra_procedure, &mux_unit);
ul->set_config(ul_harq_cfg); ul->set_config(ul_harq_cfg);
if (pcap != nullptr) { if (pcap != nullptr) {
@ -132,7 +137,7 @@ void mac::reconfiguration(const uint32_t& cc_idx, const bool& enable)
if (enable and dl_harq.at(cc_idx) == nullptr) { if (enable and dl_harq.at(cc_idx) == nullptr) {
dl_harq_entity_ptr dl = dl_harq_entity_ptr(new dl_harq_entity(cc_idx)); dl_harq_entity_ptr dl = dl_harq_entity_ptr(new dl_harq_entity(cc_idx));
dl->init(log_h, &uernti, &demux_unit); dl->init(&uernti, &demux_unit);
if (pcap != nullptr) { if (pcap != nullptr) {
dl->start_pcap(pcap); dl->start_pcap(pcap);
@ -148,7 +153,7 @@ void mac::reset()
{ {
bzero(&metrics, sizeof(mac_metrics_t)); bzero(&metrics, sizeof(mac_metrics_t));
Info("Resetting MAC\n"); Info("Resetting MAC");
timer_alignment.stop(); timer_alignment.stop();
@ -188,11 +193,12 @@ void mac::reset()
void mac::run_tti(const uint32_t tti) void mac::run_tti(const uint32_t tti)
{ {
log_h->step(tti); log_h->step(tti);
logger.set_context(tti);
/* Warning: Here order of invocation of procedures is important!! */ /* Warning: Here order of invocation of procedures is important!! */
// Step all procedures (must follow this order) // Step all procedures (must follow this order)
Debug("Running MAC tti=%d\n", tti); Debug("Running MAC tti=%d", tti);
mux_unit.step(); mux_unit.step();
bsr_procedure.step(tti); bsr_procedure.step(tti);
sr_procedure.step(tti); sr_procedure.step(tti);
@ -216,7 +222,7 @@ void mac::bcch_start_rx(int si_window_start_, int si_window_length_)
si_window_length = 0; si_window_length = 0;
si_window_start = 0; si_window_start = 0;
} }
Info("SCHED: Searching for DL dci for SI-RNTI window_st=%d, window_len=%d\n", si_window_start, si_window_length); Info("SCHED: Searching for DL dci for SI-RNTI window_st=%d, window_len=%d", si_window_start, si_window_length);
} }
void mac::bcch_stop_rx() void mac::bcch_stop_rx()
@ -302,25 +308,25 @@ uint16_t mac::get_dl_sched_rnti(uint32_t tti)
return SRSLTE_INVALID_RNTI; return SRSLTE_INVALID_RNTI;
} }
} }
Debug("SCHED: Searching SI-RNTI, tti=%d, window start=%d, length=%d\n", tti, si_window_start, si_window_length); Debug("SCHED: Searching SI-RNTI, tti=%d, window start=%d, length=%d", tti, si_window_start, si_window_length);
return SRSLTE_SIRNTI; return SRSLTE_SIRNTI;
} }
} }
if (uernti.rar_rnti && ra_window_start > 0 && ra_window_length > 0 && if (uernti.rar_rnti && ra_window_start > 0 && ra_window_length > 0 &&
is_in_window(tti, &ra_window_start, &ra_window_length)) { is_in_window(tti, &ra_window_start, &ra_window_length)) {
Debug("SCHED: Searching RAR-RNTI=0x%x, tti=%d\n", uernti.rar_rnti, tti); Debug("SCHED: Searching RAR-RNTI=0x%x, tti=%d", uernti.rar_rnti, tti);
return uernti.rar_rnti; return uernti.rar_rnti;
} }
if (uernti.temp_rnti && !uernti.crnti) { if (uernti.temp_rnti && !uernti.crnti) {
Debug("SCHED: Searching Temp-RNTI=0x%x\n", uernti.temp_rnti); Debug("SCHED: Searching Temp-RNTI=0x%x", uernti.temp_rnti);
return uernti.temp_rnti; return uernti.temp_rnti;
} }
if (uernti.crnti) { if (uernti.crnti) {
Debug("SCHED: Searching C-RNTI=0x%x\n", uernti.crnti); Debug("SCHED: Searching C-RNTI=0x%x", uernti.crnti);
return uernti.crnti; return uernti.crnti;
} }
if (p_window_start > 0) { if (p_window_start > 0) {
Debug("SCHED: Searching P-RNTI\n"); Debug("SCHED: Searching P-RNTI");
return SRSLTE_PRNTI; return SRSLTE_PRNTI;
} }
@ -339,10 +345,10 @@ void mac::bch_decoded_ok(uint32_t cc_idx, uint8_t* payload, uint32_t len)
auto p = stack_task_dispatch_queue.try_push(std::bind( auto p = stack_task_dispatch_queue.try_push(std::bind(
[this](srslte::unique_byte_buffer_t& buf) { rlc_h->write_pdu_bcch_bch(std::move(buf)); }, std::move(buf))); [this](srslte::unique_byte_buffer_t& buf) { rlc_h->write_pdu_bcch_bch(std::move(buf)); }, std::move(buf)));
if (not p.first) { if (not p.first) {
Warning("Failed to dispatch rlc::write_pdu_bcch_bch task to stack\n"); Warning("Failed to dispatch rlc::write_pdu_bcch_bch task to stack");
} }
} else { } else {
log_h->error("Fatal error: Out of buffers from the pool in write_pdu_bcch_bch()\n"); logger.error("Fatal error: Out of buffers from the pool in write_pdu_bcch_bch()");
} }
if (pcap) { if (pcap) {
@ -363,7 +369,7 @@ void mac::mch_decoded(uint32_t len, bool crc)
uint8_t lcid; uint8_t lcid;
if (mch_msg.get()->get_next_mch_sched_info(&lcid, &stop)) { if (mch_msg.get()->get_next_mch_sched_info(&lcid, &stop)) {
phy_h->set_mch_period_stop(stop); phy_h->set_mch_period_stop(stop);
Info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d \n", lcid, stop, phy_h->get_current_tti()); Info("MCH Sched Info: LCID: %d, Stop: %d, tti is %d ", lcid, stop, phy_h->get_current_tti());
} }
} }
} }
@ -400,10 +406,10 @@ void mac::tb_decoded(uint32_t cc_idx, mac_grant_dl_t grant, bool ack[SRSLTE_MAX_
auto ret = stack_task_dispatch_queue.try_push(std::bind( auto ret = stack_task_dispatch_queue.try_push(std::bind(
[this](srslte::unique_byte_buffer_t& pdu) { rlc_h->write_pdu_pcch(std::move(pdu)); }, std::move(pdu))); [this](srslte::unique_byte_buffer_t& pdu) { rlc_h->write_pdu_pcch(std::move(pdu)); }, std::move(pdu)));
if (not ret.first) { if (not ret.first) {
Warning("Failed to dispatch rlc::write_pdu_pcch task to stack\n"); Warning("Failed to dispatch rlc::write_pdu_pcch task to stack");
} }
} else { } else {
log_h->error("Fatal error: Out of buffers from the pool in write_pdu_pcch()\n"); logger.error("Fatal error: Out of buffers from the pool in write_pdu_pcch()");
} }
if (pcap) { if (pcap) {
@ -413,7 +419,7 @@ void mac::tb_decoded(uint32_t cc_idx, mac_grant_dl_t grant, bool ack[SRSLTE_MAX_
// Assert DL HARQ entity // Assert DL HARQ entity
if (dl_harq.at(cc_idx) == nullptr) { if (dl_harq.at(cc_idx) == nullptr) {
Error("HARQ entity %d has not been created\n", cc_idx); Error("HARQ entity %d has not been created", cc_idx);
return; return;
} }
@ -443,7 +449,7 @@ void mac::new_grant_dl(uint32_t cc_idx,
bzero(action, sizeof(mac_interface_phy_lte::tb_action_dl_t)); bzero(action, sizeof(mac_interface_phy_lte::tb_action_dl_t));
if (grant.tb[0].tbs > pch_payload_buffer_sz) { if (grant.tb[0].tbs > pch_payload_buffer_sz) {
Error("Received dci for PCH (%d bytes) exceeds buffer (%d bytes)\n", grant.tb[0].tbs, pch_payload_buffer_sz); Error("Received dci for PCH (%d bytes) exceeds buffer (%d bytes)", grant.tb[0].tbs, int(pch_payload_buffer_sz));
action->tb[0].enabled = false; action->tb[0].enabled = false;
} else { } else {
action->tb[0].enabled = true; action->tb[0].enabled = true;
@ -459,14 +465,14 @@ void mac::new_grant_dl(uint32_t cc_idx,
} }
// Assert DL HARQ entity // Assert DL HARQ entity
if (dl_harq.at(cc_idx) == nullptr) { if (dl_harq.at(cc_idx) == nullptr) {
Error("HARQ entity %d has not been created\n", cc_idx); Error("HARQ entity %d has not been created", cc_idx);
return; return;
} }
dl_harq.at(cc_idx)->new_grant_dl(grant, action); dl_harq.at(cc_idx)->new_grant_dl(grant, action);
} else { } else {
/* Discard */ /* Discard */
Info("Discarding dci in CC %d, RNTI=0x%x\n", cc_idx, grant.rnti); Info("Discarding dci in CC %d, RNTI=0x%x", cc_idx, grant.rnti);
} }
} }
@ -480,7 +486,7 @@ void mac::process_pdus()
} }
}); });
if (not ret.first) { if (not ret.first) {
Warning("Failed to dispatch mac::%s task to stack thread\n", __func__); Warning("Failed to dispatch mac::%s task to stack thread", __func__);
} }
} }
@ -517,7 +523,7 @@ void mac::new_grant_ul(uint32_t cc_idx,
// Assert UL HARQ entity // Assert UL HARQ entity
if (ul_harq.at(cc_idx) == nullptr) { if (ul_harq.at(cc_idx) == nullptr) {
Error("HARQ entity %d has not been created\n", cc_idx); Error("HARQ entity %d has not been created", cc_idx);
return; return;
} }
@ -557,10 +563,10 @@ void mac::setup_timers(int time_alignment_timer)
void mac::timer_expired(uint32_t timer_id) void mac::timer_expired(uint32_t timer_id)
{ {
if (timer_id == timer_alignment.id()) { if (timer_id == timer_alignment.id()) {
Info("Time Alignment Timer expired\n"); Info("Time Alignment Timer expired");
timer_alignment_expire(); timer_alignment_expire();
} else { } else {
Warning("Received callback from unknown timer_id=%d\n", timer_id); Warning("Received callback from unknown timer_id=%d", timer_id);
} }
} }
@ -599,13 +605,13 @@ void mac::set_mbsfn_config(uint32_t nof_mbsfn_services)
// Only reset SR config // Only reset SR config
void mac::set_config(sr_cfg_t& sr_cfg) void mac::set_config(sr_cfg_t& sr_cfg)
{ {
Info("Setting SR configuration\n"); Info("Setting SR configuration");
sr_procedure.set_config(sr_cfg); sr_procedure.set_config(sr_cfg);
} }
void mac::set_config(mac_cfg_t& mac_cfg) void mac::set_config(mac_cfg_t& mac_cfg)
{ {
Info("Setting configuration\n"); Info("Setting configuration");
// Set configuration for each module in MAC // Set configuration for each module in MAC
bsr_procedure.set_config(mac_cfg.bsr_cfg); bsr_procedure.set_config(mac_cfg.bsr_cfg);
phr_procedure.set_config(mac_cfg.phr_cfg); phr_procedure.set_config(mac_cfg.phr_cfg);
@ -634,7 +640,7 @@ void mac::setup_lcid(uint32_t lcid, uint32_t lcg, uint32_t priority, int PBR_x_t
void mac::setup_lcid(const logical_channel_config_t& config) void mac::setup_lcid(const logical_channel_config_t& config)
{ {
Info("Logical Channel Setup: LCID=%d, LCG=%d, priority=%d, PBR=%d, BSD=%dms, bucket_size=%d\n", Info("Logical Channel Setup: LCID=%d, LCG=%d, priority=%d, PBR=%d, BSD=%dms, bucket_size=%d",
config.lcid, config.lcid,
config.lcg, config.lcg,
config.priority, config.priority,
@ -681,7 +687,7 @@ void mac::get_metrics(mac_metrics_t m[SRSLTE_MAX_CARRIERS])
dl_avg_ret /= dl_avg_ret_count; dl_avg_ret /= dl_avg_ret_count;
} }
Info("DL retx: %.2f \%%, perpkt: %.2f, UL retx: %.2f \%% perpkt: %.2f\n", Info("DL retx: %.2f \%%, perpkt: %.2f, UL retx: %.2f \%% perpkt: %.2f",
rx_pkts ? ((float)100 * rx_errors / rx_pkts) : 0.0f, rx_pkts ? ((float)100 * rx_errors / rx_pkts) : 0.0f,
dl_avg_ret, dl_avg_ret,
tx_pkts ? ((float)100 * tx_errors / tx_pkts) : 0.0f, tx_pkts ? ((float)100 * tx_errors / tx_pkts) : 0.0f,

28
srsue/src/stack/mac/mac_nr.cc
Unescape Escape View File

@ -18,9 +18,7 @@ using namespace asn1::rrc;
namespace srsue { namespace srsue {
mac_nr::mac_nr(srslte::ext_task_sched_handle task_sched_) : mac_nr::mac_nr(srslte::ext_task_sched_handle task_sched_) :
pool(srslte::byte_buffer_pool::get_instance()), pool(srslte::byte_buffer_pool::get_instance()), log_h("MAC"), task_sched(task_sched_)
log_h("MAC"),
task_sched(task_sched_)
{ {
tx_buffer = srslte::allocate_unique_buffer(*pool); tx_buffer = srslte::allocate_unique_buffer(*pool);
rlc_buffer = srslte::allocate_unique_buffer(*pool); rlc_buffer = srslte::allocate_unique_buffer(*pool);
@ -65,7 +63,7 @@ void mac_nr::stop()
// Implement Section 5.9 // Implement Section 5.9
void mac_nr::reset() void mac_nr::reset()
{ {
Info("Resetting MAC\n"); Info("Resetting MAC");
} }
void mac_nr::run_tti(const uint32_t tti) void mac_nr::run_tti(const uint32_t tti)
@ -73,7 +71,7 @@ void mac_nr::run_tti(const uint32_t tti)
log_h->step(tti); log_h->step(tti);
// Step all procedures // Step all procedures
Debug("Running MAC tti=%d\n", tti); Debug("Running MAC tti=%d", tti);
} }
uint16_t mac_nr::get_ul_sched_rnti(uint32_t tti) uint16_t mac_nr::get_ul_sched_rnti(uint32_t tti)
@ -167,11 +165,11 @@ void mac_nr::get_ul_data(const mac_nr_grant_ul_t& grant, phy_interface_stack_nr:
// Add SDU if RLC has something to tx // Add SDU if RLC has something to tx
if (pdu_len > 0) { if (pdu_len > 0) {
rlc_buffer->N_bytes = pdu_len; rlc_buffer->N_bytes = pdu_len;
log_h->info_hex(rlc_buffer->msg, rlc_buffer->N_bytes, "Read %d B from RLC\n", rlc_buffer->N_bytes); log_h->info_hex(rlc_buffer->msg, rlc_buffer->N_bytes, "Read %d B from RLC", rlc_buffer->N_bytes);
// add to MAC PDU and pack // add to MAC PDU and pack
if (tx_pdu.add_sdu(args.drb_lcid, rlc_buffer->msg, rlc_buffer->N_bytes) != SRSLTE_SUCCESS) { if (tx_pdu.add_sdu(args.drb_lcid, rlc_buffer->msg, rlc_buffer->N_bytes) != SRSLTE_SUCCESS) {
log_h->error("Error packing MAC PDU\n"); log_h->error("Error packing MAC PDU");
} }
} else { } else {
break; break;
@ -181,7 +179,7 @@ void mac_nr::get_ul_data(const mac_nr_grant_ul_t& grant, phy_interface_stack_nr:
// Pack PDU // Pack PDU
tx_pdu.pack(); tx_pdu.pack();
log_h->info_hex(tx_buffer->msg, tx_buffer->N_bytes, "Generated MAC PDU (%d B)\n", tx_buffer->N_bytes); log_h->info_hex(tx_buffer->msg, tx_buffer->N_bytes, "Generated MAC PDU (%d B)", tx_buffer->N_bytes);
tx_request->data = tx_buffer->msg; tx_request->data = tx_buffer->msg;
tx_request->tb_len = tx_buffer->N_bytes; tx_request->tb_len = tx_buffer->N_bytes;
@ -198,7 +196,7 @@ void mac_nr::timer_expired(uint32_t timer_id)
void mac_nr::setup_lcid(const srslte::logical_channel_config_t& config) void mac_nr::setup_lcid(const srslte::logical_channel_config_t& config)
{ {
Info("Logical Channel Setup: LCID=%d, LCG=%d, priority=%d, PBR=%d, BSD=%dms, bucket_size=%d\n", Info("Logical Channel Setup: LCID=%d, LCG=%d, priority=%d, PBR=%d, BSD=%dms, bucket_size=%d",
config.lcid, config.lcid,
config.lcg, config.lcg,
config.priority, config.priority,
@ -211,14 +209,14 @@ void mac_nr::setup_lcid(const srslte::logical_channel_config_t& config)
void mac_nr::set_config(const srslte::bsr_cfg_t& bsr_cfg) void mac_nr::set_config(const srslte::bsr_cfg_t& bsr_cfg)
{ {
Info("BSR config periodic timer %d retx timer %d\n", bsr_cfg.periodic_timer, bsr_cfg.retx_timer); Info("BSR config periodic timer %d retx timer %d", bsr_cfg.periodic_timer, bsr_cfg.retx_timer);
Warning("Not handling BSR config yet\n"); Warning("Not handling BSR config yet");
} }
void mac_nr::set_config(const srslte::sr_cfg_t& sr_cfg) void mac_nr::set_config(const srslte::sr_cfg_t& sr_cfg)
{ {
Info("Scheduling Request Config DSR tansmax %d\n", sr_cfg.dsr_transmax); Info("Scheduling Request Config DSR tansmax %d", sr_cfg.dsr_transmax);
Warning("Not Scheduling Request Config yet\n"); Warning("Not Scheduling Request Config yet");
} }
void mac_nr::get_metrics(mac_metrics_t m[SRSLTE_MAX_CARRIERS]) {} void mac_nr::get_metrics(mac_metrics_t m[SRSLTE_MAX_CARRIERS]) {}
@ -237,14 +235,14 @@ void mac_nr::process_pdus()
void mac_nr::handle_pdu(srslte::unique_byte_buffer_t pdu) void mac_nr::handle_pdu(srslte::unique_byte_buffer_t pdu)
{ {
log_h->info_hex(pdu->msg, pdu->N_bytes, "Handling MAC PDU (%d B)\n", pdu->N_bytes); log_h->info_hex(pdu->msg, pdu->N_bytes, "Handling MAC PDU (%d B)", pdu->N_bytes);
rx_pdu.init_rx(); rx_pdu.init_rx();
rx_pdu.unpack(pdu->msg, pdu->N_bytes); rx_pdu.unpack(pdu->msg, pdu->N_bytes);
for (uint32_t i = 0; i < rx_pdu.get_num_subpdus(); ++i) { for (uint32_t i = 0; i < rx_pdu.get_num_subpdus(); ++i) {
srslte::mac_nr_sch_subpdu subpdu = rx_pdu.get_subpdu(i); srslte::mac_nr_sch_subpdu subpdu = rx_pdu.get_subpdu(i);
log_h->info("Handling subPDU %d/%d: lcid=%d, sdu_len=%d\n", log_h->info("Handling subPDU %d/%d: lcid=%d, sdu_len=%d",
i, i,
rx_pdu.get_num_subpdus(), rx_pdu.get_num_subpdus(),
subpdu.get_lcid(), subpdu.get_lcid(),

41
srsue/src/stack/mac/mux.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/mux.h" #include "srsue/hdr/stack/mac/mux.h"
#include "srsue/hdr/stack/mac/mac.h" #include "srsue/hdr/stack/mac/mac.h"
@ -23,7 +23,8 @@
namespace srsue { namespace srsue {
mux::mux(srslte::log_ref log_) : pdu_msg(MAX_NOF_SUBHEADERS, log_), log_h(log_) mux::mux(srslte::log_ref log_, srslog::basic_logger& logger) :
pdu_msg(MAX_NOF_SUBHEADERS, log_), log_h(log_), logger(logger)
{ {
msg3_flush(); msg3_flush();
} }
@ -58,7 +59,7 @@ void mux::step()
channel.Bj += channel.PBR; // PBR is in kByte/s, conversion in Byte and ms not needed channel.Bj += channel.PBR; // PBR is in kByte/s, conversion in Byte and ms not needed
} }
channel.Bj = SRSLTE_MIN((uint32_t)channel.Bj, channel.bucket_size); channel.Bj = SRSLTE_MIN((uint32_t)channel.Bj, channel.bucket_size);
Debug("Update Bj: lcid=%d, Bj=%d\n", channel.lcid, channel.Bj); Debug("Update Bj: lcid=%d, Bj=%d", channel.lcid, channel.Bj);
} }
} }
@ -103,7 +104,7 @@ void mux::setup_lcid(const logical_channel_config_t& config)
// warn user if there is another LCID with same prio // warn user if there is another LCID with same prio
for (auto& channel : logical_channels) { for (auto& channel : logical_channels) {
if (channel.priority == config.priority && channel.lcid != config.lcid) { if (channel.priority == config.priority && channel.lcid != config.lcid) {
log_h->warning("LCID %d and %d have same priority.\n", channel.lcid, config.lcid); logger.warning("LCID %d and %d have same priority.", channel.lcid, config.lcid);
} }
} }
} else { } else {
@ -139,7 +140,7 @@ void mux::print_logical_channel_state(const std::string& info)
logline += ", sched_len="; logline += ", sched_len=";
logline += std::to_string(channel.sched_len); logline += std::to_string(channel.sched_len);
} }
log_h->debug("%s\n", logline.c_str()); logger.debug("%s", logline.c_str());
} }
srslte::ul_sch_lcid bsr_format_convert(bsr_proc::bsr_format_t format) srslte::ul_sch_lcid bsr_format_convert(bsr_proc::bsr_format_t format)
@ -169,13 +170,13 @@ uint8_t* mux::pdu_get(srslte::byte_buffer_t* payload, uint32_t pdu_sz)
if (pending_crnti_ce) { if (pending_crnti_ce) {
if (pdu_msg.new_subh()) { if (pdu_msg.new_subh()) {
if (!pdu_msg.get()->set_c_rnti(pending_crnti_ce)) { if (!pdu_msg.get()->set_c_rnti(pending_crnti_ce)) {
Warning("Pending C-RNTI CE could not be inserted in MAC PDU\n"); Warning("Pending C-RNTI CE could not be inserted in MAC PDU");
} }
} }
} }
} else { } else {
if (pending_crnti_ce) { if (pending_crnti_ce) {
Warning("Pending C-RNTI CE was not inserted because message was for CCCH\n"); Warning("Pending C-RNTI CE was not inserted because message was for CCCH");
} }
} }
pending_crnti_ce = 0; pending_crnti_ce = 0;
@ -289,8 +290,8 @@ uint8_t* mux::pdu_get(srslte::byte_buffer_t* payload, uint32_t pdu_sz)
// Generate MAC PDU and save to buffer // Generate MAC PDU and save to buffer
uint8_t* ret = pdu_msg.write_packet(log_h); uint8_t* ret = pdu_msg.write_packet(log_h);
Info("%s\n", pdu_msg.to_string().c_str()); Info("%s", pdu_msg.to_string().c_str());
Debug("Assembled MAC PDU msg size %d/%d bytes\n", pdu_msg.get_pdu_len() - pdu_msg.rem_size(), pdu_sz); Debug("Assembled MAC PDU msg size %d/%d bytes", pdu_msg.get_pdu_len() - pdu_msg.rem_size(), pdu_sz);
return ret; return ret;
} }
@ -315,7 +316,7 @@ bool mux::sched_sdu(logical_channel_config_t* ch, int* sdu_space, int max_sdu_sz
*sdu_space -= sched_len; // UL-SCH subheader size is accounted for in the calling function *sdu_space -= sched_len; // UL-SCH subheader size is accounted for in the calling function
Debug("SDU: scheduled lcid=%d, rlc_buffer=%d, allocated=%d\n", ch->lcid, ch->buffer_len, sched_len); Debug("SDU: scheduled lcid=%d, rlc_buffer=%d, allocated=%d", ch->lcid, ch->buffer_len, sched_len);
ch->buffer_len -= sched_len; ch->buffer_len -= sched_len;
ch->sched_len += sched_len; ch->sched_len += sched_len;
@ -338,7 +339,7 @@ uint32_t mux::allocate_sdu(uint32_t lcid, srslte::sch_pdu* pdu_msg, int max_sdu_
int sdu_len = pdu_msg->get()->set_sdu(lcid, requested_sdu_len, rlc); int sdu_len = pdu_msg->get()->set_sdu(lcid, requested_sdu_len, rlc);
if (sdu_len > 0) { // new SDU could be added if (sdu_len > 0) { // new SDU could be added
Debug("SDU: allocated lcid=%d, buffer_state=%d, request_sdu_len=%d, allocated=%d/%d, max_sdu_sz=%d, " Debug("SDU: allocated lcid=%d, buffer_state=%d, request_sdu_len=%d, allocated=%d/%d, max_sdu_sz=%d, "
"remaining=%d\n", "remaining=%d",
lcid, lcid,
buffer_state, buffer_state,
requested_sdu_len, requested_sdu_len,
@ -352,7 +353,7 @@ uint32_t mux::allocate_sdu(uint32_t lcid, srslte::sch_pdu* pdu_msg, int max_sdu_
buffer_state = rlc->get_buffer_state(lcid); buffer_state = rlc->get_buffer_state(lcid);
} else { } else {
Debug("Couldn't allocate new SDU (buffer_state=%d, requested_sdu_len=%d, sdu_len=%d, sdu_space=%d, " Debug("Couldn't allocate new SDU (buffer_state=%d, requested_sdu_len=%d, sdu_len=%d, sdu_space=%d, "
"remaining=%d, get_sdu_space=%d)\n", "remaining=%d, get_sdu_space=%d)",
buffer_state, buffer_state,
requested_sdu_len, requested_sdu_len,
sdu_len, sdu_len,
@ -364,7 +365,7 @@ uint32_t mux::allocate_sdu(uint32_t lcid, srslte::sch_pdu* pdu_msg, int max_sdu_
break; break;
} }
} else { } else {
Debug("Couldn't add new MAC subheader (buffer_state=%d, requested_sdu_len=%d, sdu_space=%d, remaining=%d)\n", Debug("Couldn't add new MAC subheader (buffer_state=%d, requested_sdu_len=%d, sdu_space=%d, remaining=%d)",
buffer_state, buffer_state,
requested_sdu_len, requested_sdu_len,
sdu_space, sdu_space,
@ -378,9 +379,7 @@ uint32_t mux::allocate_sdu(uint32_t lcid, srslte::sch_pdu* pdu_msg, int max_sdu_
void mux::msg3_flush() void mux::msg3_flush()
{ {
if (log_h) { Debug("Msg3 buffer flushed");
Debug("Msg3 buffer flushed\n");
}
msg3_buff.clear(); msg3_buff.clear();
msg3_has_been_transmitted = false; msg3_has_been_transmitted = false;
msg3_pending = false; msg3_pending = false;
@ -413,7 +412,7 @@ uint8_t* mux::msg3_get(srslte::byte_buffer_t* payload, uint32_t pdu_sz)
if (pdu_sz < msg3_buff.get_tailroom()) { if (pdu_sz < msg3_buff.get_tailroom()) {
if (msg3_is_empty()) { if (msg3_is_empty()) {
if (!pdu_get(&msg3_buff, pdu_sz)) { if (!pdu_get(&msg3_buff, pdu_sz)) {
Error("Moving PDU from Mux unit to Msg3 buffer\n"); Error("Moving PDU from Mux unit to Msg3 buffer");
return NULL; return NULL;
} }
msg3_pending = false; msg3_pending = false;
@ -422,7 +421,7 @@ uint8_t* mux::msg3_get(srslte::byte_buffer_t* payload, uint32_t pdu_sz)
msg3_has_been_transmitted = true; msg3_has_been_transmitted = true;
return payload->msg; return payload->msg;
} else { } else {
Error("Msg3 size exceeds buffer\n"); Error("Msg3 size exceeds buffer");
return nullptr; return nullptr;
} }
} }

37
srsue/src/stack/mac/proc_bsr.cc
Unescape Escape View File

@ -11,19 +11,12 @@
*/ */
#include "srsue/hdr/stack/mac/proc_bsr.h" #include "srsue/hdr/stack/mac/proc_bsr.h"
#include "srslte/common/log_helper.h"
#include "srsue/hdr/stack/mac/mux.h" #include "srsue/hdr/stack/mac/mux.h"
namespace srsue { namespace srsue {
bsr_proc::bsr_proc() {} void bsr_proc::init(sr_proc* sr_, rlc_interface_mac* rlc_, srslte::ext_task_sched_handle* task_sched_)
void bsr_proc::init(sr_proc* sr_,
rlc_interface_mac* rlc_,
srslte::log_ref log_h_,
srslte::ext_task_sched_handle* task_sched_)
{ {
log_h = log_h_;
rlc = rlc_; rlc = rlc_;
sr = sr_; sr = sr_;
task_sched = task_sched_; task_sched = task_sched_;
@ -55,7 +48,7 @@ void bsr_proc::print_state()
n = srslte_print_check(str, 128, n, "%d: %d ", iter.first, iter.second.old_buffer); n = srslte_print_check(str, 128, n, "%d: %d ", iter.first, iter.second.old_buffer);
} }
} }
Info("BSR: triggered_bsr_type=%s, LCID QUEUE status: %s\n", bsr_type_tostring(triggered_bsr_type), str); logger.info("BSR: triggered_bsr_type=%s, LCID QUEUE status: %s", bsr_type_tostring(triggered_bsr_type), str);
} }
void bsr_proc::set_trigger(srsue::bsr_proc::triggered_bsr_type_t new_trigger) void bsr_proc::set_trigger(srsue::bsr_proc::triggered_bsr_type_t new_trigger)
@ -64,7 +57,7 @@ void bsr_proc::set_trigger(srsue::bsr_proc::triggered_bsr_type_t new_trigger)
// Trigger SR always when Regular BSR is triggered in the current TTI. Will be cancelled if a grant is received // Trigger SR always when Regular BSR is triggered in the current TTI. Will be cancelled if a grant is received
if (triggered_bsr_type == REGULAR) { if (triggered_bsr_type == REGULAR) {
Debug("BSR: Triggering SR procedure\n"); logger.debug("BSR: Triggering SR procedure");
sr->start(); sr->start();
} }
} }
@ -85,11 +78,11 @@ void bsr_proc::set_config(srslte::bsr_cfg_t& bsr_cfg_)
if (bsr_cfg_.periodic_timer > 0) { if (bsr_cfg_.periodic_timer > 0) {
timer_periodic.set(bsr_cfg_.periodic_timer, [this](uint32_t tid) { timer_expired(tid); }); timer_periodic.set(bsr_cfg_.periodic_timer, [this](uint32_t tid) { timer_expired(tid); });
Info("BSR: Configured timer periodic %d ms\n", bsr_cfg_.periodic_timer); logger.info("BSR: Configured timer periodic %d ms", bsr_cfg_.periodic_timer);
} }
if (bsr_cfg_.retx_timer > 0) { if (bsr_cfg_.retx_timer > 0) {
timer_retx.set(bsr_cfg_.retx_timer, [this](uint32_t tid) { timer_expired(tid); }); timer_retx.set(bsr_cfg_.retx_timer, [this](uint32_t tid) { timer_expired(tid); });
Info("BSR: Configured timer reTX %d ms\n", bsr_cfg_.retx_timer); logger.info("BSR: Configured timer reTX %d ms", bsr_cfg_.retx_timer);
} }
} }
@ -102,16 +95,16 @@ void bsr_proc::timer_expired(uint32_t timer_id)
if (timer_id == timer_periodic.id()) { if (timer_id == timer_periodic.id()) {
if (triggered_bsr_type == NONE) { if (triggered_bsr_type == NONE) {
set_trigger(PERIODIC); set_trigger(PERIODIC);
Debug("BSR: Triggering Periodic BSR\n"); logger.debug("BSR: Triggering Periodic BSR");
} }
// retxBSR-Timer // retxBSR-Timer
} else if (timer_id == timer_retx.id()) { } else if (timer_id == timer_retx.id()) {
// Enable reTx of SR only if periodic timer is not infinity // Enable reTx of SR only if periodic timer is not infinity
Debug("BSR: Timer BSR reTX expired, periodic=%d, channel=%d\n", bsr_cfg.periodic_timer, check_any_channel()); logger.debug("BSR: Timer BSR reTX expired, periodic=%d, channel=%d", bsr_cfg.periodic_timer, check_any_channel());
// Triger Regular BSR if UE has available data for transmission on any channel // Triger Regular BSR if UE has available data for transmission on any channel
if (check_any_channel()) { if (check_any_channel()) {
set_trigger(REGULAR); set_trigger(REGULAR);
Debug("BSR: Triggering BSR reTX\n"); logger.debug("BSR: Triggering BSR reTX");
} }
} }
} }
@ -144,7 +137,7 @@ bool bsr_proc::check_highest_channel()
} }
} }
if (is_max_priority) { if (is_max_priority) {
Debug("BSR: New data for lcid=%d with maximum priority in lcg=%d\n", iter->first, i); logger.debug("BSR: New data for lcid=%d with maximum priority in lcg=%d", iter->first, i);
return true; return true;
} }
} }
@ -171,7 +164,7 @@ bool bsr_proc::check_new_data()
if (get_buffer_state_lcg(i) == 0) { if (get_buffer_state_lcg(i) == 0) {
for (std::map<uint32_t, lcid_t>::iterator iter = lcgs[i].begin(); iter != lcgs[i].end(); ++iter) { for (std::map<uint32_t, lcid_t>::iterator iter = lcgs[i].begin(); iter != lcgs[i].end(); ++iter) {
if (iter->second.new_buffer > 0) { if (iter->second.new_buffer > 0) {
Debug("BSR: New data available for lcid=%d\n", iter->first); logger.debug("BSR: New data available for lcid=%d", iter->first);
return true; return true;
} }
} }
@ -251,7 +244,7 @@ bool bsr_proc::generate_bsr(bsr_t* bsr, uint32_t pdu_space)
// Restart or Start Periodic timer every time a BSR is generated and transmitted in an UL grant // Restart or Start Periodic timer every time a BSR is generated and transmitted in an UL grant
if (timer_periodic.duration() && bsr->format != TRUNC_BSR) { if (timer_periodic.duration() && bsr->format != TRUNC_BSR) {
timer_periodic.run(); timer_periodic.run();
Debug("BSR: Started periodicBSR-Timer\n"); logger.debug("BSR: Started periodicBSR-Timer");
} }
// reset trigger to avoid another BSR in the next UL grant // reset trigger to avoid another BSR in the next UL grant
triggered_bsr_type = NONE; triggered_bsr_type = NONE;
@ -299,7 +292,7 @@ void bsr_proc::step(uint32_t tti)
// Regular BSR triggered if new data arrives or channel with high priority has new data // Regular BSR triggered if new data arrives or channel with high priority has new data
if (check_new_data() || check_highest_channel()) { if (check_new_data() || check_highest_channel()) {
Debug("BSR: Triggering Regular BSR tti=%d\n", tti); logger.debug("BSR: Triggering Regular BSR tti=%d", tti);
set_trigger(REGULAR); set_trigger(REGULAR);
} }
@ -350,13 +343,13 @@ bool bsr_proc::need_to_send_bsr_on_ul_grant(uint32_t grant_size, uint32_t total_
} }
// Cancel SR if an Uplink grant is received // Cancel SR if an Uplink grant is received
Debug("BSR: Cancelling SR procedure due to uplink grant\n"); logger.debug("BSR: Cancelling SR procedure due to uplink grant");
sr->reset(); sr->reset();
// Restart or Start ReTX timer upon indication of a grant // Restart or Start ReTX timer upon indication of a grant
if (timer_retx.duration()) { if (timer_retx.duration()) {
timer_retx.run(); timer_retx.run();
Debug("BSR: Started retxBSR-Timer\n"); logger.debug("BSR: Started retxBSR-Timer");
} }
return send_bsr; return send_bsr;
} }
@ -392,7 +385,7 @@ void bsr_proc::setup_lcid(uint32_t lcid, uint32_t new_lcg, uint32_t priority)
lcgs[new_lcg][lcid].priority = priority; lcgs[new_lcg][lcid].priority = priority;
lcgs[new_lcg][lcid].old_buffer = 0; lcgs[new_lcg][lcid].old_buffer = 0;
} else { } else {
Error("BSR: Invalid lcg=%d for lcid=%d\n", new_lcg, lcid); logger.error("BSR: Invalid lcg=%d for lcid=%d", new_lcg, lcid);
} }
} }

29
srsue/src/stack/mac/proc_phr.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/proc_phr.h" #include "srsue/hdr/stack/mac/proc_phr.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
@ -22,17 +22,16 @@
namespace srsue { namespace srsue {
phr_proc::phr_proc() phr_proc::phr_proc(srslog::basic_logger& logger) : logger(logger)
{ {
initiated = false; initiated = false;
last_pathloss_db = 0; last_pathloss_db = 0;
phr_cfg = {}; phr_cfg = {};
} }
void phr_proc::init(phy_interface_mac_lte* phy_h_, srslte::log_ref log_h_, srslte::ext_task_sched_handle* task_sched_) void phr_proc::init(phy_interface_mac_lte* phy_h_, srslte::ext_task_sched_handle* task_sched_)
{ {
phy_h = phy_h_; phy_h = phy_h_;
log_h = log_h_;
task_sched = task_sched_; task_sched = task_sched_;
initiated = true; initiated = true;
@ -63,13 +62,13 @@ void phr_proc::set_config(srslte::phr_cfg_t& cfg)
timer_periodic.set(phr_cfg.periodic_timer, [this](uint32_t tid) { timer_expired(tid); }); timer_periodic.set(phr_cfg.periodic_timer, [this](uint32_t tid) { timer_expired(tid); });
timer_periodic.run(); timer_periodic.run();
phr_is_triggered = true; phr_is_triggered = true;
Info("PHR: Configured timer periodic %d ms\n", phr_cfg.periodic_timer); Info("PHR: Configured timer periodic %d ms", phr_cfg.periodic_timer);
} }
if (phr_cfg.prohibit_timer > 0) { if (phr_cfg.prohibit_timer > 0) {
timer_prohibit.set(phr_cfg.prohibit_timer, [this](uint32_t tid) { timer_expired(tid); }); timer_prohibit.set(phr_cfg.prohibit_timer, [this](uint32_t tid) { timer_expired(tid); });
timer_prohibit.run(); timer_prohibit.run();
Info("PHR: Configured timer prohibit %d ms\n", phr_cfg.prohibit_timer); Info("PHR: Configured timer prohibit %d ms", phr_cfg.prohibit_timer);
phr_is_triggered = true; phr_is_triggered = true;
} }
} }
@ -102,21 +101,21 @@ void phr_proc::start_periodic_timer()
void phr_proc::timer_expired(uint32_t timer_id) void phr_proc::timer_expired(uint32_t timer_id)
{ {
if (!phr_cfg.enabled) { if (!phr_cfg.enabled) {
Warning("PHR: %s timer triggered but PHR has been disabled\n", Warning("PHR: %s timer triggered but PHR has been disabled",
timer_id == timer_periodic.id() ? "Periodic" : "Prohibit"); timer_id == timer_periodic.id() ? "Periodic" : "Prohibit");
return; return;
} }
if (timer_id == timer_periodic.id()) { if (timer_id == timer_periodic.id()) {
timer_periodic.run(); timer_periodic.run();
Debug("PHR: Triggered by timer periodic (timer expired).\n"); Debug("PHR: Triggered by timer periodic (timer expired).");
phr_is_triggered = true; phr_is_triggered = true;
} else if (timer_id == timer_prohibit.id()) { } else if (timer_id == timer_prohibit.id()) {
if (pathloss_changed()) { if (pathloss_changed()) {
Info("PHR: Triggered by pathloss difference. cur_pathloss_db=%d (timer expired)\n", last_pathloss_db); Info("PHR: Triggered by pathloss difference. cur_pathloss_db=%d (timer expired)", last_pathloss_db);
phr_is_triggered = true; phr_is_triggered = true;
} }
} else { } else {
log_h->warning("Received timer callback from unknown timer_id=%d\n", timer_id); logger.warning("Received timer callback from unknown timer_id=%d", timer_id);
} }
} }
@ -124,7 +123,7 @@ void phr_proc::step()
{ {
if (phr_cfg.enabled && initiated) { if (phr_cfg.enabled && initiated) {
if (pathloss_changed() && timer_prohibit.is_expired()) { if (pathloss_changed() && timer_prohibit.is_expired()) {
Info("PHR: Triggered by pathloss difference. cur_pathloss_db=%d\n", last_pathloss_db); Info("PHR: Triggered by pathloss difference. cur_pathloss_db=%d", last_pathloss_db);
phr_is_triggered = true; phr_is_triggered = true;
} }
} }
@ -138,7 +137,7 @@ bool phr_proc::generate_phr_on_ul_grant(float* phr)
*phr = phy_h->get_phr(); *phr = phy_h->get_phr();
} }
Debug("PHR: Generating PHR=%f\n", phr ? *phr : 0.0); Debug("PHR: Generating PHR=%f", phr ? *phr : 0.0);
timer_periodic.run(); timer_periodic.run();
timer_prohibit.run(); timer_prohibit.run();

88
srsue/src/stack/mac/proc_ra.cc
Unescape Escape View File

@ -29,9 +29,10 @@ const char* state_str[] = {"RA: INIT: ",
"RA: WaitComplt: ", "RA: WaitComplt: ",
"RA: Complt: "}; "RA: Complt: "};
#define rError(fmt, ...) Error("%s" fmt, state_str[state], ##__VA_ARGS__) #define rError(fmt, ...) logger.error("%s" fmt, state_str[state], ##__VA_ARGS__)
#define rInfo(fmt, ...) Info("%s" fmt, state_str[state], ##__VA_ARGS__) #define rInfo(fmt, ...) logger.info("%s" fmt, state_str[state], ##__VA_ARGS__)
#define rDebug(fmt, ...) Debug("%s" fmt, state_str[state], ##__VA_ARGS__) #define rDebug(fmt, ...) logger.debug("%s" fmt, state_str[state], ##__VA_ARGS__)
#define rWarning(fmt, ...) logger.warning("%s" fmt, state_str[state], ##__VA_ARGS__)
// Table 7.2-1. Backoff Parameter values // Table 7.2-1. Backoff Parameter values
uint32_t backoff_table[16] = {0, 10, 20, 30, 40, 60, 80, 120, 160, 240, 320, 480, 960, 960, 960, 960}; uint32_t backoff_table[16] = {0, 10, 20, 30, 40, 60, 80, 120, 160, 240, 320, 480, 960, 960, 960, 960};
@ -42,14 +43,12 @@ int delta_preamble_db_table[5] = {0, 0, -3, -3, 8};
// Initializes memory and pointers to other objects // Initializes memory and pointers to other objects
void ra_proc::init(phy_interface_mac_lte* phy_h_, void ra_proc::init(phy_interface_mac_lte* phy_h_,
rrc_interface_mac* rrc_, rrc_interface_mac* rrc_,
srslte::log_ref log_h_,
mac_interface_rrc::ue_rnti_t* rntis_, mac_interface_rrc::ue_rnti_t* rntis_,
srslte::timer_handler::unique_timer* time_alignment_timer_, srslte::timer_handler::unique_timer* time_alignment_timer_,
mux* mux_unit_, mux* mux_unit_,
srslte::ext_task_sched_handle* task_sched_) srslte::ext_task_sched_handle* task_sched_)
{ {
phy_h = phy_h_; phy_h = phy_h_;
log_h = log_h_;
rntis = rntis_; rntis = rntis_;
mux_unit = mux_unit_; mux_unit = mux_unit_;
rrc = rrc_; rrc = rrc_;
@ -158,14 +157,14 @@ void ra_proc::state_pdcch_setup()
if (info.is_transmitted) { if (info.is_transmitted) {
ra_tti = info.tti_ra; ra_tti = info.tti_ra;
ra_rnti = 1 + (ra_tti % 10) + (10 * info.f_id); ra_rnti = 1 + (ra_tti % 10) + (10 * info.f_id);
rInfo("seq=%d, ra-rnti=0x%x, ra-tti=%d, f_id=%d\n", sel_preamble.load(), ra_rnti, info.tti_ra, info.f_id); rInfo("seq=%d, ra-rnti=0x%x, ra-tti=%d, f_id=%d", sel_preamble.load(), ra_rnti, info.tti_ra, info.f_id);
srslte::console( srslte::console(
"Random Access Transmission: seq=%d, tti=%d, ra-rnti=0x%x\n", sel_preamble.load(), info.tti_ra, ra_rnti); "Random Access Transmission: seq=%d, tti=%d, ra-rnti=0x%x\n", sel_preamble.load(), info.tti_ra, ra_rnti);
rar_window_st = ra_tti + 3; rar_window_st = ra_tti + 3;
rntis->rar_rnti = ra_rnti; rntis->rar_rnti = ra_rnti;
state = RESPONSE_RECEPTION; state = RESPONSE_RECEPTION;
} else { } else {
rDebug("preamble not yet transmitted\n"); rDebug("preamble not yet transmitted");
} }
} }
@ -178,7 +177,7 @@ void ra_proc::state_response_reception(uint32_t tti)
if (!rar_received) { if (!rar_received) {
uint32_t interval = srslte_tti_interval(tti, ra_tti + 3 + rach_cfg.responseWindowSize - 1); uint32_t interval = srslte_tti_interval(tti, ra_tti + 3 + rach_cfg.responseWindowSize - 1);
if (interval > 0 && interval < 100) { if (interval > 0 && interval < 100) {
Error("RA response not received within the response window\n"); logger.error("RA response not received within the response window");
response_error(); response_error();
} }
} }
@ -215,7 +214,7 @@ void ra_proc::state_contention_resolution()
// Once Msg3 is transmitted, start contention resolution timer // Once Msg3 is transmitted, start contention resolution timer
if (mux_unit->msg3_is_transmitted() && !contention_resolution_timer.is_running()) { if (mux_unit->msg3_is_transmitted() && !contention_resolution_timer.is_running()) {
// Start contention resolution timer // Start contention resolution timer
rInfo("Starting ContentionResolutionTimer=%d ms\n", contention_resolution_timer.duration()); rInfo("Starting ContentionResolutionTimer=%d ms", contention_resolution_timer.duration());
contention_resolution_timer.run(); contention_resolution_timer.run();
} }
} }
@ -239,15 +238,14 @@ void ra_proc::notify_ra_completed(uint32_t task_id)
{ {
if (current_task_id == task_id) { if (current_task_id == task_id) {
if (state != WAITING_COMPLETION) { if (state != WAITING_COMPLETION) {
rError("Received unexpected notification of RA completion\n"); rError("Received unexpected notification of RA completion");
} else { } else {
rInfo("RA waiting procedure completed\n"); rInfo("RA waiting procedure completed");
} }
state = IDLE; state = IDLE;
} else { } else {
rError("Received old notification of RA completition (old task_id=%d, current_task_id=%d)\n", rError(
task_id, "Received old notification of RA completition (old task_id=%d, current_task_id=%d)", task_id, current_task_id);
current_task_id);
} }
} }
@ -295,7 +293,7 @@ void ra_proc::resource_selection()
// randomly choose preamble from [0 nof_groupA_preambles) // randomly choose preamble from [0 nof_groupA_preambles)
sel_preamble = rand() % rach_cfg.nof_groupA_preambles; sel_preamble = rand() % rach_cfg.nof_groupA_preambles;
} else { } else {
rError("Selected group preamble A but nof_groupA_preambles=0\n"); rError("Selected group preamble A but nof_groupA_preambles=0");
state = IDLE; state = IDLE;
return; return;
} }
@ -304,7 +302,7 @@ void ra_proc::resource_selection()
// randomly choose preamble from [nof_groupA_preambles nof_groupB_preambles) // randomly choose preamble from [nof_groupA_preambles nof_groupB_preambles)
sel_preamble = rach_cfg.nof_groupA_preambles + rand() % nof_groupB_preambles; sel_preamble = rach_cfg.nof_groupA_preambles + rand() % nof_groupB_preambles;
} else { } else {
rError("Selected group preamble B but nof_groupA_preambles=0\n"); rError("Selected group preamble B but nof_groupA_preambles=0");
state = IDLE; state = IDLE;
return; return;
} }
@ -312,7 +310,7 @@ void ra_proc::resource_selection()
sel_maskIndex = 0; sel_maskIndex = 0;
} }
rDebug("Selected preambleIndex=%d maskIndex=%d GroupA=%d, GroupB=%d\n", rDebug("Selected preambleIndex=%d maskIndex=%d GroupA=%d, GroupB=%d",
sel_preamble.load(), sel_preamble.load(),
sel_maskIndex, sel_maskIndex,
rach_cfg.nof_groupA_preambles, rach_cfg.nof_groupA_preambles,
@ -347,16 +345,16 @@ void ra_proc::process_timeadv_cmd(uint32_t ta)
if (time_alignment_timer->is_running()) { if (time_alignment_timer->is_running()) {
time_alignment_timer->run(); time_alignment_timer->run();
} }
Debug("Applying RAR TA CMD %d\n", ta); logger.debug("Applying RAR TA CMD %d", ta);
} else { } else {
// Preamble selected by UE MAC // Preamble selected by UE MAC
if (!time_alignment_timer->is_running()) { if (!time_alignment_timer->is_running()) {
phy_h->set_timeadv_rar(ta); phy_h->set_timeadv_rar(ta);
time_alignment_timer->run(); time_alignment_timer->run();
Debug("Applying RAR TA CMD %d\n", ta); logger.debug("Applying RAR TA CMD %d", ta);
} else { } else {
// Ignore TA CMD // Ignore TA CMD
Warning("Ignoring RAR TA CMD because timeAlignmentTimer still running\n"); logger.warning("Ignoring RAR TA CMD because timeAlignmentTimer still running");
} }
} }
} }
@ -369,7 +367,7 @@ void ra_proc::new_grant_dl(mac_interface_phy_lte::mac_grant_dl_t grant, mac_inte
bzero(action, sizeof(mac_interface_phy_lte::tb_action_dl_t)); bzero(action, sizeof(mac_interface_phy_lte::tb_action_dl_t));
if (grant.tb[0].tbs < MAX_RAR_PDU_LEN) { if (grant.tb[0].tbs < MAX_RAR_PDU_LEN) {
rDebug("DL dci found RA-RNTI=%d\n", ra_rnti); rDebug("DL dci found RA-RNTI=%d", ra_rnti);
action->tb[0].enabled = true; action->tb[0].enabled = true;
action->tb[0].payload = rar_pdu_buffer; action->tb[0].payload = rar_pdu_buffer;
action->tb[0].rv = grant.tb[0].rv; action->tb[0].rv = grant.tb[0].rv;
@ -379,7 +377,7 @@ void ra_proc::new_grant_dl(mac_interface_phy_lte::mac_grant_dl_t grant, mac_inte
srslte_softbuffer_rx_reset(&softbuffer_rar); srslte_softbuffer_rx_reset(&softbuffer_rar);
} }
} else { } else {
rError("Received RAR dci exceeds buffer length (%d>%d)\n", grant.tb[0].tbs, MAX_RAR_PDU_LEN); rError("Received RAR dci exceeds buffer length (%d>%d)", grant.tb[0].tbs, int(MAX_RAR_PDU_LEN));
} }
} }
@ -396,10 +394,10 @@ void ra_proc::tb_decoded_ok(const uint8_t cc_idx, const uint32_t tti)
rar_pdu_msg.init_rx(rar_grant_nbytes); rar_pdu_msg.init_rx(rar_grant_nbytes);
if (rar_pdu_msg.parse_packet(rar_pdu_buffer) != SRSLTE_SUCCESS) { if (rar_pdu_msg.parse_packet(rar_pdu_buffer) != SRSLTE_SUCCESS) {
rError("Error decoding RAR PDU\n"); rError("Error decoding RAR PDU");
} }
rDebug("RAR decoded successfully TBS=%d\n", rar_grant_nbytes); rDebug("RAR decoded successfully TBS=%d", rar_grant_nbytes);
// Set Backoff parameter // Set Backoff parameter
if (rar_pdu_msg.has_backoff()) { if (rar_pdu_msg.has_backoff()) {
@ -427,7 +425,7 @@ void ra_proc::tb_decoded_ok(const uint8_t cc_idx, const uint32_t tti)
current_ta = rar_pdu_msg.get()->get_ta_cmd(); current_ta = rar_pdu_msg.get()->get_ta_cmd();
rInfo("RAPID=%d, TA=%d, T-CRNTI=0x%x\n", rInfo("RAPID=%d, TA=%d, T-CRNTI=0x%x",
sel_preamble.load(), sel_preamble.load(),
rar_pdu_msg.get()->get_ta_cmd(), rar_pdu_msg.get()->get_ta_cmd(),
rar_pdu_msg.get()->get_temp_crnti()); rar_pdu_msg.get()->get_temp_crnti());
@ -445,7 +443,7 @@ void ra_proc::tb_decoded_ok(const uint8_t cc_idx, const uint32_t tti)
// If we have a C-RNTI, tell Mux unit to append C-RNTI CE if no CCCH SDU transmission // If we have a C-RNTI, tell Mux unit to append C-RNTI CE if no CCCH SDU transmission
if (transmitted_crnti) { if (transmitted_crnti) {
rInfo("Appending C-RNTI MAC CE 0x%x in next transmission\n", transmitted_crnti.load()); rInfo("Appending C-RNTI MAC CE 0x%x in next transmission", transmitted_crnti.load());
mux_unit->append_crnti_ce_next_tx(transmitted_crnti); mux_unit->append_crnti_ce_next_tx(transmitted_crnti);
} }
} }
@ -454,7 +452,7 @@ void ra_proc::tb_decoded_ok(const uint8_t cc_idx, const uint32_t tti)
transmitted_contention_id = rntis->contention_id; transmitted_contention_id = rntis->contention_id;
task_queue.push([this]() { task_queue.push([this]() {
rDebug("Waiting for Contention Resolution\n"); rDebug("Waiting for Contention Resolution");
state = CONTENTION_RESOLUTION; state = CONTENTION_RESOLUTION;
}); });
} else { } else {
@ -463,7 +461,7 @@ void ra_proc::tb_decoded_ok(const uint8_t cc_idx, const uint32_t tti)
} }
} else { } else {
if (rar_pdu_msg.get()->has_rapid()) { if (rar_pdu_msg.get()->has_rapid()) {
rInfo("Found RAR for preamble %d\n", rar_pdu_msg.get()->get_rapid()); rInfo("Found RAR for preamble %d", rar_pdu_msg.get()->get_rapid());
} }
} }
} }
@ -478,7 +476,7 @@ void ra_proc::response_error()
preambleTransmissionCounter++; preambleTransmissionCounter++;
contention_resolution_timer.stop(); contention_resolution_timer.stop();
if (preambleTransmissionCounter >= rach_cfg.preambleTransMax + 1) { if (preambleTransmissionCounter >= rach_cfg.preambleTransMax + 1) {
rError("Maximum number of transmissions reached (%d)\n", rach_cfg.preambleTransMax); rError("Maximum number of transmissions reached (%d)", rach_cfg.preambleTransMax);
rrc->ra_problem(); rrc->ra_problem();
state = IDLE; state = IDLE;
} else { } else {
@ -489,10 +487,10 @@ void ra_proc::response_error()
backoff_interval = 0; backoff_interval = 0;
} }
if (backoff_interval) { if (backoff_interval) {
rDebug("Backoff wait interval %d\n", backoff_interval); rDebug("Backoff wait interval %d", backoff_interval);
state = BACKOFF_WAIT; state = BACKOFF_WAIT;
} else { } else {
rInfo("Transmitting new preamble immediately (%d/%d)\n", preambleTransmissionCounter, rach_cfg.preambleTransMax); rInfo("Transmitting new preamble immediately (%d/%d)", preambleTransmissionCounter, rach_cfg.preambleTransMax);
resource_selection(); resource_selection();
} }
} }
@ -517,7 +515,7 @@ void ra_proc::complete()
rrc->ra_completed(); rrc->ra_completed();
srslte::console("Random Access Complete. c-rnti=0x%x, ta=%d\n", rntis->crnti, current_ta); srslte::console("Random Access Complete. c-rnti=0x%x, ta=%d\n", rntis->crnti, current_ta);
rInfo("Random Access Complete. c-rnti=0x%x, ta=%d\n", rntis->crnti, current_ta); rInfo("Random Access Complete. c-rnti=0x%x, ta=%d", rntis->crnti, current_ta);
state = START_WAIT_COMPLETION; state = START_WAIT_COMPLETION;
} }
@ -527,10 +525,10 @@ void ra_proc::start_mac_order(uint32_t msg_len_bits)
if (state == IDLE) { if (state == IDLE) {
started_by_pdcch = false; started_by_pdcch = false;
new_ra_msg_len = msg_len_bits; new_ra_msg_len = msg_len_bits;
rInfo("Starting PRACH by MAC order\n"); rInfo("Starting PRACH by MAC order");
initialization(); initialization();
} else { } else {
Warning("Trying to start PRACH by MAC order in invalid state (%s)\n", state_str[state]); logger.warning("Trying to start PRACH by MAC order in invalid state (%s)", state_str[state]);
} }
} }
@ -538,17 +536,17 @@ void ra_proc::start_pdcch_order()
{ {
if (state == IDLE) { if (state == IDLE) {
started_by_pdcch = true; started_by_pdcch = true;
rInfo("Starting PRACH by PDCCH order\n"); rInfo("Starting PRACH by PDCCH order");
initialization(); initialization();
} else { } else {
Warning("Trying to start PRACH by MAC order in invalid state (%s)\n", state_str[state]); logger.warning("Trying to start PRACH by MAC order in invalid state (%s)", state_str[state]);
} }
} }
// Contention Resolution Timer is expired (Section 5.1.5) // Contention Resolution Timer is expired (Section 5.1.5)
void ra_proc::timer_expired(uint32_t timer_id) void ra_proc::timer_expired(uint32_t timer_id)
{ {
rInfo("Contention Resolution Timer expired. Stopping PDCCH Search and going to Response Error\n"); rInfo("Contention Resolution Timer expired. Stopping PDCCH Search and going to Response Error");
response_error(); response_error();
} }
@ -572,10 +570,10 @@ bool ra_proc::contention_resolution_id_received_unsafe(uint64_t rx_contention_id
{ {
bool uecri_successful = false; bool uecri_successful = false;
rDebug("MAC PDU Contains Contention Resolution ID CE\n"); rDebug("MAC PDU Contains Contention Resolution ID CE");
if (state != CONTENTION_RESOLUTION) { if (state != CONTENTION_RESOLUTION) {
rError("Received contention resolution in wrong state. Aborting.\n"); rError("Received contention resolution in wrong state. Aborting.");
response_error(); response_error();
} }
@ -587,7 +585,7 @@ bool ra_proc::contention_resolution_id_received_unsafe(uint64_t rx_contention_id
uecri_successful = true; uecri_successful = true;
complete(); complete();
} else { } else {
rInfo("Transmitted UE Contention Id differs from received Contention ID (0x%" PRIx64 " != 0x%" PRIx64 ")\n", rInfo("Transmitted UE Contention Id differs from received Contention ID (0x%" PRIx64 " != 0x%" PRIx64 ")",
transmitted_contention_id.load(), transmitted_contention_id.load(),
rx_contention_id); rx_contention_id);
@ -606,9 +604,9 @@ void ra_proc::pdcch_to_crnti(bool is_new_uplink_transmission)
{ {
task_queue.push([this, is_new_uplink_transmission]() { task_queue.push([this, is_new_uplink_transmission]() {
// TS 36.321 Section 5.1.5 // TS 36.321 Section 5.1.5
rDebug("PDCCH to C-RNTI received %s new UL transmission\n", is_new_uplink_transmission ? "with" : "without"); rDebug("PDCCH to C-RNTI received %s new UL transmission", is_new_uplink_transmission ? "with" : "without");
if ((!started_by_pdcch && is_new_uplink_transmission) || started_by_pdcch) { if ((!started_by_pdcch && is_new_uplink_transmission) || started_by_pdcch) {
rDebug("PDCCH for C-RNTI received\n"); rDebug("PDCCH for C-RNTI received");
contention_resolution_timer.stop(); contention_resolution_timer.stop();
complete(); complete();
} }
@ -626,14 +624,14 @@ void ra_proc::update_rar_window(int& rar_window_start, int& rar_window_length)
rar_window_length = rach_cfg.responseWindowSize; rar_window_length = rach_cfg.responseWindowSize;
rar_window_start = rar_window_st; rar_window_start = rar_window_st;
} }
rDebug("rar_window_start=%d, rar_window_length=%d\n", rar_window_start, rar_window_length); rDebug("rar_window_start=%d, rar_window_length=%d", rar_window_start, rar_window_length);
} }
// Restart timer at each Msg3 HARQ retransmission (5.1.5) // Restart timer at each Msg3 HARQ retransmission (5.1.5)
void ra_proc::harq_retx() void ra_proc::harq_retx()
{ {
task_queue.push([this]() { task_queue.push([this]() {
rInfo("Restarting ContentionResolutionTimer=%d ms\n", contention_resolution_timer.duration()); rInfo("Restarting ContentionResolutionTimer=%d ms", contention_resolution_timer.duration());
contention_resolution_timer.run(); contention_resolution_timer.run();
}); });
} }
@ -642,7 +640,7 @@ void ra_proc::harq_retx()
void ra_proc::harq_max_retx() void ra_proc::harq_max_retx()
{ {
task_queue.push([this]() { task_queue.push([this]() {
Warning("Contention Resolution is considered not successful. Stopping PDCCH Search and going to Response Error\n"); rWarning("Contention Resolution is considered not successful. Stopping PDCCH Search and going to Response Error");
response_error(); response_error();
}); });
} }

25
srsue/src/stack/mac/proc_sr.cc
Unescape Escape View File

@ -10,24 +10,23 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/proc_sr.h" #include "srsue/hdr/stack/mac/proc_sr.h"
#include "srsue/hdr/stack/mac/proc_ra.h" #include "srsue/hdr/stack/mac/proc_ra.h"
namespace srsue { namespace srsue {
sr_proc::sr_proc() sr_proc::sr_proc(srslog::basic_logger& logger) : logger(logger)
{ {
initiated = false; initiated = false;
} }
void sr_proc::init(ra_proc* ra_, phy_interface_mac_lte* phy_h_, rrc_interface_mac* rrc_, srslte::log_ref log_h_) void sr_proc::init(ra_proc* ra_, phy_interface_mac_lte* phy_h_, rrc_interface_mac* rrc_)
{ {
log_h = log_h_;
rrc = rrc_; rrc = rrc_;
ra = ra_; ra = ra_;
phy_h = phy_h_; phy_h = phy_h_;
@ -43,7 +42,7 @@ void sr_proc::reset()
bool sr_proc::need_tx(uint32_t tti) bool sr_proc::need_tx(uint32_t tti)
{ {
int last_tx_tti = phy_h->sr_last_tx_tti(); int last_tx_tti = phy_h->sr_last_tx_tti();
Debug("SR: need_tx(): last_tx_tti=%d, tti=%d\n", last_tx_tti, tti); Debug("SR: need_tx(): last_tx_tti=%d, tti=%d", last_tx_tti, tti);
if (last_tx_tti >= 0) { if (last_tx_tti >= 0) {
if (tti > (uint32_t)last_tx_tti) { if (tti > (uint32_t)last_tx_tti) {
if (tti - last_tx_tti > 8) { if (tti - last_tx_tti > 8) {
@ -62,11 +61,11 @@ bool sr_proc::need_tx(uint32_t tti)
void sr_proc::set_config(srslte::sr_cfg_t& cfg) void sr_proc::set_config(srslte::sr_cfg_t& cfg)
{ {
if (cfg.enabled && cfg.dsr_transmax == 0) { if (cfg.enabled && cfg.dsr_transmax == 0) {
Error("Zero is an invalid value for dsr-TransMax (n4, n8, n16, n32, n64 are supported). Disabling SR.\n"); Error("Zero is an invalid value for dsr-TransMax (n4, n8, n16, n32, n64 are supported). Disabling SR.");
return; return;
} }
if (cfg.enabled) { if (cfg.enabled) {
Info("SR: Set dsr_transmax=%d\n", sr_cfg.dsr_transmax); Info("SR: Set dsr_transmax=%d", sr_cfg.dsr_transmax);
} }
sr_cfg = cfg; sr_cfg = cfg;
} }
@ -79,12 +78,12 @@ void sr_proc::step(uint32_t tti)
if (sr_counter < sr_cfg.dsr_transmax) { if (sr_counter < sr_cfg.dsr_transmax) {
if (sr_counter == 0 || need_tx(tti)) { if (sr_counter == 0 || need_tx(tti)) {
sr_counter++; sr_counter++;
Info("SR: Signalling PHY sr_counter=%d\n", sr_counter); Info("SR: Signalling PHY sr_counter=%d", sr_counter);
phy_h->sr_send(); phy_h->sr_send();
} }
} else { } else {
if (need_tx(tti)) { if (need_tx(tti)) {
Info("SR: Releasing PUCCH/SRS resources, sr_counter=%d, dsr_transmax=%d\n", Info("SR: Releasing PUCCH/SRS resources, sr_counter=%d, dsr_transmax=%d",
sr_counter, sr_counter,
sr_cfg.dsr_transmax); sr_cfg.dsr_transmax);
srslte::console("Scheduling request failed: releasing RRC connection...\n"); srslte::console("Scheduling request failed: releasing RRC connection...\n");
@ -94,7 +93,7 @@ void sr_proc::step(uint32_t tti)
} }
} }
} else if (ra->is_idle()) { } else if (ra->is_idle()) {
Info("SR: PUCCH not configured. Starting RA procedure\n"); Info("SR: PUCCH not configured. Starting RA procedure");
ra->start_mac_order(); ra->start_mac_order();
reset(); reset();
} }

56
srsue/src/stack/mac/ul_harq.cc
Unescape Escape View File

@ -10,10 +10,10 @@
* *
*/ */
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__) #define Error(fmt, ...) logger.error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__) #define Warning(fmt, ...) logger.warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__) #define Info(fmt, ...) logger.info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__) #define Debug(fmt, ...) logger.debug(fmt, ##__VA_ARGS__)
#include "srsue/hdr/stack/mac/ul_harq.h" #include "srsue/hdr/stack/mac/ul_harq.h"
#include "srslte/common/interfaces_common.h" #include "srslte/common/interfaces_common.h"
@ -24,14 +24,12 @@
namespace srsue { namespace srsue {
ul_harq_entity::ul_harq_entity(const uint8_t cc_idx_) : proc(SRSLTE_MAX_HARQ_PROC), cc_idx(cc_idx_) {} ul_harq_entity::ul_harq_entity(const uint8_t cc_idx_) :
proc(SRSLTE_MAX_HARQ_PROC), logger(srslog::fetch_basic_logger("MAC")), cc_idx(cc_idx_)
{}
bool ul_harq_entity::init(srslte::log_ref log_h_, bool ul_harq_entity::init(mac_interface_rrc_common::ue_rnti_t* rntis_, ra_proc* ra_procedure_, mux* mux_unit_)
mac_interface_rrc_common::ue_rnti_t* rntis_,
ra_proc* ra_procedure_,
mux* mux_unit_)
{ {
log_h = log_h_;
mux_unit = mux_unit_; mux_unit = mux_unit_;
ra_procedure = ra_procedure_; ra_procedure = ra_procedure_;
rntis = rntis_; rntis = rntis_;
@ -76,7 +74,7 @@ void ul_harq_entity::new_grant_ul(mac_interface_phy_lte::mac_grant_ul_t grant,
bzero(action, sizeof(mac_interface_phy_lte::tb_action_ul_t)); bzero(action, sizeof(mac_interface_phy_lte::tb_action_ul_t));
if (grant.pid >= SRSLTE_MAX_HARQ_PROC) { if (grant.pid >= SRSLTE_MAX_HARQ_PROC) {
Error("Invalid PID: %d\n", grant.pid); Error("Invalid PID: %d", grant.pid);
return; return;
} }
if (grant.rnti == rntis->crnti || grant.rnti == rntis->temp_rnti || SRSLTE_RNTI_ISRAR(grant.rnti)) { if (grant.rnti == rntis->crnti || grant.rnti == rntis->temp_rnti || SRSLTE_RNTI_ISRAR(grant.rnti)) {
@ -89,17 +87,17 @@ void ul_harq_entity::new_grant_ul(mac_interface_phy_lte::mac_grant_ul_t grant,
grant.tb.ndi = proc[grant.pid].get_ndi(); grant.tb.ndi = proc[grant.pid].get_ndi();
proc[grant.pid].new_grant_ul(grant, action); proc[grant.pid].new_grant_ul(grant, action);
} else { } else {
Info("Not implemented\n"); Info("Not implemented");
} }
} else { } else {
Info("Received grant for unknown rnti=0x%x\n", grant.rnti); Info("Received grant for unknown rnti=0x%x", grant.rnti);
} }
} }
int ul_harq_entity::get_current_tbs(uint32_t pid) int ul_harq_entity::get_current_tbs(uint32_t pid)
{ {
if (pid >= SRSLTE_MAX_HARQ_PROC) { if (pid >= SRSLTE_MAX_HARQ_PROC) {
Error("Invalid PID: %d\n", pid); Error("Invalid PID: %d", pid);
return 0; return 0;
} }
return proc[pid].get_current_tbs(); return proc[pid].get_current_tbs();
@ -110,7 +108,7 @@ float ul_harq_entity::get_average_retx()
return average_retx; return average_retx;
} }
ul_harq_entity::ul_harq_process::ul_harq_process() ul_harq_entity::ul_harq_process::ul_harq_process() : logger(srslog::fetch_basic_logger("MAC"))
{ {
pdu_ptr = NULL; pdu_ptr = NULL;
payload_buffer = NULL; payload_buffer = NULL;
@ -136,18 +134,17 @@ ul_harq_entity::ul_harq_process::~ul_harq_process()
bool ul_harq_entity::ul_harq_process::init(uint32_t pid_, ul_harq_entity* parent) bool ul_harq_entity::ul_harq_process::init(uint32_t pid_, ul_harq_entity* parent)
{ {
if (srslte_softbuffer_tx_init(&softbuffer, 110)) { if (srslte_softbuffer_tx_init(&softbuffer, 110)) {
ERROR("Error initiating soft buffer\n"); ERROR("Error initiating soft buffer");
return false; return false;
} }
harq_entity = parent; harq_entity = parent;
log_h = harq_entity->log_h;
is_initiated = true; is_initiated = true;
pid = pid_; pid = pid_;
payload_buffer = std::unique_ptr<byte_buffer_t>(new byte_buffer_t); payload_buffer = std::unique_ptr<byte_buffer_t>(new byte_buffer_t);
if (!payload_buffer) { if (!payload_buffer) {
Error("Allocating memory\n"); Error("Allocating memory");
return false; return false;
} }
pdu_ptr = payload_buffer->msg; pdu_ptr = payload_buffer->msg;
@ -187,7 +184,7 @@ void ul_harq_entity::ul_harq_process::new_grant_ul(mac_interface_phy_lte::mac_gr
// Check maximum retransmissions, do not consider last retx ACK // Check maximum retransmissions, do not consider last retx ACK
if (current_tx_nb >= max_retx && !grant.hi_value) { if (current_tx_nb >= max_retx && !grant.hi_value) {
Info("UL %d: Maximum number of ReTX reached (%d). Discarding TB.\n", pid, max_retx); Info("UL %d: Maximum number of ReTX reached (%d). Discarding TB.", pid, max_retx);
if (grant.rnti == harq_entity->rntis->temp_rnti) { if (grant.rnti == harq_entity->rntis->temp_rnti) {
harq_entity->ra_procedure->harq_max_retx(); harq_entity->ra_procedure->harq_max_retx();
} }
@ -200,8 +197,7 @@ void ul_harq_entity::ul_harq_process::new_grant_ul(mac_interface_phy_lte::mac_gr
// Reset HARQ process if TB has changed // Reset HARQ process if TB has changed
if (harq_feedback && has_grant() && grant.tb.ndi_present) { if (harq_feedback && has_grant() && grant.tb.ndi_present) {
if (grant.tb.tbs != cur_grant.tb.tbs && cur_grant.tb.tbs > 0 && grant.tb.tbs > 0) { if (grant.tb.tbs != cur_grant.tb.tbs && cur_grant.tb.tbs > 0 && grant.tb.tbs > 0) {
Debug( Debug("UL %d: Reset due to change of dci size last_grant=%d, new_grant=%d", pid, cur_grant.tb.tbs, grant.tb.tbs);
"UL %d: Reset due to change of dci size last_grant=%d, new_grant=%d\n", pid, cur_grant.tb.tbs, grant.tb.tbs);
reset(); reset();
} }
} }
@ -223,22 +219,22 @@ void ul_harq_entity::ul_harq_process::new_grant_ul(mac_interface_phy_lte::mac_gr
// Check buffer size // Check buffer size
if (grant.tb.tbs > payload_buffer_len) { if (grant.tb.tbs > payload_buffer_len) {
Error("Grant size exceeds payload buffer size (%d > %d)\n", grant.tb.tbs, payload_buffer_len); Error("Grant size exceeds payload buffer size (%d > %d)", grant.tb.tbs, int(payload_buffer_len));
return; return;
} }
// Uplink dci in a RAR and there is a PDU in the Msg3 buffer // Uplink dci in a RAR and there is a PDU in the Msg3 buffer
if (grant.is_rar) { if (grant.is_rar) {
if (harq_entity->mux_unit->msg3_is_pending()) { if (harq_entity->mux_unit->msg3_is_pending()) {
Debug("Getting Msg3 buffer payload, grant size=%d bytes\n", grant.tb.tbs); Debug("Getting Msg3 buffer payload, grant size=%d bytes", grant.tb.tbs);
pdu_ptr = harq_entity->mux_unit->msg3_get(payload_buffer.get(), grant.tb.tbs); pdu_ptr = harq_entity->mux_unit->msg3_get(payload_buffer.get(), grant.tb.tbs);
if (pdu_ptr) { if (pdu_ptr) {
generate_new_tx(grant, action); generate_new_tx(grant, action);
} else { } else {
Warning("UL RAR dci available but no Msg3 on buffer\n"); Warning("UL RAR dci available but no Msg3 on buffer");
} }
} else { } else {
Warning("UL RAR available but no Msg3 pending on buffer\n"); Warning("UL RAR available but no Msg3 pending on buffer");
} }
// Normal UL dci // Normal UL dci
} else { } else {
@ -247,7 +243,7 @@ void ul_harq_entity::ul_harq_process::new_grant_ul(mac_interface_phy_lte::mac_gr
if (pdu_ptr) { if (pdu_ptr) {
generate_new_tx(grant, action); generate_new_tx(grant, action);
} else { } else {
Warning("Uplink dci but no MAC PDU in Multiplex Unit buffer\n"); Warning("Uplink dci but no MAC PDU in Multiplex Unit buffer");
} }
} }
@ -258,7 +254,7 @@ void ul_harq_entity::ul_harq_process::new_grant_ul(mac_interface_phy_lte::mac_gr
// Adaptive Re-TX // Adaptive Re-TX
generate_retx(grant, action); generate_retx(grant, action);
} else { } else {
Warning("UL %d: Received retransmission but no previous dci available for this PID.\n", pid); Warning("UL %d: Received retransmission but no previous dci available for this PID.", pid);
} }
if (harq_entity->pcap) { if (harq_entity->pcap) {
uint16_t rnti; uint16_t rnti;
@ -318,7 +314,7 @@ void ul_harq_entity::ul_harq_process::generate_retx(mac_interface_phy_lte::mac_g
current_irv = irv_of_rv[grant.tb.rv % 4]; current_irv = irv_of_rv[grant.tb.rv % 4];
} }
Info("UL %d: Adaptive retx=%d, RV=%d, TBS=%d, HI=%s, ndi=%d, prev_ndi=%d\n", Info("UL %d: Adaptive retx=%d, RV=%d, TBS=%d, HI=%s, ndi=%d, prev_ndi=%d",
pid, pid,
current_tx_nb, current_tx_nb,
get_rv(), get_rv(),
@ -338,7 +334,7 @@ void ul_harq_entity::ul_harq_process::generate_retx(mac_interface_phy_lte::mac_g
// HARQ entity requests a non-adaptive transmission // HARQ entity requests a non-adaptive transmission
} else if (!harq_feedback) { } else if (!harq_feedback) {
// Non-adaptive retx are only sent if HI=NACK. If HI=ACK but no dci was received do not reset PID // Non-adaptive retx are only sent if HI=NACK. If HI=ACK but no dci was received do not reset PID
Info("UL %d: Non-Adaptive retx=%d, RV=%d, TBS=%d, HI=%s\n", Info("UL %d: Non-Adaptive retx=%d, RV=%d, TBS=%d, HI=%s",
pid, pid,
current_tx_nb, current_tx_nb,
get_rv(), get_rv(),
@ -363,7 +359,7 @@ void ul_harq_entity::ul_harq_process::generate_new_tx(mac_interface_phy_lte::mac
action->is_rar = grant.is_rar || (grant.rnti == harq_entity->rntis->temp_rnti); action->is_rar = grant.is_rar || (grant.rnti == harq_entity->rntis->temp_rnti);
Info("UL %d: New TX%s, RV=%d, TBS=%d\n", Info("UL %d: New TX%s, RV=%d, TBS=%d",
pid, pid,
grant.rnti == harq_entity->rntis->temp_rnti ? " for Msg3" : "", grant.rnti == harq_entity->rntis->temp_rnti ? " for Msg3" : "",
get_rv(), get_rv(),

32
srsue/src/stack/rrc/phy_controller.cc
Unescape Escape View File

@ -37,13 +37,13 @@ void phy_controller::in_sync()
bool phy_controller::set_cell_config(const srslte::phy_cfg_t& config, uint32_t cc_idx) bool phy_controller::set_cell_config(const srslte::phy_cfg_t& config, uint32_t cc_idx)
{ {
log_h->info("Setting PHY config for cc_idx=%d\n", cc_idx); log_h->info("Setting PHY config for cc_idx=%d", cc_idx);
return set_cell_config(config, cc_idx, true); return set_cell_config(config, cc_idx, true);
} }
void phy_controller::set_phy_to_default() void phy_controller::set_phy_to_default()
{ {
log_h->info("Setting default PHY config (common and dedicated)\n"); log_h->info("Setting default PHY config (common and dedicated)");
srslte::phy_cfg_t& default_cfg = current_cells_cfg[0]; srslte::phy_cfg_t& default_cfg = current_cells_cfg[0];
default_cfg.set_defaults(); default_cfg.set_defaults();
@ -55,7 +55,7 @@ void phy_controller::set_phy_to_default()
/// Apply default PHY config for all SCells as specified in TS 36.331 9.2.4 /// Apply default PHY config for all SCells as specified in TS 36.331 9.2.4
void phy_controller::set_phy_to_default_dedicated() void phy_controller::set_phy_to_default_dedicated()
{ {
log_h->info("Setting default dedicated PHY config\n"); log_h->info("Setting default dedicated PHY config");
srslte::phy_cfg_t& default_cfg = current_cells_cfg[0]; srslte::phy_cfg_t& default_cfg = current_cells_cfg[0];
default_cfg.set_defaults_dedicated(); default_cfg.set_defaults_dedicated();
@ -66,7 +66,7 @@ void phy_controller::set_phy_to_default_dedicated()
void phy_controller::set_phy_to_default_pucch_srs() void phy_controller::set_phy_to_default_pucch_srs()
{ {
log_h->info("Setting default PHY config dedicated\n"); log_h->info("Setting default PHY config dedicated");
srslte::phy_cfg_t& default_cfg_ded = current_cells_cfg[0]; srslte::phy_cfg_t& default_cfg_ded = current_cells_cfg[0];
default_cfg_ded.set_defaults_pucch_sr(); default_cfg_ded.set_defaults_pucch_sr();
@ -91,7 +91,7 @@ bool phy_controller::set_cell_config(const srslte::phy_cfg_t& cfg, uint32_t cc_i
void phy_controller::set_config_complete() void phy_controller::set_config_complete()
{ {
if (nof_pending_configs == 0) { if (nof_pending_configs == 0) {
log_h->warning("Received more phy config complete signals than the ones scheduled\n"); log_h->warning("Received more phy config complete signals than the ones scheduled");
return; return;
} }
nof_pending_configs--; nof_pending_configs--;
@ -104,12 +104,12 @@ void phy_controller::set_config_complete()
bool phy_controller::start_cell_select(const phy_cell_t& phy_cell, srslte::event_observer<bool> observer) bool phy_controller::start_cell_select(const phy_cell_t& phy_cell, srslte::event_observer<bool> observer)
{ {
if (is_in_state<selecting_cell>()) { if (is_in_state<selecting_cell>()) {
log_h->warning("Failed to launch cell selection as it is already running\n"); log_h->warning("Failed to launch cell selection as it is already running");
return false; return false;
} }
trigger(cell_sel_cmd{phy_cell}); trigger(cell_sel_cmd{phy_cell});
if (not is_in_state<selecting_cell>()) { if (not is_in_state<selecting_cell>()) {
log_h->warning("Failed to launch cell selection. Current state: %s\n", current_state_name().c_str()); log_h->warning("Failed to launch cell selection. Current state: %s", current_state_name().c_str());
return false; return false;
} }
cell_selection_notifier = std::move(observer); cell_selection_notifier = std::move(observer);
@ -131,7 +131,7 @@ void phy_controller::selecting_cell::enter(phy_controller* f, const cell_sel_cmd
target_cell = ev.phy_cell; target_cell = ev.phy_cell;
csel_res.result = false; csel_res.result = false;
fsmInfo("Starting for pci=%d, earfcn=%d\n", target_cell.pci, target_cell.earfcn); fsmInfo("Starting for pci=%d, earfcn=%d", target_cell.pci, target_cell.earfcn);
if (not f->phy->cell_select(target_cell)) { if (not f->phy->cell_select(target_cell)) {
trigger(srslte::failure_ev{}); trigger(srslte::failure_ev{});
} }
@ -142,9 +142,9 @@ void phy_controller::selecting_cell::exit(phy_controller* f)
wait_in_sync_timer.stop(); wait_in_sync_timer.stop();
if (csel_res.result) { if (csel_res.result) {
fsmInfo("Cell %s successfully selected\n", to_string(target_cell).c_str()); fsmInfo("Cell %s successfully selected", to_string(target_cell).c_str());
} else { } else {
fsmWarning("Failed to select cell %s\n", to_string(target_cell).c_str()); fsmWarning("Failed to select cell %s", to_string(target_cell).c_str());
} }
// Signal result back to FSM that called cell selection // Signal result back to FSM that called cell selection
@ -169,12 +169,12 @@ void phy_controller::selecting_cell::wait_in_sync::enter(selecting_cell* f)
bool phy_controller::start_cell_search(srslte::event_observer<cell_srch_res> observer) bool phy_controller::start_cell_search(srslte::event_observer<cell_srch_res> observer)
{ {
if (is_in_state<searching_cell>()) { if (is_in_state<searching_cell>()) {
fsmInfo("Cell search already launched.\n"); fsmInfo("Cell search already launched.");
return true; return true;
} }
trigger(cell_search_cmd{}); trigger(cell_search_cmd{});
if (not is_in_state<searching_cell>()) { if (not is_in_state<searching_cell>()) {
fsmWarning("Failed to launch cell search\n"); fsmWarning("Failed to launch cell search");
return false; return false;
} }
cell_search_observers.subscribe(observer); cell_search_observers.subscribe(observer);
@ -188,7 +188,7 @@ void phy_controller::cell_search_completed(cell_search_ret_t cs_ret, phy_cell_t
void phy_controller::searching_cell::enter(phy_controller* f) void phy_controller::searching_cell::enter(phy_controller* f)
{ {
otherfsmInfo(f, "Initiating Cell search\n"); otherfsmInfo(f, "Initiating Cell search");
f->phy->cell_search(); f->phy->cell_search();
} }
@ -196,13 +196,13 @@ void phy_controller::handle_cell_search_res(searching_cell& s, const cell_srch_r
{ {
switch (result.cs_ret.found) { switch (result.cs_ret.found) {
case cell_search_ret_t::CELL_FOUND: case cell_search_ret_t::CELL_FOUND:
fsmInfo("PHY cell search completed. Found cell %s\n", to_string(result.found_cell).c_str()); fsmInfo("PHY cell search completed. Found cell %s", to_string(result.found_cell).c_str());
break; break;
case cell_search_ret_t::CELL_NOT_FOUND: case cell_search_ret_t::CELL_NOT_FOUND:
fsmWarning("PHY cell search completed. No cells found.\n"); fsmWarning("PHY cell search completed. No cells found.");
break; break;
default: default:
fsmError("Invalid cell search result\n"); fsmError("Invalid cell search result");
// TODO: check what errors can happen (currently not handled in our code) // TODO: check what errors can happen (currently not handled in our code)
} }

275
srsue/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -47,7 +47,7 @@ rrc::rrc(stack_interface_rrc* stack_, srslte::task_sched_handle task_sched_) :
state(RRC_STATE_IDLE), state(RRC_STATE_IDLE),
last_state(RRC_STATE_CONNECTED), last_state(RRC_STATE_CONNECTED),
drb_up(false), drb_up(false),
rrc_log("RRC"), logger(srslog::fetch_basic_logger("RRC")),
measurements(new rrc_meas()), measurements(new rrc_meas()),
cell_searcher(this), cell_searcher(this),
si_acquirer(this), si_acquirer(this),
@ -76,19 +76,19 @@ void rrc::log_rrc_message(const std::string source,
const T& msg, const T& msg,
const std::string& msg_type) const std::string& msg_type)
{ {
if (rrc_log->get_level() == srslte::LOG_LEVEL_INFO) { if (logger.info.enabled()) {
rrc_log->info("%s - %s %s (%d B)\n", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), pdu->N_bytes); logger.info("%s - %s %s (%d B)", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), pdu->N_bytes);
} else if (rrc_log->get_level() >= srslte::LOG_LEVEL_DEBUG) { } else if (logger.debug.enabled()) {
asn1::json_writer json_writer; asn1::json_writer json_writer;
msg.to_json(json_writer); msg.to_json(json_writer);
rrc_log->debug_hex(pdu->msg, logger.debug(pdu->msg,
pdu->N_bytes, pdu->N_bytes,
"%s - %s %s (%d B)\n", "%s - %s %s (%d B)",
source.c_str(), source.c_str(),
(dir == Rx) ? "Rx" : "Tx", (dir == Rx) ? "Rx" : "Tx",
msg_type.c_str(), msg_type.c_str(),
pdu->N_bytes); pdu->N_bytes);
rrc_log->debug_long("Content:\n%s\n", json_writer.to_string().c_str()); logger.debug("Content:\n%s", json_writer.to_string().c_str());
} }
} }
@ -152,7 +152,7 @@ void rrc::init(phy_interface_rrc_lte* phy_,
struct timeval tv; struct timeval tv;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
rrc_log->info("using srand seed of %ld\n", tv.tv_usec); logger.info("using srand seed of %ld", tv.tv_usec);
// set seed (used in CHAP auth and attach) // set seed (used in CHAP auth and attach)
srand(tv.tv_usec); srand(tv.tv_usec);
@ -225,7 +225,7 @@ void rrc::run_tti()
// Log state changes // Log state changes
if (state != last_state) { if (state != last_state) {
rrc_log->debug("State %s\n", rrc_state_text[state]); logger.debug("State %s", rrc_state_text[state]);
last_state = state; last_state = state;
} }
@ -300,7 +300,7 @@ uint16_t rrc::get_mnc()
bool rrc::plmn_search() bool rrc::plmn_search()
{ {
if (not plmn_searcher.launch()) { if (not plmn_searcher.launch()) {
rrc_log->error("Unable to initiate PLMN search\n"); logger.error("Unable to initiate PLMN search");
return false; return false;
} }
callback_list.add_proc(plmn_searcher); callback_list.add_proc(plmn_searcher);
@ -315,7 +315,7 @@ void rrc::plmn_select(srslte::plmn_id_t plmn_id)
plmn_is_selected = true; plmn_is_selected = true;
selected_plmn_id = plmn_id; selected_plmn_id = plmn_id;
rrc_log->info("PLMN Selected %s\n", plmn_id.to_string().c_str()); logger.info("PLMN Selected %s", plmn_id.to_string().c_str());
} }
/* 5.3.3.2 Initiation of RRC Connection Establishment procedure /* 5.3.3.2 Initiation of RRC Connection Establishment procedure
@ -329,7 +329,7 @@ void rrc::plmn_select(srslte::plmn_id_t plmn_id)
bool rrc::connection_request(srslte::establishment_cause_t cause, srslte::unique_byte_buffer_t dedicated_info_nas_) bool rrc::connection_request(srslte::establishment_cause_t cause, srslte::unique_byte_buffer_t dedicated_info_nas_)
{ {
if (not conn_req_proc.launch(cause, std::move(dedicated_info_nas_))) { if (not conn_req_proc.launch(cause, std::move(dedicated_info_nas_))) {
rrc_log->error("Failed to initiate connection request procedure\n"); logger.error("Failed to initiate connection request procedure");
return false; return false;
} }
callback_list.add_proc(conn_req_proc); callback_list.add_proc(conn_req_proc);
@ -340,8 +340,8 @@ void rrc::set_ue_identity(srslte::s_tmsi_t s_tmsi)
{ {
ue_identity_configured = true; ue_identity_configured = true;
ue_identity = s_tmsi; ue_identity = s_tmsi;
rrc_log->info( logger.info(
"Set ue-Identity to 0x%" PRIu64 ":0x%" PRIu64 "\n", (uint64_t)ue_identity.mmec, (uint64_t)ue_identity.m_tmsi); "Set ue-Identity to 0x%" PRIu64 ":0x%" PRIu64 "", (uint64_t)ue_identity.mmec, (uint64_t)ue_identity.m_tmsi);
} }
/******************************************************************************* /*******************************************************************************
@ -391,7 +391,7 @@ void rrc::process_cell_meas_nr()
std::vector<phy_meas_nr_t> m; std::vector<phy_meas_nr_t> m;
while (cell_meas_nr_q.try_pop(&m)) { while (cell_meas_nr_q.try_pop(&m)) {
if (cell_meas_nr_q.size() > 0) { if (cell_meas_nr_q.size() > 0) {
rrc_log->debug("MEAS: Processing measurement. %zd measurements in queue\n", cell_meas_q.size()); logger.debug("MEAS: Processing measurement. %zd measurements in queue", cell_meas_q.size());
} }
process_new_cell_meas_nr(m); process_new_cell_meas_nr(m);
} }
@ -417,7 +417,7 @@ void rrc::process_new_cell_meas_nr(const std::vector<phy_meas_nr_t>& meas)
c.set_cfo(m.cfo_hz); c.set_cfo(m.cfo_hz);
}; };
rrc_log->debug("MEAS: Processing measurement of %zd cells\n", meas.size()); logger.debug("MEAS: Processing measurement of %zd cells", meas.size());
bool neighbour_added = meas_cells_nr.process_new_cell_meas(meas_lte, filter); bool neighbour_added = meas_cells_nr.process_new_cell_meas(meas_lte, filter);
} }
@ -444,7 +444,7 @@ void rrc::process_cell_meas()
std::vector<phy_meas_t> m; std::vector<phy_meas_t> m;
while (cell_meas_q.try_pop(&m)) { while (cell_meas_q.try_pop(&m)) {
if (cell_meas_q.size() > 0) { if (cell_meas_q.size() > 0) {
rrc_log->debug("MEAS: Processing measurement. %zd measurements in queue\n", cell_meas_q.size()); logger.debug("MEAS: Processing measurement. %zd measurements in queue", cell_meas_q.size());
} }
process_new_cell_meas(m); process_new_cell_meas(m);
} }
@ -459,7 +459,7 @@ void rrc::process_new_cell_meas(const std::vector<phy_meas_t>& meas)
c.set_cfo(m.cfo_hz); c.set_cfo(m.cfo_hz);
}; };
rrc_log->debug("MEAS: Processing measurement of %zd cells\n", meas.size()); logger.debug("MEAS: Processing measurement of %zd cells", meas.size());
bool neighbour_added = meas_cells.process_new_cell_meas(meas, filter); bool neighbour_added = meas_cells.process_new_cell_meas(meas, filter);
@ -473,7 +473,7 @@ void rrc::process_new_cell_meas(const std::vector<phy_meas_t>& meas)
void rrc::out_of_sync() void rrc::out_of_sync()
{ {
// CAUTION: We do not lock in this function since they are called from real-time threads // CAUTION: We do not lock in this function since they are called from real-time threads
if (meas_cells.serving_cell().is_valid() && rrc_log) { if (meas_cells.serving_cell().is_valid()) {
phy_ctrl->out_sync(); phy_ctrl->out_sync();
// upon receiving N310 consecutive "out-of-sync" indications for the PCell from lower layers while neither T300, // upon receiving N310 consecutive "out-of-sync" indications for the PCell from lower layers while neither T300,
@ -483,15 +483,15 @@ void rrc::out_of_sync()
// nor T311 is running // nor T311 is running
bool t311_running = t311.is_running() || connection_reest.is_busy(); bool t311_running = t311.is_running() || connection_reest.is_busy();
if (!t300.is_running() and !t301.is_running() and !t304.is_running() and !t310.is_running() and !t311_running) { if (!t300.is_running() and !t301.is_running() and !t304.is_running() and !t310.is_running() and !t311_running) {
rrc_log->info("Received out-of-sync while in state %s. n310=%d, t311=%s, t310=%s\n", logger.info("Received out-of-sync while in state %s. n310=%d, t311=%s, t310=%s",
rrc_state_text[state], rrc_state_text[state],
n310_cnt, n310_cnt,
t311.is_running() ? "running" : "stop", t311.is_running() ? "running" : "stop",
t310.is_running() ? "running" : "stop"); t310.is_running() ? "running" : "stop");
n310_cnt++; n310_cnt++;
if (n310_cnt == N310) { if (n310_cnt == N310) {
rrc_log->info( logger.info(
"Detected %d out-of-sync from PHY. Trying to resync. Starting T310 timer %d ms\n", N310, t310.duration()); "Detected %d out-of-sync from PHY. Trying to resync. Starting T310 timer %d ms", N310, t310.duration());
t310.run(); t310.run();
n310_cnt = 0; n310_cnt = 0;
} }
@ -510,7 +510,7 @@ void rrc::in_sync()
if (n311_cnt == N311) { if (n311_cnt == N311) {
t310.stop(); t310.stop();
n311_cnt = 0; n311_cnt = 0;
rrc_log->info("Detected %d in-sync from PHY. Stopping T310 timer\n", N311); logger.info("Detected %d in-sync from PHY. Stopping T310 timer", N311);
} }
} }
} }
@ -569,7 +569,7 @@ void rrc::set_serving_cell(phy_cell_t phy_cell, bool discard_serving)
int rrc::start_cell_select() int rrc::start_cell_select()
{ {
if (not cell_selector.launch()) { if (not cell_selector.launch()) {
rrc_log->error("Failed to initiate a Cell Selection procedure...\n"); logger.error("Failed to initiate a Cell Selection procedure...");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
callback_list.add_proc(cell_selector); callback_list.add_proc(cell_selector);
@ -631,11 +631,11 @@ bool rrc::mbms_service_start(uint32_t serv, uint32_t port)
{ {
bool ret = false; bool ret = false;
if (!meas_cells.serving_cell().has_mcch) { if (!meas_cells.serving_cell().has_mcch) {
rrc_log->error("MCCH not available at MBMS Service Start\n"); logger.error("MCCH not available at MBMS Service Start");
return ret; return ret;
} }
rrc_log->info("%s\n", print_mbms().c_str()); logger.info("%s", print_mbms().c_str());
mcch_msg_type_c msg = meas_cells.serving_cell().mcch.msg; mcch_msg_type_c msg = meas_cells.serving_cell().mcch.msg;
for (uint32_t i = 0; i < msg.c1().mbsfn_area_cfg_r9().pmch_info_list_r9.size(); i++) { for (uint32_t i = 0; i < msg.c1().mbsfn_area_cfg_r9().pmch_info_list_r9.size(); i++) {
@ -687,14 +687,14 @@ void rrc::radio_link_failure_process()
if (state == RRC_STATE_CONNECTED) { if (state == RRC_STATE_CONNECTED) {
if (security_is_activated) { if (security_is_activated) {
rrc_log->info("Detected Radio-Link Failure with active AS security. Starting ConnectionReestablishment...\n"); logger.info("Detected Radio-Link Failure with active AS security. Starting ConnectionReestablishment...");
start_con_restablishment(reest_cause_e::other_fail); start_con_restablishment(reest_cause_e::other_fail);
} else { } else {
rrc_log->info("Detected Radio-Link Failure with AS security deactivated. Going to IDLE...\n"); logger.info("Detected Radio-Link Failure with AS security deactivated. Going to IDLE...");
start_go_idle(); start_go_idle();
} }
} else { } else {
rrc_log->info("Detected Radio-Link Failure while RRC_IDLE. Ignoring it.\n"); logger.info("Detected Radio-Link Failure while RRC_IDLE. Ignoring it.");
} }
} }
@ -710,29 +710,29 @@ void rrc::release_pucch_srs()
void rrc::ra_problem() void rrc::ra_problem()
{ {
if (not t300.is_running() and not t301.is_running() and not t304.is_running() and not t311.is_running()) { if (not t300.is_running() and not t301.is_running() and not t304.is_running() and not t311.is_running()) {
rrc_log->warning("MAC indicated RA problem. Starting RLF\n"); logger.warning("MAC indicated RA problem. Starting RLF");
radio_link_failure_push_cmd(); radio_link_failure_push_cmd();
} else { } else {
rrc_log->warning("MAC indicated RA problem but either T300, T301, T304 or T311 is running. Ignoring it.\n"); logger.warning("MAC indicated RA problem but either T300, T301, T304 or T311 is running. Ignoring it.");
} }
} }
void rrc::max_retx_attempted() void rrc::max_retx_attempted()
{ {
// TODO: Handle the radio link failure // TODO: Handle the radio link failure
rrc_log->warning("Max RLC reTx attempted. Starting RLF\n"); logger.warning("Max RLC reTx attempted. Starting RLF");
radio_link_failure_push_cmd(); radio_link_failure_push_cmd();
} }
void rrc::timer_expired(uint32_t timeout_id) void rrc::timer_expired(uint32_t timeout_id)
{ {
if (timeout_id == t310.id()) { if (timeout_id == t310.id()) {
rrc_log->info("Timer T310 expired: Radio Link Failure\n"); logger.info("Timer T310 expired: Radio Link Failure");
radio_link_failure_push_cmd(); radio_link_failure_push_cmd();
} else if (timeout_id == t311.id()) { } else if (timeout_id == t311.id()) {
srslte::console("Timer T311 expired: Going to RRC IDLE\n"); srslte::console("Timer T311 expired: Going to RRC IDLE\n");
if (connection_reest.is_idle()) { if (connection_reest.is_idle()) {
rrc_log->info("Timer T311 expired: Going to RRC IDLE\n"); logger.info("Timer T311 expired: Going to RRC IDLE");
start_go_idle(); start_go_idle();
} else { } else {
// Do nothing, this is handled by the procedure // Do nothing, this is handled by the procedure
@ -740,22 +740,22 @@ void rrc::timer_expired(uint32_t timeout_id)
} }
} else if (timeout_id == t301.id()) { } else if (timeout_id == t301.id()) {
if (state == RRC_STATE_IDLE) { if (state == RRC_STATE_IDLE) {
rrc_log->info("Timer T301 expired: Already in IDLE.\n"); logger.info("Timer T301 expired: Already in IDLE.");
} else { } else {
rrc_log->info("Timer T301 expired: Going to RRC IDLE\n"); logger.info("Timer T301 expired: Going to RRC IDLE");
connection_reest.trigger(connection_reest_proc::t301_expiry{}); connection_reest.trigger(connection_reest_proc::t301_expiry{});
} }
} else if (timeout_id == t302.id()) { } else if (timeout_id == t302.id()) {
rrc_log->info("Timer T302 expired. Informing NAS about barrier alleviation\n"); logger.info("Timer T302 expired. Informing NAS about barrier alleviation");
nas->set_barring(srslte::barring_t::none); nas->set_barring(srslte::barring_t::none);
} else if (timeout_id == t300.id()) { } else if (timeout_id == t300.id()) {
// Do nothing, handled in connection_request() // Do nothing, handled in connection_request()
} else if (timeout_id == t304.id()) { } else if (timeout_id == t304.id()) {
srslte::console("Timer t304 expired: Handover failed\n"); srslte::console("Timer t304 expired: Handover failed\n");
rrc_log->info("Timer t304 expired: Handover failed\n"); logger.info("Timer t304 expired: Handover failed");
ho_failed(); ho_failed();
} else { } else {
rrc_log->error("Timeout from unknown timer id %d\n", timeout_id); logger.error("Timeout from unknown timer id %d", timeout_id);
} }
} }
@ -827,7 +827,7 @@ bool rrc::nr_reconfiguration_proc(const rrc_conn_recfg_r8_ies_s& rx_recfg)
void rrc::send_con_request(srslte::establishment_cause_t cause) void rrc::send_con_request(srslte::establishment_cause_t cause)
{ {
rrc_log->debug("Preparing RRC Connection Request\n"); logger.debug("Preparing RRC Connection Request");
// Prepare ConnectionRequest packet // Prepare ConnectionRequest packet
ul_ccch_msg_s ul_ccch_msg; ul_ccch_msg_s ul_ccch_msg;
@ -877,8 +877,8 @@ void rrc::send_con_restablish_request(reest_cause_e cause, uint16_t crnti, uint1
uint32_t N_bits = (uint32_t)bref.distance(varShortMAC_packed); uint32_t N_bits = (uint32_t)bref.distance(varShortMAC_packed);
uint32_t N_bytes = ((N_bits - 1) / 8 + 1); uint32_t N_bytes = ((N_bits - 1) / 8 + 1);
rrc_log->info( logger.info(
"Encoded varShortMAC: cellId=0x%x, PCI=%d, rnti=0x%x (%d bytes, %d bits)\n", cellid, pci, crnti, N_bytes, N_bits); "Encoded varShortMAC: cellId=0x%x, PCI=%d, rnti=0x%x (%d bytes, %d bits)", cellid, pci, crnti, N_bytes, N_bits);
// Compute MAC-I // Compute MAC-I
uint8_t mac_key[4] = {}; uint8_t mac_key[4] = {};
@ -911,7 +911,7 @@ void rrc::send_con_restablish_request(reest_cause_e cause, uint16_t crnti, uint1
mac_key); mac_key);
break; break;
default: default:
rrc_log->info("Unsupported integrity algorithm during reestablishment\n"); logger.info("Unsupported integrity algorithm during reestablishment");
} }
// Prepare ConnectionRestalishmentRequest packet // Prepare ConnectionRestalishmentRequest packet
@ -928,7 +928,7 @@ void rrc::send_con_restablish_request(reest_cause_e cause, uint16_t crnti, uint1
meas_cells.serving_cell().phy_cell.pci, meas_cells.serving_cell().phy_cell.pci,
meas_cells.serving_cell().phy_cell.earfcn, meas_cells.serving_cell().phy_cell.earfcn,
cause.to_string().c_str()); cause.to_string().c_str());
rrc_log->info("RRC Connection Reestablishment to PCI=%d, EARFCN=%d (Cause: \"%s\")\n", logger.info("RRC Connection Reestablishment to PCI=%d, EARFCN=%d (Cause: \"%s\")",
meas_cells.serving_cell().phy_cell.pci, meas_cells.serving_cell().phy_cell.pci,
meas_cells.serving_cell().phy_cell.earfcn, meas_cells.serving_cell().phy_cell.earfcn,
cause.to_string().c_str()); cause.to_string().c_str());
@ -938,7 +938,7 @@ void rrc::send_con_restablish_request(reest_cause_e cause, uint16_t crnti, uint1
void rrc::send_con_restablish_complete() void rrc::send_con_restablish_complete()
{ {
rrc_log->debug("Preparing RRC Connection Reestablishment Complete\n"); logger.debug("Preparing RRC Connection Reestablishment Complete");
srslte::console("RRC Connected\n"); srslte::console("RRC Connected\n");
// Prepare ConnectionSetupComplete packet // Prepare ConnectionSetupComplete packet
@ -953,7 +953,7 @@ void rrc::send_con_restablish_complete()
void rrc::send_con_setup_complete(srslte::unique_byte_buffer_t nas_msg) void rrc::send_con_setup_complete(srslte::unique_byte_buffer_t nas_msg)
{ {
rrc_log->debug("Preparing RRC Connection Setup Complete\n"); logger.debug("Preparing RRC Connection Setup Complete");
// Prepare ConnectionSetupComplete packet // Prepare ConnectionSetupComplete packet
asn1::rrc::ul_dcch_msg_s ul_dcch_msg; asn1::rrc::ul_dcch_msg_s ul_dcch_msg;
@ -987,7 +987,7 @@ void rrc::send_ul_info_transfer(unique_byte_buffer_t nas_msg)
void rrc::send_security_mode_complete() void rrc::send_security_mode_complete()
{ {
rrc_log->debug("Preparing Security Mode Complete\n"); logger.debug("Preparing Security Mode Complete");
// Prepare Security Mode Command Complete // Prepare Security Mode Command Complete
ul_dcch_msg_s ul_dcch_msg; ul_dcch_msg_s ul_dcch_msg;
@ -999,7 +999,7 @@ void rrc::send_security_mode_complete()
void rrc::send_rrc_con_reconfig_complete(bool contains_nr_complete) void rrc::send_rrc_con_reconfig_complete(bool contains_nr_complete)
{ {
rrc_log->debug("Preparing RRC Connection Reconfig Complete\n"); logger.debug("Preparing RRC Connection Reconfig Complete");
ul_dcch_msg_s ul_dcch_msg; ul_dcch_msg_s ul_dcch_msg;
rrc_conn_recfg_complete_r8_ies_s* rrc_conn_recfg_complete_r8 = rrc_conn_recfg_complete_r8_ies_s* rrc_conn_recfg_complete_r8 =
@ -1007,7 +1007,7 @@ void rrc::send_rrc_con_reconfig_complete(bool contains_nr_complete)
ul_dcch_msg.msg.c1().rrc_conn_recfg_complete().rrc_transaction_id = transaction_id; ul_dcch_msg.msg.c1().rrc_conn_recfg_complete().rrc_transaction_id = transaction_id;
if (contains_nr_complete == true) { if (contains_nr_complete == true) {
rrc_log->debug("Preparing RRC Connection Reconfig Complete with NR Complete\n"); logger.debug("Preparing RRC Connection Reconfig Complete with NR Complete");
rrc_conn_recfg_complete_r8->non_crit_ext_present = true; rrc_conn_recfg_complete_r8->non_crit_ext_present = true;
rrc_conn_recfg_complete_r8->non_crit_ext.non_crit_ext_present = true; rrc_conn_recfg_complete_r8->non_crit_ext.non_crit_ext_present = true;
@ -1036,7 +1036,7 @@ void rrc::ra_completed()
bool rrc::con_reconfig_ho(const rrc_conn_recfg_s& reconfig) bool rrc::con_reconfig_ho(const rrc_conn_recfg_s& reconfig)
{ {
if (not ho_handler.launch(reconfig)) { if (not ho_handler.launch(reconfig)) {
rrc_log->error("Unable to launch Handover Preparation procedure\n"); logger.error("Unable to launch Handover Preparation procedure");
return false; return false;
} }
callback_list.add_proc(ho_handler); callback_list.add_proc(ho_handler);
@ -1046,7 +1046,7 @@ bool rrc::con_reconfig_ho(const rrc_conn_recfg_s& reconfig)
void rrc::start_go_idle() void rrc::start_go_idle()
{ {
if (not idle_setter.launch()) { if (not idle_setter.launch()) {
rrc_log->info("Failed to set RRC to IDLE\n"); logger.info("Failed to set RRC to IDLE");
return; return;
} }
callback_list.add_proc(idle_setter); callback_list.add_proc(idle_setter);
@ -1087,7 +1087,7 @@ void rrc::handle_rrc_con_reconfig(uint32_t lcid, const rrc_conn_recfg_s& reconfi
con_reconfig_ho(reconfig); con_reconfig_ho(reconfig);
} else { } else {
if (not conn_recfg_proc.launch(reconfig)) { if (not conn_recfg_proc.launch(reconfig)) {
rrc_log->error("Unable to launch Handover Preparation procedure\n"); logger.error("Unable to launch Handover Preparation procedure");
return; return;
} }
callback_list.add_proc(conn_recfg_proc); callback_list.add_proc(conn_recfg_proc);
@ -1106,7 +1106,7 @@ void rrc::rrc_connection_release(const std::string& cause)
void rrc::leave_connected() void rrc::leave_connected()
{ {
srslte::console("RRC IDLE\n"); srslte::console("RRC IDLE\n");
rrc_log->info("Leaving RRC_CONNECTED state\n"); logger.info("Leaving RRC_CONNECTED state");
state = RRC_STATE_IDLE; state = RRC_STATE_IDLE;
drb_up = false; drb_up = false;
security_is_activated = false; security_is_activated = false;
@ -1129,7 +1129,7 @@ void rrc::leave_connected()
// 1> if leaving RRC_CONNECTED was not triggered by reception of the MobilityFromEUTRACommand message: // 1> if leaving RRC_CONNECTED was not triggered by reception of the MobilityFromEUTRACommand message:
// 2> enter RRC_IDLE by performing cell selection in accordance with the cell selection process, defined for the // 2> enter RRC_IDLE by performing cell selection in accordance with the cell selection process, defined for the
// case of leaving RRC_CONNECTED, as specified in TS 36.304 [4]; // case of leaving RRC_CONNECTED, as specified in TS 36.304 [4];
rrc_log->info("Going RRC_IDLE\n"); logger.info("Going RRC_IDLE");
if (phy->cell_is_camping()) { if (phy->cell_is_camping()) {
// Receive paging // Receive paging
mac->pcch_start_rx(); mac->pcch_start_rx();
@ -1159,7 +1159,7 @@ void rrc::stop_timers()
void rrc::start_con_restablishment(reest_cause_e cause) void rrc::start_con_restablishment(reest_cause_e cause)
{ {
if (not connection_reest.launch(cause)) { if (not connection_reest.launch(cause)) {
rrc_log->info("Failed to launch connection re-establishment procedure\n"); logger.info("Failed to launch connection re-establishment procedure");
} }
callback_list.add_proc(connection_reest); callback_list.add_proc(connection_reest);
@ -1253,7 +1253,7 @@ void rrc::write_pdu_bcch_bch(unique_byte_buffer_t pdu)
asn1::SRSASN_CODE err = bch_msg.unpack(bch_bref); asn1::SRSASN_CODE err = bch_msg.unpack(bch_bref);
if (err != asn1::SRSASN_SUCCESS) { if (err != asn1::SRSASN_SUCCESS) {
rrc_log->error("Could not unpack BCCH-BCH message.\n"); logger.error("Could not unpack BCCH-BCH message.");
return; return;
} }
@ -1277,14 +1277,14 @@ void rrc::parse_pdu_bcch_dlsch(unique_byte_buffer_t pdu)
asn1::SRSASN_CODE err = dlsch_msg.unpack(dlsch_bref); asn1::SRSASN_CODE err = dlsch_msg.unpack(dlsch_bref);
if (err != asn1::SRSASN_SUCCESS or dlsch_msg.msg.type().value != bcch_dl_sch_msg_type_c::types_opts::c1) { if (err != asn1::SRSASN_SUCCESS or dlsch_msg.msg.type().value != bcch_dl_sch_msg_type_c::types_opts::c1) {
rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Could not unpack BCCH DL-SCH message (%d B).\n", pdu->N_bytes); logger.error(pdu->msg, pdu->N_bytes, "Could not unpack BCCH DL-SCH message (%d B).", pdu->N_bytes);
return; return;
} }
log_rrc_message("BCCH-DLSCH", Rx, pdu.get(), dlsch_msg, dlsch_msg.msg.c1().type().to_string()); log_rrc_message("BCCH-DLSCH", Rx, pdu.get(), dlsch_msg, dlsch_msg.msg.c1().type().to_string());
if (dlsch_msg.msg.c1().type() == bcch_dl_sch_msg_type_c::c1_c_::types::sib_type1) { if (dlsch_msg.msg.c1().type() == bcch_dl_sch_msg_type_c::c1_c_::types::sib_type1) {
rrc_log->info("Processing SIB1 (1/1)\n"); logger.info("Processing SIB1 (1/1)");
meas_cells.serving_cell().set_sib1(dlsch_msg.msg.c1().sib_type1()); meas_cells.serving_cell().set_sib1(dlsch_msg.msg.c1().sib_type1());
si_acquirer.trigger(si_acquire_proc::sib_received_ev{}); si_acquirer.trigger(si_acquire_proc::sib_received_ev{});
handle_sib1(); handle_sib1();
@ -1292,7 +1292,7 @@ void rrc::parse_pdu_bcch_dlsch(unique_byte_buffer_t pdu)
sys_info_r8_ies_s::sib_type_and_info_l_& sib_list = sys_info_r8_ies_s::sib_type_and_info_l_& sib_list =
dlsch_msg.msg.c1().sys_info().crit_exts.sys_info_r8().sib_type_and_info; dlsch_msg.msg.c1().sys_info().crit_exts.sys_info_r8().sib_type_and_info;
for (uint32_t i = 0; i < sib_list.size(); ++i) { for (uint32_t i = 0; i < sib_list.size(); ++i) {
rrc_log->info("Processing SIB%d (%d/%d)\n", sib_list[i].type().to_number(), i, sib_list.size()); logger.info("Processing SIB%d (%d/%d)", sib_list[i].type().to_number(), i, sib_list.size());
switch (sib_list[i].type().value) { switch (sib_list[i].type().value) {
case sib_info_item_c::types::sib2: case sib_info_item_c::types::sib2:
if (not meas_cells.serving_cell().has_sib2()) { if (not meas_cells.serving_cell().has_sib2()) {
@ -1316,7 +1316,7 @@ void rrc::parse_pdu_bcch_dlsch(unique_byte_buffer_t pdu)
si_acquirer.trigger(si_acquire_proc::sib_received_ev{}); si_acquirer.trigger(si_acquire_proc::sib_received_ev{});
break; break;
default: default:
rrc_log->warning("SIB%d is not supported\n", sib_list[i].type().to_number()); logger.warning("SIB%d is not supported", sib_list[i].type().to_number());
} }
} }
} }
@ -1325,7 +1325,7 @@ void rrc::parse_pdu_bcch_dlsch(unique_byte_buffer_t pdu)
void rrc::handle_sib1() void rrc::handle_sib1()
{ {
const sib_type1_s* sib1 = meas_cells.serving_cell().sib1ptr(); const sib_type1_s* sib1 = meas_cells.serving_cell().sib1ptr();
rrc_log->info("SIB1 received, CellID=%d, si_window=%d, sib2_period=%d\n", logger.info("SIB1 received, CellID=%d, si_window=%d, sib2_period=%d",
meas_cells.serving_cell().get_cell_id() & 0xfff, meas_cells.serving_cell().get_cell_id() & 0xfff,
sib1->si_win_len.to_number(), sib1->si_win_len.to_number(),
sib1->sched_info_list[0].si_periodicity.to_number()); sib1->sched_info_list[0].si_periodicity.to_number());
@ -1335,7 +1335,7 @@ void rrc::handle_sib1()
si_periodicity_r12_e p = sib1->sched_info_list[i].si_periodicity; si_periodicity_r12_e p = sib1->sched_info_list[i].si_periodicity;
for (uint32_t j = 0; j < sib1->sched_info_list[i].sib_map_info.size(); ++j) { for (uint32_t j = 0; j < sib1->sched_info_list[i].sib_map_info.size(); ++j) {
sib_type_e t = sib1->sched_info_list[i].sib_map_info[j]; sib_type_e t = sib1->sched_info_list[i].sib_map_info[j];
rrc_log->debug("SIB scheduling info, sib_type=%d, si_periodicity=%d\n", t.to_number(), p.to_number()); logger.debug("SIB scheduling info, sib_type=%d, si_periodicity=%d", t.to_number(), p.to_number());
} }
} }
@ -1350,7 +1350,7 @@ void rrc::handle_sib1()
void rrc::handle_sib2() void rrc::handle_sib2()
{ {
rrc_log->info("SIB2 received\n"); logger.info("SIB2 received");
const sib_type2_s* sib2 = meas_cells.serving_cell().sib2ptr(); const sib_type2_s* sib2 = meas_cells.serving_cell().sib2ptr();
@ -1408,7 +1408,7 @@ void rrc::handle_sib2()
N310 = sib2->ue_timers_and_consts.n310.to_number(); N310 = sib2->ue_timers_and_consts.n310.to_number();
N311 = sib2->ue_timers_and_consts.n311.to_number(); N311 = sib2->ue_timers_and_consts.n311.to_number();
rrc_log->info("Set Constants and Timers: N310=%d, N311=%d, t300=%d, t301=%d, t310=%d, t311=%d\n", logger.info("Set Constants and Timers: N310=%d, N311=%d, t300=%d, t301=%d, t310=%d, t311=%d",
N310, N310,
N311, N311,
t300.duration(), t300.duration(),
@ -1419,7 +1419,7 @@ void rrc::handle_sib2()
void rrc::handle_sib3() void rrc::handle_sib3()
{ {
rrc_log->info("SIB3 received\n"); logger.info("SIB3 received");
const sib_type3_s* sib3 = meas_cells.serving_cell().sib3ptr(); const sib_type3_s* sib3 = meas_cells.serving_cell().sib3ptr();
@ -1440,7 +1440,7 @@ void rrc::handle_sib3()
void rrc::handle_sib13() void rrc::handle_sib13()
{ {
rrc_log->info("SIB13 received\n"); logger.info("SIB13 received");
const sib_type13_r9_s* sib13 = meas_cells.serving_cell().sib13ptr(); const sib_type13_r9_s* sib13 = meas_cells.serving_cell().sib13ptr();
@ -1473,21 +1473,21 @@ void rrc::paging_completed(bool outcome)
void rrc::process_pcch(unique_byte_buffer_t pdu) void rrc::process_pcch(unique_byte_buffer_t pdu)
{ {
if (pdu->N_bytes <= 0 or pdu->N_bytes >= SRSLTE_MAX_BUFFER_SIZE_BITS) { if (pdu->N_bytes <= 0 or pdu->N_bytes >= SRSLTE_MAX_BUFFER_SIZE_BITS) {
rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Dropping PCCH message with %d B\n", pdu->N_bytes); logger.error(pdu->msg, pdu->N_bytes, "Dropping PCCH message with %d B", pdu->N_bytes);
return; return;
} }
pcch_msg_s pcch_msg; pcch_msg_s pcch_msg;
asn1::cbit_ref bref(pdu->msg, pdu->N_bytes); asn1::cbit_ref bref(pdu->msg, pdu->N_bytes);
if (pcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or pcch_msg.msg.type().value != pcch_msg_type_c::types_opts::c1) { if (pcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or pcch_msg.msg.type().value != pcch_msg_type_c::types_opts::c1) {
rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Failed to unpack PCCH message (%d B)\n", pdu->N_bytes); logger.error(pdu->msg, pdu->N_bytes, "Failed to unpack PCCH message (%d B)", pdu->N_bytes);
return; return;
} }
log_rrc_message("PCCH", Rx, pdu.get(), pcch_msg, pcch_msg.msg.c1().type().to_string()); log_rrc_message("PCCH", Rx, pdu.get(), pcch_msg, pcch_msg.msg.c1().type().to_string());
if (not ue_identity_configured) { if (not ue_identity_configured) {
rrc_log->warning("Received paging message but no ue-Identity is configured\n"); logger.warning("Received paging message but no ue-Identity is configured");
return; return;
} }
@ -1497,7 +1497,7 @@ void rrc::process_pcch(unique_byte_buffer_t pdu)
} }
if (not pcch_processor.launch(*paging)) { if (not pcch_processor.launch(*paging)) {
rrc_log->error("Failed to launch process PCCH procedure\n"); logger.error("Failed to launch process PCCH procedure");
return; return;
} }
@ -1522,7 +1522,7 @@ void rrc::parse_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
asn1::cbit_ref bref(pdu->msg, pdu->N_bytes); asn1::cbit_ref bref(pdu->msg, pdu->N_bytes);
if (meas_cells.serving_cell().mcch.unpack(bref) != asn1::SRSASN_SUCCESS or if (meas_cells.serving_cell().mcch.unpack(bref) != asn1::SRSASN_SUCCESS or
meas_cells.serving_cell().mcch.msg.type().value != mcch_msg_type_c::types_opts::c1) { meas_cells.serving_cell().mcch.msg.type().value != mcch_msg_type_c::types_opts::c1) {
rrc_log->error("Failed to unpack MCCH message\n"); logger.error("Failed to unpack MCCH message");
return; return;
} }
meas_cells.serving_cell().has_mcch = true; meas_cells.serving_cell().has_mcch = true;
@ -1530,7 +1530,7 @@ void rrc::parse_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
log_rrc_message( log_rrc_message(
"MCH", Rx, pdu.get(), meas_cells.serving_cell().mcch, meas_cells.serving_cell().mcch.msg.c1().type().to_string()); "MCH", Rx, pdu.get(), meas_cells.serving_cell().mcch, meas_cells.serving_cell().mcch.msg.c1().type().to_string());
if (args.mbms_service_id >= 0) { if (args.mbms_service_id >= 0) {
rrc_log->info("Attempting to auto-start MBMS service %d\n", args.mbms_service_id); logger.info("Attempting to auto-start MBMS service %d", args.mbms_service_id);
mbms_service_start(args.mbms_service_id, args.mbms_service_port); mbms_service_start(args.mbms_service_id, args.mbms_service_port);
} }
} }
@ -1548,7 +1548,7 @@ void rrc::send_ul_ccch_msg(const ul_ccch_msg_s& msg)
// Reset and reuse sdu buffer if provided // Reset and reuse sdu buffer if provided
unique_byte_buffer_t pdcp_buf = srslte::allocate_unique_buffer(*pool, true); unique_byte_buffer_t pdcp_buf = srslte::allocate_unique_buffer(*pool, true);
if (not pdcp_buf.get()) { if (not pdcp_buf.get()) {
rrc_log->error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().\n"); logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
return; return;
} }
@ -1566,7 +1566,7 @@ void rrc::send_ul_ccch_msg(const ul_ccch_msg_s& msg)
ue_cri_ptr[nbytes - i - 1] = pdcp_buf->msg[i]; ue_cri_ptr[nbytes - i - 1] = pdcp_buf->msg[i];
} }
rrc_log->debug("Setting UE contention resolution ID: %" PRIu64 "\n", uecri); logger.debug("Setting UE contention resolution ID: %" PRIu64 "", uecri);
mac->set_contention_id(uecri); mac->set_contention_id(uecri);
uint32_t lcid = RB_ID_SRB0; uint32_t lcid = RB_ID_SRB0;
@ -1580,7 +1580,7 @@ void rrc::send_ul_dcch_msg(uint32_t lcid, const ul_dcch_msg_s& msg)
// Reset and reuse sdu buffer if provided // Reset and reuse sdu buffer if provided
unique_byte_buffer_t pdcp_buf = srslte::allocate_unique_buffer(*pool, true); unique_byte_buffer_t pdcp_buf = srslte::allocate_unique_buffer(*pool, true);
if (not pdcp_buf.get()) { if (not pdcp_buf.get()) {
rrc_log->error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().\n"); logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
return; return;
} }
@ -1598,7 +1598,7 @@ void rrc::send_ul_dcch_msg(uint32_t lcid, const ul_dcch_msg_s& msg)
void rrc::write_sdu(srslte::unique_byte_buffer_t sdu) void rrc::write_sdu(srslte::unique_byte_buffer_t sdu)
{ {
if (state == RRC_STATE_IDLE) { if (state == RRC_STATE_IDLE) {
rrc_log->warning("Received ULInformationTransfer SDU when in IDLE\n"); logger.warning("Received ULInformationTransfer SDU when in IDLE");
return; return;
} }
send_ul_info_transfer(std::move(sdu)); send_ul_info_transfer(std::move(sdu));
@ -1611,7 +1611,7 @@ void rrc::write_pdu(uint32_t lcid, unique_byte_buffer_t pdu)
void rrc::process_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) void rrc::process_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
{ {
rrc_log->debug("RX PDU, LCID: %d\n", lcid); logger.debug("RX PDU, LCID: %d", lcid);
switch (lcid) { switch (lcid) {
case RB_ID_SRB0: case RB_ID_SRB0:
parse_dl_ccch(std::move(pdu)); parse_dl_ccch(std::move(pdu));
@ -1621,7 +1621,7 @@ void rrc::process_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
parse_dl_dcch(lcid, std::move(pdu)); parse_dl_dcch(lcid, std::move(pdu));
break; break;
default: default:
rrc_log->error("RX PDU with invalid bearer id: %d\n", lcid); logger.error("RX PDU with invalid bearer id: %d", lcid);
break; break;
} }
} }
@ -1632,7 +1632,7 @@ void rrc::parse_dl_ccch(unique_byte_buffer_t pdu)
asn1::rrc::dl_ccch_msg_s dl_ccch_msg; asn1::rrc::dl_ccch_msg_s dl_ccch_msg;
if (dl_ccch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or if (dl_ccch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or
dl_ccch_msg.msg.type().value != dl_ccch_msg_type_c::types_opts::c1) { dl_ccch_msg.msg.type().value != dl_ccch_msg_type_c::types_opts::c1) {
rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Failed to unpack DL-CCCH message (%d B)\n", pdu->N_bytes); logger.error(pdu->msg, pdu->N_bytes, "Failed to unpack DL-CCCH message (%d B)", pdu->N_bytes);
return; return;
} }
log_rrc_message(get_rb_name(RB_ID_SRB0).c_str(), Rx, pdu.get(), dl_ccch_msg, dl_ccch_msg.msg.c1().type().to_string()); log_rrc_message(get_rb_name(RB_ID_SRB0).c_str(), Rx, pdu.get(), dl_ccch_msg, dl_ccch_msg.msg.c1().type().to_string());
@ -1642,7 +1642,7 @@ void rrc::parse_dl_ccch(unique_byte_buffer_t pdu)
case dl_ccch_msg_type_c::c1_c_::types::rrc_conn_reject: { case dl_ccch_msg_type_c::c1_c_::types::rrc_conn_reject: {
// 5.3.3.8 // 5.3.3.8
rrc_conn_reject_r8_ies_s* reject_r8 = &c1->rrc_conn_reject().crit_exts.c1().rrc_conn_reject_r8(); rrc_conn_reject_r8_ies_s* reject_r8 = &c1->rrc_conn_reject().crit_exts.c1().rrc_conn_reject_r8();
rrc_log->info("Received ConnectionReject. Wait time: %d\n", reject_r8->wait_time); logger.info("Received ConnectionReject. Wait time: %d", reject_r8->wait_time);
srslte::console("Received ConnectionReject. Wait time: %d\n", reject_r8->wait_time); srslte::console("Received ConnectionReject. Wait time: %d\n", reject_r8->wait_time);
t300.stop(); t300.stop();
@ -1675,7 +1675,7 @@ void rrc::parse_dl_ccch(unique_byte_buffer_t pdu)
connection_reest.trigger(c1->rrc_conn_reest_reject()); connection_reest.trigger(c1->rrc_conn_reest_reject());
break; break;
default: default:
rrc_log->error("The provided DL-CCCH message type is not recognized\n"); logger.error("The provided DL-CCCH message type is not recognized");
break; break;
} }
} }
@ -1686,7 +1686,7 @@ void rrc::parse_dl_dcch(uint32_t lcid, unique_byte_buffer_t pdu)
asn1::rrc::dl_dcch_msg_s dl_dcch_msg; asn1::rrc::dl_dcch_msg_s dl_dcch_msg;
if (dl_dcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or if (dl_dcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or
dl_dcch_msg.msg.type().value != dl_dcch_msg_type_c::types_opts::c1) { dl_dcch_msg.msg.type().value != dl_dcch_msg_type_c::types_opts::c1) {
rrc_log->error_hex(pdu->msg, pdu->N_bytes, "Failed to unpack DL-DCCH message (%d B)\n", pdu->N_bytes); logger.error(pdu->msg, pdu->N_bytes, "Failed to unpack DL-DCCH message (%d B)", pdu->N_bytes);
return; return;
} }
log_rrc_message(get_rb_name(lcid).c_str(), Rx, pdu.get(), dl_dcch_msg, dl_dcch_msg.msg.c1().type().to_string()); log_rrc_message(get_rb_name(lcid).c_str(), Rx, pdu.get(), dl_dcch_msg, dl_dcch_msg.msg.c1().type().to_string());
@ -1696,7 +1696,7 @@ void rrc::parse_dl_dcch(uint32_t lcid, unique_byte_buffer_t pdu)
case dl_dcch_msg_type_c::c1_c_::types::dl_info_transfer: case dl_dcch_msg_type_c::c1_c_::types::dl_info_transfer:
pdu = srslte::allocate_unique_buffer(*pool, true); pdu = srslte::allocate_unique_buffer(*pool, true);
if (!pdu.get()) { if (!pdu.get()) {
rrc_log->error("Fatal error: out of buffers in pool\n"); logger.error("Fatal error: out of buffers in pool");
return; return;
} }
pdu->N_bytes = c1->dl_info_transfer().crit_exts.c1().dl_info_transfer_r8().ded_info_type.ded_info_nas().size(); pdu->N_bytes = c1->dl_info_transfer().crit_exts.c1().dl_info_transfer_r8().ded_info_type.ded_info_nas().size();
@ -1717,7 +1717,7 @@ void rrc::parse_dl_dcch(uint32_t lcid, unique_byte_buffer_t pdu)
.security_mode_cmd_r8() .security_mode_cmd_r8()
.security_cfg_smc.security_algorithm_cfg.integrity_prot_algorithm.value; .security_cfg_smc.security_algorithm_cfg.integrity_prot_algorithm.value;
rrc_log->info("Received Security Mode Command eea: %s, eia: %s\n", logger.info("Received Security Mode Command eea: %s, eia: %s",
ciphering_algorithm_id_text[sec_cfg.cipher_algo], ciphering_algorithm_id_text[sec_cfg.cipher_algo],
integrity_algorithm_id_text[sec_cfg.integ_algo]); integrity_algorithm_id_text[sec_cfg.integ_algo]);
@ -1745,7 +1745,7 @@ void rrc::parse_dl_dcch(uint32_t lcid, unique_byte_buffer_t pdu)
rrc_connection_release(c1->rrc_conn_release().crit_exts.c1().rrc_conn_release_r8().release_cause.to_string()); rrc_connection_release(c1->rrc_conn_release().crit_exts.c1().rrc_conn_release_r8().release_cause.to_string());
break; break;
default: default:
rrc_log->error("The provided DL-CCCH message type is not recognized or supported\n"); logger.error("The provided DL-CCCH message type is not recognized or supported");
break; break;
} }
} }
@ -1755,12 +1755,12 @@ void rrc::generate_as_keys(void)
{ {
uint8_t k_asme[32] = {}; uint8_t k_asme[32] = {};
nas->get_k_asme(k_asme, 32); nas->get_k_asme(k_asme, 32);
rrc_log->debug_hex(k_asme, 32, "UE K_asme"); logger.debug(k_asme, 32, "UE K_asme");
rrc_log->debug("Generating K_enb with UL NAS COUNT: %d\n", nas->get_k_enb_count()); logger.debug("Generating K_enb with UL NAS COUNT: %d", nas->get_k_enb_count());
usim->generate_as_keys(k_asme, nas->get_k_enb_count(), &sec_cfg); usim->generate_as_keys(k_asme, nas->get_k_enb_count(), &sec_cfg);
rrc_log->info_hex(sec_cfg.k_rrc_enc.data(), 32, "RRC encryption key - k_rrc_enc"); logger.info(sec_cfg.k_rrc_enc.data(), 32, "RRC encryption key - k_rrc_enc");
rrc_log->info_hex(sec_cfg.k_rrc_int.data(), 32, "RRC integrity key - k_rrc_int"); logger.info(sec_cfg.k_rrc_int.data(), 32, "RRC integrity key - k_rrc_int");
rrc_log->info_hex(sec_cfg.k_up_enc.data(), 32, "UP encryption key - k_up_enc"); logger.info(sec_cfg.k_up_enc.data(), 32, "UP encryption key - k_up_enc");
} }
/******************************************************************************* /*******************************************************************************
@ -1776,12 +1776,12 @@ void rrc::enable_capabilities()
{ {
bool enable_ul_64 = args.ue_category >= 5 && bool enable_ul_64 = args.ue_category >= 5 &&
meas_cells.serving_cell().sib2ptr()->rr_cfg_common.pusch_cfg_common.pusch_cfg_basic.enable64_qam; meas_cells.serving_cell().sib2ptr()->rr_cfg_common.pusch_cfg_common.pusch_cfg_basic.enable64_qam;
rrc_log->info("%s 64QAM PUSCH\n", enable_ul_64 ? "Enabling" : "Disabling"); logger.info("%s 64QAM PUSCH", enable_ul_64 ? "Enabling" : "Disabling");
} }
void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry) void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
{ {
rrc_log->debug("Preparing UE Capability Info\n"); logger.debug("Preparing UE Capability Info");
ul_dcch_msg_s ul_dcch_msg; ul_dcch_msg_s ul_dcch_msg;
ue_cap_info_r8_ies_s* info = &ul_dcch_msg.msg.set_c1().set_ue_cap_info().crit_exts.set_c1().set_ue_cap_info_r8(); ue_cap_info_r8_ies_s* info = &ul_dcch_msg.msg.set_c1().set_ue_cap_info().crit_exts.set_c1().set_ue_cap_info_r8();
@ -1799,7 +1799,7 @@ void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
// Check UE config arguments bounds // Check UE config arguments bounds
if (args.release < SRSLTE_RELEASE_MIN || args.release > SRSLTE_RELEASE_MAX) { if (args.release < SRSLTE_RELEASE_MIN || args.release > SRSLTE_RELEASE_MAX) {
uint32_t new_release = SRSLTE_MIN(SRSLTE_RELEASE_MAX, SRSLTE_MAX(SRSLTE_RELEASE_MIN, args.release)); uint32_t new_release = SRSLTE_MIN(SRSLTE_RELEASE_MAX, SRSLTE_MAX(SRSLTE_RELEASE_MIN, args.release));
rrc_log->error("Release is %d. It is out of bounds (%d ... %d), setting it to %d\n", logger.error("Release is %d. It is out of bounds (%d ... %d), setting it to %d",
args.release, args.release,
SRSLTE_RELEASE_MIN, SRSLTE_RELEASE_MIN,
SRSLTE_RELEASE_MAX, SRSLTE_RELEASE_MAX,
@ -1811,7 +1811,7 @@ void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
if (args.ue_category < SRSLTE_UE_CATEGORY_MIN || args.ue_category > SRSLTE_UE_CATEGORY_MAX) { if (args.ue_category < SRSLTE_UE_CATEGORY_MIN || args.ue_category > SRSLTE_UE_CATEGORY_MAX) {
uint32_t new_category = uint32_t new_category =
SRSLTE_MIN(SRSLTE_UE_CATEGORY_MAX, SRSLTE_MAX(SRSLTE_UE_CATEGORY_MIN, args.ue_category)); SRSLTE_MIN(SRSLTE_UE_CATEGORY_MAX, SRSLTE_MAX(SRSLTE_UE_CATEGORY_MIN, args.ue_category));
rrc_log->error("UE Category is %d. It is out of bounds (%d ... %d), setting it to %d\n", logger.error("UE Category is %d. It is out of bounds (%d ... %d), setting it to %d",
args.ue_category, args.ue_category,
SRSLTE_UE_CATEGORY_MIN, SRSLTE_UE_CATEGORY_MIN,
SRSLTE_UE_CATEGORY_MAX, SRSLTE_UE_CATEGORY_MAX,
@ -2081,18 +2081,18 @@ void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
else if (enquiry.crit_exts.c1().ue_cap_enquiry_r8().ue_cap_request[i] == rat_type_e::eutra_nr && has_nr_dc()) { else if (enquiry.crit_exts.c1().ue_cap_enquiry_r8().ue_cap_request[i] == rat_type_e::eutra_nr && has_nr_dc()) {
info->ue_cap_rat_container_list[rat_idx] = get_eutra_nr_capabilities(); info->ue_cap_rat_container_list[rat_idx] = get_eutra_nr_capabilities();
rrc_log->info("Including EUTRA-NR capabilities in UE Capability Info (%d B)\n", logger.info("Including EUTRA-NR capabilities in UE Capability Info (%d B)",
info->ue_cap_rat_container_list[rat_idx].ue_cap_rat_container.size()); info->ue_cap_rat_container_list[rat_idx].ue_cap_rat_container.size());
rat_idx++; rat_idx++;
} else if (enquiry.crit_exts.c1().ue_cap_enquiry_r8().ue_cap_request[i] == rat_type_e::nr && has_nr_dc()) { } else if (enquiry.crit_exts.c1().ue_cap_enquiry_r8().ue_cap_request[i] == rat_type_e::nr && has_nr_dc()) {
info->ue_cap_rat_container_list[rat_idx] = get_nr_capabilities(); info->ue_cap_rat_container_list[rat_idx] = get_nr_capabilities();
rrc_log->info("Including NR capabilities in UE Capability Info (%d B)\n", logger.info("Including NR capabilities in UE Capability Info (%d B)",
info->ue_cap_rat_container_list[rat_idx].ue_cap_rat_container.size()); info->ue_cap_rat_container_list[rat_idx].ue_cap_rat_container.size());
rat_idx++; rat_idx++;
} }
#endif #endif
else { else {
rrc_log->error("RAT Type of UE Cap request not supported or not configured\n"); logger.error("RAT Type of UE Cap request not supported or not configured");
} }
} }
// resize container back to the actually filled items // resize container back to the actually filled items
@ -2110,7 +2110,7 @@ void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
.ue_cap_enquiry_r8() .ue_cap_enquiry_r8()
.non_crit_ext.non_crit_ext.non_crit_ext.non_crit_ext.non_crit_ext .non_crit_ext.non_crit_ext.non_crit_ext.non_crit_ext.non_crit_ext
.requested_freq_bands_nr_mrdc_r15_present) { .requested_freq_bands_nr_mrdc_r15_present) {
rrc_log->debug("Requested Freq Bands NR MRDC R15 present\n"); logger.debug("Requested Freq Bands NR MRDC R15 present");
} }
} }
} }
@ -2134,25 +2134,25 @@ void rrc::handle_ue_capability_enquiry(const ue_cap_enquiry_s& enquiry)
void rrc::log_rr_config_common() void rrc::log_rr_config_common()
{ {
rrc_log->info("Set RACH ConfigCommon: NofPreambles=%d, ResponseWindow=%d, ContentionResolutionTimer=%d ms\n", logger.info("Set RACH ConfigCommon: NofPreambles=%d, ResponseWindow=%d, ContentionResolutionTimer=%d ms",
current_mac_cfg.rach_cfg.nof_preambles, current_mac_cfg.rach_cfg.nof_preambles,
current_mac_cfg.rach_cfg.responseWindowSize, current_mac_cfg.rach_cfg.responseWindowSize,
current_mac_cfg.rach_cfg.contentionResolutionTimer); current_mac_cfg.rach_cfg.contentionResolutionTimer);
const srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0]; const srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0];
rrc_log->info("Set PUSCH ConfigCommon: P0_pusch=%f, DMRS cs=%d, delta_ss=%d, N_sb=%d\n", logger.info("Set PUSCH ConfigCommon: P0_pusch=%f, DMRS cs=%d, delta_ss=%d, N_sb=%d",
current_pcell.ul_cfg.power_ctrl.p0_ue_pusch, current_pcell.ul_cfg.power_ctrl.p0_ue_pusch,
current_pcell.ul_cfg.dmrs.cyclic_shift, current_pcell.ul_cfg.dmrs.cyclic_shift,
current_pcell.ul_cfg.dmrs.delta_ss, current_pcell.ul_cfg.dmrs.delta_ss,
current_pcell.ul_cfg.hopping.n_sb); current_pcell.ul_cfg.hopping.n_sb);
rrc_log->info("Set PUCCH ConfigCommon: DeltaShift=%d, CyclicShift=%d, N1=%d, NRB=%d\n", logger.info("Set PUCCH ConfigCommon: DeltaShift=%d, CyclicShift=%d, N1=%d, NRB=%d",
current_pcell.ul_cfg.pucch.delta_pucch_shift, current_pcell.ul_cfg.pucch.delta_pucch_shift,
current_pcell.ul_cfg.pucch.N_cs, current_pcell.ul_cfg.pucch.N_cs,
current_pcell.ul_cfg.pucch.n1_pucch_an_cs[0][0], current_pcell.ul_cfg.pucch.n1_pucch_an_cs[0][0],
current_pcell.ul_cfg.pucch.n_rb_2); current_pcell.ul_cfg.pucch.n_rb_2);
rrc_log->info("Set PRACH ConfigCommon: SeqIdx=%d, HS=%s, FreqOffset=%d, ZC=%d, ConfigIndex=%d\n", logger.info("Set PRACH ConfigCommon: SeqIdx=%d, HS=%s, FreqOffset=%d, ZC=%d, ConfigIndex=%d",
current_pcell.prach_cfg.root_seq_idx, current_pcell.prach_cfg.root_seq_idx,
current_pcell.prach_cfg.hs_flag ? "yes" : "no", current_pcell.prach_cfg.hs_flag ? "yes" : "no",
current_pcell.prach_cfg.freq_offset, current_pcell.prach_cfg.freq_offset,
@ -2160,7 +2160,7 @@ void rrc::log_rr_config_common()
current_pcell.prach_cfg.config_idx); current_pcell.prach_cfg.config_idx);
if (current_pcell.ul_cfg.srs.configured) { if (current_pcell.ul_cfg.srs.configured) {
rrc_log->info("Set SRS ConfigCommon: BW-Configuration=%d, SF-Configuration=%d, Simult-ACKNACK=%s\n", logger.info("Set SRS ConfigCommon: BW-Configuration=%d, SF-Configuration=%d, Simult-ACKNACK=%s",
current_pcell.ul_cfg.srs.bw_cfg, current_pcell.ul_cfg.srs.bw_cfg,
current_pcell.ul_cfg.srs.subframe_config, current_pcell.ul_cfg.srs.subframe_config,
current_pcell.ul_cfg.srs.simul_ack ? "yes" : "no"); current_pcell.ul_cfg.srs.simul_ack ? "yes" : "no");
@ -2169,7 +2169,7 @@ void rrc::log_rr_config_common()
void rrc::apply_rr_config_common(rr_cfg_common_s* config, bool send_lower_layers) void rrc::apply_rr_config_common(rr_cfg_common_s* config, bool send_lower_layers)
{ {
rrc_log->info("Applying MAC/PHY config common\n"); logger.info("Applying MAC/PHY config common");
if (config->rach_cfg_common_present) { if (config->rach_cfg_common_present) {
set_mac_cfg_t_rach_cfg_common(&current_mac_cfg, config->rach_cfg_common); set_mac_cfg_t_rach_cfg_common(&current_mac_cfg, config->rach_cfg_common);
@ -2214,29 +2214,25 @@ void rrc::apply_rr_config_common(rr_cfg_common_s* config, bool send_lower_layers
void rrc::log_phy_config_dedicated() void rrc::log_phy_config_dedicated()
{ {
if (!rrc_log) {
return;
}
srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0]; srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0];
if (current_pcell.dl_cfg.cqi_report.periodic_configured) { if (current_pcell.dl_cfg.cqi_report.periodic_configured) {
rrc_log->info("Set cqi-PUCCH-ResourceIndex=%d, cqi-pmi-ConfigIndex=%d, cqi-FormatIndicatorPeriodic=%d\n", logger.info("Set cqi-PUCCH-ResourceIndex=%d, cqi-pmi-ConfigIndex=%d, cqi-FormatIndicatorPeriodic=%d",
current_pcell.ul_cfg.pucch.n_pucch_2, current_pcell.ul_cfg.pucch.n_pucch_2,
current_pcell.dl_cfg.cqi_report.pmi_idx, current_pcell.dl_cfg.cqi_report.pmi_idx,
current_pcell.dl_cfg.cqi_report.periodic_mode); current_pcell.dl_cfg.cqi_report.periodic_mode);
} }
if (current_pcell.dl_cfg.cqi_report.aperiodic_configured) { if (current_pcell.dl_cfg.cqi_report.aperiodic_configured) {
rrc_log->info("Set cqi-ReportModeAperiodic=%d\n", current_pcell.dl_cfg.cqi_report.aperiodic_mode); logger.info("Set cqi-ReportModeAperiodic=%d", current_pcell.dl_cfg.cqi_report.aperiodic_mode);
} }
if (current_pcell.ul_cfg.pucch.sr_configured) { if (current_pcell.ul_cfg.pucch.sr_configured) {
rrc_log->info("Set PHY config ded: SR-n_pucch=%d, SR-ConfigIndex=%d", logger.info("Set PHY config ded: SR-n_pucch=%d, SR-ConfigIndex=%d",
current_pcell.ul_cfg.pucch.n_pucch_sr, current_pcell.ul_cfg.pucch.n_pucch_sr,
current_pcell.ul_cfg.pucch.I_sr); current_pcell.ul_cfg.pucch.I_sr);
} }
if (current_pcell.ul_cfg.srs.configured) { if (current_pcell.ul_cfg.srs.configured) {
rrc_log->info("Set PHY config ded: SRS-ConfigIndex=%d, SRS-bw=%d, SRS-Nrcc=%d, SRS-hop=%d, SRS-Ncs=%d\n", logger.info("Set PHY config ded: SRS-ConfigIndex=%d, SRS-bw=%d, SRS-Nrcc=%d, SRS-hop=%d, SRS-Ncs=%d",
current_pcell.ul_cfg.srs.I_srs, current_pcell.ul_cfg.srs.I_srs,
current_pcell.ul_cfg.srs.B, current_pcell.ul_cfg.srs.B,
current_pcell.ul_cfg.srs.n_rrc, current_pcell.ul_cfg.srs.n_rrc,
@ -2251,14 +2247,14 @@ void rrc::set_phy_default()
if (phy_ctrl != nullptr) { if (phy_ctrl != nullptr) {
phy_ctrl->set_phy_to_default(); phy_ctrl->set_phy_to_default();
} else { } else {
rrc_log->info("RRC not initialized. Skipping default PHY config.\n"); logger.info("RRC not initialized. Skipping default PHY config.");
} }
} }
// Apply provided PHY config // Apply provided PHY config
void rrc::apply_phy_config_dedicated(const phys_cfg_ded_s& phy_cnfg, bool is_handover) void rrc::apply_phy_config_dedicated(const phys_cfg_ded_s& phy_cnfg, bool is_handover)
{ {
rrc_log->info("Applying PHY config dedicated\n"); logger.info("Applying PHY config dedicated");
srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0]; srslte::phy_cfg_t& current_pcell = phy_ctrl->current_cell_config()[0];
set_phy_cfg_t_dedicated_cfg(&current_pcell, phy_cnfg); set_phy_cfg_t_dedicated_cfg(&current_pcell, phy_cnfg);
@ -2279,11 +2275,11 @@ void rrc::apply_phy_scell_config(const scell_to_add_mod_r10_s& scell_config, boo
uint32_t earfcn = 0; uint32_t earfcn = 0;
if (phy == nullptr) { if (phy == nullptr) {
rrc_log->info("RRC not initialized. Skipping PHY config.\n"); logger.info("RRC not initialized. Skipping PHY config.");
return; return;
} }
rrc_log->info("Applying PHY config to scell\n"); logger.info("Applying PHY config to scell");
// Initialise default parameters from primary cell // Initialise default parameters from primary cell
earfcn = meas_cells.serving_cell().get_earfcn(); earfcn = meas_cells.serving_cell().get_earfcn();
@ -2333,23 +2329,22 @@ void rrc::apply_phy_scell_config(const scell_to_add_mod_r10_s& scell_config, boo
} }
if (!phy->set_scell(scell, scell_config.scell_idx_r10, earfcn)) { if (!phy->set_scell(scell, scell_config.scell_idx_r10, earfcn)) {
rrc_log->error("Adding SCell cc_idx=%d\n", scell_config.scell_idx_r10); logger.error("Adding SCell cc_idx=%d", scell_config.scell_idx_r10);
} else if (!phy_ctrl->set_cell_config(scell_cfg, scell_config.scell_idx_r10)) { } else if (!phy_ctrl->set_cell_config(scell_cfg, scell_config.scell_idx_r10)) {
rrc_log->error("Setting SCell configuration for cc_idx=%d\n", scell_config.scell_idx_r10); logger.error("Setting SCell configuration for cc_idx=%d", scell_config.scell_idx_r10);
} }
} }
void rrc::log_mac_config_dedicated() void rrc::log_mac_config_dedicated()
{ {
rrc_log->info( logger.info("Set MAC main config: harq-MaxReTX=%d, bsr-TimerReTX=%d, bsr-TimerPeriodic=%d, SR %s (dsr-TransMax=%d)",
"Set MAC main config: harq-MaxReTX=%d, bsr-TimerReTX=%d, bsr-TimerPeriodic=%d, SR %s (dsr-TransMax=%d)\n",
current_mac_cfg.harq_cfg.max_harq_msg3_tx, current_mac_cfg.harq_cfg.max_harq_msg3_tx,
current_mac_cfg.bsr_cfg.retx_timer, current_mac_cfg.bsr_cfg.retx_timer,
current_mac_cfg.bsr_cfg.periodic_timer, current_mac_cfg.bsr_cfg.periodic_timer,
current_mac_cfg.sr_cfg.enabled ? "enabled" : "disabled", current_mac_cfg.sr_cfg.enabled ? "enabled" : "disabled",
current_mac_cfg.sr_cfg.dsr_transmax); current_mac_cfg.sr_cfg.dsr_transmax);
if (current_mac_cfg.phr_cfg.enabled) { if (current_mac_cfg.phr_cfg.enabled) {
rrc_log->info("Set MAC PHR config: periodicPHR-Timer=%d, prohibitPHR-Timer=%d, dl-PathlossChange=%d\n", logger.info("Set MAC PHR config: periodicPHR-Timer=%d, prohibitPHR-Timer=%d, dl-PathlossChange=%d",
current_mac_cfg.phr_cfg.periodic_timer, current_mac_cfg.phr_cfg.periodic_timer,
current_mac_cfg.phr_cfg.prohibit_timer, current_mac_cfg.phr_cfg.prohibit_timer,
current_mac_cfg.phr_cfg.db_pathloss_change); current_mac_cfg.phr_cfg.db_pathloss_change);
@ -2359,7 +2354,7 @@ void rrc::log_mac_config_dedicated()
// 3GPP 36.331 v10 9.2.2 Default MAC main configuration // 3GPP 36.331 v10 9.2.2 Default MAC main configuration
void rrc::apply_mac_config_dedicated_default() void rrc::apply_mac_config_dedicated_default()
{ {
rrc_log->info("Setting MAC default configuration\n"); logger.info("Setting MAC default configuration");
current_mac_cfg.set_mac_main_cfg_default(); current_mac_cfg.set_mac_main_cfg_default();
mac->set_config(current_mac_cfg); mac->set_config(current_mac_cfg);
log_mac_config_dedicated(); log_mac_config_dedicated();
@ -2382,7 +2377,7 @@ bool rrc::apply_rr_config_dedicated(const rr_cfg_ded_s* cnfg, bool is_handover)
} }
} }
rrc_log->info("Applying MAC config dedicated\n"); logger.info("Applying MAC config dedicated");
if (cnfg->mac_main_cfg_present) { if (cnfg->mac_main_cfg_present) {
if (cnfg->mac_main_cfg.type() == rr_cfg_ded_s::mac_main_cfg_c_::types::default_value) { if (cnfg->mac_main_cfg.type() == rr_cfg_ded_s::mac_main_cfg_c_::types::default_value) {
@ -2409,7 +2404,7 @@ bool rrc::apply_rr_config_dedicated(const rr_cfg_ded_s* cnfg, bool is_handover)
N310 = cnfg->rlf_timers_and_consts_r9->setup().n310_r9.to_number(); N310 = cnfg->rlf_timers_and_consts_r9->setup().n310_r9.to_number();
N311 = cnfg->rlf_timers_and_consts_r9->setup().n311_r9.to_number(); N311 = cnfg->rlf_timers_and_consts_r9->setup().n311_r9.to_number();
rrc_log->info("Updated Constants and Timers: N310=%d, N311=%d, t300=%u, t301=%u, t310=%u, t311=%u\n", logger.info("Updated Constants and Timers: N310=%d, N311=%d, t300=%u, t301=%u, t310=%u, t311=%u",
N310, N310,
N311, N311,
t300.duration(), t300.duration(),
@ -2433,7 +2428,7 @@ bool rrc::apply_rr_config_dedicated(const rr_cfg_ded_s* cnfg, bool is_handover)
bool rrc::apply_rr_config_dedicated_on_ho_complete(const rr_cfg_ded_s& cnfg) bool rrc::apply_rr_config_dedicated_on_ho_complete(const rr_cfg_ded_s& cnfg)
{ {
rrc_log->info("Applying MAC/PHY config dedicated on HO complete\n"); logger.info("Applying MAC/PHY config dedicated on HO complete");
// Apply SR+CQI configuration to PHY // Apply SR+CQI configuration to PHY
if (cnfg.phys_cfg_ded_present) { if (cnfg.phys_cfg_ded_present) {
@ -2537,7 +2532,7 @@ void rrc::handle_con_setup(const rrc_conn_setup_s& setup)
state = RRC_STATE_CONNECTED; state = RRC_STATE_CONNECTED;
t300.stop(); t300.stop();
t302.stop(); t302.stop();
srslte::console("RRC Connected\n"); srslte::console("RRC Connected");
// Apply the Radio Resource configuration // Apply the Radio Resource configuration
apply_rr_config_dedicated(&setup.crit_exts.c1().rrc_conn_setup_r8().rr_cfg_ded); apply_rr_config_dedicated(&setup.crit_exts.c1().rrc_conn_setup_r8().rr_cfg_ded);
@ -2547,7 +2542,7 @@ void rrc::handle_con_setup(const rrc_conn_setup_s& setup)
if (dedicated_info_nas.get()) { if (dedicated_info_nas.get()) {
send_con_setup_complete(std::move(dedicated_info_nas)); send_con_setup_complete(std::move(dedicated_info_nas));
} else { } else {
rrc_log->error("Pending to transmit a ConnectionSetupComplete but no dedicatedInfoNAS was in queue\n"); logger.error("Pending to transmit a ConnectionSetupComplete but no dedicatedInfoNAS was in queue");
} }
} }
@ -2584,7 +2579,7 @@ void rrc::add_srb(const srb_to_add_mod_s& srb_cnfg)
// Set default SRB values as defined in Table 9.2.1 // Set default SRB values as defined in Table 9.2.1
switch (srb_cnfg.srb_id) { switch (srb_cnfg.srb_id) {
case RB_ID_SRB0: case RB_ID_SRB0:
rrc_log->error("Setting SRB0: Should not be set by RRC\n"); logger.error("Setting SRB0: Should not be set by RRC");
break; break;
case RB_ID_SRB1: case RB_ID_SRB1:
priority = 1; priority = 1;
@ -2614,13 +2609,13 @@ void rrc::add_srb(const srb_to_add_mod_s& srb_cnfg)
} }
srbs[srb_cnfg.srb_id] = srb_cnfg; srbs[srb_cnfg.srb_id] = srb_cnfg;
rrc_log->info("Added radio bearer %s\n", get_rb_name(srb_cnfg.srb_id).c_str()); logger.info("Added radio bearer %s", get_rb_name(srb_cnfg.srb_id).c_str());
} }
void rrc::add_drb(const drb_to_add_mod_s& drb_cnfg) void rrc::add_drb(const drb_to_add_mod_s& drb_cnfg)
{ {
if (!drb_cnfg.pdcp_cfg_present || !drb_cnfg.rlc_cfg_present || !drb_cnfg.lc_ch_cfg_present) { if (!drb_cnfg.pdcp_cfg_present || !drb_cnfg.rlc_cfg_present || !drb_cnfg.lc_ch_cfg_present) {
rrc_log->error("Cannot add DRB - incomplete configuration\n"); logger.error("Cannot add DRB - incomplete configuration");
return; return;
} }
uint32_t lcid = 0; uint32_t lcid = 0;
@ -2628,7 +2623,7 @@ void rrc::add_drb(const drb_to_add_mod_s& drb_cnfg)
lcid = drb_cnfg.lc_ch_id; lcid = drb_cnfg.lc_ch_id;
} else { } else {
lcid = RB_ID_SRB2 + drb_cnfg.drb_id; lcid = RB_ID_SRB2 + drb_cnfg.drb_id;
rrc_log->warning("LCID not present, using %d\n", lcid); logger.warning("LCID not present, using %d", lcid);
} }
// Setup RLC // Setup RLC
@ -2649,7 +2644,7 @@ void rrc::add_drb(const drb_to_add_mod_s& drb_cnfg)
if (drb_cnfg.lc_ch_cfg.ul_specific_params.lc_ch_group_present) { if (drb_cnfg.lc_ch_cfg.ul_specific_params.lc_ch_group_present) {
log_chan_group = drb_cnfg.lc_ch_cfg.ul_specific_params.lc_ch_group; log_chan_group = drb_cnfg.lc_ch_cfg.ul_specific_params.lc_ch_group;
} else { } else {
rrc_log->warning("LCG not present, setting to 0\n"); logger.warning("LCG not present, setting to 0");
} }
priority = drb_cnfg.lc_ch_cfg.ul_specific_params.prio; priority = drb_cnfg.lc_ch_cfg.ul_specific_params.prio;
prioritized_bit_rate = drb_cnfg.lc_ch_cfg.ul_specific_params.prioritised_bit_rate.to_number(); prioritized_bit_rate = drb_cnfg.lc_ch_cfg.ul_specific_params.prioritised_bit_rate.to_number();
@ -2659,16 +2654,16 @@ void rrc::add_drb(const drb_to_add_mod_s& drb_cnfg)
drbs[drb_cnfg.drb_id] = drb_cnfg; drbs[drb_cnfg.drb_id] = drb_cnfg;
drb_up = true; drb_up = true;
rrc_log->info("Added DRB Id %d (LCID=%d)\n", drb_cnfg.drb_id, lcid); logger.info("Added DRB Id %d (LCID=%d)", drb_cnfg.drb_id, lcid);
} }
void rrc::release_drb(uint32_t drb_id) void rrc::release_drb(uint32_t drb_id)
{ {
if (drbs.find(drb_id) != drbs.end()) { if (drbs.find(drb_id) != drbs.end()) {
rrc_log->info("Releasing DRB Id %d\n", drb_id); logger.info("Releasing DRB Id %d", drb_id);
drbs.erase(drb_id); drbs.erase(drb_id);
} else { } else {
rrc_log->error("Couldn't release DRB Id %d. Doesn't exist.\n", drb_id); logger.error("Couldn't release DRB Id %d. Doesn't exist.", drb_id);
} }
} }
@ -2683,7 +2678,7 @@ uint32_t rrc::get_lcid_for_eps_bearer(const uint32_t& eps_bearer_id)
lcid = drb_cnfg.lc_ch_id; lcid = drb_cnfg.lc_ch_id;
} else { } else {
lcid = RB_ID_SRB2 + drb_cnfg.drb_id; lcid = RB_ID_SRB2 + drb_cnfg.drb_id;
rrc_log->warning("LCID not present, using %d\n", lcid); logger.warning("LCID not present, using %d", lcid);
} }
return lcid; return lcid;
} }
@ -2714,7 +2709,7 @@ void rrc::add_mrb(uint32_t lcid, uint32_t port)
gw->add_mch_port(lcid, port); gw->add_mch_port(lcid, port);
rlc->add_bearer_mrb(lcid); rlc->add_bearer_mrb(lcid);
mac->mch_start_rx(lcid); mac->mch_start_rx(lcid);
rrc_log->info("Added MRB bearer for lcid:%d\n", lcid); logger.info("Added MRB bearer for lcid:%d", lcid);
} }
// PHY CONFIG DEDICATED Defaults (3GPP 36.331 v10 9.2.4) // PHY CONFIG DEDICATED Defaults (3GPP 36.331 v10 9.2.4)
@ -2723,7 +2718,7 @@ void rrc::set_phy_default_pucch_srs()
if (phy_ctrl != nullptr) { if (phy_ctrl != nullptr) {
phy_ctrl->set_phy_to_default_pucch_srs(); phy_ctrl->set_phy_to_default_pucch_srs();
} else { } else {
rrc_log->info("RRC not initialized. Skipping default PUCCH/SRS config.\n"); logger.info("RRC not initialized. Skipping default PUCCH/SRS config.");
} }
// SR configuration affects to MAC SR too // SR configuration affects to MAC SR too
@ -2757,7 +2752,7 @@ asn1::rrc::ue_cap_rat_container_s rrc::get_eutra_nr_capabilities()
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
rrc_nr->get_eutra_nr_capabilities(&caps_buf); rrc_nr->get_eutra_nr_capabilities(&caps_buf);
#else #else
rrc_log->error("Not able to access get_eutra_nr_capabilities function\n"); logger.error("Not able to access get_eutra_nr_capabilities function");
#endif #endif
cap.rat_type = asn1::rrc::rat_type_e::eutra_nr; cap.rat_type = asn1::rrc::rat_type_e::eutra_nr;
cap.ue_cap_rat_container.resize(caps_buf.N_bytes); cap.ue_cap_rat_container.resize(caps_buf.N_bytes);
@ -2772,7 +2767,7 @@ asn1::rrc::ue_cap_rat_container_s rrc::get_nr_capabilities()
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
rrc_nr->get_nr_capabilities(&caps_buf); rrc_nr->get_nr_capabilities(&caps_buf);
#else #else
rrc_log->error("Not able to access get_nr_capabilities function\n"); logger.error("Not able to access get_nr_capabilities function");
#endif #endif
cap.rat_type = asn1::rrc::rat_type_e::nr; cap.rat_type = asn1::rrc::rat_type_e::nr;
cap.ue_cap_rat_container.resize(caps_buf.N_bytes); cap.ue_cap_rat_container.resize(caps_buf.N_bytes);

33
srsue/src/stack/rrc/rrc_cell.cc
Unescape Escape View File

@ -169,8 +169,7 @@ uint16_t meas_cell_eutra::get_mnc() const
********************************************/ ********************************************/
template <class T> template <class T>
meas_cell_list<T>::meas_cell_list(srslte::task_sched_handle task_sched_) : meas_cell_list<T>::meas_cell_list(srslte::task_sched_handle task_sched_) :
serv_cell(new T(task_sched_.get_unique_timer())), serv_cell(new T(task_sched_.get_unique_timer())), task_sched(task_sched_)
task_sched(task_sched_)
{} {}
template <class T> template <class T>
@ -217,12 +216,12 @@ bool meas_cell_list<T>::add_neighbour_cell_unsorted(unique_meas_cell new_cell)
{ {
// Make sure cell is valid // Make sure cell is valid
if (!new_cell->is_valid()) { if (!new_cell->is_valid()) {
log_h->error("Trying to add cell %s but is not valid", new_cell->to_string().c_str()); logger.error("Trying to add cell %s but is not valid", new_cell->to_string().c_str());
return false; return false;
} }
if (is_same_cell(serving_cell(), *new_cell)) { if (is_same_cell(serving_cell(), *new_cell)) {
log_h->info("Added neighbour cell %s is serving cell\n", new_cell->to_string().c_str()); logger.info("Added neighbour cell %s is serving cell", new_cell->to_string().c_str());
serv_cell = std::move(new_cell); serv_cell = std::move(new_cell);
return true; return true;
} }
@ -233,22 +232,22 @@ bool meas_cell_list<T>::add_neighbour_cell_unsorted(unique_meas_cell new_cell)
if (std::isnormal(new_cell.get()->get_rsrp())) { if (std::isnormal(new_cell.get()->get_rsrp())) {
existing_cell->set_rsrp(new_cell.get()->get_rsrp()); existing_cell->set_rsrp(new_cell.get()->get_rsrp());
} }
log_h->info("Updated neighbour cell %s rsrp=%f\n", new_cell->to_string().c_str(), new_cell.get()->get_rsrp()); logger.info("Updated neighbour cell %s rsrp=%f", new_cell->to_string().c_str(), new_cell.get()->get_rsrp());
return true; return true;
} }
if (neighbour_cells.size() >= MAX_NEIGHBOUR_CELLS) { if (neighbour_cells.size() >= MAX_NEIGHBOUR_CELLS) {
// If there isn't space, keep the strongest only // If there isn't space, keep the strongest only
if (not new_cell->greater(neighbour_cells.back().get())) { if (not new_cell->greater(neighbour_cells.back().get())) {
log_h->warning("Could not add cell %s: no space in neighbours\n", new_cell->to_string().c_str()); logger.warning("Could not add cell %s: no space in neighbours", new_cell->to_string().c_str());
return false; return false;
} }
rem_last_neighbour(); rem_last_neighbour();
} }
log_h->info( logger.info(
"Adding neighbour cell %s, nof_neighbours=%zd\n", new_cell->to_string().c_str(), neighbour_cells.size() + 1); "Adding neighbour cell %s, nof_neighbours=%zd", new_cell->to_string().c_str(), neighbour_cells.size() + 1);
neighbour_cells.push_back(std::move(new_cell)); neighbour_cells.push_back(std::move(new_cell));
return true; return true;
} }
@ -257,7 +256,7 @@ void meas_cell_list<T>::rem_last_neighbour()
{ {
if (not neighbour_cells.empty()) { if (not neighbour_cells.empty()) {
unique_meas_cell& c = neighbour_cells.back(); unique_meas_cell& c = neighbour_cells.back();
log_h->debug("Delete cell %s from neighbor list.\n", c->to_string().c_str()); logger.debug("Delete cell %s from neighbor list.", c->to_string().c_str());
neighbour_cells.pop_back(); neighbour_cells.pop_back();
} }
} }
@ -301,9 +300,9 @@ void meas_cell_list<T>::log_neighbour_cells() const
} }
} }
} }
log_h->debug("Neighbours: %s]\n", ordered); logger.debug("Neighbours: %s]", ordered);
} else { } else {
log_h->debug("Neighbours: Empty\n"); logger.debug("Neighbours: Empty");
} }
} }
@ -313,7 +312,7 @@ void meas_cell_list<T>::clean_neighbours()
{ {
for (auto it = neighbour_cells.begin(); it != neighbour_cells.end();) { for (auto it = neighbour_cells.begin(); it != neighbour_cells.end();) {
if (it->get()->timer.is_expired()) { if (it->get()->timer.is_expired()) {
log_h->info("Neighbour PCI=%d timed out. Deleting.\n", (*it)->get_pci()); logger.info("Neighbour PCI=%d timed out. Deleting.", (*it)->get_pci());
it = neighbour_cells.erase(it); it = neighbour_cells.erase(it);
} else { } else {
++it; ++it;
@ -369,19 +368,19 @@ int meas_cell_list<T>::set_serving_cell(phy_cell_t phy_cell, bool discard_servin
// Remove future serving cell from neighbours to make space for current serving cell // Remove future serving cell from neighbours to make space for current serving cell
unique_meas_cell new_serving_cell = remove_neighbour_cell(phy_cell.earfcn, phy_cell.pci); unique_meas_cell new_serving_cell = remove_neighbour_cell(phy_cell.earfcn, phy_cell.pci);
if (new_serving_cell == nullptr) { if (new_serving_cell == nullptr) {
log_h->error("Setting serving cell: Unknown cell with earfcn=%d, PCI=%d\n", phy_cell.earfcn, phy_cell.pci); logger.error("Setting serving cell: Unknown cell with earfcn=%d, PCI=%d", phy_cell.earfcn, phy_cell.pci);
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
// Set new serving cell // Set new serving cell
std::swap(serv_cell, new_serving_cell); std::swap(serv_cell, new_serving_cell);
auto& old_serv_cell = new_serving_cell; auto& old_serv_cell = new_serving_cell;
log_h->info("Setting serving cell %s, nof_neighbours=%zd\n", serv_cell->to_string().c_str(), nof_neighbours()); logger.info("Setting serving cell %s, nof_neighbours=%zd", serv_cell->to_string().c_str(), nof_neighbours());
// Re-add old serving cell to list of neighbours // Re-add old serving cell to list of neighbours
if (old_serv_cell->is_valid() and not is_same_cell(phy_cell, *old_serv_cell) and not discard_serving) { if (old_serv_cell->is_valid() and not is_same_cell(phy_cell, *old_serv_cell) and not discard_serving) {
if (not add_meas_cell(std::move(old_serv_cell))) { if (not add_meas_cell(std::move(old_serv_cell))) {
log_h->info("Serving cell not added to list of neighbours. Worse than current neighbours\n"); logger.info("Serving cell not added to list of neighbours. Worse than current neighbours");
} }
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -400,7 +399,7 @@ bool meas_cell_list<T>::process_new_cell_meas(const std::vector<phy_meas_t>&
if (is_serving_cell) { if (is_serving_cell) {
c = serv_cell.get(); c = serv_cell.get();
if (not serving_cell().is_valid()) { if (not serving_cell().is_valid()) {
log_h->error("MEAS: Received serving cell measurement but undefined or invalid\n"); logger.error("MEAS: Received serving cell measurement but undefined or invalid");
continue; continue;
} }
} else { } else {
@ -416,7 +415,7 @@ bool meas_cell_list<T>::process_new_cell_meas(const std::vector<phy_meas_t>&
neighbour_added |= add_meas_cell(m); neighbour_added |= add_meas_cell(m);
} }
log_h->info("MEAS: New measurement %s cell: earfcn=%d, pci=%d, rsrp=%.2f dBm, cfo=%+.1f Hz\n", logger.info("MEAS: New measurement %s cell: earfcn=%d, pci=%d, rsrp=%.2f dBm, cfo=%+.1f Hz",
is_serving_cell ? "serving" : "neighbour", is_serving_cell ? "serving" : "neighbour",
m.earfcn, m.earfcn,
m.pci, m.pci,

172
srsue/src/stack/rrc/rrc_meas.cc
Unescape Escape View File

@ -12,8 +12,8 @@
#include "srsue/hdr/stack/rrc/rrc_meas.h" #include "srsue/hdr/stack/rrc/rrc_meas.h"
#include "srslte/asn1/rrc/dl_dcch_msg.h" #include "srslte/asn1/rrc/dl_dcch_msg.h"
#include "srsue/hdr/stack/rrc/rrc.h"
#include "srslte/rrc/rrc_cfg_utils.h" #include "srslte/rrc/rrc_cfg_utils.h"
#include "srsue/hdr/stack/rrc/rrc.h"
/************************************************************************ /************************************************************************
* *
@ -94,7 +94,7 @@ void rrc::rrc_meas::update_phy()
} }
#endif #endif
default: default:
log_h->error("Not supported\n"); logger.error("Not supported");
break; break;
} }
// Concatenate cells indicated by enodeb with discovered neighbours // Concatenate cells indicated by enodeb with discovered neighbours
@ -253,7 +253,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report_eutra(meas_results_s*
{ {
meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell(); meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell();
if (serv_cell == nullptr) { if (serv_cell == nullptr) {
log_h->warning("MEAS: Serving cell not set when evaluating triggers\n"); logger.warning("MEAS: Serving cell not set when evaluating triggers");
return; return;
} }
@ -271,7 +271,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report_eutra(meas_results_s*
for (auto& cell : var_meas.cell_triggered_list) { for (auto& cell : var_meas.cell_triggered_list) {
// report neighbour cells only // report neighbour cells only
if (cell.pci == serv_cell->get_pci() && cell.earfcn == serv_cell->get_earfcn()) { if (cell.pci == serv_cell->get_pci() && cell.earfcn == serv_cell->get_earfcn()) {
log_h->info("MEAS: skipping serving cell in report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f\n", logger.info("MEAS: skipping serving cell in report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f",
neigh_list.size(), neigh_list.size(),
cell.pci, cell.pci,
var_meas.carrier_freq, var_meas.carrier_freq,
@ -309,7 +309,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report_eutra(meas_results_s*
rc.meas_result.rsrp_result = value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrp, rsrp_value); rc.meas_result.rsrp_result = value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrp, rsrp_value);
rc.meas_result.rsrq_result = value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrq, rsrq_value); rc.meas_result.rsrq_result = value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrq, rsrq_value);
log_h->info("MEAS: Adding to report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f\n", logger.info("MEAS: Adding to report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f",
neigh_list.size(), neigh_list.size(),
rc.pci, rc.pci,
var_meas.carrier_freq, var_meas.carrier_freq,
@ -392,7 +392,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report_interrat(meas_results_
value_to_range_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_sinr_r15, 1.0); value_to_range_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_sinr_r15, 1.0);
} }
log_h->info("MEAS: Adding to report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f\n", logger.info("MEAS: Adding to report neighbour=%d, pci=%d, earfcn=%d, rsrp=%+.1f, rsrq=%+.1f",
neigh_list.size(), neigh_list.size(),
rc.pci_r15, rc.pci_r15,
var_meas.carrier_freq, var_meas.carrier_freq,
@ -438,7 +438,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report(const uint32_t measId)
{ {
meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell(); meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell();
if (serv_cell == nullptr) { if (serv_cell == nullptr) {
log_h->warning("MEAS: Serving cell not set when evaluating triggers\n"); logger.warning("MEAS: Serving cell not set when evaluating triggers");
return; return;
} }
@ -453,7 +453,7 @@ void rrc::rrc_meas::var_meas_report_list::generate_report(const uint32_t measId)
report->meas_result_pcell.rsrq_result = report->meas_result_pcell.rsrq_result =
value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrq, serv_cell->get_rsrq()); value_to_range(report_cfg_eutra_s::trigger_quant_opts::rsrq, serv_cell->get_rsrq());
log_h->info("MEAS: Generate report MeasId=%d, Pcell rsrp=%f rsrq=%f\n", logger.info("MEAS: Generate report MeasId=%d, Pcell rsrp=%f rsrq=%f",
report->meas_id, report->meas_id,
serv_cell->get_rsrp(), serv_cell->get_rsrp(),
serv_cell->get_rsrq()); serv_cell->get_rsrq());
@ -463,19 +463,19 @@ void rrc::rrc_meas::var_meas_report_list::generate_report(const uint32_t measId)
switch (var_meas.report_type) { switch (var_meas.report_type) {
case eutra: { case eutra: {
log_h->debug("MEAS: Generate EUTRA report\n"); logger.debug("MEAS: Generate EUTRA report");
generate_report_eutra(report, measId); generate_report_eutra(report, measId);
break; break;
} }
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
case inter_rat: { case inter_rat: {
log_h->debug("MEAS: Generate INTER RAT NR report\n"); logger.debug("MEAS: Generate INTER RAT NR report");
generate_report_interrat(report, measId); generate_report_interrat(report, measId);
break; break;
} }
#endif #endif
default: default:
log_h->debug("MEAS: Not supported\n"); logger.debug("MEAS: Not supported");
break; break;
} }
@ -630,7 +630,7 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers_eutra_removing_trigger(int32_t
{ {
meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell(); meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell();
if (serv_cell == nullptr) { if (serv_cell == nullptr) {
log_h->warning("MEAS: Serving cell not set when reporting triggers\n"); logger.warning("MEAS: Serving cell not set when reporting triggers");
return; return;
} }
uint32_t serving_pci = serv_cell->get_pci(); uint32_t serving_pci = serv_cell->get_pci();
@ -640,7 +640,7 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers_eutra_removing_trigger(int32_t
auto it = cells_triggered_list.begin(); auto it = cells_triggered_list.begin();
while (it != cells_triggered_list.end()) { while (it != cells_triggered_list.end()) {
if (not rrc_ptr->has_neighbour_cell(it->earfcn, it->pci) and it->pci != serving_pci) { if (not rrc_ptr->has_neighbour_cell(it->earfcn, it->pci) and it->pci != serving_pci) {
log_h->debug("MEAS: Removing unknown PCI=%d from event trigger list\n", it->pci); logger.debug("MEAS: Removing unknown PCI=%d from event trigger list", it->pci);
it = cells_triggered_list.erase(it); it = cells_triggered_list.erase(it);
meas_report->upd_measId(meas_id, cells_triggered_list); meas_report->upd_measId(meas_id, cells_triggered_list);
@ -693,7 +693,6 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers_interrat_check_new(int32_t
// initiate the measurement reporting procedure, as specified in 5.5.5; // initiate the measurement reporting procedure, as specified in 5.5.5;
meas_report->generate_report(meas_id); meas_report->generate_report(meas_id);
} }
} }
void rrc::rrc_meas::var_meas_cfg::report_triggers_interrat_check_leaving(int32_t meas_id, void rrc::rrc_meas::var_meas_cfg::report_triggers_interrat_check_leaving(int32_t meas_id,
report_cfg_inter_rat_s& report_cfg) report_cfg_inter_rat_s& report_cfg)
@ -733,7 +732,7 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers_interrat_removing_trigger(int3
auto it = cells_triggered_list.begin(); auto it = cells_triggered_list.begin();
while (it != cells_triggered_list.end()) { while (it != cells_triggered_list.end()) {
if (not rrc_ptr->has_neighbour_cell_nr(it->earfcn, it->pci)) { if (not rrc_ptr->has_neighbour_cell_nr(it->earfcn, it->pci)) {
log_h->debug("MEAS: Removing unknown PCI=%d from event trigger list\n", it->pci); logger.debug("MEAS: Removing unknown PCI=%d from event trigger list", it->pci);
it = cells_triggered_list.erase(it); it = cells_triggered_list.erase(it);
meas_report->upd_measId(meas_id, cells_triggered_list); meas_report->upd_measId(meas_id, cells_triggered_list);
@ -765,14 +764,14 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers()
for (auto& m : measIdList) { for (auto& m : measIdList) {
if (!reportConfigList.count(m.second.report_cfg_id) || !measObjectsList.count(m.second.meas_obj_id)) { if (!reportConfigList.count(m.second.report_cfg_id) || !measObjectsList.count(m.second.meas_obj_id)) {
log_h->error("MEAS: Computing report triggers. MeasId=%d has invalid report or object settings\n", m.first); logger.error("MEAS: Computing report triggers. MeasId=%d has invalid report or object settings", m.first);
continue; continue;
} }
report_cfg_to_add_mod_s& report_cfg = reportConfigList.at(m.second.report_cfg_id); report_cfg_to_add_mod_s& report_cfg = reportConfigList.at(m.second.report_cfg_id);
meas_obj_to_add_mod_s& meas_obj = measObjectsList.at(m.second.meas_obj_id); meas_obj_to_add_mod_s& meas_obj = measObjectsList.at(m.second.meas_obj_id);
log_h->debug("MEAS: Calculating reports for MeasId=%d, ObjectId=%d (Type %s), ReportId=%d (Type %s)\n", logger.debug("MEAS: Calculating reports for MeasId=%d, ObjectId=%d (Type %s), ReportId=%d (Type %s)",
m.first, m.first,
m.second.meas_obj_id, m.second.meas_obj_id,
report_cfg.report_cfg.type().to_string().c_str(), report_cfg.report_cfg.type().to_string().c_str(),
@ -792,7 +791,7 @@ void rrc::rrc_meas::var_meas_cfg::report_triggers()
} }
#endif #endif
else { else {
log_h->error("Unsupported combination of measurement object type %s and report config type %s \n", logger.error("Unsupported combination of measurement object type %s and report config type %s ",
meas_obj.meas_obj.type().to_string().c_str(), meas_obj.meas_obj.type().to_string().c_str(),
report_cfg.report_cfg.type().to_string().c_str()); report_cfg.report_cfg.type().to_string().c_str());
} }
@ -820,7 +819,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_eutra(uint32_t meas_i
float Ms = is_rsrp(report_cfg.trigger_quant.value) ? serv_cell->get_rsrp() : serv_cell->get_rsrq(); float Ms = is_rsrp(report_cfg.trigger_quant.value) ? serv_cell->get_rsrp() : serv_cell->get_rsrq();
if (!std::isnormal(Ms)) { if (!std::isnormal(Ms)) {
log_h->debug("MEAS: Serving cell Ms=%f invalid when evaluating triggers\n", Ms); logger.debug("MEAS: Serving cell Ms=%f invalid when evaluating triggers", Ms);
return; return;
} }
@ -853,7 +852,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_eutra(uint32_t meas_i
trigger_state[meas_id][serv_cell->get_pci()].event_condition(enter_condition, exit_condition); trigger_state[meas_id][serv_cell->get_pci()].event_condition(enter_condition, exit_condition);
log_h->debug("MEAS: eventId=%s, Ms=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d\n", logger.debug("MEAS: eventId=%s, Ms=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d",
event_id.type().to_string().c_str(), event_id.type().to_string().c_str(),
Ms, Ms,
hyst, hyst,
@ -865,8 +864,8 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_eutra(uint32_t meas_i
} else { } else {
auto cells = rrc_ptr->get_cells(meas_obj.carrier_freq); auto cells = rrc_ptr->get_cells(meas_obj.carrier_freq);
for (auto& pci : cells) { for (auto& pci : cells) {
log_h->debug( logger.debug(
"MEAS: eventId=%s, pci=%d, earfcn=%d\n", event_id.type().to_string().c_str(), pci, meas_obj.carrier_freq); "MEAS: eventId=%s, pci=%d, earfcn=%d", event_id.type().to_string().c_str(), pci, meas_obj.carrier_freq);
float Ofn = offset_val(meas_obj); float Ofn = offset_val(meas_obj);
float Ocn = 0; float Ocn = 0;
// If the cell was provided by the configuration, check if it has an individual q_offset // If the cell was provided by the configuration, check if it has an individual q_offset
@ -918,13 +917,13 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_eutra(uint32_t meas_i
exit_condition = (Ms - hyst > th1) && (Mn + Ofn + Ocn + hyst < th2); exit_condition = (Ms - hyst > th1) && (Mn + Ofn + Ocn + hyst < th2);
break; break;
default: default:
log_h->error("Error event %s not implemented\n", event_id.type().to_string().c_str()); logger.error("Error event %s not implemented", event_id.type().to_string().c_str());
} }
trigger_state[meas_id][pci].event_condition(enter_condition, exit_condition); trigger_state[meas_id][pci].event_condition(enter_condition, exit_condition);
log_h->debug( logger.debug(
"MEAS: eventId=%s, pci=%d, Ms=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d\n", "MEAS: eventId=%s, pci=%d, Ms=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d",
event_id.type().to_string().c_str(), event_id.type().to_string().c_str(),
pci, pci,
Ms, Ms,
@ -943,7 +942,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_interrat_nr(uint32_t
meas_obj_nr_r15_s& meas_obj) meas_obj_nr_r15_s& meas_obj)
{ {
if (!(report_cfg.trigger_type.type() == report_cfg_inter_rat_s::trigger_type_c_::types::event)) { if (!(report_cfg.trigger_type.type() == report_cfg_inter_rat_s::trigger_type_c_::types::event)) {
log_h->error("Unsupported trigger type for interrat nr eval\n"); logger.error("Unsupported trigger type for interrat nr eval");
return; return;
} }
@ -959,15 +958,15 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_interrat_nr(uint32_t
bool exit_condition = false; bool exit_condition = false;
float Mn = 0.0; float Mn = 0.0;
log_h->debug( logger.debug(
"MEAS: eventId=%s, pci=%d, earfcn=%d\n", event_id.type().to_string().c_str(), pci, meas_obj.carrier_freq_r15); "MEAS: eventId=%s, pci=%d, earfcn=%d", event_id.type().to_string().c_str(), pci, meas_obj.carrier_freq_r15);
if (event_id.event_b1_nr_r15().b1_thres_nr_r15.type().value == thres_nr_r15_c::types::nr_rsrp_r15) { if (event_id.event_b1_nr_r15().b1_thres_nr_r15.type().value == thres_nr_r15_c::types::nr_rsrp_r15) {
Mn = rrc_ptr->get_cell_rsrp_nr(meas_obj.carrier_freq_r15, pci); Mn = rrc_ptr->get_cell_rsrp_nr(meas_obj.carrier_freq_r15, pci);
thresh = range_to_value_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_rsrp_r15, thresh = range_to_value_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_rsrp_r15,
event_id.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15()); event_id.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15());
} else { } else {
log_h->warning("Other threshold values are not supported yet!\n"); logger.warning("Other threshold values are not supported yet!");
} }
enter_condition = Mn - hyst > thresh; enter_condition = Mn - hyst > thresh;
@ -975,7 +974,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers_interrat_nr(uint32_t
trigger_state_nr[meas_id][pci].event_condition(enter_condition, exit_condition); trigger_state_nr[meas_id][pci].event_condition(enter_condition, exit_condition);
log_h->debug("MEAS (NR): eventId=%s, Mn=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d\n", logger.debug("MEAS (NR): eventId=%s, Mn=%.2f, hyst=%.2f, Thresh=%.2f, enter_condition=%d, exit_condition=%d",
event_id.type().to_string().c_str(), event_id.type().to_string().c_str(),
Mn, Mn,
hyst, hyst,
@ -991,7 +990,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers()
meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell(); meas_cell_eutra* serv_cell = rrc_ptr->get_serving_cell();
if (serv_cell == nullptr) { if (serv_cell == nullptr) {
log_h->warning("MEAS: Serving cell not set when evaluating triggers\n"); logger.warning("MEAS: Serving cell not set when evaluating triggers");
return; return;
} }
@ -1014,14 +1013,14 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers()
for (auto& m : measIdList) { for (auto& m : measIdList) {
if (!reportConfigList.count(m.second.report_cfg_id) || !measObjectsList.count(m.second.meas_obj_id)) { if (!reportConfigList.count(m.second.report_cfg_id) || !measObjectsList.count(m.second.meas_obj_id)) {
log_h->error("MEAS: Computing report triggers. MeasId=%d has invalid report or object settings\n", m.first); logger.error("MEAS: Computing report triggers. MeasId=%d has invalid report or object settings", m.first);
continue; continue;
} }
report_cfg_to_add_mod_s& report_cfg = reportConfigList.at(m.second.report_cfg_id); report_cfg_to_add_mod_s& report_cfg = reportConfigList.at(m.second.report_cfg_id);
meas_obj_to_add_mod_s& meas_obj = measObjectsList.at(m.second.meas_obj_id); meas_obj_to_add_mod_s& meas_obj = measObjectsList.at(m.second.meas_obj_id);
log_h->debug("MEAS: Calculating trigger for MeasId=%d, ObjectId=%d (Type %s), ReportId=%d (Type %s)\n", logger.debug("MEAS: Calculating trigger for MeasId=%d, ObjectId=%d (Type %s), ReportId=%d (Type %s)",
m.first, m.first,
m.second.meas_obj_id, m.second.meas_obj_id,
report_cfg.report_cfg.type().to_string().c_str(), report_cfg.report_cfg.type().to_string().c_str(),
@ -1040,7 +1039,7 @@ void rrc::rrc_meas::var_meas_cfg::eval_triggers()
m.first, report_cfg.report_cfg.report_cfg_inter_rat(), meas_obj.meas_obj.meas_obj_nr_r15()); m.first, report_cfg.report_cfg.report_cfg_inter_rat(), meas_obj.meas_obj.meas_obj_nr_r15());
#endif #endif
else { else {
log_h->error("Unsupported combination of measurement object type %s and report config type %s \n", logger.error("Unsupported combination of measurement object type %s and report config type %s ",
meas_obj.meas_obj.type().to_string().c_str(), meas_obj.meas_obj.type().to_string().c_str(),
report_cfg.report_cfg.type().to_string().c_str()); report_cfg.report_cfg.type().to_string().c_str());
} }
@ -1094,17 +1093,17 @@ std::list<meas_obj_to_add_mod_s> rrc::rrc_meas::var_meas_cfg::get_active_objects
r.push_back(measObjectsList.at(m.second.meas_obj_id)); r.push_back(measObjectsList.at(m.second.meas_obj_id));
} }
} }
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
log_h->debug("MEAS: Returning %zd active objects\n", r.size()); logger.debug("MEAS: Returning %zd active objects", r.size());
for (auto& o : r) { for (auto& o : r) {
switch (o.meas_obj.type().value) { switch (o.meas_obj.type().value) {
case meas_obj_to_add_mod_s::meas_obj_c_::types_opts::meas_obj_eutra: case meas_obj_to_add_mod_s::meas_obj_c_::types_opts::meas_obj_eutra:
log_h->debug("MEAS: carrier_freq=%d, %u cells\n", logger.debug("MEAS: carrier_freq=%d, %u cells",
o.meas_obj.meas_obj_eutra().carrier_freq, o.meas_obj.meas_obj_eutra().carrier_freq,
o.meas_obj.meas_obj_eutra().cells_to_add_mod_list.size()); o.meas_obj.meas_obj_eutra().cells_to_add_mod_list.size());
break; break;
case meas_obj_to_add_mod_s::meas_obj_c_::types_opts::meas_obj_nr_r15: case meas_obj_to_add_mod_s::meas_obj_c_::types_opts::meas_obj_nr_r15:
log_h->debug("MEAS: NR: carrier_freq=%d\n", o.meas_obj.meas_obj_nr_r15().carrier_freq_r15); logger.debug("MEAS: NR: carrier_freq=%d", o.meas_obj.meas_obj_nr_r15().carrier_freq_r15);
default: default:
break; break;
} }
@ -1117,8 +1116,7 @@ std::list<meas_obj_to_add_mod_s> rrc::rrc_meas::var_meas_cfg::get_active_objects
// Procedure upon handover or reestablishment 5.5.6.1 // Procedure upon handover or reestablishment 5.5.6.1
void rrc::rrc_meas::var_meas_cfg::ho_reest_finish(const uint32_t src_earfcn, const uint32_t dst_earfcn) void rrc::rrc_meas::var_meas_cfg::ho_reest_finish(const uint32_t src_earfcn, const uint32_t dst_earfcn)
{ {
log_h->info( logger.info("MEAS: Actions upon handover and reestablishment, src_earfcn=%d, dst_earfcn=%d", src_earfcn, dst_earfcn);
"MEAS: Actions upon handover and reestablishment, src_earfcn=%d, dst_earfcn=%d\n", src_earfcn, dst_earfcn);
// for each measId included in the measIdList within VarMeasConfig, if the triggerType is set to ‘periodical’, remove // for each measId included in the measIdList within VarMeasConfig, if the triggerType is set to ‘periodical’, remove
// this measId from the measIdList within VarMeasConfig // this measId from the measIdList within VarMeasConfig
@ -1137,10 +1135,10 @@ void rrc::rrc_meas::var_meas_cfg::ho_reest_finish(const uint32_t src_earfcn, con
} }
} }
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
log_h->debug("MEAS: measId before HO\n"); logger.debug("MEAS: measId before HO");
for (auto& m : measIdList) { for (auto& m : measIdList) {
log_h->debug("MEAS: measId=%d, measObjectId=%d\n", m.first, m.second.meas_obj_id); logger.debug("MEAS: measId=%d, measObjectId=%d", m.first, m.second.meas_obj_id);
} }
} }
@ -1152,8 +1150,9 @@ void rrc::rrc_meas::var_meas_cfg::ho_reest_finish(const uint32_t src_earfcn, con
[&src_earfcn](const std::pair<uint32_t, meas_obj_to_add_mod_s>& c) { [&src_earfcn](const std::pair<uint32_t, meas_obj_to_add_mod_s>& c) {
return c.second.meas_obj.meas_obj_eutra().carrier_freq == src_earfcn; return c.second.meas_obj.meas_obj_eutra().carrier_freq == src_earfcn;
}); });
auto dst_obj = std::find_if( auto dst_obj = std::find_if(measObjectsList.begin(),
measObjectsList.begin(), measObjectsList.end(), [&dst_earfcn](const std::pair<uint32_t, meas_obj_to_add_mod_s>& c) { measObjectsList.end(),
[&dst_earfcn](const std::pair<uint32_t, meas_obj_to_add_mod_s>& c) {
return c.second.meas_obj.meas_obj_eutra().carrier_freq == dst_earfcn; return c.second.meas_obj.meas_obj_eutra().carrier_freq == dst_earfcn;
}); });
if (dst_obj != measObjectsList.end()) { if (dst_obj != measObjectsList.end()) {
@ -1183,10 +1182,10 @@ void rrc::rrc_meas::var_meas_cfg::ho_reest_finish(const uint32_t src_earfcn, con
} }
} }
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
log_h->debug("MEAS: measId after HO\n"); logger.debug("MEAS: measId after HO");
for (auto& m : measIdList) { for (auto& m : measIdList) {
log_h->debug("MEAS: measId=%d, measObjectId=%d\n", m.first, m.second.meas_obj_id); logger.debug("MEAS: measId=%d, measObjectId=%d", m.first, m.second.meas_obj_id);
} }
} }
@ -1205,14 +1204,14 @@ void rrc::rrc_meas::var_meas_cfg::measObject_removal(const meas_obj_to_rem_list_
auto it = measIdList.begin(); auto it = measIdList.begin();
while (it != measIdList.end()) { while (it != measIdList.end()) {
if (it->second.meas_obj_id == l) { if (it->second.meas_obj_id == l) {
log_h->info("MEAS: Removed measId=%d\n", it->first); logger.info("MEAS: Removed measId=%d", it->first);
remove_varmeas_report(it->first); // Remove report before `it` is updated with the next pointer remove_varmeas_report(it->first); // Remove report before `it` is updated with the next pointer
it = measIdList.erase(it); it = measIdList.erase(it);
} else { } else {
it++; it++;
} }
} }
log_h->info("MEAS: Removed measObjectId=%d\n", l); logger.info("MEAS: Removed measObjectId=%d", l);
} }
} }
} }
@ -1240,12 +1239,12 @@ void rrc::rrc_meas::var_meas_cfg::measObject_addmod_eutra(const meas_obj_to_add_
{ {
// Remove cells // Remove cells
if (cfg_obj.cells_to_rem_list_present) { if (cfg_obj.cells_to_rem_list_present) {
log_h->debug("MEAS: Removing %d cells\n", cfg_obj.cells_to_rem_list.size()); logger.debug("MEAS: Removing %d cells", cfg_obj.cells_to_rem_list.size());
apply_remlist_diff(local_obj.cells_to_add_mod_list, cfg_obj.cells_to_rem_list, local_obj.cells_to_add_mod_list); apply_remlist_diff(local_obj.cells_to_add_mod_list, cfg_obj.cells_to_rem_list, local_obj.cells_to_add_mod_list);
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
for (auto& c : local_obj.cells_to_add_mod_list) { for (auto& c : local_obj.cells_to_add_mod_list) {
log_h->debug("MEAS: cell idx=%d, pci=%d, q_offset=%d\n", logger.debug("MEAS: cell idx=%d, pci=%d, q_offset=%d",
c.cell_idx, c.cell_idx,
c.pci, c.pci,
c.cell_individual_offset.to_number()); c.cell_individual_offset.to_number());
@ -1280,19 +1279,19 @@ void rrc::rrc_meas::var_meas_cfg::measObject_addmod_eutra(const meas_obj_to_add_
} }
} }
log_h->info("MEAS: %s objectId=%d, carrier_freq=%d, %u cells, %u black-listed cells\n", logger.info("MEAS: %s objectId=%d, carrier_freq=%d, %u cells, %u black-listed cells",
!entry_exists ? "Added" : "Modified", !entry_exists ? "Added" : "Modified",
l.meas_obj_id, l.meas_obj_id,
local_obj.carrier_freq, local_obj.carrier_freq,
local_obj.cells_to_add_mod_list.size(), local_obj.cells_to_add_mod_list.size(),
local_obj.black_cells_to_add_mod_list.size()); local_obj.black_cells_to_add_mod_list.size());
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
for (auto& c : local_obj.cells_to_add_mod_list) { for (auto& c : local_obj.cells_to_add_mod_list) {
log_h->debug( logger.debug(
"MEAS: cell idx=%d, pci=%d, q_offset=%d\n", c.cell_idx, c.pci, c.cell_individual_offset.to_number()); "MEAS: cell idx=%d, pci=%d, q_offset=%d", c.cell_idx, c.pci, c.cell_individual_offset.to_number());
} }
for (auto& b : local_obj.black_cells_to_add_mod_list) { for (auto& b : local_obj.black_cells_to_add_mod_list) {
log_h->debug("MEAS: black-listed cell idx=%d\n", b.cell_idx); logger.debug("MEAS: black-listed cell idx=%d", b.cell_idx);
} }
} }
} }
@ -1335,14 +1334,14 @@ void rrc::rrc_meas::var_meas_cfg::measObject_addmod_nr_r15(const meas_obj_to_add
} }
} }
log_h->info("MEAS (NR R15): %s objectId=%d, carrier_freq=%d, %u black-listed cells\n", logger.info("MEAS (NR R15): %s objectId=%d, carrier_freq=%d, %u black-listed cells",
!entry_exists ? "Added" : "Modified", !entry_exists ? "Added" : "Modified",
l.meas_obj_id, l.meas_obj_id,
local_obj.carrier_freq_r15, local_obj.carrier_freq_r15,
local_obj.black_cells_to_add_mod_list_r15.size()); local_obj.black_cells_to_add_mod_list_r15.size());
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
for (auto& b : local_obj.black_cells_to_add_mod_list_r15) { for (auto& b : local_obj.black_cells_to_add_mod_list_r15) {
log_h->debug("MEAS: black-listed cell idx=%d\n", b.cell_idx_r15); logger.debug("MEAS: black-listed cell idx=%d", b.cell_idx_r15);
} }
} }
} }
@ -1359,7 +1358,7 @@ void rrc::rrc_meas::var_meas_cfg::measObject_addmod(const meas_obj_to_add_mod_li
measObject_addmod_nr_r15(l); measObject_addmod_nr_r15(l);
break; break;
default: default:
log_h->error("Unsupported measObject type: %s\n", l.meas_obj.type().to_string().c_str()); logger.error("Unsupported measObject type: %s", l.meas_obj.type().to_string().c_str());
break; break;
} }
} }
@ -1376,14 +1375,14 @@ void rrc::rrc_meas::var_meas_cfg::reportConfig_removal(const report_cfg_to_rem_l
auto it = measIdList.begin(); auto it = measIdList.begin();
while (it != measIdList.end()) { while (it != measIdList.end()) {
if (it->second.report_cfg_id == l) { if (it->second.report_cfg_id == l) {
log_h->info("MEAS: Removed measId=%d\n", it->first); logger.info("MEAS: Removed measId=%d", it->first);
remove_varmeas_report(it->first); // Remove report before `it` is updated with the next pointer remove_varmeas_report(it->first); // Remove report before `it` is updated with the next pointer
it = measIdList.erase(it); it = measIdList.erase(it);
} else { } else {
it++; it++;
} }
} }
log_h->info("MEAS: Removed reportObjectId=%d\n", l); logger.info("MEAS: Removed reportObjectId=%d", l);
} }
} }
} }
@ -1410,11 +1409,11 @@ void rrc::rrc_meas::var_meas_cfg::reportConfig_addmod_eutra(const report_cfg_to_
const report_cfg_eutra_s& report_cfg = l.report_cfg.report_cfg_eutra(); const report_cfg_eutra_s& report_cfg = l.report_cfg.report_cfg_eutra();
if (!(report_cfg.trigger_type.type().value == report_cfg_eutra_s::trigger_type_c_::types_opts::event)) { if (!(report_cfg.trigger_type.type().value == report_cfg_eutra_s::trigger_type_c_::types_opts::event)) {
log_h->error("MEAS: Periodical reports not supported. Received in reportConfigId=%d\n", l.report_cfg_id); logger.error("MEAS: Periodical reports not supported. Received in reportConfigId=%d", l.report_cfg_id);
return; return;
} }
bool entry_exists = reportConfig_addmod_to_reportConfigList(l); bool entry_exists = reportConfig_addmod_to_reportConfigList(l);
log_h->info("MEAS: %s reportConfig id=%d, event-type=%s, time-to-trigger=%d ms, reportInterval=%d\n", logger.info("MEAS: %s reportConfig id=%d, event-type=%s, time-to-trigger=%d ms, reportInterval=%d",
!entry_exists ? "Added" : "Modified", !entry_exists ? "Added" : "Modified",
l.report_cfg_id, l.report_cfg_id,
report_cfg.trigger_type.event().event_id.type().to_string().c_str(), report_cfg.trigger_type.event().event_id.type().to_string().c_str(),
@ -1429,11 +1428,11 @@ void rrc::rrc_meas::var_meas_cfg::reportConfig_addmod_interrat(const report_cfg_
{ {
const report_cfg_inter_rat_s& report_cfg = l.report_cfg.report_cfg_inter_rat(); const report_cfg_inter_rat_s& report_cfg = l.report_cfg.report_cfg_inter_rat();
if (!(report_cfg.trigger_type.type().value == report_cfg_inter_rat_s::trigger_type_c_::types_opts::event)) { if (!(report_cfg.trigger_type.type().value == report_cfg_inter_rat_s::trigger_type_c_::types_opts::event)) {
log_h->error("MEAS: Periodical reports not supported. Received in reportConfigId=%d\n", l.report_cfg_id); logger.error("MEAS: Periodical reports not supported. Received in reportConfigId=%d", l.report_cfg_id);
return; return;
} }
bool entry_exists = reportConfig_addmod_to_reportConfigList(l); bool entry_exists = reportConfig_addmod_to_reportConfigList(l);
log_h->info("MEAS: Inter RAT %s reportConfig id=%d, event-type=%s, time-to-trigger=%d ms, reportInterval=%d\n", logger.info("MEAS: Inter RAT %s reportConfig id=%d, event-type=%s, time-to-trigger=%d ms, reportInterval=%d",
!entry_exists ? "Added" : "Modified", !entry_exists ? "Added" : "Modified",
l.report_cfg_id, l.report_cfg_id,
report_cfg.trigger_type.event().event_id.type().to_string().c_str(), report_cfg.trigger_type.event().event_id.type().to_string().c_str(),
@ -1454,7 +1453,7 @@ void rrc::rrc_meas::var_meas_cfg::reportConfig_addmod(const report_cfg_to_add_mo
reportConfig_addmod_interrat(l); reportConfig_addmod_interrat(l);
break; break;
default: default:
log_h->error("MEAS: Unsupported reportConfig type: %s\n", l.report_cfg.type().to_string().c_str()); logger.error("MEAS: Unsupported reportConfig type: %s", l.report_cfg.type().to_string().c_str());
break; break;
} }
} }
@ -1464,16 +1463,17 @@ void rrc::rrc_meas::var_meas_cfg::reportConfig_addmod(const report_cfg_to_add_mo
void rrc::rrc_meas::var_meas_cfg::log_debug_trigger_value_interrat( void rrc::rrc_meas::var_meas_cfg::log_debug_trigger_value_interrat(
const report_cfg_inter_rat_s::trigger_type_c_::event_s_::event_id_c_& e) const report_cfg_inter_rat_s::trigger_type_c_::event_s_::event_id_c_& e)
{ {
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
switch (e.type()) { switch (e.type()) {
case report_cfg_inter_rat_s::trigger_type_c_::event_s_::event_id_c_::types_opts::event_b1_nr_r15: { case report_cfg_inter_rat_s::trigger_type_c_::event_s_::event_id_c_::types_opts::event_b1_nr_r15: {
log_h->debug("MEAS: B1-NR-R15-threashold (%d)=%.1f dBm\n", logger.debug("MEAS: B1-NR-R15-threashold (%d)=%.1f dBm",
e.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15(), e.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15(),
range_to_value_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_rsrp_r15, e.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15())); range_to_value_nr(asn1::rrc::thres_nr_r15_c::types_opts::options::nr_rsrp_r15,
e.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15()));
break; break;
} }
default: default:
log_h->debug("MEAS: Unsupported inter rat trigger type %s\n", e.type().to_string().c_str()); logger.debug("MEAS: Unsupported inter rat trigger type %s", e.type().to_string().c_str());
break; break;
} }
} }
@ -1482,26 +1482,26 @@ void rrc::rrc_meas::var_meas_cfg::log_debug_trigger_value_interrat(
// Warning: Use for Test debug purposes only. Assumes thresholds in RSRP // Warning: Use for Test debug purposes only. Assumes thresholds in RSRP
void rrc::rrc_meas::var_meas_cfg::log_debug_trigger_value_eutra(const eutra_event_s::event_id_c_& e) void rrc::rrc_meas::var_meas_cfg::log_debug_trigger_value_eutra(const eutra_event_s::event_id_c_& e)
{ {
if (log_h->get_level() == LOG_LEVEL_DEBUG) { if (logger.debug.enabled()) {
switch (e.type()) { switch (e.type()) {
case eutra_event_s::event_id_c_::types_opts::event_a1: case eutra_event_s::event_id_c_::types_opts::event_a1:
log_h->debug("MEAS: A1-threshold=%.1f dBm\n", logger.debug("MEAS: A1-threshold=%.1f dBm",
range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a1().a1_thres.thres_rsrp())); range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a1().a1_thres.thres_rsrp()));
break; break;
case eutra_event_s::event_id_c_::types_opts::event_a2: case eutra_event_s::event_id_c_::types_opts::event_a2:
log_h->debug("MEAS: A2-threshold=%.1f dBm\n", logger.debug("MEAS: A2-threshold=%.1f dBm",
range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a2().a2_thres.thres_rsrp())); range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a2().a2_thres.thres_rsrp()));
break; break;
case eutra_event_s::event_id_c_::types_opts::event_a3: case eutra_event_s::event_id_c_::types_opts::event_a3:
log_h->debug("MEAS: A3-offset=%.1f dB\n", logger.debug("MEAS: A3-offset=%.1f dB",
range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a3().a3_offset)); range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a3().a3_offset));
break; break;
case eutra_event_s::event_id_c_::types_opts::event_a4: case eutra_event_s::event_id_c_::types_opts::event_a4:
log_h->debug("MEAS: A4-threshold=%.1f dBm\n", logger.debug("MEAS: A4-threshold=%.1f dBm",
range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a4().a4_thres.thres_rsrp())); range_to_value(report_cfg_eutra_s::trigger_quant_opts::rsrp, e.event_a4().a4_thres.thres_rsrp()));
break; break;
default: default:
log_h->debug("MEAS: Unsupported\n"); logger.debug("MEAS: Unsupported");
break; break;
} }
} }
@ -1516,7 +1516,7 @@ void rrc::rrc_meas::var_meas_cfg::measId_removal(const meas_id_to_rem_list_l& li
if (measIdList.count(l)) { if (measIdList.count(l)) {
measIdList.erase(l); measIdList.erase(l);
remove_varmeas_report(l); remove_varmeas_report(l);
log_h->info("MEAS: Removed measId=%d\n", l); logger.info("MEAS: Removed measId=%d", l);
} }
} }
} }
@ -1527,11 +1527,11 @@ void rrc::rrc_meas::var_meas_cfg::measId_addmod(const meas_id_to_add_mod_list_l&
for (auto& l : list) { for (auto& l : list) {
// configure only if report and object exists // configure only if report and object exists
if (reportConfigList.count(l.report_cfg_id) == 0) { if (reportConfigList.count(l.report_cfg_id) == 0) {
log_h->error("MEAS: Adding measId=%d, reportConfigId=%d doesn't exist\n", l.meas_id, l.report_cfg_id); logger.error("MEAS: Adding measId=%d, reportConfigId=%d doesn't exist", l.meas_id, l.report_cfg_id);
continue; continue;
} }
if (measObjectsList.count(l.meas_obj_id) == 0) { if (measObjectsList.count(l.meas_obj_id) == 0) {
log_h->error("MEAS: Adding measId=%d, measObjectId=%d doesn't exist\n", l.meas_id, l.meas_obj_id); logger.error("MEAS: Adding measId=%d, measObjectId=%d doesn't exist", l.meas_id, l.meas_obj_id);
continue; continue;
} }
// add/replace entry in VarMeasConfig. Safe to use [] operator here // add/replace entry in VarMeasConfig. Safe to use [] operator here
@ -1540,8 +1540,8 @@ void rrc::rrc_meas::var_meas_cfg::measId_addmod(const meas_id_to_add_mod_list_l&
// remove the measurement reporting entry for this measId from the VarMeasReportList, if included // remove the measurement reporting entry for this measId from the VarMeasReportList, if included
remove_varmeas_report(l.meas_id); remove_varmeas_report(l.meas_id);
log_h->info( logger.info(
"MEAS: AddMod measId=%d, measObjectId=%d, reportConfigId=%d\n", l.meas_id, l.meas_obj_id, l.report_cfg_id); "MEAS: AddMod measId=%d, measObjectId=%d, reportConfigId=%d", l.meas_id, l.meas_obj_id, l.report_cfg_id);
} }
} }
@ -1565,7 +1565,7 @@ void rrc::rrc_meas::var_meas_cfg::quantity_config(const quant_cfg_s& cfg)
filter_a.rsrp = powf(0.5f, (float)k_rsrp / 4.0f); filter_a.rsrp = powf(0.5f, (float)k_rsrp / 4.0f);
filter_a.rsrq = powf(0.5f, (float)k_rsrq / 4.0f); filter_a.rsrq = powf(0.5f, (float)k_rsrq / 4.0f);
log_h->info("MEAS: Quantity configuration k_rsrp=%d, k_rsrq=%d\n", k_rsrp, k_rsrq); logger.info("MEAS: Quantity configuration k_rsrp=%d, k_rsrq=%d", k_rsrp, k_rsrq);
// for each measId included in the measIdList within VarMeasConfig // for each measId included in the measIdList within VarMeasConfig
for (auto& m : measIdList) { for (auto& m : measIdList) {
@ -1632,7 +1632,7 @@ bool rrc::rrc_meas::var_meas_cfg::parse_meas_config(const meas_cfg_s* cfg, bool
ho_reest_finish(src_earfcn, target_earfcn); ho_reest_finish(src_earfcn, target_earfcn);
} }
} else { } else {
log_h->warning("MEAS: Could not get serving cell earfcn\n"); logger.warning("MEAS: Could not get serving cell earfcn");
} }
} }
return true; return true;

102
srsue/src/stack/rrc/rrc_nr.cc
Unescape Escape View File

@ -63,7 +63,7 @@ void rrc_nr::stop()
void rrc_nr::init_core_less() void rrc_nr::init_core_less()
{ {
log_h->info("Creating dummy DRB on LCID=%d\n", args.coreless.drb_lcid); log_h->info("Creating dummy DRB on LCID=%d", args.coreless.drb_lcid);
srslte::rlc_config_t rlc_cnfg = srslte::rlc_config_t::default_rlc_um_nr_config(6); srslte::rlc_config_t rlc_cnfg = srslte::rlc_config_t::default_rlc_um_nr_config(6);
rlc->add_bearer(args.coreless.drb_lcid, rlc_cnfg); rlc->add_bearer(args.coreless.drb_lcid, rlc_cnfg);
@ -83,9 +83,9 @@ void rrc_nr::get_metrics(rrc_nr_metrics_t& m) {}
// Timeout callback interface // Timeout callback interface
void rrc_nr::timer_expired(uint32_t timeout_id) void rrc_nr::timer_expired(uint32_t timeout_id)
{ {
log_h->debug("[NR] Handling Timer Expired\n"); log_h->debug("[NR] Handling Timer Expired");
if (timeout_id == fake_measurement_timer.id()) { if (timeout_id == fake_measurement_timer.id()) {
log_h->debug("[NR] Triggered Fake Measurement\n"); log_h->debug("[NR] Triggered Fake Measurement");
phy_meas_nr_t fake_meas = {}; phy_meas_nr_t fake_meas = {};
std::vector<phy_meas_nr_t> phy_meas_nr; std::vector<phy_meas_nr_t> phy_meas_nr;
@ -113,18 +113,18 @@ void rrc_nr::log_rrc_message(const std::string& source,
const std::string& msg_type) const std::string& msg_type)
{ {
if (log_h->get_level() == srslte::LOG_LEVEL_INFO) { if (log_h->get_level() == srslte::LOG_LEVEL_INFO) {
log_h->info("%s - %s %s (%d B)\n", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), pdu->N_bytes); log_h->info("%s - %s %s (%d B)", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), pdu->N_bytes);
} else if (log_h->get_level() >= srslte::LOG_LEVEL_DEBUG) { } else if (log_h->get_level() >= srslte::LOG_LEVEL_DEBUG) {
asn1::json_writer json_writer; asn1::json_writer json_writer;
msg.to_json(json_writer); msg.to_json(json_writer);
log_h->debug_hex(pdu->msg, log_h->debug_hex(pdu->msg,
pdu->N_bytes, pdu->N_bytes,
"%s - %s %s (%d B)\n", "%s - %s %s (%d B)",
source.c_str(), source.c_str(),
(dir == Rx) ? "Rx" : "Tx", (dir == Rx) ? "Rx" : "Tx",
msg_type.c_str(), msg_type.c_str(),
pdu->N_bytes); pdu->N_bytes);
log_h->debug_long("Content:\n%s\n", json_writer.to_string().c_str()); log_h->debug_long("Content:\n%s", json_writer.to_string().c_str());
} }
} }
@ -136,28 +136,28 @@ void rrc_nr::log_rrc_message(const std::string& source,
const std::string& msg_type) const std::string& msg_type)
{ {
if (log_h->get_level() == srslte::LOG_LEVEL_INFO) { if (log_h->get_level() == srslte::LOG_LEVEL_INFO) {
log_h->info("%s - %s %s (%d B)\n", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), oct.size()); log_h->info("%s - %s %s (%d B)", source.c_str(), (dir == Rx) ? "Rx" : "Tx", msg_type.c_str(), oct.size());
} else if (log_h->get_level() >= srslte::LOG_LEVEL_DEBUG) { } else if (log_h->get_level() >= srslte::LOG_LEVEL_DEBUG) {
asn1::json_writer json_writer; asn1::json_writer json_writer;
msg.to_json(json_writer); msg.to_json(json_writer);
log_h->debug_hex(oct.data(), log_h->debug_hex(oct.data(),
oct.size(), oct.size(),
"%s - %s %s (%d B)\n", "%s - %s %s (%d B)",
source.c_str(), source.c_str(),
(dir == Rx) ? "Rx" : "Tx", (dir == Rx) ? "Rx" : "Tx",
msg_type.c_str(), msg_type.c_str(),
oct.size()); oct.size());
log_h->debug_long("Content:\n%s\n", json_writer.to_string().c_str()); log_h->debug_long("Content:\n%s", json_writer.to_string().c_str());
} }
} }
bool rrc_nr::add_lcid_rb(uint32_t lcid, rb_type_t rb_type, uint32_t rbid) bool rrc_nr::add_lcid_rb(uint32_t lcid, rb_type_t rb_type, uint32_t rbid)
{ {
if (lcid_rb.find(lcid) != lcid_rb.end()) { if (lcid_rb.find(lcid) != lcid_rb.end()) {
log_h->error("Couldn't add RB to LCID. RB %d does exist.\n", rbid); log_h->error("Couldn't add RB to LCID. RB %d does exist.", rbid);
return false; return false;
} else { } else {
log_h->info("Adding lcid %d and radio bearer ID %d with type %s \n", lcid, rbid, (rb_type == Srb) ? "SRB" : "DRB"); log_h->info("Adding lcid %d and radio bearer ID %d with type %s ", lcid, rbid, (rb_type == Srb) ? "SRB" : "DRB");
lcid_rb[lcid].rb_id = rbid; lcid_rb[lcid].rb_id = rbid;
lcid_rb[lcid].rb_type = rb_type; lcid_rb[lcid].rb_type = rb_type;
} }
@ -171,7 +171,7 @@ uint32_t rrc_nr::get_lcid_for_rbid(uint32_t rb_id)
return rb.first; return rb.first;
} }
} }
log_h->error("Couldn't find LCID for rb LCID. RB %d does exist.\n", rb_id); log_h->error("Couldn't find LCID for rb LCID. RB %d does exist.", rb_id);
return 0; return 0;
} }
@ -307,7 +307,7 @@ void rrc_nr::get_eutra_nr_capabilities(srslte::byte_buffer_t* eutra_nr_caps_pdu)
#endif #endif
log_h->debug_hex( log_h->debug_hex(
eutra_nr_caps_pdu->msg, eutra_nr_caps_pdu->N_bytes, "EUTRA-NR capabilities (%u B)\n", eutra_nr_caps_pdu->N_bytes); eutra_nr_caps_pdu->msg, eutra_nr_caps_pdu->N_bytes, "EUTRA-NR capabilities (%u B)", eutra_nr_caps_pdu->N_bytes);
return; return;
} }
@ -324,7 +324,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
// sanity check only for now // sanity check only for now
if (nr_secondary_cell_group_cfg_r15_present == false || sk_counter_r15_present == false || if (nr_secondary_cell_group_cfg_r15_present == false || sk_counter_r15_present == false ||
nr_radio_bearer_cfg1_r15_present == false) { nr_radio_bearer_cfg1_r15_present == false) {
log_h->error("RRC NR Reconfiguration failed sanity check failed\n"); log_h->error("RRC NR Reconfiguration failed sanity check failed");
return false; return false;
} }
@ -337,7 +337,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
err = rrc_recfg.unpack(bref); err = rrc_recfg.unpack(bref);
if (err != asn1::SRSASN_SUCCESS) { if (err != asn1::SRSASN_SUCCESS) {
log_h->error("Could not unpack NR reconfiguration message.\n"); log_h->error("Could not unpack NR reconfiguration message.");
return false; return false;
} }
@ -351,7 +351,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
err = cell_group_cfg.unpack(bref0); err = cell_group_cfg.unpack(bref0);
if (err != asn1::SRSASN_SUCCESS) { if (err != asn1::SRSASN_SUCCESS) {
log_h->error("Could not unpack cell group message message.\n"); log_h->error("Could not unpack cell group message message.");
return false; return false;
} }
@ -361,7 +361,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
cell_group_cfg, cell_group_cfg,
"Secondary Cell Group Config"); "Secondary Cell Group Config");
} else { } else {
log_h->error("Reconfiguration does not contain Secondary Cell Group Config\n"); log_h->error("Reconfiguration does not contain Secondary Cell Group Config");
return false; return false;
} }
} }
@ -370,7 +370,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
err = radio_bearer_cfg.unpack(bref1); err = radio_bearer_cfg.unpack(bref1);
if (err != asn1::SRSASN_SUCCESS) { if (err != asn1::SRSASN_SUCCESS) {
log_h->error("Could not unpack radio bearer config.\n"); log_h->error("Could not unpack radio bearer config.");
return false; return false;
} }
@ -381,7 +381,7 @@ bool rrc_nr::rrc_reconfiguration(bool endc_release_and_add_r15,
sk_counter_r15_present, sk_counter_r15_present,
sk_counter_r15, sk_counter_r15,
radio_bearer_cfg)) { radio_bearer_cfg)) {
log_h->error("Unable to launch NR RRC configuration procedure\n"); log_h->error("Unable to launch NR RRC configuration procedure");
return false; return false;
} else { } else {
callback_list.add_proc(conn_recfg_proc); callback_list.add_proc(conn_recfg_proc);
@ -427,7 +427,7 @@ void rrc_nr::get_nr_capabilities(srslte::byte_buffer_t* nr_caps_pdu)
} }
#endif #endif
log_h->debug_hex(nr_caps_pdu->msg, nr_caps_pdu->N_bytes, "NR capabilities (%u B)\n", nr_caps_pdu->N_bytes); log_h->debug_hex(nr_caps_pdu->msg, nr_caps_pdu->N_bytes, "NR capabilities (%u B)", nr_caps_pdu->N_bytes);
return; return;
}; };
@ -435,13 +435,13 @@ void rrc_nr::phy_meas_stop()
{ {
// possbile race condition for fake_measurement timer, which might be set at the same moment as stopped => fix with // possbile race condition for fake_measurement timer, which might be set at the same moment as stopped => fix with
// phy integration // phy integration
log_h->debug("[NR] Stopping fake measurements\n"); log_h->debug("[NR] Stopping fake measurements");
fake_measurement_timer.stop(); fake_measurement_timer.stop();
} }
void rrc_nr::phy_set_cells_to_meas(uint32_t carrier_freq_r15) void rrc_nr::phy_set_cells_to_meas(uint32_t carrier_freq_r15)
{ {
log_h->debug("[NR] Measuring phy cell %d \n", carrier_freq_r15); log_h->debug("[NR] Measuring phy cell %d ", carrier_freq_r15);
// Start timer for fake measurements // Start timer for fake measurements
auto timer_expire_func = [this](uint32_t tid) { timer_expired(tid); }; auto timer_expire_func = [this](uint32_t tid) { timer_expired(tid); };
fake_measurement_carrier_freq_r15 = carrier_freq_r15; fake_measurement_carrier_freq_r15 = carrier_freq_r15;
@ -451,7 +451,7 @@ void rrc_nr::phy_set_cells_to_meas(uint32_t carrier_freq_r15)
void rrc_nr::configure_sk_counter(uint16_t sk_counter) void rrc_nr::configure_sk_counter(uint16_t sk_counter)
{ {
log_h->info("[NR] Configure new SK counter %d. Update Key for secondary gnb\n", sk_counter); log_h->info("[NR] Configure new SK counter %d. Update Key for secondary gnb", sk_counter);
usim->generate_nr_context(sk_counter, &sec_cfg); usim->generate_nr_context(sk_counter, &sec_cfg);
} }
bool rrc_nr::is_config_pending() bool rrc_nr::is_config_pending()
@ -479,7 +479,7 @@ bool rrc_nr::apply_rlc_add_mod(const rlc_bearer_cfg_s& rlc_bearer_cfg)
add_lcid_rb(lc_ch_id, Srb, srb_id); add_lcid_rb(lc_ch_id, Srb, srb_id);
} }
} else { } else {
log_h->warning("In RLC bearer cfg does not contain served radio bearer\n"); log_h->warning("In RLC bearer cfg does not contain served radio bearer");
return false; return false;
} }
@ -490,13 +490,13 @@ bool rrc_nr::apply_rlc_add_mod(const rlc_bearer_cfg_s& rlc_bearer_cfg)
rlc_bearer_cfg.rlc_cfg.um_bi_dir().ul_um_rlc.sn_field_len_present && rlc_bearer_cfg.rlc_cfg.um_bi_dir().ul_um_rlc.sn_field_len_present &&
rlc_bearer_cfg.rlc_cfg.um_bi_dir().dl_um_rlc.sn_field_len != rlc_bearer_cfg.rlc_cfg.um_bi_dir().dl_um_rlc.sn_field_len !=
rlc_bearer_cfg.rlc_cfg.um_bi_dir().ul_um_rlc.sn_field_len) { rlc_bearer_cfg.rlc_cfg.um_bi_dir().ul_um_rlc.sn_field_len) {
log_h->warning("NR RLC sequence number length is not the same in uplink and downlink\n"); log_h->warning("NR RLC sequence number length is not the same in uplink and downlink");
} }
} else { } else {
log_h->warning("NR RLC type is not unacknowledged mode bidirectional\n"); log_h->warning("NR RLC type is not unacknowledged mode bidirectional");
} }
} else { } else {
log_h->warning("In RLC bearer cfg does not contain rlc cfg\n"); log_h->warning("In RLC bearer cfg does not contain rlc cfg");
return false; return false;
} }
@ -517,20 +517,20 @@ bool rrc_nr::apply_mac_cell_group(const mac_cell_group_cfg_s& mac_cell_group_cfg
sr_cfg_t sr_cfg; sr_cfg_t sr_cfg;
if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list_present) { if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list_present) {
if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list.size() > 1) { if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list.size() > 1) {
log_h->warning("Only handling 1 scheduling request index to add\n"); log_h->warning("Only handling 1 scheduling request index to add");
sr_cfg.dsr_transmax = mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list[1].sr_trans_max; sr_cfg.dsr_transmax = mac_cell_group_cfg.sched_request_cfg.sched_request_to_add_mod_list[1].sr_trans_max;
mac->set_config(sr_cfg); mac->set_config(sr_cfg);
} }
} }
if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_release_list_present) { if (mac_cell_group_cfg.sched_request_cfg.sched_request_to_release_list_present) {
log_h->warning("Not handling sched request to release list\n"); log_h->warning("Not handling sched request to release list");
} }
} }
if (mac_cell_group_cfg.sched_request_cfg_present) if (mac_cell_group_cfg.sched_request_cfg_present)
if (mac_cell_group_cfg.bsr_cfg_present) { if (mac_cell_group_cfg.bsr_cfg_present) {
log_h->debug("Handling MAC BSR config\n"); log_h->debug("Handling MAC BSR config");
srslte::bsr_cfg_t bsr_cfg; srslte::bsr_cfg_t bsr_cfg;
bsr_cfg.periodic_timer = mac_cell_group_cfg.bsr_cfg.periodic_bsr_timer.to_number(); bsr_cfg.periodic_timer = mac_cell_group_cfg.bsr_cfg.periodic_bsr_timer.to_number();
bsr_cfg.retx_timer = mac_cell_group_cfg.bsr_cfg.retx_bsr_timer.to_number(); bsr_cfg.retx_timer = mac_cell_group_cfg.bsr_cfg.retx_bsr_timer.to_number();
@ -538,15 +538,15 @@ bool rrc_nr::apply_mac_cell_group(const mac_cell_group_cfg_s& mac_cell_group_cfg
} }
if (mac_cell_group_cfg.tag_cfg_present) { if (mac_cell_group_cfg.tag_cfg_present) {
log_h->warning("Not handling tag cfg in MAC cell group config\n"); log_h->warning("Not handling tag cfg in MAC cell group config");
} }
if (mac_cell_group_cfg.phr_cfg_present) { if (mac_cell_group_cfg.phr_cfg_present) {
log_h->warning("Not handling phr cfg in MAC cell group config\n"); log_h->warning("Not handling phr cfg in MAC cell group config");
} }
if (mac_cell_group_cfg.skip_ul_tx_dynamic) { if (mac_cell_group_cfg.skip_ul_tx_dynamic) {
log_h->warning("Not handling phr cfg in skip_ul_tx_dynamic cell group config\n"); log_h->warning("Not handling phr cfg in skip_ul_tx_dynamic cell group config");
} }
return true; return true;
} }
@ -554,7 +554,7 @@ bool rrc_nr::apply_mac_cell_group(const mac_cell_group_cfg_s& mac_cell_group_cfg
bool rrc_nr::apply_sp_cell_cfg(const sp_cell_cfg_s& sp_cell_cfg) bool rrc_nr::apply_sp_cell_cfg(const sp_cell_cfg_s& sp_cell_cfg)
{ {
// TODO Setup PHY @andre and @phy interface? // TODO Setup PHY @andre and @phy interface?
log_h->warning("Not handling SP Cell config\n"); log_h->warning("Not handling SP Cell config");
return true; return true;
} }
@ -569,7 +569,7 @@ bool rrc_nr::apply_cell_group_cfg(const cell_group_cfg_s& cell_group_cfg)
apply_mac_cell_group(cell_group_cfg.mac_cell_group_cfg); apply_mac_cell_group(cell_group_cfg.mac_cell_group_cfg);
} }
if (cell_group_cfg.phys_cell_group_cfg_present == true) { if (cell_group_cfg.phys_cell_group_cfg_present == true) {
log_h->warning("Not handling physical cell group config\n"); log_h->warning("Not handling physical cell group config");
} }
if (cell_group_cfg.sp_cell_cfg_present) { if (cell_group_cfg.sp_cell_cfg_present) {
// apply_sp_cell_cfg(cell_group_cfg.sp_cell_cfg); // apply_sp_cell_cfg(cell_group_cfg.sp_cell_cfg);
@ -580,7 +580,7 @@ bool rrc_nr::apply_cell_group_cfg(const cell_group_cfg_s& cell_group_cfg)
bool rrc_nr::apply_drb_add_mod(const drb_to_add_mod_s& drb_cfg) bool rrc_nr::apply_drb_add_mod(const drb_to_add_mod_s& drb_cfg)
{ {
if (!drb_cfg.pdcp_cfg_present) { if (!drb_cfg.pdcp_cfg_present) {
log_h->error("Cannot add DRB - incomplete configuration\n"); log_h->error("Cannot add DRB - incomplete configuration");
return false; return false;
} }
@ -588,17 +588,17 @@ bool rrc_nr::apply_drb_add_mod(const drb_to_add_mod_s& drb_cfg)
// Setup PDCP // Setup PDCP
if (!(drb_cfg.pdcp_cfg.drb_present == true)) { if (!(drb_cfg.pdcp_cfg.drb_present == true)) {
log_h->error("PDCP config does not contain DRB config\n"); log_h->error("PDCP config does not contain DRB config");
return false; return false;
} }
if (!(drb_cfg.cn_assoc_present == true)) { if (!(drb_cfg.cn_assoc_present == true)) {
log_h->error("DRB config does not contain an associated cn\n"); log_h->error("DRB config does not contain an associated cn");
return false; return false;
} }
if (!(drb_cfg.cn_assoc.type() == drb_to_add_mod_s::cn_assoc_c_::types_opts::eps_bearer_id)) { if (!(drb_cfg.cn_assoc.type() == drb_to_add_mod_s::cn_assoc_c_::types_opts::eps_bearer_id)) {
log_h->error("CN associtaion type not supported %s \n", drb_cfg.cn_assoc.type().to_string().c_str()); log_h->error("CN associtaion type not supported %s ", drb_cfg.cn_assoc.type().to_string().c_str());
return false; return false;
} }
@ -606,7 +606,7 @@ bool rrc_nr::apply_drb_add_mod(const drb_to_add_mod_s& drb_cfg)
if (drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl_present && drb_cfg.pdcp_cfg.drb.pdcp_sn_size_ul_present && if (drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl_present && drb_cfg.pdcp_cfg.drb.pdcp_sn_size_ul_present &&
(drb_cfg.pdcp_cfg.drb.pdcp_sn_size_ul.to_number() != drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl.to_number())) { (drb_cfg.pdcp_cfg.drb.pdcp_sn_size_ul.to_number() != drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl.to_number())) {
log_h->warning("PDCP SN size in UL and DL are not the same. make_drb_pdcp_config_t will use the DL SN size %d \n", log_h->warning("PDCP SN size in UL and DL are not the same. make_drb_pdcp_config_t will use the DL SN size %d ",
drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl.to_number()); drb_cfg.pdcp_cfg.drb.pdcp_sn_size_dl.to_number());
} }
@ -622,7 +622,7 @@ bool rrc_nr::apply_security_cfg(const security_cfg_s& security_cfg)
// TODO derive correct keys // TODO derive correct keys
if (security_cfg.key_to_use_present) { if (security_cfg.key_to_use_present) {
if (security_cfg.key_to_use.value != security_cfg_s::key_to_use_opts::options::secondary) { if (security_cfg.key_to_use.value != security_cfg_s::key_to_use_opts::options::secondary) {
log_h->warning("Only secondary key supported yet\n"); log_h->warning("Only secondary key supported yet");
} }
} }
@ -641,7 +641,7 @@ bool rrc_nr::apply_security_cfg(const security_cfg_s& security_cfg)
sec_cfg.cipher_algo = CIPHERING_ALGORITHM_ID_128_EEA3; sec_cfg.cipher_algo = CIPHERING_ALGORITHM_ID_128_EEA3;
break; break;
default: default:
log_h->warning("Unsupported algorithm\n"); log_h->warning("Unsupported algorithm");
break; break;
} }
@ -660,7 +660,7 @@ bool rrc_nr::apply_security_cfg(const security_cfg_s& security_cfg)
sec_cfg.integ_algo = INTEGRITY_ALGORITHM_ID_128_EIA3; sec_cfg.integ_algo = INTEGRITY_ALGORITHM_ID_128_EIA3;
break; break;
default: default:
log_h->warning("Unsupported algorithm\n"); log_h->warning("Unsupported algorithm");
break; break;
} }
} }
@ -704,19 +704,19 @@ proc_outcome_t rrc_nr::connection_reconf_no_ho_proc::init(const bool
const uint32_t sk_counter_r15, const uint32_t sk_counter_r15,
const asn1::rrc_nr::radio_bearer_cfg_s& radio_bearer_cfg) const asn1::rrc_nr::radio_bearer_cfg_s& radio_bearer_cfg)
{ {
Info("Starting...\n"); Info("Starting...");
Info("Applying Cell Group Cfg\n"); Info("Applying Cell Group Cfg");
if (!rrc_ptr->apply_cell_group_cfg(cell_group_cfg)) { if (!rrc_ptr->apply_cell_group_cfg(cell_group_cfg)) {
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (sk_counter_r15_present) { if (sk_counter_r15_present) {
Info("Applying Cell Group Cfg\n"); Info("Applying Cell Group Cfg");
rrc_ptr->configure_sk_counter((uint16_t)sk_counter_r15); rrc_ptr->configure_sk_counter((uint16_t)sk_counter_r15);
} }
Info("Applying Radio Bearer Cfg\n"); Info("Applying Radio Bearer Cfg");
if (!rrc_ptr->apply_radio_bearer_cfg(radio_bearer_cfg)) { if (!rrc_ptr->apply_radio_bearer_cfg(radio_bearer_cfg)) {
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -726,21 +726,21 @@ proc_outcome_t rrc_nr::connection_reconf_no_ho_proc::init(const bool
proc_outcome_t rrc_nr::connection_reconf_no_ho_proc::react(const bool& config_complete) proc_outcome_t rrc_nr::connection_reconf_no_ho_proc::react(const bool& config_complete)
{ {
if (not config_complete) { if (not config_complete) {
Error("Failed to config PHY\n"); Error("Failed to config PHY");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
rrc_ptr->rrc_eutra->nr_rrc_con_reconfig_complete(true); rrc_ptr->rrc_eutra->nr_rrc_con_reconfig_complete(true);
Info("Reconfig NR return successful\n"); Info("Reconfig NR return successful");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
void rrc_nr::connection_reconf_no_ho_proc::then(const srslte::proc_state_t& result) void rrc_nr::connection_reconf_no_ho_proc::then(const srslte::proc_state_t& result)
{ {
if (result.is_success()) { if (result.is_success()) {
Info("Finished %s successfully\n", name()); Info("Finished %s successfully", name());
srslte::console("RRC NR reconfiguration successful.\n"); srslte::console("RRC NR reconfiguration successful.");
return; return;
} }

301
srsue/src/stack/rrc/rrc_procedures.cc
Unescape Escape View File

@ -17,10 +17,10 @@
#include "srsue/hdr/stack/rrc/rrc_meas.h" #include "srsue/hdr/stack/rrc/rrc_meas.h"
#include <inttypes.h> // for printing uint64_t #include <inttypes.h> // for printing uint64_t
#define Error(fmt, ...) rrc_ptr->rrc_log->error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define Error(fmt, ...) rrc_ptr->logger.error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define Warning(fmt, ...) rrc_ptr->rrc_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define Warning(fmt, ...) rrc_ptr->logger.warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define Info(fmt, ...) rrc_ptr->rrc_log->info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define Info(fmt, ...) rrc_ptr->logger.info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define Debug(fmt, ...) rrc_ptr->rrc_log->debug("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define Debug(fmt, ...) rrc_ptr->logger.debug("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
namespace srsue { namespace srsue {
@ -36,10 +36,10 @@ rrc::cell_search_proc::cell_search_proc(rrc* parent_) : rrc_ptr(parent_) {}
/* Searches for a cell in the current frequency and retrieves SIB1 if not retrieved yet */ /* Searches for a cell in the current frequency and retrieves SIB1 if not retrieved yet */
proc_outcome_t rrc::cell_search_proc::init() proc_outcome_t rrc::cell_search_proc::init()
{ {
Info("Starting...\n"); Info("Starting...");
state = state_t::phy_cell_search; state = state_t::phy_cell_search;
if (not rrc_ptr->phy_ctrl->start_cell_search(rrc_ptr->cell_searcher)) { if (not rrc_ptr->phy_ctrl->start_cell_search(rrc_ptr->cell_searcher)) {
Warning("Failed to initiate Cell Search.\n"); Warning("Failed to initiate Cell Search.");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -68,22 +68,22 @@ proc_outcome_t rrc::cell_search_proc::step_si_acquire()
} }
// SI Acquire has completed // SI Acquire has completed
if (si_acquire_fut.is_error()) { if (si_acquire_fut.is_error()) {
Error("Failed SI acquire for SIB0\n"); Error("Failed SI acquire for SIB0");
search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND; search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND;
return proc_outcome_t::success; return proc_outcome_t::success;
} }
Info("Completed successfully\n"); Info("Completed successfully");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_cell_t& new_cell) proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_cell_t& new_cell)
{ {
Info("Cell found in this frequency. Setting new serving cell EARFCN=%d PCI=%d ...\n", new_cell.earfcn, new_cell.pci); Info("Cell found in this frequency. Setting new serving cell EARFCN=%d PCI=%d ...", new_cell.earfcn, new_cell.pci);
// Create a cell with NaN RSRP. Will be updated by new_phy_meas() during SIB search. // Create a cell with NaN RSRP. Will be updated by new_phy_meas() during SIB search.
if (not rrc_ptr->meas_cells.add_meas_cell( if (not rrc_ptr->meas_cells.add_meas_cell(
unique_cell_t(new meas_cell_eutra(new_cell, rrc_ptr->task_sched.get_unique_timer())))) { unique_cell_t(new meas_cell_eutra(new_cell, rrc_ptr->task_sched.get_unique_timer())))) {
Error("Could not add new found cell\n"); Error("Could not add new found cell");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -92,7 +92,7 @@ proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_cell_t& new_ce
// set new serving cell in PHY // set new serving cell in PHY
state = state_t::phy_cell_select; state = state_t::phy_cell_select;
if (not rrc_ptr->phy_ctrl->start_cell_select(rrc_ptr->meas_cells.serving_cell().phy_cell, rrc_ptr->cell_searcher)) { if (not rrc_ptr->phy_ctrl->start_cell_select(rrc_ptr->meas_cells.serving_cell().phy_cell, rrc_ptr->cell_searcher)) {
Error("Couldn't start phy cell selection\n"); Error("Couldn't start phy cell selection");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -105,14 +105,14 @@ proc_outcome_t rrc::cell_search_proc::step_wait_measurement()
} }
if (rrc_ptr->meas_cells.serving_cell().has_sib1()) { if (rrc_ptr->meas_cells.serving_cell().has_sib1()) {
Info("Cell has SIB1\n"); Info("Cell has SIB1");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
Info("Cell has no SIB1. Obtaining SIB1...\n"); Info("Cell has no SIB1. Obtaining SIB1...");
if (not rrc_ptr->si_acquirer.launch(&si_acquire_fut, 0)) { if (not rrc_ptr->si_acquirer.launch(&si_acquire_fut, 0)) {
// disallow concurrent si_acquire // disallow concurrent si_acquire
Error("SI Acquire is already running...\n"); Error("SI Acquire is already running...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
state = state_t::si_acquire; state = state_t::si_acquire;
@ -122,24 +122,24 @@ proc_outcome_t rrc::cell_search_proc::step_wait_measurement()
proc_outcome_t rrc::cell_search_proc::react(const bool& cs_ret) proc_outcome_t rrc::cell_search_proc::react(const bool& cs_ret)
{ {
if (state != state_t::phy_cell_select) { if (state != state_t::phy_cell_select) {
Warning("Received unexpected cell search result\n"); Warning("Received unexpected cell search result");
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
if (not cs_ret) { if (not cs_ret) {
Error("Couldn't select new serving cell\n"); Error("Couldn't select new serving cell");
search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND; search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND;
return proc_outcome_t::success; return proc_outcome_t::success;
} }
if (not rrc_ptr->phy->cell_is_camping()) { if (not rrc_ptr->phy->cell_is_camping()) {
Warning("Could not camp on found cell.\n"); Warning("Could not camp on found cell.");
search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND; search_result.cs_ret.found = cell_search_ret_t::CELL_NOT_FOUND;
return proc_outcome_t::success; return proc_outcome_t::success;
} }
if (not std::isnormal(rrc_ptr->meas_cells.serving_cell().get_rsrp())) { if (not std::isnormal(rrc_ptr->meas_cells.serving_cell().get_rsrp())) {
Info("No valid measurement found for the serving cell. Wait for valid measurement...\n"); Info("No valid measurement found for the serving cell. Wait for valid measurement...");
} }
state = state_t::wait_measurement; state = state_t::wait_measurement;
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -148,7 +148,7 @@ proc_outcome_t rrc::cell_search_proc::react(const bool& cs_ret)
proc_outcome_t rrc::cell_search_proc::react(const phy_controller::cell_srch_res& event) proc_outcome_t rrc::cell_search_proc::react(const phy_controller::cell_srch_res& event)
{ {
if (state != state_t::phy_cell_search) { if (state != state_t::phy_cell_search) {
Error("Received unexpected cell search result\n"); Error("Received unexpected cell search result");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
search_result = event; search_result = event;
@ -236,7 +236,7 @@ compute_si_window(uint32_t tti, uint32_t sib_index, uint32_t n, uint32_t T, cons
rrc::si_acquire_proc::si_acquire_proc(rrc* parent_) : rrc::si_acquire_proc::si_acquire_proc(rrc* parent_) :
rrc_ptr(parent_), rrc_ptr(parent_),
log_h(srslte::logmap::get("RRC")), logger(srslog::fetch_basic_logger("RRC")),
si_acq_timeout(rrc_ptr->task_sched.get_unique_timer()), si_acq_timeout(rrc_ptr->task_sched.get_unique_timer()),
si_acq_retry_timer(rrc_ptr->task_sched.get_unique_timer()) si_acq_retry_timer(rrc_ptr->task_sched.get_unique_timer())
{ {
@ -252,22 +252,22 @@ proc_outcome_t rrc::si_acquire_proc::init(uint32_t sib_index_)
{ {
// make sure we dont already have the SIB of interest // make sure we dont already have the SIB of interest
if (rrc_ptr->meas_cells.serving_cell().has_sib(sib_index_)) { if (rrc_ptr->meas_cells.serving_cell().has_sib(sib_index_)) {
Info("The UE has already acquired SIB%d\n", sib_index + 1); Info("The UE has already acquired SIB%d", sib_index + 1);
return proc_outcome_t::success; return proc_outcome_t::success;
} }
Info("Starting SI Acquisition procedure for SIB%d\n", sib_index_ + 1); Info("Starting SI Acquisition procedure for SIB%d", sib_index_ + 1);
// make sure SIB1 is captured before other SIBs // make sure SIB1 is captured before other SIBs
sib_index = sib_index_; sib_index = sib_index_;
if (sib_index > 0 and not rrc_ptr->meas_cells.serving_cell().has_sib1()) { if (sib_index > 0 and not rrc_ptr->meas_cells.serving_cell().has_sib1()) {
Error("Trying to acquire SIB%d but SIB1 not received yet\n", sib_index + 1); Error("Trying to acquire SIB%d but SIB1 not received yet", sib_index + 1);
return proc_outcome_t::error; return proc_outcome_t::error;
} }
// compute the si-Periodicity and schedInfoList index // compute the si-Periodicity and schedInfoList index
auto ret = compute_si_periodicity_and_idx(sib_index, rrc_ptr->meas_cells.serving_cell().sib1ptr()); auto ret = compute_si_periodicity_and_idx(sib_index, rrc_ptr->meas_cells.serving_cell().sib1ptr());
if (ret.second < 0) { if (ret.second < 0) {
Info("Could not find SIB%d scheduling in SIB1\n", sib_index + 1); Info("Could not find SIB%d scheduling in SIB1", sib_index + 1);
return proc_outcome_t::error; return proc_outcome_t::error;
} }
period = ret.first; // si-Periodicity period = ret.first; // si-Periodicity
@ -289,9 +289,9 @@ void rrc::si_acquire_proc::then(const srslte::proc_state_t& result)
si_acq_timeout.stop(); si_acq_timeout.stop();
if (result.is_success()) { if (result.is_success()) {
Info("SIB%d acquired successfully\n", sib_index + 1); Info("SIB%d acquired successfully", sib_index + 1);
} else { } else {
Error("Failed to acquire SIB%d\n", sib_index + 1); Error("Failed to acquire SIB%d", sib_index + 1);
} }
} }
@ -305,7 +305,7 @@ void rrc::si_acquire_proc::start_si_acquire()
compute_si_window(tti.to_uint(), sib_index, sched_index, period, rrc_ptr->meas_cells.serving_cell().sib1ptr()); compute_si_window(tti.to_uint(), sib_index, sched_index, period, rrc_ptr->meas_cells.serving_cell().sib1ptr());
tti_point si_win_start = tti_point{ret.first}; tti_point si_win_start = tti_point{ret.first};
if (si_win_start < tti) { if (si_win_start < tti) {
Error("The SI Window start was incorrectly calculated. si_win_start=%d, tti=%d\n", Error("The SI Window start was incorrectly calculated. si_win_start=%d, tti=%d",
si_win_start.to_uint(), si_win_start.to_uint(),
tti.to_uint()); tti.to_uint());
return; return;
@ -320,7 +320,7 @@ void rrc::si_acquire_proc::start_si_acquire()
si_acq_retry_timer.set(tics_until_si_retry); si_acq_retry_timer.set(tics_until_si_retry);
si_acq_retry_timer.run(); si_acq_retry_timer.run();
Info("Instructed MAC to search for SIB%d, win_start=%d, win_len=%d, period=%d, sched_index=%d\n", Info("Instructed MAC to search for SIB%d, win_start=%d, win_len=%d, period=%d, sched_index=%d",
sib_index + 1, sib_index + 1,
si_win_start.to_uint(), si_win_start.to_uint(),
si_win_len, si_win_len,
@ -341,16 +341,16 @@ proc_outcome_t rrc::si_acquire_proc::react(si_acq_timer_expired ev)
// retry si acquire // retry si acquire
if (ev.timer_id == si_acq_retry_timer.id()) { if (ev.timer_id == si_acq_retry_timer.id()) {
Info("SI Acquire Retry Timeout for SIB%d\n", sib_index + 1); Info("SI Acquire Retry Timeout for SIB%d", sib_index + 1);
start_si_acquire(); start_si_acquire();
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
// timeout. SI acquire failed // timeout. SI acquire failed
if (ev.timer_id == si_acq_timeout.id()) { if (ev.timer_id == si_acq_timeout.id()) {
Error("Timeout while acquiring SIB%d\n", sib_index + 1); Error("Timeout while acquiring SIB%d", sib_index + 1);
} else { } else {
Error("Unrecognized timer id\n"); Error("Unrecognized timer id");
} }
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -360,8 +360,7 @@ proc_outcome_t rrc::si_acquire_proc::react(si_acq_timer_expired ev)
*************************************/ *************************************/
rrc::serving_cell_config_proc::serving_cell_config_proc(rrc* parent_) : rrc::serving_cell_config_proc::serving_cell_config_proc(rrc* parent_) :
rrc_ptr(parent_), rrc_ptr(parent_), logger(srslog::fetch_basic_logger("RRC"))
log_h(srslte::logmap::get("RRC"))
{} {}
/* /*
@ -374,10 +373,10 @@ proc_outcome_t rrc::serving_cell_config_proc::init(const std::vector<uint32_t>&
std::sort(required_sibs.begin(), required_sibs.end()); std::sort(required_sibs.begin(), required_sibs.end());
required_sibs.erase(std::unique(required_sibs.begin(), required_sibs.end()), required_sibs.end()); required_sibs.erase(std::unique(required_sibs.begin(), required_sibs.end()), required_sibs.end());
Info("Starting a Serving Cell Configuration Procedure\n"); Info("Starting a Serving Cell Configuration Procedure");
if (not rrc_ptr->phy->cell_is_camping()) { if (not rrc_ptr->phy->cell_is_camping()) {
Error("Trying to configure Cell while not camping on it\n"); Error("Trying to configure Cell while not camping on it");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -394,9 +393,9 @@ srslte::proc_outcome_t rrc::serving_cell_config_proc::launch_sib_acquire()
uint32_t required_sib = required_sibs[req_idx]; uint32_t required_sib = required_sibs[req_idx];
if (not rrc_ptr->meas_cells.serving_cell().has_sib(required_sib)) { if (not rrc_ptr->meas_cells.serving_cell().has_sib(required_sib)) {
if (required_sib < 2 or rrc_ptr->meas_cells.serving_cell().is_sib_scheduled(required_sib)) { if (required_sib < 2 or rrc_ptr->meas_cells.serving_cell().is_sib_scheduled(required_sib)) {
Info("Cell has no SIB%d. Obtaining SIB%d\n", required_sib + 1, required_sib + 1); Info("Cell has no SIB%d. Obtaining SIB%d", required_sib + 1, required_sib + 1);
if (not rrc_ptr->si_acquirer.launch(&si_acquire_fut, required_sib)) { if (not rrc_ptr->si_acquirer.launch(&si_acquire_fut, required_sib)) {
Error("SI Acquire is already running...\n"); Error("SI Acquire is already running...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
// wait for si acquire to finish // wait for si acquire to finish
@ -405,7 +404,7 @@ srslte::proc_outcome_t rrc::serving_cell_config_proc::launch_sib_acquire()
// SIB is not scheduled in SchedInfoList. Skipping it... // SIB is not scheduled in SchedInfoList. Skipping it...
} else { } else {
// UE had SIB already. Handle its SIB // UE had SIB already. Handle its SIB
Info("Cell has SIB%d\n", required_sib + 1); Info("Cell has SIB%d", required_sib + 1);
switch (required_sib) { switch (required_sib) {
case 1: case 1:
rrc_ptr->handle_sib2(); rrc_ptr->handle_sib2();
@ -419,7 +418,7 @@ srslte::proc_outcome_t rrc::serving_cell_config_proc::launch_sib_acquire()
} }
} }
Info("Serving Cell Configuration Procedure has finished successfully\n"); Info("Serving Cell Configuration Procedure has finished successfully");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
@ -431,7 +430,7 @@ proc_outcome_t rrc::serving_cell_config_proc::step()
uint32_t required_sib = required_sibs[req_idx]; uint32_t required_sib = required_sibs[req_idx];
if (si_acquire_fut.is_error() or not rrc_ptr->meas_cells.serving_cell().has_sib(required_sib)) { if (si_acquire_fut.is_error() or not rrc_ptr->meas_cells.serving_cell().has_sib(required_sib)) {
if (required_sib < 2) { if (required_sib < 2) {
log_h->warning("Serving Cell Configuration has failed\n"); logger.warning("Serving Cell Configuration has failed");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
} }
@ -505,21 +504,21 @@ proc_outcome_t rrc::cell_selection_proc::init(std::vector<uint32_t> required_sib
// Skip cell selection if serving cell is suitable and there are no stronger neighbours in same earfcn // Skip cell selection if serving cell is suitable and there are no stronger neighbours in same earfcn
if (is_serv_cell_suitable() and not stronger_neigh) { if (is_serv_cell_suitable() and not stronger_neigh) {
Debug("Skipping cell selection procedure as there are no stronger neighbours in same EARFCN.\n"); Debug("Skipping cell selection procedure as there are no stronger neighbours in same EARFCN.");
return set_proc_complete(); return set_proc_complete();
} }
Info("Starting...\n"); Info("Starting...");
Info("Current neighbor cells: [%s]\n", meas_cells->print_neighbour_cells().c_str()); Info("Current neighbor cells: [%s]", meas_cells->print_neighbour_cells().c_str());
Info("Current PHY state: %s\n", rrc_ptr->phy_ctrl->is_in_sync() ? "in-sync" : "out-of-sync"); Info("Current PHY state: %s", rrc_ptr->phy_ctrl->is_in_sync() ? "in-sync" : "out-of-sync");
if (meas_cells->serving_cell().has_sib3()) { if (meas_cells->serving_cell().has_sib3()) {
Info("Cell selection criteria: Qrxlevmin=%f, Qrxlevminoffset=%f\n", Info("Cell selection criteria: Qrxlevmin=%f, Qrxlevminoffset=%f",
rrc_ptr->cell_resel_cfg.Qrxlevmin, rrc_ptr->cell_resel_cfg.Qrxlevmin,
rrc_ptr->cell_resel_cfg.Qrxlevminoffset); rrc_ptr->cell_resel_cfg.Qrxlevminoffset);
} else { } else {
Info("Cell selection criteria: not available\n"); Info("Cell selection criteria: not available");
} }
Info("Current serving cell: %s\n", meas_cells->serving_cell().to_string().c_str()); Info("Current serving cell: %s", meas_cells->serving_cell().to_string().c_str());
neigh_index = 0; neigh_index = 0;
cs_result = cs_result_t::no_cell; cs_result = cs_result_t::no_cell;
@ -564,7 +563,7 @@ proc_outcome_t rrc::cell_selection_proc::start_next_cell_selection()
// If any of the known cells meets the selection criteria or could not be selected, search again. // If any of the known cells meets the selection criteria or could not be selected, search again.
if (not cell_search_called) { if (not cell_search_called) {
Info("Could not select any known cell. Searching new cells\n"); Info("Could not select any known cell. Searching new cells");
state = search_state_t::cell_search; state = search_state_t::cell_search;
cell_search_called = true; cell_search_called = true;
if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) { if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) {
@ -578,7 +577,7 @@ proc_outcome_t rrc::cell_selection_proc::start_next_cell_selection()
proc_outcome_t rrc::cell_selection_proc::react(const bool& cell_selection_result) proc_outcome_t rrc::cell_selection_proc::react(const bool& cell_selection_result)
{ {
if (state != search_state_t::cell_selection) { if (state != search_state_t::cell_selection) {
Warning("Unexpected cell selection event received\n"); Warning("Unexpected cell selection event received");
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -592,7 +591,7 @@ proc_outcome_t rrc::cell_selection_proc::react(const bool& cell_selection_result
} }
} }
Info("Cell selection criteria not passed.\n"); Info("Cell selection criteria not passed.");
discard_serving = not is_same_cell(init_serv_cell, meas_cells->serving_cell()); discard_serving = not is_same_cell(init_serv_cell, meas_cells->serving_cell());
return start_next_cell_selection(); return start_next_cell_selection();
@ -603,7 +602,7 @@ srslte::proc_outcome_t rrc::cell_selection_proc::start_phy_cell_selection(const
if (not is_same_cell(cell, meas_cells->serving_cell())) { if (not is_same_cell(cell, meas_cells->serving_cell())) {
rrc_ptr->set_serving_cell(cell.phy_cell, discard_serving); rrc_ptr->set_serving_cell(cell.phy_cell, discard_serving);
discard_serving = false; discard_serving = false;
Info("Set serving cell: %s\n", meas_cells->serving_cell().to_string().c_str()); Info("Set serving cell: %s", meas_cells->serving_cell().to_string().c_str());
} else { } else {
// in case the cell had already been selected // in case the cell had already been selected
if (is_serv_cell_suitable()) { if (is_serv_cell_suitable()) {
@ -616,7 +615,7 @@ srslte::proc_outcome_t rrc::cell_selection_proc::start_phy_cell_selection(const
state = search_state_t::cell_selection; state = search_state_t::cell_selection;
if (not rrc_ptr->phy_ctrl->start_cell_select(meas_cells->serving_cell().phy_cell, rrc_ptr->cell_selector)) { if (not rrc_ptr->phy_ctrl->start_cell_select(meas_cells->serving_cell().phy_cell, rrc_ptr->cell_selector)) {
Error("Failed to launch PHY Cell Selection\n"); Error("Failed to launch PHY Cell Selection");
return set_proc_complete(); return set_proc_complete();
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -624,10 +623,10 @@ srslte::proc_outcome_t rrc::cell_selection_proc::start_phy_cell_selection(const
srslte::proc_outcome_t rrc::cell_selection_proc::start_sib_acquisition() srslte::proc_outcome_t rrc::cell_selection_proc::start_sib_acquisition()
{ {
Info("PHY is camping on serving cell, but SIBs need to be acquired\n"); Info("PHY is camping on serving cell, but SIBs need to be acquired");
state = search_state_t::cell_config; state = search_state_t::cell_config;
if (not rrc_ptr->serv_cell_cfg.launch(&serv_cell_cfg_fut, required_sibs)) { if (not rrc_ptr->serv_cell_cfg.launch(&serv_cell_cfg_fut, required_sibs)) {
Warning("Failed to launch %s procedure\n", rrc_ptr->serv_cell_cfg.get()->name()); Warning("Failed to launch %s procedure", rrc_ptr->serv_cell_cfg.get()->name());
return set_proc_complete(); return set_proc_complete();
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -654,7 +653,7 @@ proc_outcome_t rrc::cell_selection_proc::step_cell_config()
if (is_serv_cell_suitable()) { if (is_serv_cell_suitable()) {
return set_proc_complete(); return set_proc_complete();
} }
Error("Failed to configure serving cell\n"); Error("Failed to configure serving cell");
return start_next_cell_selection(); return start_next_cell_selection();
} }
@ -677,7 +676,7 @@ proc_outcome_t rrc::cell_selection_proc::step()
void rrc::cell_selection_proc::then(const srslte::proc_result_t<cs_result_t>& proc_result) const void rrc::cell_selection_proc::then(const srslte::proc_result_t<cs_result_t>& proc_result) const
{ {
Info("Completed with %s.\n", proc_result.is_success() ? "success" : "failure"); Info("Completed with %s.", proc_result.is_success() ? "success" : "failure");
// Inform Connection Request Procedure // Inform Connection Request Procedure
rrc_ptr->task_sched.defer_task([this, proc_result]() { rrc_ptr->task_sched.defer_task([this, proc_result]() {
if (rrc_ptr->conn_req_proc.is_busy()) { if (rrc_ptr->conn_req_proc.is_busy()) {
@ -692,15 +691,15 @@ void rrc::cell_selection_proc::then(const srslte::proc_result_t<cs_result_t>& pr
* PLMN search Procedure * PLMN search Procedure
*************************************/ *************************************/
rrc::plmn_search_proc::plmn_search_proc(rrc* parent_) : rrc_ptr(parent_), log_h(srslte::logmap::get("RRC")) {} rrc::plmn_search_proc::plmn_search_proc(rrc* parent_) : rrc_ptr(parent_), logger(srslog::fetch_basic_logger("RRC")) {}
proc_outcome_t rrc::plmn_search_proc::init() proc_outcome_t rrc::plmn_search_proc::init()
{ {
Info("Starting PLMN search\n"); Info("Starting PLMN search");
nof_plmns = 0; nof_plmns = 0;
cell_search_fut = rrc_ptr->cell_searcher.get_future(); cell_search_fut = rrc_ptr->cell_searcher.get_future();
if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) { if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) {
Error("Failed due to fail to init cell search...\n"); Error("Failed due to fail to init cell search...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
return step(); return step();
@ -720,7 +719,7 @@ proc_outcome_t rrc::plmn_search_proc::step()
if (cell_search_fut.is_error() or cell_search_fut.value()->found == cell_search_ret_t::ERROR) { if (cell_search_fut.is_error() or cell_search_fut.value()->found == cell_search_ret_t::ERROR) {
// stop search // stop search
nof_plmns = -1; nof_plmns = -1;
Error("Failed due to failed cell search sub-procedure\n"); Error("Failed due to failed cell search sub-procedure");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -733,21 +732,21 @@ proc_outcome_t rrc::plmn_search_proc::step()
found_plmns[nof_plmns].tac = rrc_ptr->meas_cells.serving_cell().get_tac(); found_plmns[nof_plmns].tac = rrc_ptr->meas_cells.serving_cell().get_tac();
nof_plmns++; nof_plmns++;
} else { } else {
Error("No more space for plmns (%d)\n", nof_plmns); Error("No more space for plmns (%d)", nof_plmns);
} }
} }
} else { } else {
Error("SIB1 not acquired\n"); Error("SIB1 not acquired");
} }
} }
if (cell_search_fut.value()->last_freq == cell_search_ret_t::NO_MORE_FREQS) { if (cell_search_fut.value()->last_freq == cell_search_ret_t::NO_MORE_FREQS) {
Info("completed PLMN search\n"); Info("completed PLMN search");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) { if (not rrc_ptr->cell_searcher.launch(&cell_search_fut)) {
Error("Failed due to fail to init cell search...\n"); Error("Failed due to fail to init cell search...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -759,10 +758,10 @@ void rrc::plmn_search_proc::then(const srslte::proc_state_t& result) const
{ {
// on cleanup, call plmn_search_completed // on cleanup, call plmn_search_completed
if (result.is_success()) { if (result.is_success()) {
Info("completed with success\n"); Info("completed with success");
rrc_ptr->nas->plmn_search_completed(found_plmns, nof_plmns); rrc_ptr->nas->plmn_search_completed(found_plmns, nof_plmns);
} else { } else {
Error("PLMN Search completed with an error\n"); Error("PLMN Search completed with an error");
rrc_ptr->nas->plmn_search_completed(nullptr, -1); rrc_ptr->nas->plmn_search_completed(nullptr, -1);
} }
} }
@ -772,8 +771,7 @@ void rrc::plmn_search_proc::then(const srslte::proc_state_t& result) const
*************************************/ *************************************/
rrc::connection_request_proc::connection_request_proc(rrc* parent_) : rrc::connection_request_proc::connection_request_proc(rrc* parent_) :
rrc_ptr(parent_), rrc_ptr(parent_), logger(srslog::fetch_basic_logger("RRC"))
log_h(srslte::logmap::get("RRC"))
{} {}
proc_outcome_t rrc::connection_request_proc::init(srslte::establishment_cause_t cause_, proc_outcome_t rrc::connection_request_proc::init(srslte::establishment_cause_t cause_,
@ -783,22 +781,22 @@ proc_outcome_t rrc::connection_request_proc::init(srslte::establishment_cause_t
dedicated_info_nas = std::move(dedicated_info_nas_); dedicated_info_nas = std::move(dedicated_info_nas_);
if (!rrc_ptr->plmn_is_selected) { if (!rrc_ptr->plmn_is_selected) {
Error("Trying to connect but PLMN not selected.\n"); Error("Trying to connect but PLMN not selected.");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (rrc_ptr->state != RRC_STATE_IDLE) { if (rrc_ptr->state != RRC_STATE_IDLE) {
log_h->warning("Requested RRC connection establishment while not in IDLE\n"); logger.warning("Requested RRC connection establishment while not in IDLE");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (rrc_ptr->t302.is_running()) { if (rrc_ptr->t302.is_running()) {
Info("Requested RRC connection establishment while T302 is running\n"); Info("Requested RRC connection establishment while T302 is running");
rrc_ptr->nas->set_barring(srslte::barring_t::mo_data); rrc_ptr->nas->set_barring(srslte::barring_t::mo_data);
return proc_outcome_t::error; return proc_outcome_t::error;
} }
Info("Initiation of Connection establishment procedure\n"); Info("Initiation of Connection establishment procedure");
cs_ret = cs_result_t::no_cell; cs_ret = cs_result_t::no_cell;
@ -806,12 +804,12 @@ proc_outcome_t rrc::connection_request_proc::init(srslte::establishment_cause_t
if (rrc_ptr->cell_selector.is_idle()) { if (rrc_ptr->cell_selector.is_idle()) {
// No one is running cell selection // No one is running cell selection
if (not rrc_ptr->cell_selector.launch()) { if (not rrc_ptr->cell_selector.launch()) {
Error("Failed to initiate cell selection procedure...\n"); Error("Failed to initiate cell selection procedure...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
rrc_ptr->callback_list.add_proc(rrc_ptr->cell_selector); rrc_ptr->callback_list.add_proc(rrc_ptr->cell_selector);
} else { } else {
Info("Cell selection proc already on-going. Wait for its result\n"); Info("Cell selection proc already on-going. Wait for its result");
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -826,7 +824,7 @@ proc_outcome_t rrc::connection_request_proc::step()
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
if (serv_cfg_fut.is_error()) { if (serv_cfg_fut.is_error()) {
Error("Configuring serving cell\n"); Error("Configuring serving cell");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -838,17 +836,17 @@ proc_outcome_t rrc::connection_request_proc::step()
// Save dedicatedInfoNAS SDU, if needed // Save dedicatedInfoNAS SDU, if needed
if (dedicated_info_nas.get()) { if (dedicated_info_nas.get()) {
if (rrc_ptr->dedicated_info_nas.get()) { if (rrc_ptr->dedicated_info_nas.get()) {
Warning("Received a new dedicatedInfoNAS SDU but there was one still in queue. Removing it.\n"); Warning("Received a new dedicatedInfoNAS SDU but there was one still in queue. Removing it.");
rrc_ptr->dedicated_info_nas.reset(); rrc_ptr->dedicated_info_nas.reset();
} }
Debug("Updating dedicatedInfoNAS in RRC\n"); Debug("Updating dedicatedInfoNAS in RRC");
rrc_ptr->dedicated_info_nas = std::move(dedicated_info_nas); rrc_ptr->dedicated_info_nas = std::move(dedicated_info_nas);
} else { } else {
Debug("dedicatedInfoNAS has already been provided to RRC.\n"); Debug("dedicatedInfoNAS has already been provided to RRC.");
} }
Info("Waiting for RRCConnectionSetup/Reject or expiry\n"); Info("Waiting for RRCConnectionSetup/Reject or expiry");
state = state_t::wait_t300; state = state_t::wait_t300;
return step(); return step();
@ -863,13 +861,13 @@ proc_outcome_t rrc::connection_request_proc::step()
return proc_outcome_t::success; return proc_outcome_t::success;
} else if (rrc_ptr->t300.is_expired()) { } else if (rrc_ptr->t300.is_expired()) {
// T300 is expired: 5.3.3.6 // T300 is expired: 5.3.3.6
Warning("Timer T300 expired: ConnectionRequest timed out\n"); Warning("Timer T300 expired: ConnectionRequest timed out");
rrc_ptr->mac->reset(); rrc_ptr->mac->reset();
rrc_ptr->set_mac_default(); rrc_ptr->set_mac_default();
rrc_ptr->rlc->reestablish(); rrc_ptr->rlc->reestablish();
} else { } else {
// T300 is stopped but RRC not Connected is because received Reject: Section 5.3.3.8 // T300 is stopped but RRC not Connected is because received Reject: Section 5.3.3.8
Warning("Timer T300 stopped: Received ConnectionReject\n"); Warning("Timer T300 stopped: Received ConnectionReject");
rrc_ptr->mac->reset(); rrc_ptr->mac->reset();
rrc_ptr->set_mac_default(); rrc_ptr->set_mac_default();
} }
@ -881,11 +879,11 @@ proc_outcome_t rrc::connection_request_proc::step()
void rrc::connection_request_proc::then(const srslte::proc_state_t& result) void rrc::connection_request_proc::then(const srslte::proc_state_t& result)
{ {
if (result.is_error()) { if (result.is_error()) {
log_h->warning("Could not establish connection. Deallocating dedicatedInfoNAS PDU\n"); logger.warning("Could not establish connection. Deallocating dedicatedInfoNAS PDU");
dedicated_info_nas.reset(); dedicated_info_nas.reset();
rrc_ptr->dedicated_info_nas.reset(); rrc_ptr->dedicated_info_nas.reset();
} else { } else {
Info("Finished connection request procedure successfully.\n"); Info("Finished connection request procedure successfully.");
} }
rrc_ptr->nas->connection_request_completed(result.is_success()); rrc_ptr->nas->connection_request_completed(result.is_success());
} }
@ -910,23 +908,23 @@ srslte::proc_outcome_t rrc::connection_request_proc::react(const cell_selection_
// CCCH configuration applied already at start // CCCH configuration applied already at start
// timeAlignmentCommon applied in configure_serving_cell // timeAlignmentCommon applied in configure_serving_cell
Info("Configuring serving cell...\n"); Info("Configuring serving cell...");
state = state_t::config_serving_cell; state = state_t::config_serving_cell;
if (not rrc_ptr->serv_cell_cfg.launch(&serv_cfg_fut, rrc_ptr->ue_required_sibs)) { if (not rrc_ptr->serv_cell_cfg.launch(&serv_cfg_fut, rrc_ptr->ue_required_sibs)) {
Error("Attach request failed to configure serving cell...\n"); Error("Attach request failed to configure serving cell...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
return step(); return step();
} else { } else {
switch (cs_ret) { switch (cs_ret) {
case cs_result_t::same_cell: case cs_result_t::same_cell:
log_h->warning("Did not reselect cell but serving cell is out-of-sync.\n"); logger.warning("Did not reselect cell but serving cell is out-of-sync.");
break; break;
case cs_result_t::changed_cell: case cs_result_t::changed_cell:
log_h->warning("Selected a new cell but could not camp on. Setting out-of-sync.\n"); logger.warning("Selected a new cell but could not camp on. Setting out-of-sync.");
break; break;
default: default:
log_h->warning("Could not find any suitable cell to connect\n"); logger.warning("Could not find any suitable cell to connect");
} }
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -941,7 +939,7 @@ rrc::connection_reconf_no_ho_proc::connection_reconf_no_ho_proc(srsue::rrc* pare
srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& recfg_) srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& recfg_)
{ {
Info("Starting...\n"); Info("Starting...");
rx_recfg = recfg_.crit_exts.c1().rrc_conn_recfg_r8(); rx_recfg = recfg_.crit_exts.c1().rrc_conn_recfg_r8();
// If first message after reestablishment, resume SRB2 and all DRB // If first message after reestablishment, resume SRB2 and all DRB
@ -986,7 +984,7 @@ srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::init(const asn1::rrc::
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
bool rtn = rrc_ptr->nr_reconfiguration_proc(rx_recfg); bool rtn = rrc_ptr->nr_reconfiguration_proc(rx_recfg);
if (rtn == false) { if (rtn == false) {
rrc_ptr->rrc_log->error("Can not launch NR RRC Reconfiguration procedure\n"); rrc_ptr->logger.error("Can not launch NR RRC Reconfiguration procedure");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
has_5g_nr_reconfig = true; has_5g_nr_reconfig = true;
@ -1002,7 +1000,7 @@ srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::init(const asn1::rrc::
srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::react(const bool& config_complete) srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::react(const bool& config_complete)
{ {
if (not config_complete) { if (not config_complete) {
rrc_ptr->rrc_log->error("Failed to config PHY\n"); rrc_ptr->logger.error("Failed to config PHY");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -1032,7 +1030,7 @@ srslte::proc_outcome_t rrc::connection_reconf_no_ho_proc::react(const bool& conf
nas_pdu->N_bytes = pdu.size(); nas_pdu->N_bytes = pdu.size();
rrc_ptr->nas->write_pdu(RB_ID_SRB1, std::move(nas_pdu)); rrc_ptr->nas->write_pdu(RB_ID_SRB1, std::move(nas_pdu));
} else { } else {
rrc_ptr->rrc_log->error("Fatal Error: Couldn't allocate PDU in %s.\n", __FUNCTION__); rrc_ptr->logger.error("Fatal Error: Couldn't allocate PDU in %s.", __FUNCTION__);
return proc_outcome_t::error; return proc_outcome_t::error;
} }
} }
@ -1046,7 +1044,7 @@ void rrc::connection_reconf_no_ho_proc::then(const srslte::proc_state_t& result)
has_5g_nr_reconfig = false; has_5g_nr_reconfig = false;
if (result.is_success()) { if (result.is_success()) {
rrc_ptr->rrc_log->info("Finished %s successfully\n", name()); rrc_ptr->logger.info("Finished %s successfully", name());
return; return;
} }
@ -1059,7 +1057,9 @@ void rrc::connection_reconf_no_ho_proc::then(const srslte::proc_state_t& result)
* Process PCCH procedure * Process PCCH procedure
*************************************/ *************************************/
rrc::process_pcch_proc::process_pcch_proc(srsue::rrc* parent_) : rrc_ptr(parent_), log_h(srslte::logmap::get("RRC")) {} rrc::process_pcch_proc::process_pcch_proc(srsue::rrc* parent_) :
rrc_ptr(parent_), logger(srslog::fetch_basic_logger("RRC"))
{}
proc_outcome_t rrc::process_pcch_proc::init(const asn1::rrc::paging_s& paging_) proc_outcome_t rrc::process_pcch_proc::init(const asn1::rrc::paging_s& paging_)
{ {
@ -1067,7 +1067,7 @@ proc_outcome_t rrc::process_pcch_proc::init(const asn1::rrc::paging_s& paging_)
paging_idx = 0; paging_idx = 0;
state = state_t::next_record; state = state_t::next_record;
Info("starting...\n"); Info("starting...");
return step(); return step();
} }
@ -1076,40 +1076,40 @@ proc_outcome_t rrc::process_pcch_proc::step()
if (state == state_t::next_record) { if (state == state_t::next_record) {
for (; paging_idx < paging.paging_record_list.size(); ++paging_idx) { for (; paging_idx < paging.paging_record_list.size(); ++paging_idx) {
srslte::s_tmsi_t s_tmsi_paged = srslte::make_s_tmsi_t(paging.paging_record_list[paging_idx].ue_id.s_tmsi()); srslte::s_tmsi_t s_tmsi_paged = srslte::make_s_tmsi_t(paging.paging_record_list[paging_idx].ue_id.s_tmsi());
Info("Received paging (%d/%d) for UE %" PRIu64 ":%" PRIu64 "\n", Info("Received paging (%d/%d) for UE %" PRIu64 ":%" PRIu64 "",
paging_idx + 1, paging_idx + 1,
paging.paging_record_list.size(), paging.paging_record_list.size(),
paging.paging_record_list[paging_idx].ue_id.s_tmsi().mmec.to_number(), paging.paging_record_list[paging_idx].ue_id.s_tmsi().mmec.to_number(),
paging.paging_record_list[paging_idx].ue_id.s_tmsi().m_tmsi.to_number()); paging.paging_record_list[paging_idx].ue_id.s_tmsi().m_tmsi.to_number());
if (rrc_ptr->ue_identity == s_tmsi_paged) { if (rrc_ptr->ue_identity == s_tmsi_paged) {
if (RRC_STATE_IDLE == rrc_ptr->state) { if (RRC_STATE_IDLE == rrc_ptr->state) {
Info("S-TMSI match in paging message\n"); Info("S-TMSI match in paging message");
srslte::console("S-TMSI match in paging message\n"); srslte::console("S-TMSI match in paging message\n");
if (not rrc_ptr->nas->paging(&s_tmsi_paged)) { if (not rrc_ptr->nas->paging(&s_tmsi_paged)) {
Error("Unable to start NAS paging proc\n"); Error("Unable to start NAS paging proc");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
state = state_t::nas_paging; state = state_t::nas_paging;
return step(); return step();
} else { } else {
Warning("Received paging while in CONNECT\n"); Warning("Received paging while in CONNECT");
} }
} else { } else {
Info("Received paging for unknown identity\n"); Info("Received paging for unknown identity");
} }
} }
if (paging.sys_info_mod_present) { if (paging.sys_info_mod_present) {
Info("Received System Information notification update request.\n"); Info("Received System Information notification update request.");
// invalidate and then update all SIBs of serving cell // invalidate and then update all SIBs of serving cell
rrc_ptr->meas_cells.serving_cell().reset_sibs(); rrc_ptr->meas_cells.serving_cell().reset_sibs();
// create a serving cell config procedure and push it to callback list // create a serving cell config procedure and push it to callback list
if (not rrc_ptr->serv_cell_cfg.launch(&serv_cfg_fut, rrc_ptr->ue_required_sibs)) { if (not rrc_ptr->serv_cell_cfg.launch(&serv_cfg_fut, rrc_ptr->ue_required_sibs)) {
Error("Failed to initiate a serving cell configuration procedure\n"); Error("Failed to initiate a serving cell configuration procedure");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
} else { } else {
Info("Completed successfully\n"); Info("Completed successfully");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
state = state_t::serv_cell_cfg; state = state_t::serv_cell_cfg;
@ -1122,10 +1122,10 @@ proc_outcome_t rrc::process_pcch_proc::step()
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
if (serv_cfg_fut.is_success()) { if (serv_cfg_fut.is_success()) {
Info("All SIBs of serving cell obtained successfully\n"); Info("All SIBs of serving cell obtained successfully");
return proc_outcome_t::success; return proc_outcome_t::success;
} else { } else {
Error("While obtaining SIBs of serving cell\n"); Error("While obtaining SIBs of serving cell");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
} }
@ -1135,16 +1135,16 @@ proc_outcome_t rrc::process_pcch_proc::step()
proc_outcome_t rrc::process_pcch_proc::react(paging_complete e) proc_outcome_t rrc::process_pcch_proc::react(paging_complete e)
{ {
if (state != state_t::nas_paging) { if (state != state_t::nas_paging) {
Warning("Received an unexpected paging complete\n"); Warning("Received an unexpected paging complete");
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
if (not e.outcome) { if (not e.outcome) {
Info("NAS Paging has failed\n"); Info("NAS Paging has failed");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
paging_idx++; paging_idx++;
state = state_t::next_record; state = state_t::next_record;
Info("Received paging complete event\n"); Info("Received paging complete event");
return step(); return step();
} }
@ -1160,7 +1160,7 @@ rrc::go_idle_proc::go_idle_proc(srsue::rrc* rrc_) : rrc_ptr(rrc_)
proc_outcome_t rrc::go_idle_proc::init() proc_outcome_t rrc::go_idle_proc::init()
{ {
Info("Starting...\n"); Info("Starting...");
rlc_flush_timer.run(); rlc_flush_timer.run();
// Do not call step() directly. Instead we defer for one TTI to avoid double-locking the RLC mutex // Do not call step() directly. Instead we defer for one TTI to avoid double-locking the RLC mutex
return proc_outcome_t::yield; return proc_outcome_t::yield;
@ -1169,24 +1169,25 @@ proc_outcome_t rrc::go_idle_proc::init()
srslte::proc_outcome_t rrc::go_idle_proc::react(bool timeout) srslte::proc_outcome_t rrc::go_idle_proc::react(bool timeout)
{ {
rrc_ptr->leave_connected(); rrc_ptr->leave_connected();
Info("Left connected state\n"); Info("Left connected state");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
proc_outcome_t rrc::go_idle_proc::step() proc_outcome_t rrc::go_idle_proc::step()
{ {
if (rrc_ptr->state == RRC_STATE_IDLE) { if (rrc_ptr->state == RRC_STATE_IDLE) {
Info("Interrupting as RRC has already became IDLE\n"); Info("Interrupting as RRC has already became IDLE");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
// wait for RLC of SRB1 and SRB2 to be flushed // wait for RLC of SRB1 and SRB2 to be flushed
if (rrc_ptr->srbs_flushed()) { if (rrc_ptr->srbs_flushed()) {
rrc_ptr->leave_connected(); rrc_ptr->leave_connected();
Info("Left connected state\n"); Info("Left connected state");
return proc_outcome_t::success; return proc_outcome_t::success;
} else { } else {
Debug("Postponing transition to RRC IDLE (%d ms < %d ms)\n", rlc_flush_timer.time_elapsed(), rlc_flush_timeout_ms); Debug(
"Postponing transition to RRC IDLE (%d ms < %d ms)", rlc_flush_timer.time_elapsed(), int(rlc_flush_timeout_ms));
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -1194,7 +1195,7 @@ proc_outcome_t rrc::go_idle_proc::step()
void rrc::go_idle_proc::then(const srslte::proc_state_t& result) void rrc::go_idle_proc::then(const srslte::proc_state_t& result)
{ {
if (rrc_ptr->nas->is_registered() and not rrc_ptr->cell_reselector.launch()) { if (rrc_ptr->nas->is_registered() and not rrc_ptr->cell_reselector.launch()) {
rrc_ptr->rrc_log->error("Failed to initiate a Cell Reselection procedure...\n"); rrc_ptr->logger.error("Failed to initiate a Cell Reselection procedure...");
return; return;
} }
rrc_ptr->callback_list.add_proc(rrc_ptr->cell_reselector); rrc_ptr->callback_list.add_proc(rrc_ptr->cell_reselector);
@ -1210,7 +1211,7 @@ rrc::cell_reselection_proc::cell_reselection_proc(srsue::rrc* rrc_) : rrc_ptr(rr
reselection_timer = rrc_ptr->task_sched.get_unique_timer(); reselection_timer = rrc_ptr->task_sched.get_unique_timer();
reselection_timer.set(cell_reselection_periodicity_ms, [this](uint32_t tid) { reselection_timer.set(cell_reselection_periodicity_ms, [this](uint32_t tid) {
if (not rrc_ptr->cell_reselector.launch()) { if (not rrc_ptr->cell_reselector.launch()) {
rrc_ptr->rrc_log->error("Failed to initiate a Cell Reselection procedure...\n"); rrc_ptr->logger.error("Failed to initiate a Cell Reselection procedure...");
return; return;
} }
rrc_ptr->callback_list.add_proc(rrc_ptr->cell_reselector); rrc_ptr->callback_list.add_proc(rrc_ptr->cell_reselector);
@ -1219,9 +1220,9 @@ rrc::cell_reselection_proc::cell_reselection_proc(srsue::rrc* rrc_) : rrc_ptr(rr
proc_outcome_t rrc::cell_reselection_proc::init() proc_outcome_t rrc::cell_reselection_proc::init()
{ {
Info("Starting...\n"); Info("Starting...");
if (not rrc_ptr->cell_selector.launch(&cell_selection_fut)) { if (not rrc_ptr->cell_selector.launch(&cell_selection_fut)) {
Error("Failed to initiate a Cell Selection procedure...\n"); Error("Failed to initiate a Cell Selection procedure...");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -1234,29 +1235,29 @@ proc_outcome_t rrc::cell_reselection_proc::step()
return srslte::proc_outcome_t::yield; return srslte::proc_outcome_t::yield;
} }
if (cell_selection_fut.is_error()) { if (cell_selection_fut.is_error()) {
Error("Error while selecting a cell\n"); Error("Error while selecting a cell");
return srslte::proc_outcome_t::error; return srslte::proc_outcome_t::error;
} }
cell_sel_result = *cell_selection_fut.value(); cell_sel_result = *cell_selection_fut.value();
Info("Cell Selection completed. Handling its result...\n"); Info("Cell Selection completed. Handling its result...");
switch (cell_sel_result) { switch (cell_sel_result) {
case cs_result_t::changed_cell: case cs_result_t::changed_cell:
if (rrc_ptr->state == rrc_state_t::RRC_STATE_IDLE) { if (rrc_ptr->state == rrc_state_t::RRC_STATE_IDLE) {
Info("New cell has been selected, start receiving PCCH\n"); Info("New cell has been selected, start receiving PCCH");
rrc_ptr->mac->pcch_start_rx(); rrc_ptr->mac->pcch_start_rx();
} }
break; break;
case cs_result_t::no_cell: case cs_result_t::no_cell:
Warning("Could not find any cell to camp on\n"); Warning("Could not find any cell to camp on");
break; break;
case cs_result_t::same_cell: case cs_result_t::same_cell:
if (!rrc_ptr->phy->cell_is_camping()) { if (!rrc_ptr->phy->cell_is_camping()) {
Warning("Did not reselect cell but serving cell is out-of-sync.\n"); Warning("Did not reselect cell but serving cell is out-of-sync.");
} }
break; break;
} }
Info("Finished successfully\n"); Info("Finished successfully");
return srslte::proc_outcome_t::success; return srslte::proc_outcome_t::success;
} }
@ -1305,7 +1306,7 @@ proc_outcome_t rrc::connection_reest_proc::init(asn1::rrc::reest_cause_e cause)
// 5.3.7.1 - Conditions for Reestablishment procedure // 5.3.7.1 - Conditions for Reestablishment procedure
if (not rrc_ptr->security_is_activated or rrc_ptr->state != RRC_STATE_CONNECTED or if (not rrc_ptr->security_is_activated or rrc_ptr->state != RRC_STATE_CONNECTED or
uernti.crnti == SRSLTE_INVALID_RNTI) { uernti.crnti == SRSLTE_INVALID_RNTI) {
Warning("Conditions are NOT met to start procedure.\n"); Warning("Conditions are NOT met to start procedure.");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -1322,7 +1323,7 @@ proc_outcome_t rrc::connection_reest_proc::init(asn1::rrc::reest_cause_e cause)
} }
reest_cellid = rrc_ptr->meas_cells.find_cell(reest_source_freq, reest_source_pci)->get_cell_id(); reest_cellid = rrc_ptr->meas_cells.find_cell(reest_source_freq, reest_source_pci)->get_cell_id();
Info("Starting... cause: \"%s\", UE context: {C-RNTI=0x%x, PCI=%d, CELL ID=%d}\n", Info("Starting... cause: \"%s\", UE context: {C-RNTI=0x%x, PCI=%d, CELL ID=%d}",
reest_cause == asn1::rrc::reest_cause_opts::recfg_fail reest_cause == asn1::rrc::reest_cause_opts::recfg_fail
? "Reconfiguration failure" ? "Reconfiguration failure"
: cause == asn1::rrc::reest_cause_opts::ho_fail ? "Handover failure" : "Other failure", : cause == asn1::rrc::reest_cause_opts::ho_fail ? "Handover failure" : "Other failure",
@ -1377,17 +1378,17 @@ bool rrc::connection_reest_proc::passes_cell_criteria() const
srslte::proc_outcome_t rrc::connection_reest_proc::cell_criteria() srslte::proc_outcome_t rrc::connection_reest_proc::cell_criteria()
{ {
if (not passes_cell_criteria()) { if (not passes_cell_criteria()) {
Info("Selected Serving cell does not pass criteria. Re-launching re-selection procedure\n"); Info("Selected Serving cell does not pass criteria. Re-launching re-selection procedure");
return start_cell_selection(); return start_cell_selection();
} }
// Upon selecting a suitable E-UTRA cell, the UE shall: // Upon selecting a suitable E-UTRA cell, the UE shall:
Info("Cell Selection criteria passed after %dms. Sending RRC Connection Reestablishment Request\n", Info("Cell Selection criteria passed after %dms. Sending RRC Connection Reestablishment Request",
rrc_ptr->t311.time_elapsed()); rrc_ptr->t311.time_elapsed());
// Note: Not explicitly defined in the specs, but UE should apply SIB1 and SIB2 configuration in order to attempt // Note: Not explicitly defined in the specs, but UE should apply SIB1 and SIB2 configuration in order to attempt
// a PRACH to a different cell // a PRACH to a different cell
Info("Applying SIB2 configuration\n"); Info("Applying SIB2 configuration");
rrc_ptr->handle_sib2(); rrc_ptr->handle_sib2();
// 1> stop timer T311; // 1> stop timer T311;
@ -1411,7 +1412,7 @@ srslte::proc_outcome_t rrc::connection_reest_proc::start_cell_selection()
// Launch cell reselection // Launch cell reselection
state = state_t::wait_cell_selection; state = state_t::wait_cell_selection;
if (not rrc_ptr->cell_selector.launch(std::vector<uint32_t>{0, 1, 2})) { if (not rrc_ptr->cell_selector.launch(std::vector<uint32_t>{0, 1, 2})) {
Error("Failed to initiate a Cell re-selection procedure...\n"); Error("Failed to initiate a Cell re-selection procedure...");
// Wait for T311 to expire // Wait for T311 to expire
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -1423,14 +1424,14 @@ srslte::proc_outcome_t
rrc::connection_reest_proc::react(const cell_selection_proc::cell_selection_complete_ev& cell_selected_ev) rrc::connection_reest_proc::react(const cell_selection_proc::cell_selection_complete_ev& cell_selected_ev)
{ {
if (state != state_t::wait_cell_selection) { if (state != state_t::wait_cell_selection) {
Warning("Received unexpected \"%s\" completion signal\n", rrc_ptr->cell_selector.get()->name()); Warning("Received unexpected \"%s\" completion signal", rrc_ptr->cell_selector.get()->name());
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
// Relaunch cell selection if there is still time // Relaunch cell selection if there is still time
if (cell_selected_ev.is_error() or not rrc_ptr->phy_ctrl->is_in_sync()) { if (cell_selected_ev.is_error() or not rrc_ptr->phy_ctrl->is_in_sync()) {
// Out-of-sync, relaunch reselection // Out-of-sync, relaunch reselection
Info("Serving cell is out-of-sync, re-launching re-selection procedure. T311: %d/%d ms\n", Info("Serving cell is out-of-sync, re-launching re-selection procedure. T311: %d/%d ms",
rrc_ptr->t311.time_elapsed(), rrc_ptr->t311.time_elapsed(),
rrc_ptr->t311.duration()); rrc_ptr->t311.duration());
return start_cell_selection(); return start_cell_selection();
@ -1439,7 +1440,7 @@ rrc::connection_reest_proc::react(const cell_selection_proc::cell_selection_comp
// SIBs should be available // SIBs should be available
if (not rrc_ptr->meas_cells.serving_cell().has_sib1() or not rrc_ptr->meas_cells.serving_cell().has_sib2() or if (not rrc_ptr->meas_cells.serving_cell().has_sib1() or not rrc_ptr->meas_cells.serving_cell().has_sib2() or
not rrc_ptr->meas_cells.serving_cell().has_sib3()) { not rrc_ptr->meas_cells.serving_cell().has_sib3()) {
Warning("SIBs missing (%d, %d, %d) after cell selection procedure\n", Warning("SIBs missing (%d, %d, %d) after cell selection procedure",
rrc_ptr->meas_cells.serving_cell().has_sib1(), rrc_ptr->meas_cells.serving_cell().has_sib1(),
rrc_ptr->meas_cells.serving_cell().has_sib2(), rrc_ptr->meas_cells.serving_cell().has_sib2(),
rrc_ptr->meas_cells.serving_cell().has_sib3()); rrc_ptr->meas_cells.serving_cell().has_sib3());
@ -1496,14 +1497,14 @@ srslte::proc_outcome_t rrc::connection_reest_proc::react(const asn1::rrc::rrc_co
// procedure ends; // procedure ends;
rrc_ptr->send_con_restablish_complete(); rrc_ptr->send_con_restablish_complete();
Info("Finished successfully\n"); Info("Finished successfully");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
// 5.3.7.7 - T301 expiry or selected cell no longer suitable // 5.3.7.7 - T301 expiry or selected cell no longer suitable
srslte::proc_outcome_t rrc::connection_reest_proc::react(const t301_expiry& ev) srslte::proc_outcome_t rrc::connection_reest_proc::react(const t301_expiry& ev)
{ {
Info("Timer T301 expired: Going to RRC IDLE\n"); Info("Timer T301 expired: Going to RRC IDLE");
srslte::console("Timer T301 expired: Going to RRC IDLE\n"); srslte::console("Timer T301 expired: Going to RRC IDLE\n");
rrc_ptr->start_go_idle(); rrc_ptr->start_go_idle();
@ -1512,7 +1513,7 @@ srslte::proc_outcome_t rrc::connection_reest_proc::react(const t301_expiry& ev)
srslte::proc_outcome_t rrc::connection_reest_proc::step() srslte::proc_outcome_t rrc::connection_reest_proc::step()
{ {
if (rrc_ptr->t301.is_running() and not passes_cell_criteria()) { if (rrc_ptr->t301.is_running() and not passes_cell_criteria()) {
Info("Selected cell no longer suitable: Going to RRC IDLE\n"); Info("Selected cell no longer suitable: Going to RRC IDLE");
srslte::console("Selected cell no longer suitable: Going to RRC IDLE\n"); srslte::console("Selected cell no longer suitable: Going to RRC IDLE\n");
rrc_ptr->start_go_idle(); rrc_ptr->start_go_idle();
return proc_outcome_t::error; return proc_outcome_t::error;
@ -1524,7 +1525,7 @@ srslte::proc_outcome_t rrc::connection_reest_proc::step()
srslte::proc_outcome_t rrc::connection_reest_proc::react(const asn1::rrc::rrc_conn_reest_reject_s& reject_msg) srslte::proc_outcome_t rrc::connection_reest_proc::react(const asn1::rrc::rrc_conn_reest_reject_s& reject_msg)
{ {
srslte::console("Reestablishment Reject. Going to RRC IDLE\n"); srslte::console("Reestablishment Reject. Going to RRC IDLE\n");
Info("Reestablishment Reject. Going to RRC IDLE\n"); Info("Reestablishment Reject. Going to RRC IDLE");
rrc_ptr->t301.stop(); rrc_ptr->t301.stop();
rrc_ptr->start_go_idle(); rrc_ptr->start_go_idle();
return proc_outcome_t::error; return proc_outcome_t::error;
@ -1534,7 +1535,7 @@ srslte::proc_outcome_t rrc::connection_reest_proc::react(const asn1::rrc::rrc_co
srslte::proc_outcome_t rrc::connection_reest_proc::react(const t311_expiry& ev) srslte::proc_outcome_t rrc::connection_reest_proc::react(const t311_expiry& ev)
{ {
// Abort procedure if T311 expires // Abort procedure if T311 expires
Info("T311 expired during cell configuration. Going to RRC IDLE\n"); Info("T311 expired during cell configuration. Going to RRC IDLE");
rrc_ptr->start_go_idle(); rrc_ptr->start_go_idle();
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -1560,12 +1561,12 @@ rrc::ho_proc::ho_proc(srsue::rrc* rrc_) : rrc_ptr(rrc_) {}
*/ */
srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc_reconf) srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc_reconf)
{ {
Info("Starting...\n"); Info("Starting...");
recfg_r8 = rrc_reconf.crit_exts.c1().rrc_conn_recfg_r8(); recfg_r8 = rrc_reconf.crit_exts.c1().rrc_conn_recfg_r8();
asn1::rrc::mob_ctrl_info_s* mob_ctrl_info = &recfg_r8.mob_ctrl_info; asn1::rrc::mob_ctrl_info_s* mob_ctrl_info = &recfg_r8.mob_ctrl_info;
size_t nof_scells_active = rrc_ptr->phy_ctrl->current_config_scells().count(); size_t nof_scells_active = rrc_ptr->phy_ctrl->current_config_scells().count();
Info("Received HO command to target PCell=%d\n", mob_ctrl_info->target_pci); Info("Received HO command to target PCell=%d", mob_ctrl_info->target_pci);
srslte::console("Received HO command to target PCell=%d, NCC=%d\n", srslte::console("Received HO command to target PCell=%d, NCC=%d\n",
mob_ctrl_info->target_pci, mob_ctrl_info->target_pci,
recfg_r8.security_cfg_ho.handov_type.intra_lte().next_hop_chaining_count); recfg_r8.security_cfg_ho.handov_type.intra_lte().next_hop_chaining_count);
@ -1579,7 +1580,7 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
target_cell = cell_to_ho->phy_cell; target_cell = cell_to_ho->phy_cell;
} else { } else {
srslte::console("Received HO command to unknown PCI=%d\n", mob_ctrl_info->target_pci); srslte::console("Received HO command to unknown PCI=%d\n", mob_ctrl_info->target_pci);
Error("Could not find target cell earfcn=%d, pci=%d\n", Error("Could not find target cell earfcn=%d, pci=%d",
rrc_ptr->meas_cells.serving_cell().get_earfcn(), rrc_ptr->meas_cells.serving_cell().get_earfcn(),
mob_ctrl_info->target_pci); mob_ctrl_info->target_pci);
rrc_ptr->con_reconfig_failed(); rrc_ptr->con_reconfig_failed();
@ -1599,9 +1600,9 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
// starting at start synchronising to the DL of the target PCell // starting at start synchronising to the DL of the target PCell
rrc_ptr->set_serving_cell(target_cell, false); rrc_ptr->set_serving_cell(target_cell, false);
Info("Starting cell selection of target cell PCI=%d EARFCN=%d\n", target_cell.pci, target_cell.earfcn); Info("Starting cell selection of target cell PCI=%d EARFCN=%d", target_cell.pci, target_cell.earfcn);
if (not rrc_ptr->phy_ctrl->start_cell_select(target_cell)) { if (not rrc_ptr->phy_ctrl->start_cell_select(target_cell)) {
Error("Failed to launch the selection of target cell PCI=%d EARFCN=%d\n", target_cell.pci, target_cell.earfcn); Error("Failed to launch the selection of target cell PCI=%d EARFCN=%d", target_cell.pci, target_cell.earfcn);
return proc_outcome_t::yield; // wait t304 expiry return proc_outcome_t::yield; // wait t304 expiry
} }
@ -1622,7 +1623,7 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
// perform radio configuration when fullConfig is enabled // perform radio configuration when fullConfig is enabled
if (recfg_r8.non_crit_ext.non_crit_ext.full_cfg_r9_present) { if (recfg_r8.non_crit_ext.non_crit_ext.full_cfg_r9_present) {
Error("fullConfig section was present but is not supported. Ignoring it.\n"); Error("fullConfig section was present but is not supported. Ignoring it.");
} }
// configure lower layers in accordance with the received radioResourceConfigCommon // configure lower layers in accordance with the received radioResourceConfigCommon
@ -1632,7 +1633,7 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
// configure lower layers in accordance with any additional fields, not covered in the previous, if included in the // configure lower layers in accordance with any additional fields, not covered in the previous, if included in the
// received mobilityControlInfo // received mobilityControlInfo
if (recfg_r8.mob_ctrl_info.rach_cfg_ded_present) { if (recfg_r8.mob_ctrl_info.rach_cfg_ded_present) {
Info("Configuring RACH dedicated configuration with preamble_idx=%d, mask_idx=%d\n", Info("Configuring RACH dedicated configuration with preamble_idx=%d, mask_idx=%d",
recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_preamb_idx, recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_preamb_idx,
recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_prach_mask_idx); recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_prach_mask_idx);
rrc_ptr->mac->set_rach_ded_cfg(recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_preamb_idx, rrc_ptr->mac->set_rach_ded_cfg(recfg_r8.mob_ctrl_info.rach_cfg_ded.ra_preamb_idx,
@ -1660,7 +1661,7 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
(srslte::CIPHERING_ALGORITHM_ID_ENUM)sec_intralte.security_algorithm_cfg.ciphering_algorithm.to_number(); (srslte::CIPHERING_ALGORITHM_ID_ENUM)sec_intralte.security_algorithm_cfg.ciphering_algorithm.to_number();
rrc_ptr->sec_cfg.integ_algo = rrc_ptr->sec_cfg.integ_algo =
(srslte::INTEGRITY_ALGORITHM_ID_ENUM)sec_intralte.security_algorithm_cfg.integrity_prot_algorithm.to_number(); (srslte::INTEGRITY_ALGORITHM_ID_ENUM)sec_intralte.security_algorithm_cfg.integrity_prot_algorithm.to_number();
Info("Changed Ciphering to %s and Integrity to %s\n", Info("Changed Ciphering to %s and Integrity to %s",
srslte::ciphering_algorithm_id_text[rrc_ptr->sec_cfg.cipher_algo], srslte::ciphering_algorithm_id_text[rrc_ptr->sec_cfg.cipher_algo],
srslte::integrity_algorithm_id_text[rrc_ptr->sec_cfg.integ_algo]); srslte::integrity_algorithm_id_text[rrc_ptr->sec_cfg.integ_algo]);
} }
@ -1675,7 +1676,7 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
// if the RRCConnectionReconfiguration message includes the measConfig: // if the RRCConnectionReconfiguration message includes the measConfig:
if (not rrc_ptr->measurements->parse_meas_config(&recfg_r8, true, ho_src_cell.earfcn)) { if (not rrc_ptr->measurements->parse_meas_config(&recfg_r8, true, ho_src_cell.earfcn)) {
Error("Parsing measurementConfig. TODO: Send ReconfigurationReject\n"); Error("Parsing measurementConfig. TODO: Send ReconfigurationReject");
return proc_outcome_t::yield; // wait for t304 expiry return proc_outcome_t::yield; // wait for t304 expiry
} }
@ -1685,14 +1686,14 @@ srslte::proc_outcome_t rrc::ho_proc::init(const asn1::rrc::rrc_conn_recfg_s& rrc
// SCell addition/removal can take some time to compute. Enqueue in a background task and do it in the end. // SCell addition/removal can take some time to compute. Enqueue in a background task and do it in the end.
rrc_ptr->apply_scell_config(&recfg_r8, false); rrc_ptr->apply_scell_config(&recfg_r8, false);
Info("Finished HO configuration. Waiting PHY to synchronize with target cell\n"); Info("Finished HO configuration. Waiting PHY to synchronize with target cell");
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_outcome_t rrc::ho_proc::react(t304_expiry ev) srslte::proc_outcome_t rrc::ho_proc::react(t304_expiry ev)
{ {
Info("HO preparation timed out. Reverting RRC security config from source cell.\n"); Info("HO preparation timed out. Reverting RRC security config from source cell.");
// revert security settings from source cell for reestablishment according to Sec 5.3.7.4 // revert security settings from source cell for reestablishment according to Sec 5.3.7.4
rrc_ptr->usim->restore_keys_from_failed_ho(&rrc_ptr->sec_cfg); rrc_ptr->usim->restore_keys_from_failed_ho(&rrc_ptr->sec_cfg);
@ -1705,7 +1706,7 @@ srslte::proc_outcome_t rrc::ho_proc::react(t304_expiry ev)
srslte::proc_outcome_t rrc::ho_proc::react(ra_completed_ev ev) srslte::proc_outcome_t rrc::ho_proc::react(ra_completed_ev ev)
{ {
if (ev.success) { if (ev.success) {
Info("Random Access completed. Applying final configuration and finishing procedure\n"); Info("Random Access completed. Applying final configuration and finishing procedure");
// TS 36.331, sec. 5.3.5.4, last "1>" // TS 36.331, sec. 5.3.5.4, last "1>"
rrc_ptr->t304.stop(); rrc_ptr->t304.stop();
@ -1720,7 +1721,7 @@ srslte::proc_outcome_t rrc::ho_proc::react(ra_completed_ev ev)
void rrc::ho_proc::then(const srslte::proc_state_t& result) void rrc::ho_proc::then(const srslte::proc_state_t& result)
{ {
Info("HO to PCI=%d, EARFCN=%d %ssuccessful\n", target_cell.pci, target_cell.earfcn, result.is_success() ? "" : "un"); Info("HO to PCI=%d, EARFCN=%d %ssuccessful", target_cell.pci, target_cell.earfcn, result.is_success() ? "" : "un");
srslte::console("HO %ssuccessful\n", result.is_success() ? "" : "un"); srslte::console("HO %ssuccessful\n", result.is_success() ? "" : "un");
rrc_ptr->t304.stop(); rrc_ptr->t304.stop();

35
srsue/src/stack/ue_stack_lte.cc
Unescape Escape View File

@ -22,10 +22,17 @@ using namespace srslte;
namespace srsue { namespace srsue {
ue_stack_lte::ue_stack_lte() : ue_stack_lte::ue_stack_lte(srslog::sink& log_sink) :
running(false), running(false),
args(), args(),
logger(nullptr), logger(nullptr),
stack_logger(srslog::fetch_basic_logger("STCK", log_sink, false)),
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)),
usim_logger(srslog::fetch_basic_logger("USIM", log_sink, false)),
nas_logger(srslog::fetch_basic_logger("NAS", log_sink, false)),
usim(nullptr), usim(nullptr),
phy(nullptr), phy(nullptr),
rlc("RLC"), rlc("RLC"),
@ -78,8 +85,8 @@ int ue_stack_lte::init(const stack_args_t& args_, srslte::logger* logger_)
logger = logger_; logger = logger_;
// init own log // init own log
stack_log->set_level(args.log.stack_level); stack_logger.set_level(srslog::str_to_basic_level(args.log.stack_level));
stack_log->set_hex_limit(args.log.stack_hex_limit); stack_logger.set_hex_dump_max_size(args.log.stack_hex_limit);
pool_log->set_level(srslte::LOG_LEVEL_WARNING); pool_log->set_level(srslte::LOG_LEVEL_WARNING);
byte_buffer_pool::get_instance()->set_log(pool_log.get()); byte_buffer_pool::get_instance()->set_log(pool_log.get());
@ -87,16 +94,28 @@ int ue_stack_lte::init(const stack_args_t& args_, srslte::logger* logger_)
srslte::logmap::register_log(std::unique_ptr<srslte::log>{new srslte::log_filter{"MAC", logger, true}}); srslte::logmap::register_log(std::unique_ptr<srslte::log>{new srslte::log_filter{"MAC", logger, true}});
mac_log->set_level(args.log.mac_level); mac_log->set_level(args.log.mac_level);
mac_log->set_hex_limit(args.log.mac_hex_limit); 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);
rlc_log->set_level(args.log.rlc_level); rlc_log->set_level(args.log.rlc_level);
rlc_log->set_hex_limit(args.log.rlc_hex_limit); rlc_log->set_hex_limit(args.log.rlc_hex_limit);
rlc_logger.set_level(srslog::str_to_basic_level(args.log.rlc_level));
rlc_logger.set_hex_dump_max_size(args.log.rlc_hex_limit);
pdcp_log->set_level(args.log.pdcp_level); pdcp_log->set_level(args.log.pdcp_level);
pdcp_log->set_hex_limit(args.log.pdcp_hex_limit); pdcp_log->set_hex_limit(args.log.pdcp_hex_limit);
pdcp_logger.set_level(srslog::str_to_basic_level(args.log.pdcp_level));
pdcp_logger.set_hex_dump_max_size(args.log.pdcp_hex_limit);
rrc_log->set_level(args.log.rrc_level); rrc_log->set_level(args.log.rrc_level);
rrc_log->set_hex_limit(args.log.rrc_hex_limit); rrc_log->set_hex_limit(args.log.rrc_hex_limit);
rrc_logger.set_level(srslog::str_to_basic_level(args.log.rrc_level));
rrc_logger.set_hex_dump_max_size(args.log.rrc_hex_limit);
usim_log->set_level(args.log.usim_level); usim_log->set_level(args.log.usim_level);
usim_log->set_hex_limit(args.log.usim_hex_limit); usim_log->set_hex_limit(args.log.usim_hex_limit);
usim_logger.set_level(srslog::str_to_basic_level(args.log.usim_level));
usim_logger.set_hex_dump_max_size(args.log.usim_hex_limit);
nas_log->set_level(args.log.nas_level); nas_log->set_level(args.log.nas_level);
nas_log->set_hex_limit(args.log.nas_hex_limit); nas_log->set_hex_limit(args.log.nas_hex_limit);
nas_logger.set_level(srslog::str_to_basic_level(args.log.nas_level));
nas_logger.set_hex_dump_max_size(args.log.nas_hex_limit);
// Set up pcap // Set up pcap
if (args.pcap.enable) { if (args.pcap.enable) {
@ -109,7 +128,7 @@ int ue_stack_lte::init(const stack_args_t& args_, srslte::logger* logger_)
} }
// Init USIM first to allow early exit in case reader couldn't be found // Init USIM first to allow early exit in case reader couldn't be found
usim = usim_base::get_instance(&args.usim, usim_log.get()); usim = usim_base::get_instance(&args.usim, usim_logger);
if (usim->init(&args.usim)) { if (usim->init(&args.usim)) {
srslte::console("Failed to initialize USIM.\n"); srslte::console("Failed to initialize USIM.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
@ -186,7 +205,7 @@ bool ue_stack_lte::switch_off()
} }
bool detach_sent = true; bool detach_sent = true;
if (not rrc.srbs_flushed()) { if (not rrc.srbs_flushed()) {
logmap::get("NAS ")->warning("Detach couldn't be sent after %dms.\n", timeout_ms); srslog::fetch_basic_logger("NAS").warning("Detach couldn't be sent after %dms.", timeout_ms);
detach_sent = false; detach_sent = false;
} }
@ -257,7 +276,7 @@ void ue_stack_lte::write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu)
auto task = [this, lcid](srslte::unique_byte_buffer_t& sdu) { pdcp.write_sdu(lcid, std::move(sdu)); }; auto task = [this, lcid](srslte::unique_byte_buffer_t& sdu) { pdcp.write_sdu(lcid, std::move(sdu)); };
bool ret = gw_queue_id.try_push(std::bind(task, std::move(sdu))).first; bool ret = gw_queue_id.try_push(std::bind(task, std::move(sdu))).first;
if (not ret) { if (not ret) {
pdcp_log->warning("GW SDU with lcid=%d was discarded.\n", lcid); pdcp_logger.warning("GW SDU with lcid=%d was discarded.", lcid);
} }
} }
@ -337,7 +356,7 @@ void ue_stack_lte::run_tti_impl(uint32_t tti, uint32_t tti_jump)
if (args.have_tti_time_stats) { if (args.have_tti_time_stats) {
std::chrono::nanoseconds dur = tti_tprof.stop(); std::chrono::nanoseconds dur = tti_tprof.stop();
if (dur > TTI_WARN_THRESHOLD_MS) { if (dur > TTI_WARN_THRESHOLD_MS) {
mac_log->warning("%s: detected long duration=%" PRId64 "ms\n", mac_logger.warning("%s: detected long duration=%" PRId64 "ms",
"proc_time", "proc_time",
std::chrono::duration_cast<std::chrono::milliseconds>(dur).count()); std::chrono::duration_cast<std::chrono::milliseconds>(dur).count());
} }
@ -345,7 +364,7 @@ void ue_stack_lte::run_tti_impl(uint32_t tti, uint32_t tti_jump)
// print warning if PHY pushes new TTI messages faster than we process them // print warning if PHY pushes new TTI messages faster than we process them
if (sync_task_queue.size() > SYNC_QUEUE_WARN_THRESHOLD) { if (sync_task_queue.size() > SYNC_QUEUE_WARN_THRESHOLD) {
stack_log->warning("Detected slow task processing (sync_queue_len=%zd).\n", sync_task_queue.size()); stack_logger.warning("Detected slow task processing (sync_queue_len=%zd).", sync_task_queue.size());
} }
} }

9
srsue/src/stack/ue_stack_nr.cc
Unescape Escape View File

@ -18,12 +18,7 @@ using namespace srslte;
namespace srsue { namespace srsue {
ue_stack_nr::ue_stack_nr(srslte::logger* logger_) : ue_stack_nr::ue_stack_nr(srslte::logger* logger_) :
logger(logger_), logger(logger_), thread("STACK"), task_sched(64, 2, 64), rlc_log("RLC"), pdcp_log("PDCP"), pool_log("POOL")
thread("STACK"),
task_sched(64, 2, 64),
rlc_log("RLC"),
pdcp_log("PDCP"),
pool_log("POOL")
{ {
mac.reset(new mac_nr(&task_sched)); mac.reset(new mac_nr(&task_sched));
pdcp.reset(new srslte::pdcp(&task_sched, "PDCP")); pdcp.reset(new srslte::pdcp(&task_sched, "PDCP"));
@ -165,7 +160,7 @@ void ue_stack_nr::write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu)
std::pair<bool, move_task_t> ret = gw_task_queue.try_push(std::bind( std::pair<bool, move_task_t> ret = gw_task_queue.try_push(std::bind(
[this, lcid](srslte::unique_byte_buffer_t& sdu) { pdcp->write_sdu(lcid, std::move(sdu)); }, std::move(sdu))); [this, lcid](srslte::unique_byte_buffer_t& sdu) { pdcp->write_sdu(lcid, std::move(sdu)); }, std::move(sdu)));
if (not ret.first) { if (not ret.first) {
pdcp_log->warning("GW SDU with lcid=%d was discarded.\n", lcid); pdcp_log->warning("GW SDU with lcid=%d was discarded.", lcid);
} }
} }
} }

122
srsue/src/stack/upper/gw.cc
Unescape Escape View File

@ -25,29 +25,33 @@
namespace srsue { namespace srsue {
gw::gw() : thread("GW"), pool(srslte::byte_buffer_pool::get_instance()), tft_matcher(&log) {} gw::gw() :
thread("GW"),
pool(srslte::byte_buffer_pool::get_instance()),
logger(srslog::fetch_basic_logger("GW", false)),
tft_matcher(logger)
{}
int gw::init(const gw_args_t& args_, srslte::logger* logger_, stack_interface_gw* stack_) int gw::init(const gw_args_t& args_, srslte::logger* logger_, stack_interface_gw* stack_)
{ {
stack = stack_; stack = stack_;
logger = logger_; old_logger = logger_;
args = args_; args = args_;
run_enable = true; run_enable = true;
log.init("GW ", logger); logger.set_level(srslog::str_to_basic_level(args.log.gw_level));
log.set_level(args.log.gw_level); logger.set_hex_dump_max_size(args.log.gw_hex_limit);
log.set_hex_limit(args.log.gw_hex_limit);
metrics_tp = std::chrono::high_resolution_clock::now(); metrics_tp = std::chrono::high_resolution_clock::now();
// MBSFN // MBSFN
mbsfn_sock_fd = socket(AF_INET, SOCK_DGRAM, 0); mbsfn_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (mbsfn_sock_fd < 0) { if (mbsfn_sock_fd < 0) {
log.error("Failed to create MBSFN sink socket\n"); logger.error("Failed to create MBSFN sink socket");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (fcntl(mbsfn_sock_fd, F_SETFL, O_NONBLOCK)) { if (fcntl(mbsfn_sock_fd, F_SETFL, O_NONBLOCK)) {
log.error("Failed to set non-blocking MBSFN sink socket\n"); logger.error("Failed to set non-blocking MBSFN sink socket");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -95,7 +99,7 @@ void gw::get_metrics(gw_metrics_t& m, const uint32_t nof_tti)
m.dl_tput_mbps = (nof_tti > 0) ? ((dl_tput_bytes * 8 / (double)1e6) / (nof_tti / 1000.0)) : 0.0; m.dl_tput_mbps = (nof_tti > 0) ? ((dl_tput_bytes * 8 / (double)1e6) / (nof_tti / 1000.0)) : 0.0;
m.ul_tput_mbps = (nof_tti > 0) ? ((ul_tput_bytes * 8 / (double)1e6) / (nof_tti / 1000.0)) : 0.0; m.ul_tput_mbps = (nof_tti > 0) ? ((ul_tput_bytes * 8 / (double)1e6) / (nof_tti / 1000.0)) : 0.0;
log.info("gw_rx_rate_mbps=%4.2f (real=%4.2f), gw_tx_rate_mbps=%4.2f (real=%4.2f)\n", logger.info("gw_rx_rate_mbps=%4.2f (real=%4.2f), gw_tx_rate_mbps=%4.2f (real=%4.2f)",
m.dl_tput_mbps, m.dl_tput_mbps,
dl_tput_mbps_real_time, dl_tput_mbps_real_time,
m.ul_tput_mbps, m.ul_tput_mbps,
@ -112,23 +116,23 @@ void gw::get_metrics(gw_metrics_t& m, const uint32_t nof_tti)
*******************************************************************************/ *******************************************************************************/
void gw::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) void gw::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
{ {
log.info_hex(pdu->msg, pdu->N_bytes, "RX PDU. Stack latency: %ld us\n", pdu->get_latency_us().count()); logger.info(pdu->msg, pdu->N_bytes, "RX PDU. Stack latency: %ld us", pdu->get_latency_us().count());
dl_tput_bytes += pdu->N_bytes; dl_tput_bytes += pdu->N_bytes;
if (!if_up) { if (!if_up) {
log.warning("TUN/TAP not up - dropping gw RX message\n"); logger.warning("TUN/TAP not up - dropping gw RX message");
} else if (pdu->N_bytes < 20) { } else if (pdu->N_bytes < 20) {
// Packet not large enough to hold IPv4 Header // Packet not large enough to hold IPv4 Header
log.warning("Packet to small to hold IPv4 header. Dropping packet with %d B\n", pdu->N_bytes); logger.warning("Packet to small to hold IPv4 header. Dropping packet with %d B", pdu->N_bytes);
} else { } else {
// Only handle IPv4 and IPv6 packets // Only handle IPv4 and IPv6 packets
struct iphdr* ip_pkt = (struct iphdr*)pdu->msg; struct iphdr* ip_pkt = (struct iphdr*)pdu->msg;
if (ip_pkt->version == 4 || ip_pkt->version == 6) { if (ip_pkt->version == 4 || ip_pkt->version == 6) {
int n = write(tun_fd, pdu->msg, pdu->N_bytes); int n = write(tun_fd, pdu->msg, pdu->N_bytes);
if (n > 0 && (pdu->N_bytes != (uint32_t)n)) { if (n > 0 && (pdu->N_bytes != (uint32_t)n)) {
log.warning("DL TUN/TAP write failure. Wanted to write %d B but only wrote %d B.\n", pdu->N_bytes, n); logger.warning("DL TUN/TAP write failure. Wanted to write %d B but only wrote %d B.", pdu->N_bytes, n);
} }
} else { } else {
log.error("Unsupported IP version. Dropping packet with %d B\n", pdu->N_bytes); logger.error("Unsupported IP version. Dropping packet with %d B", pdu->N_bytes);
} }
} }
} }
@ -136,9 +140,9 @@ void gw::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
void gw::write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) void gw::write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
{ {
if (pdu->N_bytes > 2) { if (pdu->N_bytes > 2) {
log.info_hex(pdu->msg, logger.info(pdu->msg,
pdu->N_bytes, pdu->N_bytes,
"RX MCH PDU (%d B). Stack latency: %ld us\n", "RX MCH PDU (%d B). Stack latency: %ld us",
pdu->N_bytes, pdu->N_bytes,
pdu->get_latency_us().count()); pdu->get_latency_us().count());
dl_tput_bytes += pdu->N_bytes; dl_tput_bytes += pdu->N_bytes;
@ -150,11 +154,11 @@ void gw::write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
memcpy(&dst_addr.s_addr, &pdu->msg[16], 4); memcpy(&dst_addr.s_addr, &pdu->msg[16], 4);
if (!if_up) { if (!if_up) {
log.warning("TUN/TAP not up - dropping gw RX message\n"); logger.warning("TUN/TAP not up - dropping gw RX message");
} else { } else {
int n = write(tun_fd, pdu->msg, pdu->N_bytes); int n = write(tun_fd, pdu->msg, pdu->N_bytes);
if (n > 0 && (pdu->N_bytes != (uint32_t)n)) { if (n > 0 && (pdu->N_bytes != (uint32_t)n)) {
log.warning("DL TUN/TAP write failure\n"); logger.warning("DL TUN/TAP write failure");
} }
} }
} }
@ -196,7 +200,7 @@ int gw::apply_traffic_flow_template(const uint8_t&
void gw::set_test_loop_mode(const test_loop_mode_state_t mode, const uint32_t ip_pdu_delay_ms) void gw::set_test_loop_mode(const test_loop_mode_state_t mode, const uint32_t ip_pdu_delay_ms)
{ {
log.error("UE test loop mode not supported\n"); logger.error("UE test loop mode not supported");
} }
/******************************************************************************* /*******************************************************************************
@ -219,14 +223,14 @@ void gw::run_thread()
srslte::unique_byte_buffer_t pdu = srslte::allocate_unique_buffer(*pool, true); srslte::unique_byte_buffer_t pdu = srslte::allocate_unique_buffer(*pool, true);
if (!pdu) { if (!pdu) {
log.error("Fatal Error: Couldn't allocate PDU in run_thread().\n"); logger.error("Fatal Error: Couldn't allocate PDU in run_thread().");
return; return;
} }
const static uint32_t REGISTER_WAIT_TOUT = 40, SERVICE_WAIT_TOUT = 40; // 4 sec const static uint32_t REGISTER_WAIT_TOUT = 40, SERVICE_WAIT_TOUT = 40; // 4 sec
uint32_t register_wait = 0, service_wait = 0; uint32_t register_wait = 0, service_wait = 0;
log.info("GW IP packet receiver thread run_enable\n"); logger.info("GW IP packet receiver thread run_enable");
running = true; running = true;
while (run_enable) { while (run_enable) {
@ -234,14 +238,14 @@ void gw::run_thread()
if (SRSLTE_MAX_BUFFER_SIZE_BYTES - SRSLTE_BUFFER_HEADER_OFFSET > idx) { if (SRSLTE_MAX_BUFFER_SIZE_BYTES - SRSLTE_BUFFER_HEADER_OFFSET > idx) {
N_bytes = read(tun_fd, &pdu->msg[idx], SRSLTE_MAX_BUFFER_SIZE_BYTES - SRSLTE_BUFFER_HEADER_OFFSET - idx); N_bytes = read(tun_fd, &pdu->msg[idx], SRSLTE_MAX_BUFFER_SIZE_BYTES - SRSLTE_BUFFER_HEADER_OFFSET - idx);
} else { } else {
log.error("GW pdu buffer full - gw receive thread exiting.\n"); logger.error("GW pdu buffer full - gw receive thread exiting.");
srslte::console("GW pdu buffer full - gw receive thread exiting.\n"); srslte::console("GW pdu buffer full - gw receive thread exiting.\n");
break; break;
} }
log.debug("Read %d bytes from TUN fd=%d, idx=%d\n", N_bytes, tun_fd, idx); logger.debug("Read %d bytes from TUN fd=%d, idx=%d", N_bytes, tun_fd, idx);
if (N_bytes <= 0) { if (N_bytes <= 0) {
log.error("Failed to read from TUN interface - gw receive thread exiting.\n"); logger.error("Failed to read from TUN interface - gw receive thread exiting.");
srslte::console("Failed to read from TUN interface - gw receive thread exiting.\n"); srslte::console("Failed to read from TUN interface - gw receive thread exiting.\n");
break; break;
} }
@ -256,19 +260,19 @@ void gw::run_thread()
} else if (ip_pkt->version == 6) { } else if (ip_pkt->version == 6) {
pkt_len = ntohs(ip6_pkt->payload_len) + 40; pkt_len = ntohs(ip6_pkt->payload_len) + 40;
} else { } else {
log.error_hex(pdu->msg, pdu->N_bytes, "Unsupported IP version. Dropping packet.\n"); logger.error(pdu->msg, pdu->N_bytes, "Unsupported IP version. Dropping packet.");
continue; continue;
} }
log.debug("IPv%d packet total length: %d Bytes\n", ip_pkt->version, pkt_len); logger.debug("IPv%d packet total length: %d Bytes", int(ip_pkt->version), pkt_len);
// Check if entire packet was received // Check if entire packet was received
if (pkt_len == pdu->N_bytes) { if (pkt_len == pdu->N_bytes) {
log.info_hex(pdu->msg, pdu->N_bytes, "TX PDU"); logger.info(pdu->msg, pdu->N_bytes, "TX PDU");
// Make sure UE is attached // Make sure UE is attached
while (run_enable && !stack->is_registered() && register_wait < REGISTER_WAIT_TOUT) { while (run_enable && !stack->is_registered() && register_wait < REGISTER_WAIT_TOUT) {
if (!register_wait) { if (!register_wait) {
log.info("UE is not attached, waiting for NAS attach (%d/%d)\n", register_wait, REGISTER_WAIT_TOUT); logger.info("UE is not attached, waiting for NAS attach (%d/%d)", register_wait, REGISTER_WAIT_TOUT);
} }
usleep(100000); usleep(100000);
register_wait++; register_wait++;
@ -283,8 +287,8 @@ void gw::run_thread()
// Wait for service request if necessary // Wait for service request if necessary
while (run_enable && !stack->is_lcid_enabled(default_lcid) && service_wait < SERVICE_WAIT_TOUT) { while (run_enable && !stack->is_lcid_enabled(default_lcid) && service_wait < SERVICE_WAIT_TOUT) {
if (!service_wait) { if (!service_wait) {
log.info( logger.info(
"UE does not have service, waiting for NAS service request (%d/%d)\n", service_wait, SERVICE_WAIT_TOUT); "UE does not have service, waiting for NAS service request (%d/%d)", service_wait, SERVICE_WAIT_TOUT);
stack->start_service_request(); stack->start_service_request();
} }
usleep(100000); usleep(100000);
@ -306,7 +310,7 @@ void gw::run_thread()
do { do {
pdu = srslte::allocate_unique_buffer(*pool); pdu = srslte::allocate_unique_buffer(*pool);
if (!pdu) { if (!pdu) {
log.error("Fatal Error: Couldn't allocate PDU in run_thread().\n"); logger.error("Fatal Error: Couldn't allocate PDU in run_thread().");
usleep(100000); usleep(100000);
} }
} while (!pdu); } while (!pdu);
@ -314,11 +318,11 @@ void gw::run_thread()
} }
} else { } else {
idx += N_bytes; idx += N_bytes;
log.debug("Entire packet not read from socket. Total Length %d, N_Bytes %d.\n", ip_pkt->tot_len, pdu->N_bytes); logger.debug("Entire packet not read from socket. Total Length %d, N_Bytes %d.", ip_pkt->tot_len, pdu->N_bytes);
} }
} }
running = false; running = false;
log.info("GW IP receiver thread exiting.\n"); logger.info("GW IP receiver thread exiting.");
} }
/**************************/ /**************************/
@ -337,22 +341,22 @@ int gw::init_if(char* err_str)
netns_fd = open(netns.c_str(), O_RDONLY); netns_fd = open(netns.c_str(), O_RDONLY);
if (netns_fd == -1) { if (netns_fd == -1) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to find netns %s (%s): %s\n", args.netns.c_str(), netns.c_str(), err_str); logger.error("Failed to find netns %s (%s): %s", args.netns.c_str(), netns.c_str(), err_str);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
if (setns(netns_fd, CLONE_NEWNET) == -1) { if (setns(netns_fd, CLONE_NEWNET) == -1) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to change netns: %s\n", err_str); logger.error("Failed to change netns: %s", err_str);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
} }
// Construct the TUN device // Construct the TUN device
tun_fd = open("/dev/net/tun", O_RDWR); tun_fd = open("/dev/net/tun", O_RDWR);
log.info("TUN file descriptor = %d\n", tun_fd); logger.info("TUN file descriptor = %d", tun_fd);
if (0 > tun_fd) { if (0 > tun_fd) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to open TUN device: %s\n", err_str); logger.error("Failed to open TUN device: %s", err_str);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -363,7 +367,7 @@ int gw::init_if(char* err_str)
ifr.ifr_ifrn.ifrn_name[IFNAMSIZ - 1] = 0; ifr.ifr_ifrn.ifrn_name[IFNAMSIZ - 1] = 0;
if (0 > ioctl(tun_fd, TUNSETIFF, &ifr)) { if (0 > ioctl(tun_fd, TUNSETIFF, &ifr)) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to set TUN device name: %s\n", err_str); logger.error("Failed to set TUN device name: %s", err_str);
close(tun_fd); close(tun_fd);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -372,14 +376,14 @@ int gw::init_if(char* err_str)
sock = socket(AF_INET, SOCK_DGRAM, 0); sock = socket(AF_INET, SOCK_DGRAM, 0);
if (0 > ioctl(sock, SIOCGIFFLAGS, &ifr)) { if (0 > ioctl(sock, SIOCGIFFLAGS, &ifr)) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to bring up socket: %s\n", err_str); logger.error("Failed to bring up socket: %s", err_str);
close(tun_fd); close(tun_fd);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
ifr.ifr_flags |= IFF_UP | IFF_RUNNING; ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if (0 > ioctl(sock, SIOCSIFFLAGS, &ifr)) { if (0 > ioctl(sock, SIOCSIFFLAGS, &ifr)) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Failed to set socket flags: %s\n", err_str); logger.error("Failed to set socket flags: %s", err_str);
close(tun_fd); close(tun_fd);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -388,10 +392,10 @@ int gw::init_if(char* err_str)
struct in6_addr in6p; struct in6_addr in6p;
char addr_str[INET6_ADDRSTRLEN]; char addr_str[INET6_ADDRSTRLEN];
if (find_ipv6_addr(&in6p)) { if (find_ipv6_addr(&in6p)) {
log.debug("Found link-local IPv6 address: %s\n", inet_ntop(AF_INET6, &in6p, addr_str, INET6_ADDRSTRLEN)); logger.debug("Found link-local IPv6 address: %s", inet_ntop(AF_INET6, &in6p, addr_str, INET6_ADDRSTRLEN));
del_ipv6_addr(&in6p); del_ipv6_addr(&in6p);
} else { } else {
log.warning("Could not find link-local IPv6 address.\n"); logger.warning("Could not find link-local IPv6 address.");
} }
if_up = true; if_up = true;
@ -403,7 +407,7 @@ int gw::setup_if_addr4(uint32_t ip_addr, char* err_str)
if (ip_addr != current_ip_addr) { if (ip_addr != current_ip_addr) {
if (!if_up) { if (!if_up) {
if (init_if(err_str)) { if (init_if(err_str)) {
log.error("init_if failed\n"); logger.error("init_if failed");
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
} }
@ -414,7 +418,7 @@ int gw::setup_if_addr4(uint32_t ip_addr, char* err_str)
((struct sockaddr_in*)&ifr.ifr_addr)->sin_addr.s_addr = htonl(ip_addr); ((struct sockaddr_in*)&ifr.ifr_addr)->sin_addr.s_addr = htonl(ip_addr);
if (0 > ioctl(sock, SIOCSIFADDR, &ifr)) { if (0 > ioctl(sock, SIOCSIFADDR, &ifr)) {
err_str = strerror(errno); err_str = strerror(errno);
log.debug("Failed to set socket address: %s\n", err_str); logger.debug("Failed to set socket address: %s", err_str);
close(tun_fd); close(tun_fd);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -422,7 +426,7 @@ int gw::setup_if_addr4(uint32_t ip_addr, char* err_str)
((struct sockaddr_in*)&ifr.ifr_netmask)->sin_addr.s_addr = inet_addr(args.tun_dev_netmask.c_str()); ((struct sockaddr_in*)&ifr.ifr_netmask)->sin_addr.s_addr = inet_addr(args.tun_dev_netmask.c_str());
if (0 > ioctl(sock, SIOCSIFNETMASK, &ifr)) { if (0 > ioctl(sock, SIOCSIFNETMASK, &ifr)) {
err_str = strerror(errno); err_str = strerror(errno);
log.debug("Failed to set socket netmask: %s\n", err_str); logger.debug("Failed to set socket netmask: %s", err_str);
close(tun_fd); close(tun_fd);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -447,7 +451,7 @@ int gw::setup_if_addr6(uint8_t* ipv6_if_id, char* err_str)
if (!match) { if (!match) {
if (!if_up) { if (!if_up) {
if (init_if(err_str)) { if (init_if(err_str)) {
log.error("init_if failed\n"); logger.error("init_if failed");
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
} }
@ -457,7 +461,7 @@ int gw::setup_if_addr6(uint8_t* ipv6_if_id, char* err_str)
ifr.ifr_addr.sa_family = AF_INET6; ifr.ifr_addr.sa_family = AF_INET6;
if (inet_pton(AF_INET6, "fe80::", (void*)&sai.sin6_addr) <= 0) { if (inet_pton(AF_INET6, "fe80::", (void*)&sai.sin6_addr) <= 0) {
log.error("Bad address\n"); logger.error("Bad address");
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -472,7 +476,7 @@ int gw::setup_if_addr6(uint8_t* ipv6_if_id, char* err_str)
if (ioctl(sock, SIOCSIFADDR, &ifr6) < 0) { if (ioctl(sock, SIOCSIFADDR, &ifr6) < 0) {
err_str = strerror(errno); err_str = strerror(errno);
log.error("Could not set IPv6 Link local address. Error %s\n", err_str); logger.error("Could not set IPv6 Link local address. Error %s", err_str);
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
@ -499,19 +503,19 @@ bool gw::find_ipv6_addr(struct in6_addr* in6_out)
char buf[1024]; char buf[1024];
} req; } req;
log.debug("Trying to obtain IPv6 addr of %s interface\n", args.tun_dev_name.c_str()); logger.debug("Trying to obtain IPv6 addr of %s interface", args.tun_dev_name.c_str());
// Get Interface Index // Get Interface Index
if_index = if_nametoindex(args.tun_dev_name.c_str()); if_index = if_nametoindex(args.tun_dev_name.c_str());
if (if_index == 0) { if (if_index == 0) {
log.error("Could not find interface index\n"); logger.error("Could not find interface index");
goto err_out; goto err_out;
} }
// Open NETLINK socket // Open NETLINK socket
fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (fd < 0) { if (fd < 0) {
log.error("Error openning NETLINK socket -- %s\n", strerror(errno)); logger.error("Error openning NETLINK socket -- %s", strerror(errno));
goto err_out; goto err_out;
} }
@ -532,18 +536,18 @@ bool gw::find_ipv6_addr(struct in6_addr* in6_out)
// Time to send and recv the message from kernel // Time to send and recv the message from kernel
n = send(fd, &req, req.n.nlmsg_len, 0); n = send(fd, &req, req.n.nlmsg_len, 0);
if (n < 0) { if (n < 0) {
log.error("Error sending NETLINK message to kernel -- %s", strerror(errno)); logger.error("Error sending NETLINK message to kernel -- %s", strerror(errno));
goto err_out; goto err_out;
} }
n = recv(fd, buf, sizeof(buf), 0); n = recv(fd, buf, sizeof(buf), 0);
if (n < 0) { if (n < 0) {
log.error("Error receiving from NETLINK socket\n"); logger.error("Error receiving from NETLINK socket");
goto err_out; goto err_out;
} }
if (n == 0) { if (n == 0) {
log.error("Nothing received from NETLINK Socket\n"); logger.error("Nothing received from NETLINK Socket");
goto err_out; goto err_out;
} }
@ -552,14 +556,14 @@ bool gw::find_ipv6_addr(struct in6_addr* in6_out)
// Chack NL message type // Chack NL message type
if (nlmp->nlmsg_type == NLMSG_DONE) { if (nlmp->nlmsg_type == NLMSG_DONE) {
log.error("Reach end of NETLINK message without finding IPv6 address.\n"); logger.error("Reach end of NETLINK message without finding IPv6 address.");
goto err_out; goto err_out;
} }
if (nlmp->nlmsg_type == NLMSG_ERROR) { if (nlmp->nlmsg_type == NLMSG_ERROR) {
log.error("NLMSG_ERROR in NETLINK reply\n"); logger.error("NLMSG_ERROR in NETLINK reply");
goto err_out; goto err_out;
} }
log.debug("NETLINK message type %d\n", nlmp->nlmsg_type); logger.debug("NETLINK message type %d", nlmp->nlmsg_type);
// Get IFA message // Get IFA message
rtmp = (struct ifaddrmsg*)NLMSG_DATA(nlmp); rtmp = (struct ifaddrmsg*)NLMSG_DATA(nlmp);
@ -603,14 +607,14 @@ void gw::del_ipv6_addr(struct in6_addr* in6p)
// Get Interface Index // Get Interface Index
if_index = if_nametoindex(args.tun_dev_name.c_str()); if_index = if_nametoindex(args.tun_dev_name.c_str());
if (if_index == 0) { if (if_index == 0) {
log.error("Could not find interface index\n"); logger.error("Could not find interface index");
goto out; goto out;
} }
// Open netlink socket // Open netlink socket
fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (fd < 0) { if (fd < 0) {
log.error("Error openning NETLINK socket -- %s\n", strerror(errno)); logger.error("Error openning NETLINK socket -- %s", strerror(errno));
goto out; goto out;
} }
@ -635,7 +639,7 @@ void gw::del_ipv6_addr(struct in6_addr* in6p)
status = send(fd, &req, req.n.nlmsg_len, 0); status = send(fd, &req, req.n.nlmsg_len, 0);
if (status < 0) { if (status < 0) {
log.error("Error sending NETLINK message\n"); logger.error("Error sending NETLINK message");
goto out; goto out;
} }

433
srsue/src/stack/upper/nas.cc
View File

File diff suppressed because it is too large Load Diff

14
srsue/src/stack/upper/nas_emm_state.cc
Unescape Escape View File

@ -19,7 +19,7 @@ void emm_state_t::set_null()
state = state_t::null; state = state_t::null;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_deregistered(deregistered_substate_t substate) void emm_state_t::set_deregistered(deregistered_substate_t substate)
@ -27,7 +27,7 @@ void emm_state_t::set_deregistered(deregistered_substate_t substate)
state = state_t::deregistered; state = state_t::deregistered;
deregistered_substate = substate; deregistered_substate = substate;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_deregistered_initiated() void emm_state_t::set_deregistered_initiated()
@ -35,7 +35,7 @@ void emm_state_t::set_deregistered_initiated()
state = state_t::deregistered_initiated; state = state_t::deregistered_initiated;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_registered(registered_substate_t substate) void emm_state_t::set_registered(registered_substate_t substate)
@ -43,7 +43,7 @@ void emm_state_t::set_registered(registered_substate_t substate)
state = state_t::registered; state = state_t::registered;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = substate; registered_substate = substate;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_registered_initiated() void emm_state_t::set_registered_initiated()
@ -51,7 +51,7 @@ void emm_state_t::set_registered_initiated()
state = state_t::registered_initiated; state = state_t::registered_initiated;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_tau_initiated() void emm_state_t::set_tau_initiated()
@ -59,7 +59,7 @@ void emm_state_t::set_tau_initiated()
state = state_t::tau_initiated; state = state_t::tau_initiated;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
void emm_state_t::set_service_request_initiated() void emm_state_t::set_service_request_initiated()
@ -67,7 +67,7 @@ void emm_state_t::set_service_request_initiated()
state = state_t::service_request_initiated; state = state_t::service_request_initiated;
deregistered_substate = deregistered_substate_t::null; deregistered_substate = deregistered_substate_t::null;
registered_substate = registered_substate_t::null; registered_substate = registered_substate_t::null;
nas_log->debug("Changed to EMM state: %s\n", get_full_state_text().c_str()); logger.debug("Changed to EMM state: %s", get_full_state_text().c_str());
} }
const std::string emm_state_t::get_full_state_text() const std::string emm_state_t::get_full_state_text()

23
srsue/src/stack/upper/nas_idle_procedures.cc
Unescape Escape View File

@ -14,9 +14,9 @@
using namespace srslte; using namespace srslte;
#define ProcError(fmt, ...) nas_ptr->nas_log->error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define ProcError(fmt, ...) nas_ptr->logger.error("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define ProcWarning(fmt, ...) nas_ptr->nas_log->warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define ProcWarning(fmt, ...) nas_ptr->logger.warning("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
#define ProcInfo(fmt, ...) nas_ptr->nas_log->info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__) #define ProcInfo(fmt, ...) nas_ptr->logger.info("Proc \"%s\" - " fmt, name(), ##__VA_ARGS__)
namespace srsue { namespace srsue {
@ -30,11 +30,11 @@ proc_outcome_t nas::plmn_search_proc::init()
{ {
// start RRC PLMN selection // start RRC PLMN selection
if (not nas_ptr->rrc->plmn_search()) { if (not nas_ptr->rrc->plmn_search()) {
ProcError("ProcError while searching for PLMNs\n"); ProcError("ProcError while searching for PLMNs");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
ProcInfo("Starting...\n"); ProcInfo("Starting...");
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -45,7 +45,7 @@ proc_outcome_t nas::plmn_search_proc::step()
void nas::plmn_search_proc::then(const srslte::proc_state_t& result) void nas::plmn_search_proc::then(const srslte::proc_state_t& result)
{ {
ProcInfo("Completed with %s\n", result.is_success() ? "success" : "failure"); ProcInfo("Completed with %s", result.is_success() ? "success" : "failure");
if (result.is_error()) { if (result.is_error()) {
nas_ptr->enter_emm_deregistered(emm_state_t::deregistered_substate_t::plmn_search); nas_ptr->enter_emm_deregistered(emm_state_t::deregistered_substate_t::plmn_search);
@ -57,16 +57,16 @@ proc_outcome_t nas::plmn_search_proc::react(const plmn_search_complete_t& t)
// check whether the NAS state hasn't changed // check whether the NAS state hasn't changed
if (nas_ptr->state.get_state() != emm_state_t::state_t::deregistered and if (nas_ptr->state.get_state() != emm_state_t::state_t::deregistered and
nas_ptr->state.get_deregistered_substate() != emm_state_t::deregistered_substate_t::plmn_search) { nas_ptr->state.get_deregistered_substate() != emm_state_t::deregistered_substate_t::plmn_search) {
ProcError("ProcError while searching for PLMNs\n"); ProcError("ProcError while searching for PLMNs");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (t.nof_plmns < 0) { if (t.nof_plmns < 0) {
ProcError("Error while searching for PLMNs\n"); ProcError("Error while searching for PLMNs");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (t.nof_plmns == 0) { if (t.nof_plmns == 0) {
ProcWarning("Did not find any PLMN in the set of frequencies.\n"); ProcWarning("Did not find any PLMN in the set of frequencies.");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -74,8 +74,7 @@ proc_outcome_t nas::plmn_search_proc::react(const plmn_search_complete_t& t)
nas_ptr->known_plmns.clear(); nas_ptr->known_plmns.clear();
for (int i = 0; i < t.nof_plmns; i++) { for (int i = 0; i < t.nof_plmns; i++) {
nas_ptr->known_plmns.push_back(t.found_plmns[i].plmn_id); nas_ptr->known_plmns.push_back(t.found_plmns[i].plmn_id);
nas_ptr->nas_log->info( ProcInfo("Found PLMN: Id=%s, TAC=%d", t.found_plmns[i].plmn_id.to_string().c_str(), t.found_plmns[i].tac);
"Found PLMN: Id=%s, TAC=%d\n", t.found_plmns[i].plmn_id.to_string().c_str(), t.found_plmns[i].tac);
srslte::console("Found PLMN: Id=%s, TAC=%d\n", t.found_plmns[i].plmn_id.to_string().c_str(), t.found_plmns[i].tac); srslte::console("Found PLMN: Id=%s, TAC=%d\n", t.found_plmns[i].plmn_id.to_string().c_str(), t.found_plmns[i].tac);
} }
nas_ptr->select_plmn(); nas_ptr->select_plmn();
@ -83,7 +82,7 @@ proc_outcome_t nas::plmn_search_proc::react(const plmn_search_complete_t& t)
// Select PLMN in request establishment of RRC connection // Select PLMN in request establishment of RRC connection
if (nas_ptr->state.get_state() != emm_state_t::state_t::deregistered and if (nas_ptr->state.get_state() != emm_state_t::state_t::deregistered and
nas_ptr->state.get_deregistered_substate() != emm_state_t::deregistered_substate_t::normal_service) { nas_ptr->state.get_deregistered_substate() != emm_state_t::deregistered_substate_t::normal_service) {
ProcError("PLMN is not selected because no suitable PLMN was found\n"); ProcError("PLMN is not selected because no suitable PLMN was found");
return proc_outcome_t::error; return proc_outcome_t::error;
} }

271
srsue/src/stack/upper/pcsc_usim.cc
Unescape Escape View File

@ -22,7 +22,7 @@ using namespace srslte;
namespace srsue { namespace srsue {
pcsc_usim::pcsc_usim(srslte::log* log_) : usim_base(log_) pcsc_usim::pcsc_usim(srslog::basic_logger& logger) : usim_base(logger), sc(logger)
{ {
bzero(ck, CK_LEN); bzero(ck, CK_LEN);
bzero(ik, IK_LEN); bzero(ik, IK_LEN);
@ -41,7 +41,7 @@ int pcsc_usim::init(usim_args_t* args)
{ {
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
if (sc.init(args, log) != SRSLTE_SUCCESS) { if (sc.init(args) != SRSLTE_SUCCESS) {
return ret; return ret;
} }
@ -49,7 +49,7 @@ int pcsc_usim::init(usim_args_t* args)
char tmp[15]; char tmp[15];
size_t tmp_len = 15; // set to max IMSI length size_t tmp_len = 15; // set to max IMSI length
if (sc.get_imsi(tmp, &tmp_len)) { if (sc.get_imsi(tmp, &tmp_len)) {
log->error("Error reading IMSI from SIM.\n"); logger.error("Error reading IMSI from SIM.");
return ret; return ret;
} }
imsi_str.assign(tmp, tmp_len); imsi_str.assign(tmp, tmp_len);
@ -63,7 +63,7 @@ int pcsc_usim::init(usim_args_t* args)
imsi += imsi_c[i] - '0'; imsi += imsi_c[i] - '0';
} }
} else { } else {
log->error("Invalid length for IMSI: %zu should be %d\n", imsi_str.length(), 15); logger.error("Invalid length for IMSI: %zu should be %d", imsi_str.length(), 15);
srslte::console("Invalid length for IMSI: %zu should be %d\n", imsi_str.length(), 15); srslte::console("Invalid length for IMSI: %zu should be %d\n", imsi_str.length(), 15);
return ret; return ret;
} }
@ -77,7 +77,7 @@ int pcsc_usim::init(usim_args_t* args)
imei += imei_c[i] - '0'; imei += imei_c[i] - '0';
} }
} else { } else {
log->error("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15); logger.error("Invalid length for IMEI: %zu should be %d", args->imei.length(), 15);
srslte::console("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15); srslte::console("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15);
return ret; return ret;
} }
@ -104,26 +104,26 @@ auth_result_t pcsc_usim::generate_authentication_response(uint8_t* rand,
{ {
auth_result_t ret = AUTH_FAILED; auth_result_t ret = AUTH_FAILED;
if (!initiated) { if (!initiated) {
ERROR("USIM not initiated!\n"); ERROR("USIM not initiated!");
return ret; return ret;
} }
// Use RAND and AUTN to compute RES, CK, IK using SIM card // Use RAND and AUTN to compute RES, CK, IK using SIM card
switch (sc.umts_auth(rand, autn_enb, res, res_len, ik, ck, auts)) { switch (sc.umts_auth(rand, autn_enb, res, res_len, ik, ck, auts)) {
case 0: case 0:
log->info("SCARD: USIM authentication successful.\n"); logger.info("SCARD: USIM authentication successful.");
break; break;
case -1: case -1:
log->error("SCARD: Failure during USIM UMTS authentication\n"); logger.error("SCARD: Failure during USIM UMTS authentication");
return ret; return ret;
case -2: case -2:
log->info("SCARD: USIM synchronization failure, AUTS generated\n"); logger.info("SCARD: USIM synchronization failure, AUTS generated");
log->debug_hex(auts, AKA_AUTS_LEN, "AUTS\n"); logger.debug(auts, AKA_AUTS_LEN, "AUTS");
memcpy(res, auts, AKA_AUTS_LEN); memcpy(res, auts, AKA_AUTS_LEN);
*res_len = AKA_AUTS_LEN; *res_len = AKA_AUTS_LEN;
return AUTH_SYNCH_FAILURE; return AUTH_SYNCH_FAILURE;
default: default:
log->warning("SCARD: Unknown USIM failure.\n"); logger.warning("SCARD: Unknown USIM failure.");
return ret; return ret;
} }
@ -137,13 +137,13 @@ auth_result_t pcsc_usim::generate_authentication_response(uint8_t* rand,
} }
// Generate K_asme // Generate K_asme
log->debug_hex(ck, CK_LEN, "CK:\n"); logger.debug(ck, CK_LEN, "CK:");
log->debug_hex(ik, IK_LEN, "IK:\n"); logger.debug(ik, IK_LEN, "IK:");
log->debug_hex(ak, AK_LEN, "AK:\n"); logger.debug(ak, AK_LEN, "AK:");
log->debug_hex(sqn, SQN_LEN, "SQN:\n"); logger.debug(sqn, SQN_LEN, "SQN:");
log->debug("mcc=%d, mnc=%d\n", mcc, mnc); logger.debug("mcc=%d, mnc=%d", mcc, mnc);
security_generate_k_asme(ck, ik, ak, sqn, mcc, mnc, k_asme); security_generate_k_asme(ck, ik, ak, sqn, mcc, mnc, k_asme);
log->info_hex(k_asme, KEY_LEN, "K_ASME:\n"); logger.info(k_asme, KEY_LEN, "K_ASME:");
ret = AUTH_OK; ret = AUTH_OK;
@ -168,49 +168,48 @@ std::string pcsc_usim::get_mnc_str(const uint8_t* imsi_vec, std::string mcc_str)
********************************/ ********************************/
// return 0 if initialization was successfull, -1 otherwies // return 0 if initialization was successfull, -1 otherwies
int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_) int pcsc_usim::scard::init(usim_args_t* args)
{ {
int ret_value = SRSLTE_ERROR; int ret_value = SRSLTE_ERROR;
uint pos = 0; // SC reader uint pos = 0; // SC reader
bool reader_found = false; bool reader_found = false;
// int transaction = 1; // int transaction = 1;
size_t blen; size_t blen;
log = log_;
long ret; long ret;
ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &scard_context); ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &scard_context);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->error("SCardEstablishContext(): %s\n", pcsc_stringify_error(ret)); logger.error("SCardEstablishContext(): %s", pcsc_stringify_error(ret));
return ret_value; return ret_value;
} }
unsigned long len = 0; unsigned long len = 0;
ret = SCardListReaders(scard_context, NULL, NULL, &len); ret = SCardListReaders(scard_context, NULL, NULL, &len);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->error("SCardListReaders(): %s\n", pcsc_stringify_error(ret)); logger.error("SCardListReaders(): %s", pcsc_stringify_error(ret));
return ret_value; return ret_value;
} }
char* readers = (char*)malloc(len); char* readers = (char*)malloc(len);
if (readers == NULL) { if (readers == NULL) {
log->error("Malloc failed\n"); logger.error("Malloc failed");
return ret_value; return ret_value;
} }
ret = SCardListReaders(scard_context, NULL, readers, &len); ret = SCardListReaders(scard_context, NULL, readers, &len);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->error("SCardListReaders() 2: %s\n", pcsc_stringify_error(ret)); logger.error("SCardListReaders() 2: %s", pcsc_stringify_error(ret));
goto clean_exit; goto clean_exit;
} }
if (len < 3) { if (len < 3) {
log->info("No smart card readers available.\n"); logger.info("No smart card readers available.");
return ret_value; return ret_value;
} }
/* readers: NULL-separated list of reader names, and terminating NULL */ /* readers: NULL-separated list of reader names, and terminating NULL */
pos = 0; pos = 0;
while (pos < len - 1) { while (pos < len - 1) {
log->info("Available Card Reader: %s\n", &readers[pos]); logger.info("Available Card Reader: %s", &readers[pos]);
while (readers[pos] != '\0' && pos < len) { while (readers[pos] != '\0' && pos < len) {
pos++; pos++;
} }
@ -223,7 +222,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
// If no reader specified, test all available readers for SIM cards. Otherwise consider specified reader only. // If no reader specified, test all available readers for SIM cards. Otherwise consider specified reader only.
if (args->reader.length() == 0) { if (args->reader.length() == 0) {
while (pos < len && !reader_found) { while (pos < len && !reader_found) {
log->info("Trying Card Reader: %s\n", &readers[pos]); logger.info("Trying Card Reader: %s", &readers[pos]);
// Connect to card // Connect to card
ret = SCardConnect(scard_context, ret = SCardConnect(scard_context,
&readers[pos], &readers[pos],
@ -235,11 +234,11 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
reader_found = true; reader_found = true;
} else { } else {
if (ret == (long)SCARD_E_NO_SMARTCARD) { if (ret == (long)SCARD_E_NO_SMARTCARD) {
log->error("No smart card inserted.\n"); logger.error("No smart card inserted.");
} else { } else {
log->error("%s\n", pcsc_stringify_error(ret)); logger.error("%s", pcsc_stringify_error(ret));
} }
log->info("Failed to use Card Reader: %s\n", &readers[pos]); logger.info("Failed to use Card Reader: %s", &readers[pos]);
// proceed to next reader // proceed to next reader
while (pos < len && readers[pos] != '\0') { while (pos < len && readers[pos] != '\0') {
@ -253,7 +252,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
while (pos < len && !reader_found) { while (pos < len && !reader_found) {
if (strcmp(&readers[pos], args->reader.c_str()) == 0) { if (strcmp(&readers[pos], args->reader.c_str()) == 0) {
reader_found = true; reader_found = true;
log->info("Card Reader found: %s\n", args->reader.c_str()); logger.info("Card Reader found: %s", args->reader.c_str());
} else { } else {
// next reader // next reader
while (pos < len && readers[pos] != '\0') { while (pos < len && readers[pos] != '\0') {
@ -263,7 +262,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
} }
} }
if (!reader_found) { if (!reader_found) {
log->error("Cannot find reader: %s\n", args->reader.c_str()); logger.error("Cannot find reader: %s", args->reader.c_str());
} else { } else {
ret = SCardConnect(scard_context, ret = SCardConnect(scard_context,
&readers[pos], &readers[pos],
@ -275,12 +274,12 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
// successfully connected to card // successfully connected to card
} else { } else {
if (ret == (long)SCARD_E_NO_SMARTCARD) { if (ret == (long)SCARD_E_NO_SMARTCARD) {
log->error("No smart card inserted.\n"); logger.error("No smart card inserted.");
} else { } else {
log->error("%s\n", pcsc_stringify_error(ret)); logger.error("%s", pcsc_stringify_error(ret));
} }
log->info("Failed to use Card Reader: %s\n", args->reader.c_str()); logger.info("Failed to use Card Reader: %s", args->reader.c_str());
} }
} }
} }
@ -288,14 +287,14 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
free(readers); free(readers);
readers = NULL; readers = NULL;
log->info("Card=0x%x active_protocol=%lu (%s)\n", logger.info("Card=0x%x active_protocol=%lu (%s)",
(unsigned int)scard_handle, (unsigned int)scard_handle,
(unsigned long)scard_protocol, (unsigned long)scard_protocol,
scard_protocol == SCARD_PROTOCOL_T0 ? "T0" : "T1"); scard_protocol == SCARD_PROTOCOL_T0 ? "T0" : "T1");
ret = SCardBeginTransaction(scard_handle); ret = SCardBeginTransaction(scard_handle);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->error("%s\n", pcsc_stringify_error(ret)); logger.error("%s", pcsc_stringify_error(ret));
goto clean_exit; goto clean_exit;
} }
@ -303,23 +302,23 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
unsigned char buf[100]; unsigned char buf[100];
blen = sizeof(buf); blen = sizeof(buf);
if (_select_file(SCARD_FILE_MF, buf, &blen, SCARD_USIM, NULL, 0)) { if (_select_file(SCARD_FILE_MF, buf, &blen, SCARD_USIM, NULL, 0)) {
log->info("USIM is not supported. Trying to use GSM SIM"); logger.info("USIM is not supported. Trying to use GSM SIM");
sim_type = SCARD_GSM_SIM; sim_type = SCARD_GSM_SIM;
} else { } else {
log->info("USIM is supported\n"); logger.info("USIM is supported");
sim_type = SCARD_USIM; sim_type = SCARD_USIM;
} }
if (sim_type == SCARD_GSM_SIM) { if (sim_type == SCARD_GSM_SIM) {
blen = sizeof(buf); blen = sizeof(buf);
if (select_file(SCARD_FILE_MF, buf, &blen)) { if (select_file(SCARD_FILE_MF, buf, &blen)) {
log->debug("SCARD: Failed to read MF\n"); logger.debug("SCARD: Failed to read MF");
goto clean_exit; goto clean_exit;
} }
blen = sizeof(buf); blen = sizeof(buf);
if (select_file(SCARD_FILE_GSM_DF, buf, &blen)) { if (select_file(SCARD_FILE_GSM_DF, buf, &blen)) {
log->debug("SCARD: Failed to read GSM DF\n"); logger.debug("SCARD: Failed to read GSM DF");
goto clean_exit; goto clean_exit;
} }
} else { } else {
@ -328,19 +327,19 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
aid_len = get_aid(aid, sizeof(aid)); aid_len = get_aid(aid, sizeof(aid));
if (aid_len < 0) { if (aid_len < 0) {
log->debug("SCARD: Failed to find AID for 3G USIM app - try to use standard 3G RID\n"); logger.debug("SCARD: Failed to find AID for 3G USIM app - try to use standard 3G RID");
memcpy(aid, "\xa0\x00\x00\x00\x87", 5); memcpy(aid, "\xa0\x00\x00\x00\x87", 5);
aid_len = 5; aid_len = 5;
} }
log->debug_hex(aid, aid_len, "SCARD: 3G USIM AID\n"); logger.debug(aid, aid_len, "SCARD: 3G USIM AID");
/* Select based on AID = 3G RID from EF_DIR. This is usually /* Select based on AID = 3G RID from EF_DIR. This is usually
* starting with A0 00 00 00 87. */ * starting with A0 00 00 00 87. */
blen = sizeof(buf); blen = sizeof(buf);
if (_select_file(0, buf, &blen, sim_type, aid, aid_len)) { if (_select_file(0, buf, &blen, sim_type, aid, aid_len)) {
log->error("SCARD: Failed to read 3G USIM app\n"); logger.error("SCARD: Failed to read 3G USIM app");
log->error_hex(aid, aid_len, "SCARD: 3G USIM AID\n"); logger.error(aid, aid_len, "SCARD: 3G USIM AID");
goto clean_exit; goto clean_exit;
} }
} }
@ -349,11 +348,11 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
// Verify whether CHV1 (PIN1) is needed to access the card. // Verify whether CHV1 (PIN1) is needed to access the card.
ret = pin_needed(buf, blen); ret = pin_needed(buf, blen);
if (ret < 0) { if (ret < 0) {
log->debug("SCARD: Failed to determine whether PIN is needed\n"); logger.debug("SCARD: Failed to determine whether PIN is needed");
goto clean_exit; goto clean_exit;
} }
if (ret) { if (ret) {
log->debug("PIN1 needed for SIM access (retry counter=%d)\n", get_pin_retry_counter()); logger.debug("PIN1 needed for SIM access (retry counter=%d)", get_pin_retry_counter());
pin1_needed = true; pin1_needed = true;
} else { } else {
pin1_needed = false; pin1_needed = false;
@ -361,7 +360,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
// stop before pin retry counter reaches zero // stop before pin retry counter reaches zero
if (pin1_needed && get_pin_retry_counter() <= 1) { if (pin1_needed && get_pin_retry_counter() <= 1) {
log->error("PIN1 needed for SIM access (retry counter=%d), emergency stop.\n", get_pin_retry_counter()); logger.error("PIN1 needed for SIM access (retry counter=%d), emergency stop.", get_pin_retry_counter());
goto clean_exit; goto clean_exit;
} }
@ -370,7 +369,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
// verify PIN // verify PIN
ret = verify_pin(args->pin.c_str()); ret = verify_pin(args->pin.c_str());
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->debug("SCARD: Could not verify PIN\n"); logger.debug("SCARD: Could not verify PIN");
goto clean_exit; goto clean_exit;
} }
} }
@ -380,7 +379,7 @@ int pcsc_usim::scard::init(usim_args_t* args, srslte::log* log_)
ret = SCardEndTransaction(scard_handle, SCARD_LEAVE_CARD); ret = SCardEndTransaction(scard_handle, SCARD_LEAVE_CARD);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->debug("SCARD: Could not end transaction: 0x%x\n", (unsigned int)ret); logger.debug("SCARD: Could not end transaction: 0x%x", (unsigned int)ret);
goto clean_exit; goto clean_exit;
} }
@ -414,9 +413,9 @@ int pcsc_usim::scard::_select_file(unsigned short file_id,
get_resp[0] = USIM_CLA; get_resp[0] = USIM_CLA;
} }
log->debug("SCARD: select file %04x\n", file_id); logger.debug("SCARD: select file %04x", file_id);
if (aid) { if (aid) {
log->debug_hex(aid, aidlen, "SCARD: select file by AID"); logger.debug(aid, aidlen, "SCARD: select file by AID");
if (5 + aidlen > sizeof(cmd)) if (5 + aidlen > sizeof(cmd))
return -1; return -1;
cmd[2] = 0x04; /* Select by AID */ cmd[2] = 0x04; /* Select by AID */
@ -431,34 +430,34 @@ int pcsc_usim::scard::_select_file(unsigned short file_id,
len = sizeof(resp); len = sizeof(resp);
ret = transmit(cmd, cmdlen, resp, &len); ret = transmit(cmd, cmdlen, resp, &len);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->error("SCARD: SCardTransmit failed %s\n", pcsc_stringify_error(ret)); logger.error("SCARD: SCardTransmit failed %s", pcsc_stringify_error(ret));
return -1; return -1;
} }
if (len != 2) { if (len != 2) {
log->error("SCARD: unexpected resp len %d (expected 2)\n", (int)len); logger.error("SCARD: unexpected resp len %d (expected 2)", (int)len);
return -1; return -1;
} }
if (resp[0] == 0x98 && resp[1] == 0x04) { if (resp[0] == 0x98 && resp[1] == 0x04) {
/* Security status not satisfied (PIN_WLAN) */ /* Security status not satisfied (PIN_WLAN) */
log->warning("SCARD: Security status not satisfied.\n"); logger.warning("SCARD: Security status not satisfied.");
return -1; return -1;
} }
if (resp[0] == 0x6e) { if (resp[0] == 0x6e) {
log->debug("SCARD: used CLA not supported.\n"); logger.debug("SCARD: used CLA not supported.");
return -1; return -1;
} }
if (resp[0] != 0x6c && resp[0] != 0x9f && resp[0] != 0x61) { if (resp[0] != 0x6c && resp[0] != 0x9f && resp[0] != 0x61) {
log->warning("SCARD: unexpected response 0x%02x (expected 0x61, 0x6c, or 0x9f)\n", resp[0]); logger.warning("SCARD: unexpected response 0x%02x (expected 0x61, 0x6c, or 0x9f)", resp[0]);
return -1; return -1;
} }
/* Normal ending of command; resp[1] bytes available */ /* Normal ending of command; resp[1] bytes available */
get_resp[4] = resp[1]; get_resp[4] = resp[1];
log->debug("SCARD: trying to get response (%d bytes)\n", resp[1]); logger.debug("SCARD: trying to get response (%d bytes)", resp[1]);
rlen = *buf_len; rlen = *buf_len;
ret = transmit(get_resp, sizeof(get_resp), buf, &rlen); ret = transmit(get_resp, sizeof(get_resp), buf, &rlen);
@ -467,7 +466,7 @@ int pcsc_usim::scard::_select_file(unsigned short file_id,
return 0; return 0;
} }
log->warning("SCARD: SCardTransmit err=0x%lx\n", ret); logger.warning("SCARD: SCardTransmit err=0x%lx", ret);
return -1; return -1;
} }
@ -481,7 +480,7 @@ long pcsc_usim::scard::transmit(unsigned char* _send, size_t send_len, unsigned
long ret; long ret;
unsigned long rlen; unsigned long rlen;
log->debug_hex(_send, send_len, "SCARD: scard_transmit: send\n"); logger.debug(_send, send_len, "SCARD: scard_transmit: send");
rlen = *recv_len; rlen = *recv_len;
ret = SCardTransmit(scard_handle, ret = SCardTransmit(scard_handle,
scard_protocol == SCARD_PROTOCOL_T1 ? SCARD_PCI_T1 : SCARD_PCI_T0, scard_protocol == SCARD_PROTOCOL_T1 ? SCARD_PCI_T1 : SCARD_PCI_T0,
@ -492,9 +491,9 @@ long pcsc_usim::scard::transmit(unsigned char* _send, size_t send_len, unsigned
&rlen); &rlen);
*recv_len = rlen; *recv_len = rlen;
if (ret == SCARD_S_SUCCESS) { if (ret == SCARD_S_SUCCESS) {
log->debug_hex(_recv, rlen, "SCARD: SCardTransmit: recv\n"); logger.debug(_recv, rlen, "SCARD: SCardTransmit: recv");
} else { } else {
log->error("SCARD: SCardTransmit failed %s\n", pcsc_stringify_error(ret)); logger.error("SCARD: SCardTransmit failed %s", pcsc_stringify_error(ret));
} }
return ret; return ret;
} }
@ -529,7 +528,7 @@ int pcsc_usim::scard::get_pin_retry_counter()
size_t len; size_t len;
uint16_t val; uint16_t val;
log->info("SCARD: fetching PIN retry counter\n"); logger.info("SCARD: fetching PIN retry counter");
if (sim_type == SCARD_USIM) if (sim_type == SCARD_USIM)
cmd[0] = USIM_CLA; cmd[0] = USIM_CLA;
@ -541,20 +540,20 @@ int pcsc_usim::scard::get_pin_retry_counter()
return -2; return -2;
if (len != 2) { if (len != 2) {
log->error("SCARD: failed to fetch PIN retry counter\n"); logger.error("SCARD: failed to fetch PIN retry counter");
return -1; return -1;
} }
val = to_uint16(resp); val = to_uint16(resp);
if (val == 0x63c0 || val == 0x6983) { if (val == 0x63c0 || val == 0x6983) {
log->debug("SCARD: PIN has been blocked\n"); logger.debug("SCARD: PIN has been blocked");
return 0; return 0;
} }
if (val >= 0x63c0 && val <= 0x63cf) if (val >= 0x63c0 && val <= 0x63cf)
return val & 0x000f; return val & 0x000f;
log->info("SCARD: Unexpected PIN retry counter response value 0x%x\n", val); logger.info("SCARD: Unexpected PIN retry counter response value 0x%x", val);
return 0; return 0;
} }
@ -577,64 +576,64 @@ int pcsc_usim::scard::get_aid(unsigned char* aid, size_t maxlen)
aid_pos = &buf[4]; aid_pos = &buf[4];
blen = sizeof(buf); blen = sizeof(buf);
if (select_file(SCARD_FILE_EF_DIR, buf, &blen)) { if (select_file(SCARD_FILE_EF_DIR, buf, &blen)) {
log->debug("SCARD: Failed to read EF_DIR\n"); logger.debug("SCARD: Failed to read EF_DIR");
return -1; return -1;
} }
log->debug_hex(buf, blen, "SCARD: EF_DIR select\n"); logger.debug(buf, blen, "SCARD: EF_DIR select");
for (rec = 1; rec < 10; rec++) { for (rec = 1; rec < 10; rec++) {
rlen = get_record_len(rec, SIM_RECORD_MODE_ABSOLUTE); rlen = get_record_len(rec, SIM_RECORD_MODE_ABSOLUTE);
if (rlen < 0) { if (rlen < 0) {
log->debug("SCARD: Failed to get EF_DIR record length\n"); logger.debug("SCARD: Failed to get EF_DIR record length");
return -1; return -1;
} }
blen = sizeof(buf); blen = sizeof(buf);
if (rlen > (int)blen) { if (rlen > (int)blen) {
log->debug("SCARD: Too long EF_DIR record\n"); logger.debug("SCARD: Too long EF_DIR record");
return -1; return -1;
} }
if (read_record(buf, rlen, rec, SIM_RECORD_MODE_ABSOLUTE) < 0) { if (read_record(buf, rlen, rec, SIM_RECORD_MODE_ABSOLUTE) < 0) {
log->debug("SCARD: Failed to read EF_DIR record %d", rec); logger.debug("SCARD: Failed to read EF_DIR record %d", rec);
return -1; return -1;
} }
log->debug_hex(buf, rlen, "SCARD: EF_DIR record\n"); logger.debug(buf, rlen, "SCARD: EF_DIR record");
if (efdir->appl_template_tag != 0x61) { if (efdir->appl_template_tag != 0x61) {
log->debug("SCARD: Unexpected application template tag 0x%x", efdir->appl_template_tag); logger.debug("SCARD: Unexpected application template tag 0x%x", efdir->appl_template_tag);
continue; continue;
} }
if (efdir->appl_template_len > rlen - 2) { if (efdir->appl_template_len > rlen - 2) {
log->debug("SCARD: Too long application template (len=%d rlen=%d)", efdir->appl_template_len, rlen); logger.debug("SCARD: Too long application template (len=%d rlen=%d)", efdir->appl_template_len, rlen);
continue; continue;
} }
if (efdir->appl_id_tag != 0x4f) { if (efdir->appl_id_tag != 0x4f) {
log->debug("SCARD: Unexpected application identifier tag 0x%x", efdir->appl_id_tag); logger.debug("SCARD: Unexpected application identifier tag 0x%x", efdir->appl_id_tag);
continue; continue;
} }
aid_len = efdir->aid_len; aid_len = efdir->aid_len;
if (aid_len < 1 || aid_len > 16) { if (aid_len < 1 || aid_len > 16) {
log->debug("SCARD: Invalid AID length %u\n", aid_len); logger.debug("SCARD: Invalid AID length %u", aid_len);
continue; continue;
} }
log->debug_hex(aid_pos, aid_len, "SCARD: AID from EF_DIR record\n"); logger.debug(aid_pos, aid_len, "SCARD: AID from EF_DIR record");
if (efdir->appl_code[0] == 0x10 && efdir->appl_code[1] == 0x02) { if (efdir->appl_code[0] == 0x10 && efdir->appl_code[1] == 0x02) {
log->debug("SCARD: 3G USIM app found from EF_DIR record %d\n", rec); logger.debug("SCARD: 3G USIM app found from EF_DIR record %d", rec);
break; break;
} }
} }
if (rec >= 10) { if (rec >= 10) {
log->debug("SCARD: 3G USIM app not found from EF_DIR records\n"); logger.debug("SCARD: 3G USIM app not found from EF_DIR records");
return -1; return -1;
} }
if (aid_len > maxlen) { if (aid_len > maxlen) {
log->debug("SCARD: Too long AID\n"); logger.debug("SCARD: Too long AID");
return -1; return -1;
} }
@ -659,14 +658,14 @@ int pcsc_usim::scard::get_record_len(unsigned char recnum, unsigned char mode)
blen = sizeof(buf); blen = sizeof(buf);
ret = transmit(cmd, sizeof(cmd), buf, &blen); ret = transmit(cmd, sizeof(cmd), buf, &blen);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->debug("SCARD: failed to determine file length for record %d\n", recnum); logger.debug("SCARD: failed to determine file length for record %d", recnum);
return -1; return -1;
} }
log->debug_hex(buf, blen, "SCARD: file length determination response\n"); logger.debug(buf, blen, "SCARD: file length determination response");
if (blen < 2 || (buf[0] != 0x6c && buf[0] != 0x67)) { if (blen < 2 || (buf[0] != 0x6c && buf[0] != 0x67)) {
log->error("SCARD: unexpected response to file length determination\n"); logger.error("SCARD: unexpected response to file length determination");
return -1; return -1;
} }
@ -696,13 +695,13 @@ int pcsc_usim::scard::read_record(unsigned char* data, size_t len, unsigned char
return -2; return -2;
} }
if (blen != len + 2) { if (blen != len + 2) {
log->debug("SCARD: record read returned unexpected length %ld (expected %ld)\n", (long)blen, (long)len + 2); logger.debug("SCARD: record read returned unexpected length %ld (expected %ld)", (long)blen, (long)len + 2);
free(buf); free(buf);
return -3; return -3;
} }
if (buf[len] != 0x90 || buf[len + 1] != 0x00) { if (buf[len] != 0x90 || buf[len + 1] != 0x00) {
log->debug("SCARD: record read returned unexpected status %02x %02x (expected 90 00)\n", buf[len], buf[len + 1]); logger.debug("SCARD: record read returned unexpected status %02x %02x (expected 90 00)", buf[len], buf[len + 1]);
free(buf); free(buf);
return -4; return -4;
} }
@ -733,12 +732,12 @@ int pcsc_usim::scard::get_imsi(char* imsi, size_t* len)
size_t blen, imsilen, i; size_t blen, imsilen, i;
char* pos; char* pos;
log->debug("SCARD: reading IMSI from (GSM) EF-IMSI\n"); logger.debug("SCARD: reading IMSI from (GSM) EF-IMSI");
blen = sizeof(buf); blen = sizeof(buf);
if (select_file(SCARD_FILE_GSM_EF_IMSI, buf, &blen)) if (select_file(SCARD_FILE_GSM_EF_IMSI, buf, &blen))
return -1; return -1;
if (blen < 4) { if (blen < 4) {
log->warning("SCARD: too short (GSM) EF-IMSI header (len=%ld)\n", (long)blen); logger.warning("SCARD: too short (GSM) EF-IMSI header (len=%ld)", (long)blen);
return -2; return -2;
} }
@ -751,12 +750,12 @@ int pcsc_usim::scard::get_imsi(char* imsi, size_t* len)
blen = file_size; blen = file_size;
} }
if (blen < 2 || blen > sizeof(buf)) { if (blen < 2 || blen > sizeof(buf)) {
log->debug("SCARD: invalid IMSI file length=%ld\n", (long)blen); logger.debug("SCARD: invalid IMSI file length=%ld", (long)blen);
return -3; return -3;
} }
imsilen = (blen - 2) * 2 + 1; imsilen = (blen - 2) * 2 + 1;
log->debug("SCARD: IMSI file length=%ld imsilen=%ld\n", (long)blen, (long)imsilen); logger.debug("SCARD: IMSI file length=%ld imsilen=%ld", (long)blen, (long)imsilen);
if (imsilen > *len) { if (imsilen > *len) {
*len = imsilen; *len = imsilen;
return -4; return -4;
@ -808,13 +807,13 @@ int pcsc_usim::scard::read_file(unsigned char* data, size_t len)
return -2; return -2;
} }
if (blen != len + 2) { if (blen != len + 2) {
log->error("SCARD: file read returned unexpected length %ld (expected %ld)\n", (long)blen, (long)len + 2); logger.error("SCARD: file read returned unexpected length %ld (expected %ld)", (long)blen, (long)len + 2);
free(buf); free(buf);
return -3; return -3;
} }
if (buf[len] != 0x90 || buf[len + 1] != 0x00) { if (buf[len] != 0x90 || buf[len + 1] != 0x00) {
log->error("SCARD: file read returned unexpected status %02x %02x (expected 90 00)\n", buf[len], buf[len + 1]); logger.error("SCARD: file read returned unexpected status %02x %02x (expected 90 00)", buf[len], buf[len + 1]);
free(buf); free(buf);
return -4; return -4;
} }
@ -837,7 +836,7 @@ int pcsc_usim::scard::parse_fsp_templ(unsigned char* buf, size_t buf_len, int* p
pos = buf; pos = buf;
end = pos + buf_len; end = pos + buf_len;
if (*pos != USIM_FSP_TEMPL_TAG) { if (*pos != USIM_FSP_TEMPL_TAG) {
log->error("SCARD: file header did not start with FSP template tag\n"); logger.error("SCARD: file header did not start with FSP template tag");
return -1; return -1;
} }
pos++; pos++;
@ -846,14 +845,14 @@ int pcsc_usim::scard::parse_fsp_templ(unsigned char* buf, size_t buf_len, int* p
if (pos[0] < end - pos) if (pos[0] < end - pos)
end = pos + 1 + pos[0]; end = pos + 1 + pos[0];
pos++; pos++;
log->debug_hex(pos, end - pos, "SCARD: file header FSP template\n"); logger.debug(pos, end - pos, "SCARD: file header FSP template");
while (end - pos >= 2) { while (end - pos >= 2) {
unsigned char type, len; unsigned char type, len;
type = pos[0]; type = pos[0];
len = pos[1]; len = pos[1];
log->debug("SCARD: file header TLV 0x%02x len=%d\n", type, len); logger.debug("SCARD: file header TLV 0x%02x len=%d", type, len);
pos += 2; pos += 2;
if (len > (unsigned int)(end - pos)) if (len > (unsigned int)(end - pos))
@ -861,51 +860,51 @@ int pcsc_usim::scard::parse_fsp_templ(unsigned char* buf, size_t buf_len, int* p
switch (type) { switch (type) {
case USIM_TLV_FILE_DESC: case USIM_TLV_FILE_DESC:
log->debug_hex(pos, len, "SCARD: File Descriptor TLV\n"); logger.debug(pos, len, "SCARD: File Descriptor TLV");
break; break;
case USIM_TLV_FILE_ID: case USIM_TLV_FILE_ID:
log->debug_hex(pos, len, "SCARD: File Identifier TLV\n"); logger.debug(pos, len, "SCARD: File Identifier TLV");
break; break;
case USIM_TLV_DF_NAME: case USIM_TLV_DF_NAME:
log->debug_hex(pos, len, "SCARD: DF name (AID) TLV\n"); logger.debug(pos, len, "SCARD: DF name (AID) TLV");
break; break;
case USIM_TLV_PROPR_INFO: case USIM_TLV_PROPR_INFO:
log->debug_hex(pos, len, "SCARD: Proprietary information TLV\n"); logger.debug(pos, len, "SCARD: Proprietary information TLV");
break; break;
case USIM_TLV_LIFE_CYCLE_STATUS: case USIM_TLV_LIFE_CYCLE_STATUS:
log->debug_hex(pos, len, "SCARD: Life Cycle Status Integer TLV\n"); logger.debug(pos, len, "SCARD: Life Cycle Status Integer TLV");
break; break;
case USIM_TLV_FILE_SIZE: case USIM_TLV_FILE_SIZE:
log->debug_hex(pos, len, "SCARD: File size TLV\n"); logger.debug(pos, len, "SCARD: File size TLV");
if ((len == 1 || len == 2) && file_len) { if ((len == 1 || len == 2) && file_len) {
if (len == 1) { if (len == 1) {
*file_len = (int)pos[0]; *file_len = (int)pos[0];
} else { } else {
*file_len = to_uint16(pos); *file_len = to_uint16(pos);
} }
log->debug("SCARD: file_size=%d\n", *file_len); logger.debug("SCARD: file_size=%d", *file_len);
} }
break; break;
case USIM_TLV_TOTAL_FILE_SIZE: case USIM_TLV_TOTAL_FILE_SIZE:
log->debug_hex(pos, len, "SCARD: Total file size TLV\n"); logger.debug(pos, len, "SCARD: Total file size TLV");
break; break;
case USIM_TLV_PIN_STATUS_TEMPLATE: case USIM_TLV_PIN_STATUS_TEMPLATE:
log->debug_hex(pos, len, "SCARD: PIN Status Template DO TLV\n"); logger.debug(pos, len, "SCARD: PIN Status Template DO TLV");
if (len >= 2 && pos[0] == USIM_PS_DO_TAG && pos[1] >= 1 && ps_do) { if (len >= 2 && pos[0] == USIM_PS_DO_TAG && pos[1] >= 1 && ps_do) {
log->debug("SCARD: PS_DO=0x%02x\n", pos[2]); logger.debug("SCARD: PS_DO=0x%02x", pos[2]);
*ps_do = (int)pos[2]; *ps_do = (int)pos[2];
} }
break; break;
case USIM_TLV_SHORT_FILE_ID: case USIM_TLV_SHORT_FILE_ID:
log->debug_hex(pos, len, "SCARD: Short File Identifier (SFI) TLV\n"); logger.debug(pos, len, "SCARD: Short File Identifier (SFI) TLV");
break; break;
case USIM_TLV_SECURITY_ATTR_8B: case USIM_TLV_SECURITY_ATTR_8B:
case USIM_TLV_SECURITY_ATTR_8C: case USIM_TLV_SECURITY_ATTR_8C:
case USIM_TLV_SECURITY_ATTR_AB: case USIM_TLV_SECURITY_ATTR_AB:
log->debug_hex(pos, len, "SCARD: Security attribute TLV\n"); logger.debug(pos, len, "SCARD: Security attribute TLV");
break; break;
default: default:
log->debug_hex(pos, len, "SCARD: Unrecognized TLV\n"); logger.debug(pos, len, "SCARD: Unrecognized TLV");
break; break;
} }
@ -927,16 +926,16 @@ void pcsc_usim::scard::deinit()
{ {
long ret; long ret;
log->debug("SCARD: deinitializing smart card interface\n"); logger.debug("SCARD: deinitializing smart card interface");
ret = SCardDisconnect(scard_handle, SCARD_UNPOWER_CARD); ret = SCardDisconnect(scard_handle, SCARD_UNPOWER_CARD);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->debug("SCARD: Failed to disconnect smart card (err=%ld)\n", ret); logger.debug("SCARD: Failed to disconnect smart card (err=%ld)", ret);
} }
ret = SCardReleaseContext(scard_context); ret = SCardReleaseContext(scard_context);
if (ret != SCARD_S_SUCCESS) { if (ret != SCARD_S_SUCCESS) {
log->debug("Failed to release smart card context (err=%ld)\n", ret); logger.debug("Failed to release smart card context (err=%ld)", ret);
} }
} }
@ -956,12 +955,12 @@ int pcsc_usim::scard::get_mnc_len()
size_t blen; size_t blen;
int file_size; int file_size;
log->debug("SCARD: reading MNC len from (GSM) EF-AD\n"); logger.debug("SCARD: reading MNC len from (GSM) EF-AD");
blen = sizeof(buf); blen = sizeof(buf);
if (select_file(SCARD_FILE_GSM_EF_AD, buf, &blen)) if (select_file(SCARD_FILE_GSM_EF_AD, buf, &blen))
return -1; return -1;
if (blen < 4) { if (blen < 4) {
log->debug("SCARD: too short (GSM) EF-AD header (len=%ld)\n", (long)blen); logger.debug("SCARD: too short (GSM) EF-AD header (len=%ld)", (long)blen);
return -2; return -2;
} }
@ -972,11 +971,11 @@ int pcsc_usim::scard::get_mnc_len()
return -3; return -3;
} }
if (file_size == 3) { if (file_size == 3) {
log->debug("SCARD: MNC length not available\n"); logger.debug("SCARD: MNC length not available");
return -7; return -7;
} }
if (file_size < 4 || file_size > (int)sizeof(buf)) { if (file_size < 4 || file_size > (int)sizeof(buf)) {
log->debug("SCARD: invalid file length=%ld\n", (long)file_size); logger.debug("SCARD: invalid file length=%ld", (long)file_size);
return -4; return -4;
} }
@ -984,10 +983,10 @@ int pcsc_usim::scard::get_mnc_len()
return -5; return -5;
buf[3] = buf[3] & 0x0f; /* upper nibble reserved for future use */ buf[3] = buf[3] & 0x0f; /* upper nibble reserved for future use */
if (buf[3] < 2 || buf[3] > 3) { if (buf[3] < 2 || buf[3] > 3) {
log->debug("SCARD: invalid MNC length=%ld\n", (long)buf[3]); logger.debug("SCARD: invalid MNC length=%ld", (long)buf[3]);
return -6; return -6;
} }
log->debug("SCARD: MNC length=%ld\n", (long)buf[3]); logger.debug("SCARD: MNC length=%ld", (long)buf[3]);
return buf[3]; return buf[3];
} }
@ -1026,12 +1025,12 @@ int pcsc_usim::scard::umts_auth(const unsigned char* _rand,
long ret; long ret;
if (sim_type == SCARD_GSM_SIM) { if (sim_type == SCARD_GSM_SIM) {
log->debug("SCARD: Non-USIM card - cannot do UMTS auth\n"); logger.debug("SCARD: Non-USIM card - cannot do UMTS auth");
return -1; return -1;
} }
log->debug_hex(_rand, AKA_RAND_LEN, "SCARD: UMTS auth - RAND\n"); logger.debug(_rand, AKA_RAND_LEN, "SCARD: UMTS auth - RAND");
log->debug_hex(autn, AKA_AUTN_LEN, "SCARD: UMTS auth - AUTN\n"); logger.debug(autn, AKA_AUTN_LEN, "SCARD: UMTS auth - AUTN");
cmd[5] = AKA_RAND_LEN; cmd[5] = AKA_RAND_LEN;
memcpy(cmd + 6, _rand, AKA_RAND_LEN); memcpy(cmd + 6, _rand, AKA_RAND_LEN);
cmd[6 + AKA_RAND_LEN] = AKA_AUTN_LEN; cmd[6 + AKA_RAND_LEN] = AKA_AUTN_LEN;
@ -1043,17 +1042,17 @@ int pcsc_usim::scard::umts_auth(const unsigned char* _rand,
return -1; return -1;
if (len <= sizeof(resp)) if (len <= sizeof(resp))
log->debug_hex(resp, len, "SCARD: UMTS alg response\n"); logger.debug(resp, len, "SCARD: UMTS alg response");
if (len == 2 && resp[0] == 0x98 && resp[1] == 0x62) { if (len == 2 && resp[0] == 0x98 && resp[1] == 0x62) {
// Authentication error, application specific // Authentication error, application specific
log->warning("SCARD: UMTS auth failed - MAC != XMAC\n"); logger.warning("SCARD: UMTS auth failed - MAC != XMAC");
return -1; return -1;
} }
if (len != 2 || resp[0] != 0x61) { if (len != 2 || resp[0] != 0x61) {
log->warning( logger.warning(
"SCARD: unexpected response for UMTS auth request (len=%ld resp=%02x %02x)\n", (long)len, resp[0], resp[1]); "SCARD: unexpected response for UMTS auth request (len=%ld resp=%02x %02x)", (long)len, resp[0], resp[1]);
return -1; return -1;
} }
get_resp[4] = resp[1]; get_resp[4] = resp[1];
@ -1063,11 +1062,11 @@ int pcsc_usim::scard::umts_auth(const unsigned char* _rand,
if (ret != SCARD_S_SUCCESS || len > sizeof(buf)) if (ret != SCARD_S_SUCCESS || len > sizeof(buf))
return -1; return -1;
log->debug_hex(buf, len, "SCARD: UMTS get response result\n"); logger.debug(buf, len, "SCARD: UMTS get response result");
if (len >= 2 + AKA_AUTS_LEN && buf[0] == 0xdc && buf[1] == AKA_AUTS_LEN) { if (len >= 2 + AKA_AUTS_LEN && buf[0] == 0xdc && buf[1] == AKA_AUTS_LEN) {
log->debug("SCARD: UMTS Synchronization-Failure\n"); logger.debug("SCARD: UMTS Synchronization-Failure");
memcpy(auts, buf + 2, AKA_AUTS_LEN); memcpy(auts, buf + 2, AKA_AUTS_LEN);
log->debug_hex(auts, AKA_AUTS_LEN, "SCARD: AUTS\n"); logger.debug(auts, AKA_AUTS_LEN, "SCARD: AUTS");
*res_len = AKA_AUTS_LEN; *res_len = AKA_AUTS_LEN;
return -2; return -2;
} }
@ -1078,42 +1077,42 @@ int pcsc_usim::scard::umts_auth(const unsigned char* _rand,
/* RES */ /* RES */
if (pos[0] > RES_MAX_LEN || pos[0] > end - pos) { if (pos[0] > RES_MAX_LEN || pos[0] > end - pos) {
log->debug("SCARD: Invalid RES\n"); logger.debug("SCARD: Invalid RES");
return -1; return -1;
} }
*res_len = *pos++; *res_len = *pos++;
memcpy(res, pos, *res_len); memcpy(res, pos, *res_len);
pos += *res_len; pos += *res_len;
log->debug_hex(res, *res_len, "SCARD: RES\n"); logger.debug(res, *res_len, "SCARD: RES");
/* CK */ /* CK */
if (pos[0] != CK_LEN || CK_LEN > end - pos) { if (pos[0] != CK_LEN || CK_LEN > end - pos) {
log->debug("SCARD: Invalid CK\n"); logger.debug("SCARD: Invalid CK");
return -1; return -1;
} }
pos++; pos++;
memcpy(ck, pos, CK_LEN); memcpy(ck, pos, CK_LEN);
pos += CK_LEN; pos += CK_LEN;
log->debug_hex(ck, CK_LEN, "SCARD: CK\n"); logger.debug(ck, CK_LEN, "SCARD: CK");
/* IK */ /* IK */
if (pos[0] != IK_LEN || IK_LEN > end - pos) { if (pos[0] != IK_LEN || IK_LEN > end - pos) {
log->debug("SCARD: Invalid IK\n"); logger.debug("SCARD: Invalid IK");
return -1; return -1;
} }
pos++; pos++;
memcpy(ik, pos, IK_LEN); memcpy(ik, pos, IK_LEN);
pos += IK_LEN; pos += IK_LEN;
log->debug_hex(ik, IK_LEN, "SCARD: IK\n"); logger.debug(ik, IK_LEN, "SCARD: IK");
if (end > pos) { if (end > pos) {
log->debug_hex(pos, end - pos, "SCARD: Ignore extra data in end\n"); logger.debug(pos, end - pos, "SCARD: Ignore extra data in end");
} }
return 0; return 0;
} }
log->debug("SCARD: Unrecognized response\n"); logger.debug("SCARD: Unrecognized response");
return -1; return -1;
} }
@ -1124,7 +1123,7 @@ int pcsc_usim::scard::verify_pin(const char* pin)
unsigned char cmd[5 + 8] = {SIM_CMD_VERIFY_CHV1}; unsigned char cmd[5 + 8] = {SIM_CMD_VERIFY_CHV1};
size_t len; size_t len;
log->debug("SCARD: verifying PIN\n"); logger.debug("SCARD: verifying PIN");
if (pin == NULL || strlen(pin) > 8) if (pin == NULL || strlen(pin) > 8)
return -1; return -1;
@ -1140,11 +1139,11 @@ int pcsc_usim::scard::verify_pin(const char* pin)
return -2; return -2;
if (len != 2 || resp[0] != 0x90 || resp[1] != 0x00) { if (len != 2 || resp[0] != 0x90 || resp[1] != 0x00) {
log->debug("SCARD: PIN verification failed\n"); logger.debug("SCARD: PIN verification failed");
return -1; return -1;
} }
log->debug("SCARD: PIN verified successfully\n"); logger.debug("SCARD: PIN verified successfully");
return SCARD_S_SUCCESS; return SCARD_S_SUCCESS;
} }

16
srsue/src/stack/upper/tft_packet_filter.cc
Unescape Escape View File

@ -21,13 +21,13 @@ namespace srsue {
tft_packet_filter_t::tft_packet_filter_t(uint8_t eps_bearer_id_, tft_packet_filter_t::tft_packet_filter_t(uint8_t eps_bearer_id_,
uint8_t lcid_, uint8_t lcid_,
const LIBLTE_MME_PACKET_FILTER_STRUCT& tft, const LIBLTE_MME_PACKET_FILTER_STRUCT& tft,
srslte::log* log_) : srslog::basic_logger& logger) :
eps_bearer_id(eps_bearer_id_), eps_bearer_id(eps_bearer_id_),
lcid(lcid_), lcid(lcid_),
id(tft.id), id(tft.id),
eval_precedence(tft.eval_precedence), eval_precedence(tft.eval_precedence),
active_filters(0), active_filters(0),
log(log_) logger(logger)
{ {
int idx = 0; int idx = 0;
uint32_t length_in_bytes = 0; uint32_t length_in_bytes = 0;
@ -160,7 +160,7 @@ tft_packet_filter_t::tft_packet_filter_t(uint8_t
break; break;
default: default:
log->error("ERROR: wrong type: 0x%02x\n", filter_type); logger.error("ERROR: wrong type: 0x%02x", filter_type);
return; return;
} }
} }
@ -383,7 +383,7 @@ uint8_t tft_pdu_matcher::check_tft_filter_match(const srslte::unique_byte_buffer
bool match = filter_pair.second.match(pdu); bool match = filter_pair.second.match(pdu);
if (match) { if (match) {
lcid = filter_pair.second.lcid; lcid = filter_pair.second.lcid;
log->debug("Found filter match -- EPS bearer Id %d, LCID %d\n", filter_pair.second.eps_bearer_id, lcid); logger.debug("Found filter match -- EPS bearer Id %d, LCID %d", filter_pair.second.eps_bearer_id, lcid);
break; break;
} }
} }
@ -398,17 +398,17 @@ int tft_pdu_matcher::apply_traffic_flow_template(const uint8_t&
switch (tft->tft_op_code) { switch (tft->tft_op_code) {
case LIBLTE_MME_TFT_OPERATION_CODE_CREATE_NEW_TFT: case LIBLTE_MME_TFT_OPERATION_CODE_CREATE_NEW_TFT:
for (int i = 0; i < tft->packet_filter_list_size; i++) { for (int i = 0; i < tft->packet_filter_list_size; i++) {
log->info("New packet filter for TFT\n"); logger.info("New packet filter for TFT");
tft_packet_filter_t filter(erab_id, lcid, tft->packet_filter_list[i], log); tft_packet_filter_t filter(erab_id, lcid, tft->packet_filter_list[i], logger);
auto it = tft_filter_map.insert(std::make_pair(filter.eval_precedence, filter)); auto it = tft_filter_map.insert(std::make_pair(filter.eval_precedence, filter));
if (it.second == false) { if (it.second == false) {
log->error("Error inserting TFT Packet Filter\n"); logger.error("Error inserting TFT Packet Filter");
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
} }
break; break;
default: default:
log->error("Unhandled TFT OP code\n"); logger.error("Unhandled TFT OP code");
return SRSLTE_ERROR_CANT_START; return SRSLTE_ERROR_CANT_START;
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;

12
srsue/src/stack/upper/usim.cc
Unescape Escape View File

@ -18,7 +18,7 @@ using namespace srslte;
namespace srsue { namespace srsue {
usim::usim(srslte::log* log_) : usim_base(log_) {} usim::usim(srslog::basic_logger& logger) : usim_base(logger) {}
int usim::init(usim_args_t* args) int usim::init(usim_args_t* args)
{ {
@ -36,7 +36,7 @@ int usim::init(usim_args_t* args)
if (32 == args->k.length()) { if (32 == args->k.length()) {
str_to_hex(args->k, k); str_to_hex(args->k, k);
} else { } else {
log->error("Invalid length for K: %zu should be %d\n", args->k.length(), 32); logger.error("Invalid length for K: %zu should be %d", args->k.length(), 32);
srslte::console("Invalid length for K: %zu should be %d\n", args->k.length(), 32); srslte::console("Invalid length for K: %zu should be %d\n", args->k.length(), 32);
} }
@ -46,14 +46,14 @@ int usim::init(usim_args_t* args)
str_to_hex(args->op, op); str_to_hex(args->op, op);
compute_opc(k, op, opc); compute_opc(k, op, opc);
} else { } else {
log->error("Invalid length for OP: %zu should be %d\n", args->op.length(), 32); logger.error("Invalid length for OP: %zu should be %d", args->op.length(), 32);
srslte::console("Invalid length for OP: %zu should be %d\n", args->op.length(), 32); srslte::console("Invalid length for OP: %zu should be %d\n", args->op.length(), 32);
} }
} else { } else {
if (32 == args->opc.length()) { if (32 == args->opc.length()) {
str_to_hex(args->opc, opc); str_to_hex(args->opc, opc);
} else { } else {
log->error("Invalid length for OPc: %zu should be %d\n", args->opc.length(), 32); logger.error("Invalid length for OPc: %zu should be %d", args->opc.length(), 32);
srslte::console("Invalid length for OPc: %zu should be %d\n", args->opc.length(), 32); srslte::console("Invalid length for OPc: %zu should be %d\n", args->opc.length(), 32);
} }
} }
@ -66,7 +66,7 @@ int usim::init(usim_args_t* args)
imsi += imsi_c[i] - '0'; imsi += imsi_c[i] - '0';
} }
} else { } else {
log->error("Invalid length for IMSI: %zu should be %d\n", args->imsi.length(), 15); logger.error("Invalid length for IMSI: %zu should be %d", args->imsi.length(), 15);
srslte::console("Invalid length for IMSI: %zu should be %d\n", args->imsi.length(), 15); srslte::console("Invalid length for IMSI: %zu should be %d\n", args->imsi.length(), 15);
} }
@ -77,7 +77,7 @@ int usim::init(usim_args_t* args)
imei += imei_c[i] - '0'; imei += imei_c[i] - '0';
} }
} else { } else {
log->error("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15); logger.error("Invalid length for IMEI: %zu should be %d", args->imei.length(), 15);
srslte::console("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15); srslte::console("Invalid length for IMEI: %zu should be %d\n", args->imei.length(), 15);
} }

90
srsue/src/stack/upper/usim_base.cc
Unescape Escape View File

@ -19,19 +19,19 @@
namespace srsue { namespace srsue {
std::unique_ptr<usim_base> usim_base::get_instance(usim_args_t* args, srslte::log* log_) std::unique_ptr<usim_base> usim_base::get_instance(usim_args_t* args, srslog::basic_logger& logger)
{ {
#if HAVE_PCSC #if HAVE_PCSC
if (args->mode == "pcsc") { if (args->mode == "pcsc") {
return std::unique_ptr<usim_base>(new pcsc_usim(log_)); return std::unique_ptr<usim_base>(new pcsc_usim(logger));
} }
#endif #endif
// default to soft USIM // default to soft USIM
return std::unique_ptr<usim_base>(new usim(log_)); return std::unique_ptr<usim_base>(new usim(logger));
} }
usim_base::usim_base(srslte::log* _log) : log(_log) {} usim_base::usim_base(srslog::basic_logger& logger) : logger(logger) {}
usim_base::~usim_base() {} usim_base::~usim_base() {}
@ -50,12 +50,12 @@ std::string usim_base::get_imei_str()
bool usim_base::get_imsi_vec(uint8_t* imsi_, uint32_t n) bool usim_base::get_imsi_vec(uint8_t* imsi_, uint32_t n)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return false; return false;
} }
if (NULL == imsi_ || n < 15) { if (NULL == imsi_ || n < 15) {
log->error("Invalid parameters to get_imsi_vec\n"); logger.error("Invalid parameters to get_imsi_vec");
return false; return false;
} }
@ -70,12 +70,12 @@ bool usim_base::get_imsi_vec(uint8_t* imsi_, uint32_t n)
bool usim_base::get_imei_vec(uint8_t* imei_, uint32_t n) bool usim_base::get_imei_vec(uint8_t* imei_, uint32_t n)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return false; return false;
} }
if (NULL == imei_ || n < 15) { if (NULL == imei_ || n < 15) {
log->error("Invalid parameters to get_imei_vec\n"); logger.error("Invalid parameters to get_imei_vec");
return false; return false;
} }
@ -100,7 +100,7 @@ std::string usim_base::get_mcc_str(const uint8_t* imsi_vec)
bool usim_base::get_home_plmn_id(srslte::plmn_id_t* home_plmn_id) bool usim_base::get_home_plmn_id(srslte::plmn_id_t* home_plmn_id)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return false; return false;
} }
@ -112,11 +112,11 @@ bool usim_base::get_home_plmn_id(srslte::plmn_id_t* home_plmn_id)
std::string plmn_str = mcc_str + mnc_str; std::string plmn_str = mcc_str + mnc_str;
if (home_plmn_id->from_string(plmn_str)) { if (home_plmn_id->from_string(plmn_str)) {
log->error("Error reading home PLMN from SIM.\n"); logger.error("Error reading home PLMN from SIM.");
return false; return false;
} }
log->info("Read Home PLMN Id=%s\n", home_plmn_id->to_string().c_str()); logger.info("Read Home PLMN Id=%s", home_plmn_id->to_string().c_str());
return true; return true;
} }
@ -128,7 +128,7 @@ void usim_base::generate_nas_keys(uint8_t* k_asme,
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return; return;
} }
@ -142,12 +142,12 @@ void usim_base::generate_nas_keys(uint8_t* k_asme,
void usim_base::generate_as_keys(uint8_t* k_asme_, uint32_t count_ul, srslte::as_security_config_t* sec_cfg) void usim_base::generate_as_keys(uint8_t* k_asme_, uint32_t count_ul, srslte::as_security_config_t* sec_cfg)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return; return;
} }
log->info("Generating AS Keys. NAS UL COUNT %d\n", count_ul); logger.info("Generating AS Keys. NAS UL COUNT %d", count_ul);
log->debug_hex(k_asme_, 32, "K_asme"); logger.debug(k_asme_, 32, "K_asme");
// Generate K_enb // Generate K_enb
srslte::security_generate_k_enb(k_asme_, count_ul, k_enb_ctx.k_enb.data()); srslte::security_generate_k_enb(k_asme_, count_ul, k_enb_ctx.k_enb.data());
@ -174,22 +174,22 @@ void usim_base::generate_as_keys(uint8_t* k_asme_, uint32_t count_ul, srslte::as
k_enb_ctx.ncc = 0; k_enb_ctx.ncc = 0;
k_enb_ctx.is_first_ncc = true; k_enb_ctx.is_first_ncc = true;
log->debug_hex(k_enb_ctx.k_enb.data(), 32, "Initial K_eNB"); logger.debug(k_enb_ctx.k_enb.data(), 32, "Initial K_eNB");
log->debug_hex(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "K_RRC_int"); logger.debug(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "K_RRC_int");
log->debug_hex(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "K_RRC_enc"); logger.debug(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "K_RRC_enc");
log->debug_hex(sec_cfg->k_up_int.data(), sec_cfg->k_up_int.size(), "K_UP_int"); logger.debug(sec_cfg->k_up_int.data(), sec_cfg->k_up_int.size(), "K_UP_int");
log->debug_hex(sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.size(), "K_UP_enc"); logger.debug(sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.size(), "K_UP_enc");
} }
void usim_base::generate_as_keys_ho(uint32_t pci, uint32_t earfcn, int ncc, srslte::as_security_config_t* sec_cfg) void usim_base::generate_as_keys_ho(uint32_t pci, uint32_t earfcn, int ncc, srslte::as_security_config_t* sec_cfg)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return; return;
} }
log->info("Re-generating AS Keys. PCI 0x%02x, DL-EARFCN %d, NCC %d\n", pci, earfcn, ncc); logger.info("Re-generating AS Keys. PCI 0x%02x, DL-EARFCN %d, NCC %d", pci, earfcn, ncc);
log->info_hex(k_enb_ctx.k_enb.data(), 32, "Old K_eNB"); logger.info(k_enb_ctx.k_enb.data(), 32, "Old K_eNB");
uint8_t* enb_star_key = k_enb_ctx.k_enb.data(); uint8_t* enb_star_key = k_enb_ctx.k_enb.data();
@ -200,14 +200,14 @@ void usim_base::generate_as_keys_ho(uint32_t pci, uint32_t earfcn, int ncc, srsl
while (k_enb_ctx.ncc != (uint32_t)ncc) { while (k_enb_ctx.ncc != (uint32_t)ncc) {
uint8_t* sync = nullptr; uint8_t* sync = nullptr;
if (k_enb_ctx.is_first_ncc) { if (k_enb_ctx.is_first_ncc) {
log->debug("Using K_enb_initial for sync. 0x%02x, DL-EARFCN %d, NCC used: %d\n", pci, earfcn, k_enb_ctx.ncc); logger.debug("Using K_enb_initial for sync. 0x%02x, DL-EARFCN %d, NCC used: %d", pci, earfcn, k_enb_ctx.ncc);
sync = k_enb_initial; sync = k_enb_initial;
k_enb_ctx.is_first_ncc = false; k_enb_ctx.is_first_ncc = false;
} else { } else {
log->debug("Using NH for sync. 0x%02x, DL-EARFCN %d, NCC %d\n", pci, earfcn, k_enb_ctx.ncc); logger.debug("Using NH for sync. 0x%02x, DL-EARFCN %d, NCC %d", pci, earfcn, k_enb_ctx.ncc);
sync = k_enb_ctx.nh.data(); sync = k_enb_ctx.nh.data();
} }
log->debug_hex(k_enb_ctx.nh.data(), 32, "NH:"); logger.debug(k_enb_ctx.nh.data(), 32, "NH:");
// Generate NH // Generate NH
srslte::security_generate_nh(k_asme, sync, k_enb_ctx.nh.data()); srslte::security_generate_nh(k_asme, sync, k_enb_ctx.nh.data());
@ -239,19 +239,19 @@ void usim_base::generate_as_keys_ho(uint32_t pci, uint32_t earfcn, int ncc, srsl
sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.data(),
sec_cfg->k_up_int.data()); sec_cfg->k_up_int.data());
log->info_hex(k_enb_ctx.k_enb.data(), 32, "HO K_eNB"); logger.info(k_enb_ctx.k_enb.data(), 32, "HO K_eNB");
log->info_hex(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "HO K_RRC_enc"); logger.info(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "HO K_RRC_enc");
log->info_hex(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "HO K_RRC_int"); logger.info(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "HO K_RRC_int");
} }
void usim_base::store_keys_before_ho(const srslte::as_security_config_t& as_ctx) void usim_base::store_keys_before_ho(const srslte::as_security_config_t& as_ctx)
{ {
log->info("Storing AS Keys pre-handover. NCC=%d\n", k_enb_ctx.ncc); logger.info("Storing AS Keys pre-handover. NCC=%d", k_enb_ctx.ncc);
log->info_hex(k_enb_ctx.k_enb.data(), 32, "Old K_eNB"); logger.info(k_enb_ctx.k_enb.data(), 32, "Old K_eNB");
log->info_hex(as_ctx.k_rrc_enc.data(), as_ctx.k_rrc_enc.size(), "Old K_RRC_enc"); logger.info(as_ctx.k_rrc_enc.data(), as_ctx.k_rrc_enc.size(), "Old K_RRC_enc");
log->info_hex(as_ctx.k_rrc_enc.data(), as_ctx.k_rrc_enc.size(), "Old K_RRC_enc"); logger.info(as_ctx.k_rrc_enc.data(), as_ctx.k_rrc_enc.size(), "Old K_RRC_enc");
log->info_hex(as_ctx.k_rrc_int.data(), as_ctx.k_rrc_int.size(), "Old K_RRC_int"); logger.info(as_ctx.k_rrc_int.data(), as_ctx.k_rrc_int.size(), "Old K_RRC_int");
log->info_hex(as_ctx.k_rrc_int.data(), as_ctx.k_rrc_int.size(), "Old K_RRC_int"); logger.info(as_ctx.k_rrc_int.data(), as_ctx.k_rrc_int.size(), "Old K_RRC_int");
old_k_enb_ctx = k_enb_ctx; old_k_enb_ctx = k_enb_ctx;
old_as_ctx = as_ctx; old_as_ctx = as_ctx;
return; return;
@ -259,7 +259,7 @@ void usim_base::store_keys_before_ho(const srslte::as_security_config_t& as_ctx)
void usim_base::restore_keys_from_failed_ho(srslte::as_security_config_t* as_ctx) void usim_base::restore_keys_from_failed_ho(srslte::as_security_config_t* as_ctx)
{ {
log->info("Restoring Keys from failed handover. NCC=%d\n", old_k_enb_ctx.ncc); logger.info("Restoring Keys from failed handover. NCC=%d", old_k_enb_ctx.ncc);
*as_ctx = old_as_ctx; *as_ctx = old_as_ctx;
k_enb_ctx = old_k_enb_ctx; k_enb_ctx = old_k_enb_ctx;
return; return;
@ -272,23 +272,23 @@ void usim_base::restore_keys_from_failed_ho(srslte::as_security_config_t* as_ctx
void usim_base::generate_nr_context(uint16_t sk_counter, srslte::as_security_config_t* sec_cfg) void usim_base::generate_nr_context(uint16_t sk_counter, srslte::as_security_config_t* sec_cfg)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return; return;
} }
log->info("Generating Keys. SCG Counter %d\n", sk_counter); logger.info("Generating Keys. SCG Counter %d", sk_counter);
srslte::security_generate_sk_gnb(k_enb_ctx.k_enb.data(), k_gnb_ctx.sk_gnb.data(), sk_counter); srslte::security_generate_sk_gnb(k_enb_ctx.k_enb.data(), k_gnb_ctx.sk_gnb.data(), sk_counter);
log->info_hex(k_gnb_ctx.sk_gnb.data(), 32, "k_sk_gnb"); logger.info(k_gnb_ctx.sk_gnb.data(), 32, "k_sk_gnb");
update_nr_context(sec_cfg); update_nr_context(sec_cfg);
} }
void usim_base::update_nr_context(srslte::as_security_config_t* sec_cfg) void usim_base::update_nr_context(srslte::as_security_config_t* sec_cfg)
{ {
if (!initiated) { if (!initiated) {
log->error("USIM not initiated!\n"); logger.error("USIM not initiated!");
return; return;
} }
log->info_hex(k_gnb_ctx.sk_gnb.data(), 32, "k_sk_gnb"); logger.info(k_gnb_ctx.sk_gnb.data(), 32, "k_sk_gnb");
// Generate K_rrc_enc and K_rrc_int // Generate K_rrc_enc and K_rrc_int
security_generate_k_nr_rrc(k_gnb_ctx.sk_gnb.data(), security_generate_k_nr_rrc(k_gnb_ctx.sk_gnb.data(),
sec_cfg->cipher_algo, sec_cfg->cipher_algo,
@ -303,10 +303,10 @@ void usim_base::update_nr_context(srslte::as_security_config_t* sec_cfg)
sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.data(),
sec_cfg->k_up_int.data()); sec_cfg->k_up_int.data());
log->debug_hex(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "NR K_RRC_int"); logger.debug(sec_cfg->k_rrc_int.data(), sec_cfg->k_rrc_int.size(), "NR K_RRC_int");
log->debug_hex(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "NR K_RRC_enc"); logger.debug(sec_cfg->k_rrc_enc.data(), sec_cfg->k_rrc_enc.size(), "NR K_RRC_enc");
log->debug_hex(sec_cfg->k_up_int.data(), sec_cfg->k_up_int.size(), "NR K_UP_int"); logger.debug(sec_cfg->k_up_int.data(), sec_cfg->k_up_int.size(), "NR K_UP_int");
log->debug_hex(sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.size(), "NR K_UP_enc"); logger.debug(sec_cfg->k_up_enc.data(), sec_cfg->k_up_enc.size(), "NR K_UP_enc");
} }
} // namespace srsue } // namespace srsue

52
srsue/src/ue.cc
Unescape Escape View File

@ -31,10 +31,11 @@ using namespace srslte;
namespace srsue { namespace srsue {
ue::ue() : logger(nullptr) ue::ue(srslog::sink& log_sink) :
old_logger(nullptr), log_sink(log_sink), logger(srslog::fetch_basic_logger("UE", log_sink, false))
{ {
// print build info // print build info
std::cout << std::endl << get_build_string() << std::endl; std::cout << std::endl << get_build_string() << std::endl << std::endl;
pool = byte_buffer_pool::get_instance(); pool = byte_buffer_pool::get_instance();
} }
@ -46,12 +47,11 @@ ue::~ue()
int ue::init(const all_args_t& args_, srslte::logger* logger_) int ue::init(const all_args_t& args_, srslte::logger* logger_)
{ {
int ret = SRSLTE_SUCCESS; int ret = SRSLTE_SUCCESS;
logger = logger_; old_logger = logger_;
// Init UE log // Init UE log
log.init("UE ", logger); logger.set_level(srslog::basic_levels::info);
log.set_level(srslte::LOG_LEVEL_INFO); logger.info("%s", get_build_string().c_str());
log.info("%s", get_build_string().c_str());
// Validate arguments // Validate arguments
if (parse_args(args_)) { if (parse_args(args_)) {
@ -61,7 +61,7 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
// Instantiate layers and stack together our UE // Instantiate layers and stack together our UE
if (args.stack.type == "lte") { if (args.stack.type == "lte") {
std::unique_ptr<ue_stack_lte> lte_stack(new ue_stack_lte()); std::unique_ptr<ue_stack_lte> lte_stack(new ue_stack_lte(log_sink));
if (!lte_stack) { if (!lte_stack) {
srslte::console("Error creating LTE stack instance.\n"); srslte::console("Error creating LTE stack instance.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
@ -73,13 +73,13 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
std::unique_ptr<srsue::phy> lte_phy = std::unique_ptr<srsue::phy>(new srsue::phy(logger)); std::unique_ptr<srsue::phy> lte_phy = std::unique_ptr<srsue::phy>(new srsue::phy(old_logger, log_sink));
if (!lte_phy) { if (!lte_phy) {
srslte::console("Error creating LTE PHY instance.\n"); srslte::console("Error creating LTE PHY instance.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
std::unique_ptr<srslte::radio> lte_radio = std::unique_ptr<srslte::radio>(new srslte::radio(logger)); std::unique_ptr<srslte::radio> lte_radio = std::unique_ptr<srslte::radio>(new srslte::radio(old_logger));
if (!lte_radio) { if (!lte_radio) {
srslte::console("Error creating radio multi instance.\n"); srslte::console("Error creating radio multi instance.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
@ -97,12 +97,12 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
if (lte_stack->init(args.stack, logger, lte_phy.get(), gw_ptr.get())) { if (lte_stack->init(args.stack, old_logger, lte_phy.get(), gw_ptr.get())) {
srslte::console("Error initializing stack.\n"); srslte::console("Error initializing stack.\n");
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
if (gw_ptr->init(args.gw, logger, lte_stack.get())) { if (gw_ptr->init(args.gw, old_logger, lte_stack.get())) {
srslte::console("Error initializing GW.\n"); srslte::console("Error initializing GW.\n");
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
@ -113,11 +113,11 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
phy = std::move(lte_phy); phy = std::move(lte_phy);
radio = std::move(lte_radio); radio = std::move(lte_radio);
} else if (args.stack.type == "nr") { } else if (args.stack.type == "nr") {
log.info("Initializing NR stack.\n"); logger.info("Initializing NR stack");
#ifdef HAVE_5GNR #ifdef HAVE_5GNR
std::unique_ptr<srsue::ue_stack_nr> nr_stack(new srsue::ue_stack_nr(logger)); std::unique_ptr<srsue::ue_stack_nr> nr_stack(new srsue::ue_stack_nr(old_logger));
std::unique_ptr<srslte::radio_null> nr_radio(new srslte::radio_null(logger)); std::unique_ptr<srslte::radio_null> nr_radio(new srslte::radio_null(old_logger));
std::unique_ptr<srsue::vnf_phy_nr> nr_phy(new srsue::vnf_phy_nr(logger)); std::unique_ptr<srsue::vnf_phy_nr> nr_phy(new srsue::vnf_phy_nr(old_logger));
std::unique_ptr<gw> gw_ptr(new gw()); std::unique_ptr<gw> gw_ptr(new gw());
// Init layers // Init layers
@ -136,7 +136,7 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (gw_ptr->init(args.gw, logger, nr_stack.get())) { if (gw_ptr->init(args.gw, old_logger, nr_stack.get())) {
srslte::console("Error initializing GW.\n"); srslte::console("Error initializing GW.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -148,7 +148,7 @@ int ue::init(const all_args_t& args_, srslte::logger* logger_)
radio = std::move(nr_radio); radio = std::move(nr_radio);
#else #else
srslte::console("ERROR: 5G NR stack not compiled. Please, activate CMAKE HAVE_5GNR flag.\n"); 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"); logger.error("5G NR stack not compiled. Please, activate CMAKE HAVE_5GNR flag.");
#endif #endif
} else { } else {
srslte::console("Invalid stack type %s. Supported values are [lte].\n", args.stack.type.c_str()); srslte::console("Invalid stack type %s. Supported values are [lte].\n", args.stack.type.c_str());
@ -172,20 +172,20 @@ int ue::parse_args(const all_args_t& args_)
// carry out basic sanity checks // carry out basic sanity checks
if (args.stack.rrc.mbms_service_id > -1) { if (args.stack.rrc.mbms_service_id > -1) {
if (!args.phy.interpolate_subframe_enabled) { if (!args.phy.interpolate_subframe_enabled) {
log.error("interpolate_subframe_enabled = %d, While using MBMS, " logger.error("interpolate_subframe_enabled = %d, While using MBMS, "
"please set interpolate_subframe_enabled to true\n", "please set interpolate_subframe_enabled to true",
args.phy.interpolate_subframe_enabled); args.phy.interpolate_subframe_enabled);
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (args.phy.nof_phy_threads > 2) { if (args.phy.nof_phy_threads > 2) {
log.error("nof_phy_threads = %d, While using MBMS, please set " logger.error("nof_phy_threads = %d, While using MBMS, please set "
"number of phy threads to 1 or 2\n", "number of phy threads to 1 or 2",
args.phy.nof_phy_threads); args.phy.nof_phy_threads);
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if ((0 == args.phy.snr_estim_alg.find("refs"))) { if ((0 == args.phy.snr_estim_alg.find("refs"))) {
log.error("snr_estim_alg = refs, While using MBMS, please set " logger.error("snr_estim_alg = refs, While using MBMS, please set "
"algorithm to pss or empty \n"); "algorithm to pss or empty");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
} }
@ -229,7 +229,7 @@ int ue::parse_args(const all_args_t& args_)
} }
} }
} else { } else {
log.error("Error: dl_earfcn list is empty\n"); logger.error("Error: dl_earfcn list is empty");
srslte::console("Error: dl_earfcn list is empty\n"); srslte::console("Error: dl_earfcn list is empty\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -266,7 +266,7 @@ int ue::parse_args(const all_args_t& args_)
} }
} }
} else { } else {
log.error("Error: dl_nr_arfcn list is empty\n"); logger.error("Error: dl_nr_arfcn list is empty");
srslte::console("Error: dl_nr_arfcn list is empty\n"); srslte::console("Error: dl_nr_arfcn list is empty\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -345,7 +345,7 @@ std::string ue::get_build_info()
std::string ue::get_build_string() std::string ue::get_build_string()
{ {
std::stringstream ss; 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(); return ss.str();
} }

259
srsue/test/mac_test.cc
Unescape Escape View File

@ -29,15 +29,13 @@ using namespace srslte;
static std::unique_ptr<srslte::mac_pcap> pcap_handle = nullptr; static std::unique_ptr<srslte::mac_pcap> pcap_handle = nullptr;
srslte::log_ref mac_log{"MAC"};
namespace srslte { namespace srslte {
// fake classes // fake classes
class rlc_dummy : public srsue::rlc_dummy_interface class rlc_dummy : public srsue::rlc_dummy_interface
{ {
public: public:
rlc_dummy(srslte::log_filter* log_) : received_bytes(0), log(log_) {} rlc_dummy() : received_bytes(0) {}
bool has_data_locked(const uint32_t lcid) final { return ul_queues[lcid] > 0; } bool has_data_locked(const uint32_t lcid) final { return ul_queues[lcid] > 0; }
uint32_t get_buffer_state(const uint32_t lcid) final { return ul_queues[lcid]; } uint32_t get_buffer_state(const uint32_t lcid) final { return ul_queues[lcid]; }
int read_pdu(uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) final int read_pdu(uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) final
@ -62,7 +60,7 @@ public:
}; };
void write_pdu(uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) final void write_pdu(uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) final
{ {
log->debug_hex(payload, nof_bytes, "Received %d B on LCID %d\n", nof_bytes, lcid); logger.debug(payload, nof_bytes, "Received %d B on LCID %d", nof_bytes, lcid);
received_bytes += nof_bytes; received_bytes += nof_bytes;
} }
@ -84,7 +82,7 @@ private:
int32_t read_len = -1; // read all int32_t read_len = -1; // read all
uint32_t read_min = 0; // minimum "grant size" for read_pdu() to return data uint32_t read_min = 0; // minimum "grant size" for read_pdu() to return data
uint32_t received_bytes; uint32_t received_bytes;
srslte::log_filter* log; srslog::basic_logger& logger = srslog::fetch_basic_logger("RLC");
// UL queues where key is LCID and value the queue length // UL queues where key is LCID and value the queue length
std::map<uint32_t, uint32_t> ul_queues; std::map<uint32_t, uint32_t> ul_queues;
}; };
@ -94,7 +92,6 @@ class phy_dummy : public phy_interface_mac_lte
public: public:
phy_dummy() : scell_cmd(0){}; phy_dummy() : scell_cmd(0){};
void set_log(srslte::log* log_h_) { log_h = log_h_; }
void reset() void reset()
{ {
last_preamble_idx = 0; last_preamble_idx = 0;
@ -127,7 +124,7 @@ public:
last_target_power = target_power_dbm; last_target_power = target_power_dbm;
prach_transmitted = true; prach_transmitted = true;
prach_info_tx = true; prach_info_tx = true;
log_h->info("PRACH will be transmitted at tti=%d, preamble_idx=%d\n", prach_tti, preamble_idx); logger.info("PRACH will be transmitted at tti=%d, preamble_idx=%d", prach_tti, preamble_idx);
} }
prach_info_t prach_get_info() override prach_info_t prach_get_info() override
@ -139,7 +136,7 @@ public:
info.tti_ra = prach_tti; info.tti_ra = prach_tti;
prach_info_tx = false; prach_info_tx = false;
info.is_transmitted = true; info.is_transmitted = true;
log_h->info("PRACH has been transmitted\n"); logger.info("PRACH has been transmitted");
} }
} }
return info; return info;
@ -195,8 +192,7 @@ public:
memcpy(dl_action.tb[0].payload, payload, len); memcpy(dl_action.tb[0].payload, payload, len);
// print generated PDU // print generated PDU
log_h->info_hex( logger.info(dl_action.tb[0].payload, dl_mac_grant.tb[0].tbs, "Generated DL PDU (%d B)", dl_mac_grant.tb[0].tbs);
dl_action.tb[0].payload, dl_mac_grant.tb[0].tbs, "Generated DL PDU (%d B)\n", dl_mac_grant.tb[0].tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_dl_crnti(dl_action.tb[0].payload, dl_mac_grant.tb[0].tbs, rnti, true, 1, 0); pcap_handle->write_dl_crnti(dl_action.tb[0].payload, dl_mac_grant.tb[0].tbs, rnti, true, 1, 0);
@ -275,7 +271,9 @@ public:
mac_h->new_grant_ul(0, ul_mac_grant, &ul_action); mac_h->new_grant_ul(0, ul_mac_grant, &ul_action);
// print generated PDU // print generated PDU
log_h->info_hex(ul_action.tb.payload, ul_mac_grant.tb.tbs, "Generated UL PDU (%d B)\n", ul_mac_grant.tb.tbs); if (ul_action.tb.payload) {
logger.info(ul_action.tb.payload, ul_mac_grant.tb.tbs, "Generated UL PDU (%d B)", ul_mac_grant.tb.tbs);
}
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, ul_mac_grant.tb.tbs, rnti, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, ul_mac_grant.tb.tbs, rnti, true, 1, 0);
@ -310,7 +308,7 @@ private:
uint16_t last_crnti = 0; uint16_t last_crnti = 0;
srslte::log* log_h; srslog::basic_logger& logger = srslog::fetch_basic_logger("PHY");
bool ul_ndi = false; bool ul_ndi = false;
bool dl_ndi = false; bool dl_ndi = false;
@ -376,14 +374,9 @@ int mac_unpack_test()
0xc3, 0xb3, 0x5c, 0xa3, 0x23, 0xad, 0x00, 0x03, 0x20, 0x1b, 0x00, 0x00, 0x00, 0xc3, 0xb3, 0x5c, 0xa3, 0x23, 0xad, 0x00, 0x03, 0x20, 0x1b, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x13, 0x89, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x13, 0x89, 0x00, 0x00};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -428,13 +421,9 @@ int mac_ul_sch_pdu_test1()
{ {
const uint8_t tv[] = {0x3f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; const uint8_t tv[] = {0x3f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -463,7 +452,8 @@ int mac_ul_sch_pdu_test1()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -492,13 +482,9 @@ int mac_ul_logical_channel_prioritization_test1()
const uint8_t tv[] = {0x21, 0x0a, 0x22, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, const uint8_t tv[] = {0x21, 0x0a, 0x22, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03}; 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -560,7 +546,8 @@ int mac_ul_logical_channel_prioritization_test1()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -598,13 +585,9 @@ int mac_ul_logical_channel_prioritization_test2()
0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}; 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -666,7 +649,8 @@ int mac_ul_logical_channel_prioritization_test2()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -693,13 +677,9 @@ int mac_ul_logical_channel_prioritization_test3()
const uint8_t tv[] = {0x24, 0x0a, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, const uint8_t tv[] = {0x24, 0x0a, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}; 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -755,7 +735,8 @@ int mac_ul_logical_channel_prioritization_test3()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -777,13 +758,9 @@ int mac_ul_logical_channel_prioritization_test4()
const uint8_t tv2[] = {0x3d, 0x04, 0x88, 0x04}; // Short BSR plus SDU for LCID4 const uint8_t tv2[] = {0x3d, 0x04, 0x88, 0x04}; // Short BSR plus SDU for LCID4
const uint8_t tv3[] = {0x1e, 0x00, 0x12, 0x00}; // Long BSR const uint8_t tv3[] = {0x1e, 0x00, 0x12, 0x00}; // Long BSR
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -844,7 +821,8 @@ int mac_ul_logical_channel_prioritization_test4()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -874,7 +852,8 @@ int mac_ul_logical_channel_prioritization_test4()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -906,7 +885,8 @@ int mac_ul_logical_channel_prioritization_test4()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -926,13 +906,9 @@ int mac_ul_sch_pdu_with_short_bsr_test()
{ {
const uint8_t tv[] = {0x3f, 0x3d, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; const uint8_t tv[] = {0x3f, 0x3d, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -966,7 +942,8 @@ int mac_ul_sch_pdu_with_short_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -986,13 +963,9 @@ int mac_ul_sch_pdu_with_short_bsr_zero_test()
{ {
const uint8_t tv[] = {0x3f, 0x3d, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; const uint8_t tv[] = {0x3f, 0x3d, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1026,7 +999,8 @@ int mac_ul_sch_pdu_with_short_bsr_zero_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1045,13 +1019,9 @@ int mac_ul_sch_pdu_with_short_bsr_zero_test()
// Because there is no outstanding data, all LCGs are reported as zero // Because there is no outstanding data, all LCGs are reported as zero
int mac_ul_sch_pdu_with_padding_long_bsr_test() int mac_ul_sch_pdu_with_padding_long_bsr_test()
{ {
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1079,7 +1049,8 @@ int mac_ul_sch_pdu_with_padding_long_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1097,13 +1068,9 @@ int mac_ul_sch_pdu_with_padding_long_bsr_test()
// PDU SDU and Long BSR as padding (indicating that more data is ready to be sent) // PDU SDU and Long BSR as padding (indicating that more data is ready to be sent)
int mac_ul_sch_pdu_with_padding_long_bsr_test2() int mac_ul_sch_pdu_with_padding_long_bsr_test2()
{ {
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1154,7 +1121,8 @@ int mac_ul_sch_pdu_with_padding_long_bsr_test2()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1173,13 +1141,9 @@ int mac_ul_sch_pdu_with_padding_long_bsr_test2()
// LCG 1 has highest priority and 100 B to transmit // LCG 1 has highest priority and 100 B to transmit
int mac_ul_sch_pdu_with_padding_trunc_bsr_test() int mac_ul_sch_pdu_with_padding_trunc_bsr_test()
{ {
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1239,7 +1203,8 @@ int mac_ul_sch_pdu_with_padding_trunc_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1261,13 +1226,9 @@ int mac_ul_sch_regular_bsr_retx_test()
const uint8_t tv2[] = {0x01, 0x01, 0x01, 0x01, 0x01}; // Second PDU is just SDU for LCID1 const uint8_t tv2[] = {0x01, 0x01, 0x01, 0x01, 0x01}; // Second PDU is just SDU for LCID1
const uint8_t tv3[] = {0x3f, 0x1e, 0x04, 0x00, 0x1f}; // 3rd PDU is after retx Timer is expired and contains BSR again const uint8_t tv3[] = {0x3f, 0x1e, 0x04, 0x00, 0x1f}; // 3rd PDU is after retx Timer is expired and contains BSR again
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1325,7 +1286,8 @@ int mac_ul_sch_regular_bsr_retx_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1352,7 +1314,8 @@ int mac_ul_sch_regular_bsr_retx_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1382,7 +1345,8 @@ int mac_ul_sch_regular_bsr_retx_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1423,14 +1387,9 @@ int mac_ul_sch_periodic_bsr_test()
// 4th PDU contains LCID 1 and LCID 3 SDUs // 4th PDU contains LCID 1 and LCID 3 SDUs
const uint8_t tv4[] = {0x21, 0x05, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03}; const uint8_t tv4[] = {0x21, 0x05, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1494,7 +1453,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1530,7 +1490,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1561,7 +1522,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1596,7 +1558,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1629,7 +1592,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1658,7 +1622,8 @@ int mac_ul_sch_periodic_bsr_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1694,13 +1659,9 @@ int mac_ul_sch_trunc_bsr_test2()
// Following PDU includes only SDUs for highest priority LCID // Following PDU includes only SDUs for highest priority LCID
const uint8_t tv2[] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; const uint8_t tv2[] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1765,7 +1726,8 @@ int mac_ul_sch_trunc_bsr_test2()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1794,7 +1756,8 @@ int mac_ul_sch_trunc_bsr_test2()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1825,7 +1788,8 @@ int mac_ul_sch_trunc_bsr_test2()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1845,13 +1809,9 @@ int mac_ul_sch_pdu_one_byte_test()
{ {
const uint8_t tv[] = {0x1f}; const uint8_t tv[] = {0x1f};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1880,7 +1840,8 @@ int mac_ul_sch_pdu_one_byte_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1900,13 +1861,9 @@ int mac_ul_sch_pdu_two_byte_test()
{ {
const uint8_t tv[] = {0x01, 0x01}; const uint8_t tv[] = {0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1935,7 +1892,8 @@ int mac_ul_sch_pdu_two_byte_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -1955,13 +1913,9 @@ int mac_ul_sch_pdu_three_byte_test()
{ {
const uint8_t tv[] = {0x3f, 0x01, 0x01}; const uint8_t tv[] = {0x3f, 0x01, 0x01};
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
rlc_dummy rlc(&rlc_log); rlc_dummy rlc;
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -1990,7 +1944,8 @@ int mac_ul_sch_pdu_three_byte_test()
mac.new_grant_ul(cc_idx, mac_grant, &ul_action); mac.new_grant_ul(cc_idx, mac_grant, &ul_action);
// print generated PDU // print generated PDU
mac_log->info_hex(ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)\n", mac_grant.tb.tbs); srslog::fetch_basic_logger("MAC").info(
ul_action.tb.payload, mac_grant.tb.tbs, "Generated PDU (%d B)", mac_grant.tb.tbs);
#if HAVE_PCAP #if HAVE_PCAP
pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0); pcap_handle->write_ul_crnti(ul_action.tb.payload, mac_grant.tb.tbs, 0x1001, true, 1, 0);
#endif #endif
@ -2186,18 +2141,9 @@ int mac_random_access_test()
{ {
uint64_t contention_id = 0xf0f0f0f0f0f; uint64_t contention_id = 0xf0f0f0f0f0f;
srslte::log_filter phy_log("PHY");
phy_log.set_level(srslte::LOG_LEVEL_DEBUG);
phy_log.set_hex_limit(100000);
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
// dummy layers // dummy layers
phy_dummy phy; phy_dummy phy;
phy.set_log(&phy_log); rlc_dummy rlc;
rlc_dummy rlc(&rlc_log);
rrc_dummy rrc; rrc_dummy rrc;
stack_dummy stack; stack_dummy stack;
@ -2251,7 +2197,7 @@ int mac_random_access_test()
// Test 1: No RAR is received. // Test 1: No RAR is received.
// According to end of 5.1.5, UE sends up to preamb_trans_max upon which indicates RA problem to higher layers // According to end of 5.1.5, UE sends up to preamb_trans_max upon which indicates RA problem to higher layers
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.rach_cfg = rach_cfg; my_test.rach_cfg = rach_cfg;
my_test.nof_prachs = rach_cfg.ra_supervision_info.preamb_trans_max.to_number(); my_test.nof_prachs = rach_cfg.ra_supervision_info.preamb_trans_max.to_number();
TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack)); TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack));
@ -2268,7 +2214,7 @@ int mac_random_access_test()
// Test 2: RAR received but no matching RAPID // Test 2: RAR received but no matching RAPID
// The UE receives a RAR without a matching RAPID on every RAR response window TTI. // The UE receives a RAR without a matching RAPID on every RAR response window TTI.
// According to 5.1.5, the RA procedure is considered non successful and tries again // According to 5.1.5, the RA procedure is considered non successful and tries again
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.rar_nof_rapid = 1; my_test.rar_nof_rapid = 1;
my_test.nof_prachs = 1; my_test.nof_prachs = 1;
my_test.rar_nof_invalid_rapid = rach_cfg.ra_supervision_info.ra_resp_win_size.to_number(); my_test.rar_nof_invalid_rapid = rach_cfg.ra_supervision_info.ra_resp_win_size.to_number();
@ -2277,7 +2223,7 @@ int mac_random_access_test()
// Test 3: RAR with valid RAPID. Test Msg3 retransmissions // Test 3: RAR with valid RAPID. Test Msg3 retransmissions
// On each HARQ retx, contention resolution timer must be restarted (5.1.5) // On each HARQ retx, contention resolution timer must be restarted (5.1.5)
// When max-HARQ-msg3-retx, contention not successful // When max-HARQ-msg3-retx, contention not successful
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.rar_nof_invalid_rapid = 0; my_test.rar_nof_invalid_rapid = 0;
my_test.nof_msg3_retx = rach_cfg.max_harq_msg3_tx; my_test.nof_msg3_retx = rach_cfg.max_harq_msg3_tx;
TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack)); TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack));
@ -2296,12 +2242,12 @@ int mac_random_access_test()
// Test 4: RAR with valid RAPID. Msg3 transmitted, Msg4 received but invalid ConRes // Test 4: RAR with valid RAPID. Msg3 transmitted, Msg4 received but invalid ConRes
// Contention resolution is defined in 5.1.5. If ConResID does not match, the ConRes is considered // Contention resolution is defined in 5.1.5. If ConResID does not match, the ConRes is considered
// not successful and tries again // not successful and tries again
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.msg4_enable = true; my_test.msg4_enable = true;
TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack)); TESTASSERT(!run_mac_ra_test(my_test, &mac, &phy, &tti, &stack));
// Test 5: Msg4 received and valid ConRes. In this case a valid ConResID is received and RA procedure is successful // Test 5: Msg4 received and valid ConRes. In this case a valid ConResID is received and RA procedure is successful
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.temp_rnti++; // Temporal C-RNTI has to change to avoid duplicate my_test.temp_rnti++; // Temporal C-RNTI has to change to avoid duplicate
my_test.msg4_valid_conres = true; my_test.msg4_valid_conres = true;
my_test.check_ra_successful = true; my_test.check_ra_successful = true;
@ -2317,7 +2263,7 @@ int mac_random_access_test()
// or wait until BSR-reTX is triggered // or wait until BSR-reTX is triggered
rlc.write_sdu(1, 100); rlc.write_sdu(1, 100);
phy.set_crnti(0); phy.set_crnti(0);
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.crnti = my_test.temp_rnti; my_test.crnti = my_test.temp_rnti;
my_test.temp_rnti++; // Temporal C-RNTI has to change to avoid duplicate my_test.temp_rnti++; // Temporal C-RNTI has to change to avoid duplicate
my_test.assume_prach_transmitted = -1; my_test.assume_prach_transmitted = -1;
@ -2328,7 +2274,7 @@ int mac_random_access_test()
// It is similar to Test 5 because C-RNTI is available to the UE when start the RA but // It is similar to Test 5 because C-RNTI is available to the UE when start the RA but
// In this case we will let the procedure expire the Contention Resolution window and make sure // In this case we will let the procedure expire the Contention Resolution window and make sure
// and RRC HO fail signal is sent to RRC. // and RRC HO fail signal is sent to RRC.
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
rrc.ho_finish_successful = false; rrc.ho_finish_successful = false;
phy.set_prach_tti(tti + phy.prach_delay); phy.set_prach_tti(tti + phy.prach_delay);
phy.set_crnti(0); phy.set_crnti(0);
@ -2346,7 +2292,7 @@ int mac_random_access_test()
TESTASSERT(rrc.rach_problem == 2); TESTASSERT(rrc.rach_problem == 2);
// Test 8: Test Contention based Random Access. Same as above but we let the procedure finish successfully. // Test 8: Test Contention based Random Access. Same as above but we let the procedure finish successfully.
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
rrc.ho_finish_successful = false; rrc.ho_finish_successful = false;
// Reset queue to make sure BSR retriggers a SR // Reset queue to make sure BSR retriggers a SR
rlc.reset_queues(); rlc.reset_queues();
@ -2367,7 +2313,7 @@ int mac_random_access_test()
// Test 9: Test non-Contention based HO. Used in HO but preamble is given by the network. In addition to checking // Test 9: Test non-Contention based HO. Used in HO but preamble is given by the network. In addition to checking
// that the given preamble is correctly passed to the PHY, in this case there is no contention. // that the given preamble is correctly passed to the PHY, in this case there is no contention.
// In this first test, no RAR is received and RA procedure fails // In this first test, no RAR is received and RA procedure fails
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
rrc.ho_finish_successful = false; rrc.ho_finish_successful = false;
// Reset queue to make sure BSR retriggers a SR // Reset queue to make sure BSR retriggers a SR
my_test.preamble_idx = 3; my_test.preamble_idx = 3;
@ -2388,7 +2334,7 @@ int mac_random_access_test()
// Test 10: Test non-Contention based HO. Used in HO but preamble is given by the network. We check that // Test 10: Test non-Contention based HO. Used in HO but preamble is given by the network. We check that
// the procedure is considered successful without waiting for contention // the procedure is considered successful without waiting for contention
mac_log->info("\n=========== Test %d =============\n", test_id++); srslog::fetch_basic_logger("MAC").info("\n=========== Test %d =============", test_id++);
my_test.preamble_idx = 3; my_test.preamble_idx = 3;
mac.set_rach_ded_cfg(my_test.preamble_idx, 0); mac.set_rach_ded_cfg(my_test.preamble_idx, 0);
stack.run_pending_tasks(); stack.run_pending_tasks();
@ -2418,8 +2364,23 @@ int main(int argc, char** argv)
pcap_handle->open("mac_test.pcap"); pcap_handle->open("mac_test.pcap");
#endif #endif
mac_log->set_level(srslte::LOG_LEVEL_DEBUG); auto& mac_logger = srslog::fetch_basic_logger("MAC");
mac_log->set_hex_limit(100000); mac_logger.set_level(srslog::basic_levels::debug);
mac_logger.set_hex_dump_max_size(100000);
auto& rlc_logger = srslog::fetch_basic_logger("RLC", false);
rlc_logger.set_level(srslog::basic_levels::debug);
rlc_logger.set_hex_dump_max_size(100000);
auto& phy_logger = srslog::fetch_basic_logger("PHY", false);
phy_logger.set_level(srslog::basic_levels::none);
phy_logger.set_hex_dump_max_size(100000);
srslog::init();
srslte::log_filter rlc_log("RLC");
rlc_log.set_level(srslte::LOG_LEVEL_DEBUG);
rlc_log.set_hex_limit(100000);
srslte::log_filter mac_log("MAC");
mac_log.set_level(srslte::LOG_LEVEL_DEBUG);
mac_log.set_hex_limit(100000);
TESTASSERT(mac_unpack_test() == SRSLTE_SUCCESS); TESTASSERT(mac_unpack_test() == SRSLTE_SUCCESS);
TESTASSERT(mac_ul_sch_pdu_test1() == SRSLTE_SUCCESS); TESTASSERT(mac_ul_sch_pdu_test1() == SRSLTE_SUCCESS);
@ -2437,7 +2398,9 @@ int main(int argc, char** argv)
TESTASSERT(mac_ul_sch_pdu_one_byte_test() == SRSLTE_SUCCESS); TESTASSERT(mac_ul_sch_pdu_one_byte_test() == SRSLTE_SUCCESS);
TESTASSERT(mac_ul_sch_pdu_two_byte_test() == SRSLTE_SUCCESS); TESTASSERT(mac_ul_sch_pdu_two_byte_test() == SRSLTE_SUCCESS);
TESTASSERT(mac_ul_sch_pdu_three_byte_test() == SRSLTE_SUCCESS); TESTASSERT(mac_ul_sch_pdu_three_byte_test() == SRSLTE_SUCCESS);
phy_logger.set_level(srslog::basic_levels::debug);
TESTASSERT(mac_random_access_test() == SRSLTE_SUCCESS); TESTASSERT(mac_random_access_test() == SRSLTE_SUCCESS);
phy_logger.set_level(srslog::basic_levels::none);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }

41
srsue/test/phy/scell_search_test.cc
Unescape Escape View File

@ -10,6 +10,7 @@
* *
*/ */
#include "srslte/srslog/srslog.h"
#include <boost/program_options.hpp> #include <boost/program_options.hpp>
#include <boost/program_options/parsers.hpp> #include <boost/program_options/parsers.hpp>
#include <iostream> #include <iostream>
@ -111,20 +112,20 @@ public:
for (uint32_t i = 0; i < cell_base.nof_ports; i++) { for (uint32_t i = 0; i < cell_base.nof_ports; i++) {
signal_buffer[i] = srslte_vec_cf_malloc(SRSLTE_SF_LEN_PRB(cell_base.nof_prb)); signal_buffer[i] = srslte_vec_cf_malloc(SRSLTE_SF_LEN_PRB(cell_base.nof_prb));
if (!signal_buffer[i]) { if (!signal_buffer[i]) {
ERROR("Error allocating buffer\n"); ERROR("Error allocating buffer");
} }
} }
if (srslte_enb_dl_init(&enb_dl, signal_buffer, cell.nof_prb)) { if (srslte_enb_dl_init(&enb_dl, signal_buffer, cell.nof_prb)) {
ERROR("Error initiating eNb downlink\n"); ERROR("Error initiating eNb downlink");
} }
if (srslte_enb_dl_set_cell(&enb_dl, cell)) { if (srslte_enb_dl_set_cell(&enb_dl, cell)) {
ERROR("Error setting eNb DL cell\n"); ERROR("Error setting eNb DL cell");
} }
if (srslte_enb_dl_add_rnti(&enb_dl, serving_cell_pdsch_rnti)) { if (srslte_enb_dl_add_rnti(&enb_dl, serving_cell_pdsch_rnti)) {
ERROR("Error adding RNTI\n"); ERROR("Error adding RNTI");
} }
} }
@ -145,19 +146,19 @@ public:
// Put PDSCH only if it is required // Put PDSCH only if it is required
if (dci && dci_cfg && softbuffer_tx && data_tx) { if (dci && dci_cfg && softbuffer_tx && data_tx) {
if (srslte_enb_dl_put_pdcch_dl(&enb_dl, dci_cfg, dci)) { if (srslte_enb_dl_put_pdcch_dl(&enb_dl, dci_cfg, dci)) {
ERROR("Error putting PDCCH sf_idx=%d\n", dl_sf->tti); ERROR("Error putting PDCCH sf_idx=%d", dl_sf->tti);
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
// Create pdsch config // Create pdsch config
srslte_pdsch_cfg_t pdsch_cfg; srslte_pdsch_cfg_t pdsch_cfg;
if (srslte_ra_dl_dci_to_grant(&enb_dl.cell, dl_sf, serving_cell_pdsch_tm, false, dci, &pdsch_cfg.grant)) { if (srslte_ra_dl_dci_to_grant(&enb_dl.cell, dl_sf, serving_cell_pdsch_tm, false, dci, &pdsch_cfg.grant)) {
ERROR("Computing DL grant sf_idx=%d\n", dl_sf->tti); ERROR("Computing DL grant sf_idx=%d", dl_sf->tti);
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
char str[512]; char str[512];
srslte_dci_dl_info(dci, str, 512); srslte_dci_dl_info(dci, str, 512);
INFO("eNb PDCCH: rnti=0x%x, %s\n", serving_cell_pdsch_rnti, str); INFO("eNb PDCCH: rnti=0x%x, %s", serving_cell_pdsch_rnti, str);
for (uint32_t i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { for (uint32_t i = 0; i < SRSLTE_MAX_CODEWORDS; i++) {
pdsch_cfg.softbuffers.tx[i] = softbuffer_tx[i]; pdsch_cfg.softbuffers.tx[i] = softbuffer_tx[i];
@ -171,11 +172,11 @@ public:
pdsch_cfg.meas_time_en = false; pdsch_cfg.meas_time_en = false;
if (srslte_enb_dl_put_pdsch(&enb_dl, &pdsch_cfg, data_tx) < 0) { if (srslte_enb_dl_put_pdsch(&enb_dl, &pdsch_cfg, data_tx) < 0) {
ERROR("Error putting PDSCH sf_idx=%d\n", dl_sf->tti); ERROR("Error putting PDSCH sf_idx=%d", dl_sf->tti);
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
} }
srslte_pdsch_tx_info(&pdsch_cfg, str, 512); srslte_pdsch_tx_info(&pdsch_cfg, str, 512);
INFO("eNb PDSCH: rnti=0x%x, %s\n", serving_cell_pdsch_rnti, str); INFO("eNb PDSCH: rnti=0x%x, %s", serving_cell_pdsch_rnti, str);
} }
srslte_enb_dl_gen_signal(&enb_dl); srslte_enb_dl_gen_signal(&enb_dl);
@ -400,12 +401,14 @@ int main(int argc, char** argv)
} }
// Common for simulation and over-the-air // Common for simulation and over-the-air
srslog::basic_logger& logger = srslog::fetch_basic_logger("intra_measure");
srslog::init();
cf_t* baseband_buffer = srslte_vec_cf_malloc(SRSLTE_SF_LEN_MAX); cf_t* baseband_buffer = srslte_vec_cf_malloc(SRSLTE_SF_LEN_MAX);
srslte::rf_timestamp_t ts = {}; srslte::rf_timestamp_t ts = {};
srsue::scell::intra_measure intra_measure; srsue::scell::intra_measure intra_measure(logger);
srslte::log_filter logger("intra_measure");
meas_itf_listener rrc; meas_itf_listener rrc;
srsue::phy_common common; srsue::phy_common common(logger);
// Simulation only // Simulation only
std::vector<std::unique_ptr<test_enb> > test_enb_v; std::vector<std::unique_ptr<test_enb> > test_enb_v;
@ -447,16 +450,16 @@ int main(int argc, char** argv)
const size_t nof_bytes = (6144 * 16 * 3 / 8); const size_t nof_bytes = (6144 * 16 * 3 / 8);
softbuffer_tx[i] = (srslte_softbuffer_tx_t*)calloc(sizeof(srslte_softbuffer_tx_t), 1); softbuffer_tx[i] = (srslte_softbuffer_tx_t*)calloc(sizeof(srslte_softbuffer_tx_t), 1);
if (!softbuffer_tx[i]) { if (!softbuffer_tx[i]) {
ERROR("Error allocating softbuffer_tx\n"); ERROR("Error allocating softbuffer_tx");
} }
if (srslte_softbuffer_tx_init(softbuffer_tx[i], cell_base.nof_prb)) { if (srslte_softbuffer_tx_init(softbuffer_tx[i], cell_base.nof_prb)) {
ERROR("Error initiating softbuffer_tx\n"); ERROR("Error initiating softbuffer_tx");
} }
data_tx[i] = srslte_vec_u8_malloc(nof_bytes); data_tx[i] = srslte_vec_u8_malloc(nof_bytes);
if (!data_tx[i]) { if (!data_tx[i]) {
ERROR("Error allocating data tx\n"); ERROR("Error allocating data tx");
} else { } else {
for (uint32_t j = 0; j < nof_bytes; j++) { for (uint32_t j = 0; j < nof_bytes; j++) {
data_tx[i][j] = (uint8_t)srslte_random_uniform_int_dist(random_gen, 0, 255); data_tx[i][j] = (uint8_t)srslte_random_uniform_int_dist(random_gen, 0, 255);
@ -473,9 +476,9 @@ int main(int argc, char** argv)
uint32_t serving_cell_id = *pcis_to_simulate.begin(); uint32_t serving_cell_id = *pcis_to_simulate.begin();
cell_base.id = serving_cell_id; cell_base.id = serving_cell_id;
logger.set_level(intra_meas_log_level); logger.set_level(srslog::str_to_basic_level(intra_meas_log_level));
intra_measure.init(0, &common, &rrc, &logger); intra_measure.init(0, &common, &rrc);
intra_measure.set_primary_cell(SRSLTE_MAX(earfcn_dl, 0), cell_base); intra_measure.set_primary_cell(SRSLTE_MAX(earfcn_dl, 0), cell_base);
if (earfcn_dl >= 0) { if (earfcn_dl >= 0) {
@ -625,7 +628,7 @@ int main(int argc, char** argv)
dci.tb[i].cw_idx = i; dci.tb[i].cw_idx = i;
} }
} else { } else {
ERROR("Wrong transmission mode (%d)\n", serving_cell_pdsch_tm); ERROR("Wrong transmission mode (%d)", serving_cell_pdsch_tm);
} }
enb->work(&sf_cfg_dl, &dci_cfg, &dci, softbuffer_tx, data_tx, baseband_buffer, ts); enb->work(&sf_cfg_dl, &dci_cfg, &dci, softbuffer_tx, data_tx, baseband_buffer, ts);
} else { } else {
@ -676,6 +679,8 @@ int main(int argc, char** argv)
} }
} }
srslog::flush();
if (ret && radio == nullptr) { if (ret && radio == nullptr) {
printf("Error\n"); printf("Error\n");
} else { } else {

68
srsue/test/phy/ue_phy_test.cc
Unescape Escape View File

@ -37,7 +37,7 @@ public:
expired = (cvar.wait_until(lock, expire_time) == std::cv_status::timeout); \ expired = (cvar.wait_until(lock, expire_time) == std::cv_status::timeout); \
} \ } \
if (expired) { \ if (expired) { \
log_h.debug("Expired " #NAME " waiting\n"); \ logger.debug("Expired " #NAME " waiting"); \
} \ } \
return received_##NAME; \ return received_##NAME; \
} \ } \
@ -49,7 +49,7 @@ private:
{ \ { \
std::unique_lock<std::mutex> lock(mutex); \ std::unique_lock<std::mutex> lock(mutex); \
cvar.notify_all(); \ cvar.notify_all(); \
log_h.debug(#NAME " received\n"); \ logger.debug(#NAME " received"); \
received_##NAME = true; \ received_##NAME = true; \
} }
@ -60,7 +60,7 @@ private:
class dummy_stack final : public srsue::stack_interface_phy_lte class dummy_stack final : public srsue::stack_interface_phy_lte
{ {
private: private:
srslte::log_filter log_h; srslog::basic_logger& logger;
uint16_t rnti = 0x3c; uint16_t rnti = 0x3c;
std::mutex mutex; std::mutex mutex;
std::condition_variable cvar; std::condition_variable cvar;
@ -78,9 +78,9 @@ private:
public: public:
// Local test access methods // Local test access methods
explicit dummy_stack(srslte::logger& logger) : log_h("stack", &logger) {} dummy_stack() : logger(srslog::fetch_basic_logger("stack", false)) {}
void set_rnti(uint16_t rnti_) { rnti = rnti_; } void set_rnti(uint16_t rnti_) { rnti = rnti_; }
void set_loglevel(std::string& str) { log_h.set_level(str); } void set_loglevel(std::string& str) { logger.set_level(srslog::str_to_basic_level(str)); }
void in_sync() override { notify_in_sync(); } void in_sync() override { notify_in_sync(); }
void out_of_sync() override { notify_out_of_sync(); } void out_of_sync() override { notify_out_of_sync(); }
@ -88,8 +88,7 @@ private:
{ {
for (auto& m : meas) { for (auto& m : meas) {
notify_new_phy_meas(); notify_new_phy_meas();
log_h.info( logger.info("New measurement earfcn=%d; pci=%d; rsrp=%+.1fdBm; rsrq=%+.1fdB;", m.earfcn, m.pci, m.rsrp, m.rsrq);
"New measurement earfcn=%d; pci=%d; rsrp=%+.1fdBm; rsrq=%+.1fdB;\n", m.earfcn, m.pci, m.rsrp, m.rsrq);
} }
} }
uint16_t get_dl_sched_rnti(uint32_t tti) override { return rnti; } uint16_t get_dl_sched_rnti(uint32_t tti) override { return rnti; }
@ -110,7 +109,7 @@ private:
void run_tti(const uint32_t tti, const uint32_t tti_jump) override void run_tti(const uint32_t tti, const uint32_t tti_jump) override
{ {
notify_run_tti(); notify_run_tti();
log_h.debug("Run TTI %d\n", tti); logger.debug("Run TTI %d", tti);
} }
void cell_search_complete(cell_search_ret_t ret, srsue::phy_cell_t found_cell) override void cell_search_complete(cell_search_ret_t ret, srsue::phy_cell_t found_cell) override
@ -143,7 +142,7 @@ private:
class dummy_radio : public srslte::radio_interface_phy class dummy_radio : public srslte::radio_interface_phy
{ {
private: private:
srslte::log_filter log_h; srslog::basic_logger& logger;
std::vector<srslte_ringbuffer_t> ring_buffers; std::vector<srslte_ringbuffer_t> ring_buffers;
float base_srate = 0.0f; float base_srate = 0.0f;
float tx_srate = 0.0f; float tx_srate = 0.0f;
@ -164,10 +163,8 @@ private:
CALLBACK(late) CALLBACK(late)
public: public:
dummy_radio(srslte::logger& logger, uint32_t nof_channels, float base_srate_) : dummy_radio(uint32_t nof_channels, float base_srate_) :
log_h("radio", &logger), logger(srslog::fetch_basic_logger("radio", false)), ring_buffers(nof_channels), base_srate(base_srate_)
ring_buffers(nof_channels),
base_srate(base_srate_)
{ {
// Create Ring buffers // Create Ring buffers
for (auto& rb : ring_buffers) { for (auto& rb : ring_buffers) {
@ -199,7 +196,7 @@ private:
} }
} }
void set_loglevel(std::string& str) { log_h.set_level(str); } void set_loglevel(std::string& str) { logger.set_level(srslog::str_to_basic_level(str)); }
void write_ring_buffers(cf_t** buffer, uint32_t nsamples) void write_ring_buffers(cf_t** buffer, uint32_t nsamples)
{ {
@ -207,7 +204,7 @@ private:
int ret = SRSLTE_SUCCESS; int ret = SRSLTE_SUCCESS;
do { do {
if (ret != SRSLTE_SUCCESS) { if (ret != SRSLTE_SUCCESS) {
log_h.error("Ring buffer write failed (full). Trying again.\n"); logger.error("Ring buffer write failed (full). Trying again.");
} }
ret = srslte_ringbuffer_write_timed(&ring_buffers[i], buffer[i], (uint32_t)sizeof(cf_t) * nsamples, 1000); ret = srslte_ringbuffer_write_timed(&ring_buffers[i], buffer[i], (uint32_t)sizeof(cf_t) * nsamples, 1000);
} while (ret == SRSLTE_ERROR_TIMEOUT); } while (ret == SRSLTE_ERROR_TIMEOUT);
@ -251,9 +248,9 @@ private:
// Read base srate samples // Read base srate samples
int ret = srslte_ringbuffer_read(&ring_buffers[i], buf_ptr, (uint32_t)sizeof(cf_t) * base_nsamples); int ret = srslte_ringbuffer_read(&ring_buffers[i], buf_ptr, (uint32_t)sizeof(cf_t) * base_nsamples);
if (ret < 0) { if (ret < 0) {
log_h.error("Reading ring buffer\n"); logger.error("Reading ring buffer");
} else { } else {
log_h.debug("-- %d samples read from ring buffer\n", base_nsamples); logger.debug("-- %d samples read from ring buffer", base_nsamples);
} }
// Only if baseband buffer is provided // Only if baseband buffer is provided
@ -292,43 +289,43 @@ private:
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
tx_freq = (float)freq; tx_freq = (float)freq;
log_h.info("Set Tx freq to %+.0f MHz.\n", freq * 1.0e-6); logger.info("Set Tx freq to %+.0f MHz.", freq * 1.0e-6);
} }
void set_rx_freq(const uint32_t& channel_idx, const double& freq) override void set_rx_freq(const uint32_t& channel_idx, const double& freq) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
rx_freq = (float)freq; rx_freq = (float)freq;
log_h.info("Set Rx freq to %+.0f MHz.\n", freq * 1.0e-6); logger.info("Set Rx freq to %+.0f MHz.", freq * 1.0e-6);
} }
void set_rx_gain_th(const float& gain) override void set_rx_gain_th(const float& gain) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
rx_gain = srslte_convert_dB_to_amplitude(gain); rx_gain = srslte_convert_dB_to_amplitude(gain);
log_h.info("Set Rx gain-th to %+.1f dB (%.6f).\n", gain, rx_gain); logger.info("Set Rx gain-th to %+.1f dB (%.6f).", gain, rx_gain);
} }
void set_tx_gain(const float& gain) override void set_tx_gain(const float& gain) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
rx_gain = srslte_convert_dB_to_amplitude(gain); rx_gain = srslte_convert_dB_to_amplitude(gain);
log_h.info("Set Tx gain to %+.1f dB (%.6f).\n", gain, rx_gain); logger.info("Set Tx gain to %+.1f dB (%.6f).", gain, rx_gain);
} }
void set_rx_gain(const float& gain) override void set_rx_gain(const float& gain) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
rx_gain = srslte_convert_dB_to_amplitude(gain); rx_gain = srslte_convert_dB_to_amplitude(gain);
log_h.info("Set Rx gain to %+.1f dB (%.6f).\n", gain, rx_gain); logger.info("Set Rx gain to %+.1f dB (%.6f).", gain, rx_gain);
} }
void set_tx_srate(const double& srate) override void set_tx_srate(const double& srate) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
tx_srate = (float)srate; tx_srate = (float)srate;
log_h.info("Set Tx sampling rate to %+.3f MHz.\n", srate * 1.0e-6); logger.info("Set Tx sampling rate to %+.3f MHz.", srate * 1.0e-6);
} }
void set_rx_srate(const double& srate) override void set_rx_srate(const double& srate) override
{ {
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
rx_srate = (float)srate; rx_srate = (float)srate;
log_h.info("Set Rx sampling rate to %+.3f MHz.\n", srate * 1.0e-6); logger.info("Set Rx sampling rate to %+.3f MHz.", srate * 1.0e-6);
} }
void set_channel_rx_offset(uint32_t ch, int32_t offset_samples) override{}; void set_channel_rx_offset(uint32_t ch, int32_t offset_samples) override{};
float get_rx_gain() override float get_rx_gain() override
@ -345,7 +342,7 @@ private:
}; };
// Common instances // Common instances
srslte::log_filter log_h; srslog::basic_logger& logger;
// Dummy instances // Dummy instances
dummy_stack stack; dummy_stack stack;
@ -368,16 +365,15 @@ private:
public: public:
phy_test_bench(const srsue::phy_args_t& phy_args, const srslte_cell_t& cell, srslte::logger& logger_) : phy_test_bench(const srsue::phy_args_t& phy_args, const srslte_cell_t& cell, srslte::logger& logger_) :
stack(logger_), radio(cell.nof_ports, srslte_sampling_freq_hz(cell.nof_prb)),
radio(logger_, cell.nof_ports, srslte_sampling_freq_hz(cell.nof_prb)),
thread("phy_test_bench"), thread("phy_test_bench"),
log_h("test bench") logger(srslog::fetch_basic_logger("test bench", false))
{ {
// Deduce physical attributes // Deduce physical attributes
sf_len = SRSLTE_SF_LEN_PRB(cell.nof_prb); sf_len = SRSLTE_SF_LEN_PRB(cell.nof_prb);
// Initialise UE // Initialise UE
phy = std::unique_ptr<srsue::phy>(new srsue::phy(&logger_)); phy = std::unique_ptr<srsue::phy>(new srsue::phy(&logger_, srslog::get_default_sink()));
phy->init(phy_args, &stack, &radio); phy->init(phy_args, &stack, &radio);
// Initialise DL baseband buffers // Initialise DL baseband buffers
@ -430,7 +426,7 @@ public:
// Free run DL // Free run DL
do { do {
log_h.debug("-- generating DL baseband SFN=%" PRId64 " TTI=%d;\n", sfn, dl_sf_cfg.tti); logger.debug("-- generating DL baseband SFN=%" PRId64 " TTI=%d;", sfn, dl_sf_cfg.tti);
// Create empty resource grid with basic signals // Create empty resource grid with basic signals
srslte_enb_dl_put_base(&enb_dl, &dl_sf_cfg); srslte_enb_dl_put_base(&enb_dl, &dl_sf_cfg);
@ -480,7 +476,7 @@ public:
void set_loglevel(std::string str) void set_loglevel(std::string str)
{ {
log_h.set_level(str); logger.set_level(srslog::str_to_basic_level(str));
radio.set_loglevel(str); radio.set_loglevel(str);
stack.set_loglevel(str); stack.set_loglevel(str);
} }
@ -506,15 +502,7 @@ int main(int argc, char** argv)
phy_args.log.phy_level = "info"; phy_args.log.phy_level = "info";
// Setup logging. // Setup logging.
srslog::sink* log_sink = srslog::create_stdout_sink(); srslte::srslog_wrapper log_wrapper(srslog::fetch_log_channel("main_channel"));
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);
// Start the log backend. // Start the log backend.
srslog::init(); srslog::init();

5
srsue/test/ttcn3/hdr/lte_ttcn3_phy.h
Unescape Escape View File

@ -35,7 +35,7 @@ public:
} cell_t; } cell_t;
typedef std::vector<cell_t> cell_list_t; typedef std::vector<cell_t> cell_list_t;
lte_ttcn3_phy(srslte::logger* logger_); lte_ttcn3_phy();
~lte_ttcn3_phy() = default; ~lte_ttcn3_phy() = default;
int init(const phy_args_t& args_, stack_interface_phy_lte* stack_, syssim_interface_phy* syssim_); int init(const phy_args_t& args_, stack_interface_phy_lte* stack_, syssim_interface_phy* syssim_);
@ -103,8 +103,7 @@ public:
void run_tti(); void run_tti();
private: private:
srslte::logger* logger = nullptr; srslog::basic_logger& logger;
srslte::log_filter log;
// All available cells // All available cells
cell_list_t cells; cell_list_t cells;

9
srsue/test/ttcn3/hdr/swappable_sink.h
Unescape Escape View File

@ -16,7 +16,7 @@
#include "srslte/srslog/sink.h" #include "srslte/srslog/sink.h"
/// A custom sink implementation that allows hot swapping file sinks so that loggers can write to different files /// A custom sink implementation that allows hot swapping file sinks so that loggers can write to different files
/// dynamically. /// dynamically or other stream-like sinks like stdout.
class swappable_sink : public srslog::sink class swappable_sink : public srslog::sink
{ {
public: public:
@ -38,6 +38,13 @@ public:
s = &srslog::fetch_file_sink(filename); s = &srslog::fetch_file_sink(filename);
} }
/// Swaps the current sink to use the stdout sink.
void swap_to_stdout()
{
srslog::flush();
s = &srslog::fetch_stdout_sink();
}
private: private:
srslog::sink* s; srslog::sink* s;
}; };

25
srsue/test/ttcn3/hdr/ttcn3_drb_interface.h
Unescape Escape View File

@ -27,27 +27,28 @@ using namespace srslte;
class ttcn3_drb_interface : public ttcn3_port_handler class ttcn3_drb_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_drb_interface() : pool(byte_buffer_pool::get_instance()) {} explicit ttcn3_drb_interface(srslog::basic_logger& logger) :
ttcn3_port_handler(logger), pool(byte_buffer_pool::get_instance())
{}
~ttcn3_drb_interface() = default; ~ttcn3_drb_interface() = default;
int init(ss_srb_interface* syssim_, srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(ss_srb_interface* syssim_, std::string net_ip_, uint32_t net_port_)
{ {
syssim = syssim_; syssim = syssim_;
log = log_;
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
initialized = true; initialized = true;
log->debug("Initialized.\n"); logger.debug("Initialized.");
return port_listen(); return port_listen();
} }
void tx(const uint8_t* buffer, uint32_t len) void tx(const uint8_t* buffer, uint32_t len)
{ {
if (initialized) { if (initialized) {
log->info_hex(buffer, len, "Sending %d B to Titan\n", len); logger.info(buffer, len, "Sending %d B to Titan", len);
send(buffer, len); send(buffer, len);
} else { } else {
log->error("Trying to transmit but port not connected.\n"); logger.error("Trying to transmit but port not connected.");
} }
} }
@ -55,7 +56,7 @@ private:
///< Main message handler ///< Main message handler
int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n)
{ {
log->debug_hex(rx_buf->begin(), n, "Received %d B from remote.\n", n); logger.debug(rx_buf->begin(), n, "Received %d B from remote.", n);
// Chop incoming msg, first two bytes are length of the JSON // Chop incoming msg, first two bytes are length of the JSON
// (see IPL4_EUTRA_SYSTEM_Definitions.ttcn // (see IPL4_EUTRA_SYSTEM_Definitions.ttcn
@ -67,7 +68,7 @@ private:
Document document; Document document;
if (document.Parse((char*)&rx_buf->at(2)).HasParseError() || document.IsObject() == false) { if (document.Parse((char*)&rx_buf->at(2)).HasParseError() || document.IsObject() == false) {
log->error_hex((uint8*)&rx_buf->at(2), json_len, "Error parsing incoming data.\n"); logger.error((uint8*)&rx_buf->at(2), json_len, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -75,7 +76,7 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info("Received JSON with %d B\n%s\n", json_len, (char*)buffer.GetString()); logger.info("Received JSON with %d B\n%s", json_len, (char*)buffer.GetString());
// check for common // check for common
assert(document.HasMember("Common")); assert(document.HasMember("Common"));
@ -106,9 +107,9 @@ private:
handle_sdu(document, lcid, octstr.data(), octstr.size(), ttcn3_helpers::get_follow_on_flag(document)); handle_sdu(document, lcid, octstr.data(), octstr.size(), ttcn3_helpers::get_follow_on_flag(document));
} }
} else if ((*itr)["PduSduList"].HasMember("MacPdu")) { } else if ((*itr)["PduSduList"].HasMember("MacPdu")) {
log->warning("Not handling MacPdu type."); logger.warning("Not handling MacPdu type.");
} else { } else {
log->warning("Not handling this PduSdu type.\n"); logger.warning("Not handling this PduSdu type.");
} }
} }
@ -117,7 +118,7 @@ private:
void handle_sdu(Document& document, const uint16_t lcid, const uint8_t* payload, const uint16_t len, bool follow_on) void handle_sdu(Document& document, const uint16_t lcid, const uint8_t* payload, const uint16_t len, bool follow_on)
{ {
log->info_hex(payload, len, "Received DRB PDU (lcid=%d)\n", lcid); logger.info(payload, len, "Received DRB PDU (lcid=%d)", lcid);
// pack into byte buffer // pack into byte buffer
unique_byte_buffer_t pdu = pool_allocate_blocking; unique_byte_buffer_t pdu = pool_allocate_blocking;

19
srsue/test/ttcn3/hdr/ttcn3_ip_ctrl_interface.h
Unescape Escape View File

@ -25,16 +25,15 @@ using namespace rapidjson;
class ttcn3_ip_ctrl_interface : public ttcn3_port_handler class ttcn3_ip_ctrl_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_ip_ctrl_interface() = default; explicit ttcn3_ip_ctrl_interface(srslog::basic_logger& logger) : ttcn3_port_handler(logger) {}
~ttcn3_ip_ctrl_interface() = default; ~ttcn3_ip_ctrl_interface() = default;
int init(srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(std::string net_ip_, uint32_t net_port_)
{ {
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
log = log_;
initialized = true; initialized = true;
log->debug("Initialized.\n"); logger.debug("Initialized.");
return port_listen(); return port_listen();
} }
@ -42,11 +41,11 @@ private:
///< Main message handler ///< Main message handler
int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n)
{ {
log->debug("Received %d B from remote.\n", n); logger.debug("Received %d B from remote.", n);
Document document; Document document;
if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) { if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) {
log->error_hex(rx_buf->begin(), n, "Error parsing incoming data.\n"); logger.error(rx_buf->begin(), n, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -54,14 +53,14 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info("Received %d bytes\n%s\n", n, (char*)buffer.GetString()); logger.info("Received %d bytes\n%s", n, (char*)buffer.GetString());
// Get message // Get message
if (document.HasMember("RoutingInfo")) { if (document.HasMember("RoutingInfo")) {
log->info("Received RoutingInfo\n"); logger.info("Received RoutingInfo");
handle_routing_info(document); handle_routing_info(document);
} else { } else {
log->error("Received unknown request.\n"); logger.error("Received unknown request.");
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -86,7 +85,7 @@ private:
std::string resp = ttcn3_helpers::get_drbmux_common_ind_cnf(); std::string resp = ttcn3_helpers::get_drbmux_common_ind_cnf();
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
}; };

19
srsue/test/ttcn3/hdr/ttcn3_ip_sock_interface.h
Unescape Escape View File

@ -19,16 +19,15 @@
class ttcn3_ip_sock_interface : public ttcn3_port_handler class ttcn3_ip_sock_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_ip_sock_interface() = default; explicit ttcn3_ip_sock_interface(srslog::basic_logger& logger) : ttcn3_port_handler(logger) {}
~ttcn3_ip_sock_interface() = default; ~ttcn3_ip_sock_interface() = default;
int init(srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(std::string net_ip_, uint32_t net_port_)
{ {
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
log = log_;
initialized = true; initialized = true;
log->debug("Initialized.\n"); logger.debug("Initialized.");
return port_listen(); return port_listen();
} }
@ -36,11 +35,11 @@ private:
///< Main message handler ///< Main message handler
int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n)
{ {
log->debug("Received %d B from remote.\n", n); logger.debug("Received %d B from remote.", n);
Document document; Document document;
if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) { if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) {
log->error_hex(rx_buf->begin(), n, "Error parsing incoming data.\n"); logger.error(rx_buf->begin(), n, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -48,14 +47,14 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info("Received %d bytes\n%s\n", n, (char*)buffer.GetString()); logger.info("Received %d bytes\n%s", n, (char*)buffer.GetString());
// Get message // Get message
if (document.HasMember("CTRL")) { if (document.HasMember("CTRL")) {
log->info("Received CTRL command.\n"); logger.info("Received CTRL command.");
handle_ctrl(document); handle_ctrl(document);
} else { } else {
log->error("Received unknown request.\n"); logger.error("Received unknown request.");
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -102,7 +101,7 @@ private:
// Send response // Send response
if (resp.length() > 0) { if (resp.length() > 0) {
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
} }

25
srsue/test/ttcn3/hdr/ttcn3_port_handler.h
Unescape Escape View File

@ -20,6 +20,7 @@
#include "srslte/common/epoll_helper.h" #include "srslte/common/epoll_helper.h"
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "srslte/srslog/srslog.h"
#include "ttcn3_common.h" #include "ttcn3_common.h"
#include <arpa/inet.h> #include <arpa/inet.h>
#include <fcntl.h> #include <fcntl.h>
@ -28,7 +29,9 @@
class ttcn3_port_handler : public epoll_handler class ttcn3_port_handler : public epoll_handler
{ {
public: public:
ttcn3_port_handler() : rx_buf(unique_byte_array_t(new byte_array_t)) {} explicit ttcn3_port_handler(srslog::basic_logger& logger) :
logger(logger), rx_buf(unique_byte_array_t(new byte_array_t))
{}
virtual ~ttcn3_port_handler() {} virtual ~ttcn3_port_handler() {}
virtual int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) = 0; virtual int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) = 0;
@ -42,9 +45,9 @@ public:
int rd_sz = int rd_sz =
sctp_recvmsg(fd, rx_buf->begin(), RX_BUF_SIZE, (struct sockaddr*)&client_addr, &fromlen, &sri, &msg_flags); sctp_recvmsg(fd, rx_buf->begin(), RX_BUF_SIZE, (struct sockaddr*)&client_addr, &fromlen, &sri, &msg_flags);
if (rd_sz == -1 && errno != EAGAIN) { if (rd_sz == -1 && errno != EAGAIN) {
log->error("Error reading from SCTP socket: %s", strerror(errno)); logger.error("Error reading from SCTP socket: %s", strerror(errno));
} else if (rd_sz == -1 && errno == EAGAIN) { } else if (rd_sz == -1 && errno == EAGAIN) {
log->debug("Socket timeout reached"); logger.debug("Socket timeout reached");
} else { } else {
if (msg_flags & MSG_NOTIFICATION) { if (msg_flags & MSG_NOTIFICATION) {
// Received notification // Received notification
@ -96,8 +99,8 @@ public:
break; break;
} }
log->debug( logger.debug(
"SCTP_ASSOC_CHANGE notif: state: %s, error code: %d, out streams: %d, in streams: %d, assoc id: %d\n", "SCTP_ASSOC_CHANGE notif: state: %s, error code: %d, out streams: %d, in streams: %d, assoc id: %d",
state, state,
n->sac_error, n->sac_error,
n->sac_outbound_streams, n->sac_outbound_streams,
@ -112,12 +115,12 @@ public:
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
struct sctp_shutdown_event* n = &notif->sn_shutdown_event; struct sctp_shutdown_event* n = &notif->sn_shutdown_event;
log->debug("SCTP_SHUTDOWN_EVENT notif: assoc id: %d\n", n->sse_assoc_id); logger.debug("SCTP_SHUTDOWN_EVENT notif: assoc id: %d", n->sse_assoc_id);
break; break;
} }
default: default:
log->warning("Unhandled notification type %d\n", notif->sn_header.sn_type); logger.warning("Unhandled notification type %d", notif->sn_header.sn_type);
break; break;
} }
@ -128,7 +131,7 @@ public:
void send(const uint8_t* buffer, const uint32_t len) void send(const uint8_t* buffer, const uint32_t len)
{ {
if (sendto(sock_fd, buffer, len, 0, (struct sockaddr*)&client_addr, sizeof(client_addr)) == -1) { if (sendto(sock_fd, buffer, len, 0, (struct sockaddr*)&client_addr, sizeof(client_addr)) == -1) {
log->error("Error sending message to tester.\n"); logger.error("Error sending message to tester.");
} }
} }
@ -185,7 +188,7 @@ public:
ret = bind(sock_fd, (struct sockaddr*)&bind_addr, sizeof(bind_addr)); ret = bind(sock_fd, (struct sockaddr*)&bind_addr, sizeof(bind_addr));
if (ret != 0) { if (ret != 0) {
close(sock_fd); close(sock_fd);
log->error("Error binding SCTP socket\n"); logger.error("Error binding SCTP socket");
srslte::console("Error binding SCTP socket\n"); srslte::console("Error binding SCTP socket\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -194,7 +197,7 @@ public:
ret = listen(sock_fd, SOMAXCONN); ret = listen(sock_fd, SOMAXCONN);
if (ret != SRSLTE_SUCCESS) { if (ret != SRSLTE_SUCCESS) {
close(sock_fd); close(sock_fd);
log->error("Error in SCTP socket listen\n"); logger.error("Error in SCTP socket listen");
srslte::console("Error in SCTP socket listen\n"); srslte::console("Error in SCTP socket listen\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -208,7 +211,7 @@ public:
uint32_t net_port = 0; uint32_t net_port = 0;
int sock_fd = -1; int sock_fd = -1;
struct sockaddr client_addr = {}; struct sockaddr client_addr = {};
srslte::log* log = nullptr; srslog::basic_logger& logger;
unique_byte_array_t rx_buf; ///< Receive buffer for this port unique_byte_array_t rx_buf; ///< Receive buffer for this port
}; };

28
srsue/test/ttcn3/hdr/ttcn3_srb_interface.h
Unescape Escape View File

@ -26,27 +26,28 @@ using namespace srslte;
class ttcn3_srb_interface : public ttcn3_port_handler class ttcn3_srb_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_srb_interface() : pool(byte_buffer_pool::get_instance()) {} explicit ttcn3_srb_interface(srslog::basic_logger& logger) :
ttcn3_port_handler(logger), pool(byte_buffer_pool::get_instance())
{}
~ttcn3_srb_interface() = default; ~ttcn3_srb_interface() = default;
int init(ss_srb_interface* syssim_, srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(ss_srb_interface* syssim_, std::string net_ip_, uint32_t net_port_)
{ {
syssim = syssim_; syssim = syssim_;
log = log_;
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
initialized = true; initialized = true;
log->debug("Initialized.\n"); logger.debug("Initialized.");
return port_listen(); return port_listen();
} }
void tx(const uint8_t* buffer, uint32_t len) void tx(const uint8_t* buffer, uint32_t len)
{ {
if (initialized) { if (initialized) {
log->info_hex(buffer, len, "Sending %d B to Titan\n", len); logger.info(buffer, len, "Sending %d B to Titan", len);
send(buffer, len); send(buffer, len);
} else { } else {
log->error("Trying to transmit but port not connected.\n"); logger.error("Trying to transmit but port not connected.");
} }
} }
@ -54,7 +55,7 @@ private:
///< Main message handler ///< Main message handler
int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n)
{ {
log->debug_hex(rx_buf->begin(), n, "Received %d B from remote.\n", n); logger.debug(rx_buf->begin(), n, "Received %d B from remote.", n);
// Chop incoming msg, first two bytes are length of the JSON // Chop incoming msg, first two bytes are length of the JSON
// (see IPL4_EUTRA_SYSTEM_Definitions.ttcn // (see IPL4_EUTRA_SYSTEM_Definitions.ttcn
@ -66,7 +67,7 @@ private:
Document document; Document document;
if (document.Parse((char*)&rx_buf->at(2)).HasParseError() || document.IsObject() == false) { if (document.Parse((char*)&rx_buf->at(2)).HasParseError() || document.IsObject() == false) {
log->error_hex((uint8*)&rx_buf->at(2), json_len, "Error parsing incoming data.\n"); logger.error((uint8*)&rx_buf->at(2), json_len, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -74,7 +75,7 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info("Received JSON with %d B\n%s\n", json_len, (char*)buffer.GetString()); logger.info("Received JSON with %d B\n%s", json_len, (char*)buffer.GetString());
// check for common // check for common
assert(document.HasMember("Common")); assert(document.HasMember("Common"));
@ -92,9 +93,10 @@ private:
} else if (rrcpdu.HasMember("Dcch")) { } else if (rrcpdu.HasMember("Dcch")) {
rx_buf_offset += 2; rx_buf_offset += 2;
uint32_t lcid = document["Common"]["RoutingInfo"]["RadioBearerId"]["Srb"].GetInt(); uint32_t lcid = document["Common"]["RoutingInfo"]["RadioBearerId"]["Srb"].GetInt();
handle_dcch_pdu(document, lcid, &rx_buf->at(rx_buf_offset), n - rx_buf_offset, ttcn3_helpers::get_follow_on_flag(document)); handle_dcch_pdu(
document, lcid, &rx_buf->at(rx_buf_offset), n - rx_buf_offset, ttcn3_helpers::get_follow_on_flag(document));
} else { } else {
log->error("Received unknown request.\n"); logger.error("Received unknown request.");
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -103,7 +105,7 @@ private:
// Todo: move to SYSSIM // Todo: move to SYSSIM
void handle_ccch_pdu(Document& document, const uint8_t* payload, const uint16_t len) void handle_ccch_pdu(Document& document, const uint8_t* payload, const uint16_t len)
{ {
log->info_hex(payload, len, "Received CCCH RRC PDU\n"); logger.info(payload, len, "Received CCCH RRC PDU");
// pack into byte buffer // pack into byte buffer
unique_byte_buffer_t pdu = pool_allocate_blocking; unique_byte_buffer_t pdu = pool_allocate_blocking;
@ -123,7 +125,7 @@ private:
void void
handle_dcch_pdu(Document& document, const uint16_t lcid, const uint8_t* payload, const uint16_t len, bool follow_on) handle_dcch_pdu(Document& document, const uint16_t lcid, const uint8_t* payload, const uint16_t len, bool follow_on)
{ {
log->info_hex(payload, len, "Received DCCH RRC PDU (lcid=%d)\n", lcid); logger.info(payload, len, "Received DCCH RRC PDU (lcid=%d)", lcid);
// pack into byte buffer // pack into byte buffer
unique_byte_buffer_t pdu = pool_allocate_blocking; unique_byte_buffer_t pdu = pool_allocate_blocking;

95
srsue/test/ttcn3/hdr/ttcn3_sys_interface.h
Unescape Escape View File

@ -24,17 +24,16 @@ using namespace srslte;
class ttcn3_sys_interface : public ttcn3_port_handler class ttcn3_sys_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_sys_interface(){}; explicit ttcn3_sys_interface(srslog::basic_logger& logger) : ttcn3_port_handler(logger) {}
~ttcn3_sys_interface(){}; ~ttcn3_sys_interface(){};
int init(ss_sys_interface* syssim_, srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(ss_sys_interface* syssim_, std::string net_ip_, uint32_t net_port_)
{ {
syssim = syssim_; syssim = syssim_;
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
log = log_;
initialized = true; initialized = true;
log->debug("Initialized.\n"); logger.debug("Initialized.");
pool = byte_buffer_pool::get_instance(); pool = byte_buffer_pool::get_instance();
return port_listen(); return port_listen();
} }
@ -43,7 +42,7 @@ private:
///< Main message handler ///< Main message handler
int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n) int handle_message(const unique_byte_array_t& rx_buf, const uint32_t n)
{ {
log->debug("Received %d B from remote.\n", n); logger.debug("Received %d B from remote.", n);
// Chop incoming msg, first two bytes are length of the JSON // Chop incoming msg, first two bytes are length of the JSON
// (see IPL4_EUTRA_SYSTEM_Definitions.ttcn // (see IPL4_EUTRA_SYSTEM_Definitions.ttcn
@ -60,7 +59,7 @@ private:
Document document; Document document;
if (document.Parse(json).HasParseError() || document.IsObject() == false) { if (document.Parse(json).HasParseError() || document.IsObject() == false) {
log->error_hex((uint8*)json, json_len, "Error parsing incoming data.\n"); logger.error((uint8*)json, json_len, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -68,7 +67,7 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info_long("Received %d bytes\n%s\n", json_len, (char*)buffer.GetString()); logger.info("Received %d bytes\n%s", json_len, (char*)buffer.GetString());
// check for common // check for common
assert(document.HasMember("Common")); assert(document.HasMember("Common"));
@ -81,34 +80,34 @@ private:
// Get request type // Get request type
const Value& request = document["Request"]; const Value& request = document["Request"];
if (request.HasMember("Cell")) { if (request.HasMember("Cell")) {
log->info("Received Cell request.\n"); logger.info("Received Cell request.");
handle_request_cell(document, &rx_buf->at(rx_buf_offset), n - rx_buf_offset); handle_request_cell(document, &rx_buf->at(rx_buf_offset), n - rx_buf_offset);
} else if (request.HasMember("L1MacIndCtrl")) { } else if (request.HasMember("L1MacIndCtrl")) {
log->info("Received L1MacIndCtrl request.\n"); logger.info("Received L1MacIndCtrl request.");
handle_request_l1_mac_ind_ctrl(document); handle_request_l1_mac_ind_ctrl(document);
} else if (request.HasMember("RadioBearerList")) { } else if (request.HasMember("RadioBearerList")) {
log->info("Received RadioBearerList request.\n"); logger.info("Received RadioBearerList request.");
handle_request_radio_bearer_list(document); handle_request_radio_bearer_list(document);
} else if (request.HasMember("CellAttenuationList")) { } else if (request.HasMember("CellAttenuationList")) {
log->info("Received CellAttenuationList request.\n"); logger.info("Received CellAttenuationList request.");
handle_request_cell_attenuation_list(document); handle_request_cell_attenuation_list(document);
} else if (request.HasMember("PdcpCount")) { } else if (request.HasMember("PdcpCount")) {
log->info("Received PdcpCount request.\n"); logger.info("Received PdcpCount request.");
handle_request_pdcp_count(document); handle_request_pdcp_count(document);
} else if (request.HasMember("AS_Security")) { } else if (request.HasMember("AS_Security")) {
log->info("Received AS_Security request.\n"); logger.info("Received AS_Security request.");
handle_request_as_security(document); handle_request_as_security(document);
} else if (request.HasMember("EnquireTiming")) { } else if (request.HasMember("EnquireTiming")) {
log->info("Received EnquireTiming request.\n"); logger.info("Received EnquireTiming request.");
handle_request_enquire_timing(document); handle_request_enquire_timing(document);
} else if (request.HasMember("Paging")) { } else if (request.HasMember("Paging")) {
log->info("Received Paging request.\n"); logger.info("Received Paging request.");
handle_request_paging(document, &rx_buf->at(rx_buf_offset), n - rx_buf_offset); handle_request_paging(document, &rx_buf->at(rx_buf_offset), n - rx_buf_offset);
} else if (request.HasMember("PdcpHandoverControl")) { } else if (request.HasMember("PdcpHandoverControl")) {
log->info("Received PdcpHandoverControl.\n"); logger.info("Received PdcpHandoverControl.");
handle_request_pdcp_handover_control(document); handle_request_pdcp_handover_control(document);
} else { } else {
log->error("Received unknown request.\n"); logger.error("Received unknown request.");
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -155,7 +154,7 @@ private:
(strcmp(phy_dl_config["Phich"]["PhichConfig"]["R8"]["phich_Resource"].GetString(), "one") == 0) (strcmp(phy_dl_config["Phich"]["PhichConfig"]["R8"]["phich_Resource"].GetString(), "one") == 0)
? SRSLTE_PHICH_R_1 ? SRSLTE_PHICH_R_1
: SRSLTE_PHICH_R_1_6; : SRSLTE_PHICH_R_1_6;
log->info("DL EARFCN is %d with n_prb=%d\n", cell.earfcn, cell.phy_cell.nof_prb); logger.info("DL EARFCN is %d with n_prb=%d", cell.earfcn, cell.phy_cell.nof_prb);
const Value& ref_power = const Value& ref_power =
document["Request"]["Cell"]["AddOrReconfigure"]["Basic"]["InitialCellPower"]["MaxReferencePower"]; document["Request"]["Cell"]["AddOrReconfigure"]["Basic"]["InitialCellPower"]["MaxReferencePower"];
@ -183,7 +182,7 @@ private:
// Now configure cell // Now configure cell
syssim->set_cell_config(ttcn3_helpers::get_timing_info(document), cell); syssim->set_cell_config(ttcn3_helpers::get_timing_info(document), cell);
log->info("Configuring attenuation of %s to %.2f dB\n", cell_name.GetString(), cell.attenuation); logger.info("Configuring attenuation of %s to %.2f dB", cell_name.GetString(), cell.attenuation);
syssim->set_cell_attenuation(ttcn3_helpers::get_timing_info(document), cell_name.GetString(), cell.attenuation); syssim->set_cell_attenuation(ttcn3_helpers::get_timing_info(document), cell_name.GetString(), cell.attenuation);
} }
@ -200,7 +199,7 @@ private:
sib->N_bytes = tb_len; sib->N_bytes = tb_len;
// Push to main component // Push to main component
log->info_hex(sib->msg, sib->N_bytes, "Received BCCH DL-SCH for %s\n", cell_name.GetString()); logger.info(sib->msg, sib->N_bytes, "Received BCCH DL-SCH for %s", cell_name.GetString());
syssim->add_bcch_dlsch_pdu(cell_name.GetString(), std::move(sib)); syssim->add_bcch_dlsch_pdu(cell_name.GetString(), std::move(sib));
consumed_bytes = payload_ptr - payload; consumed_bytes = payload_ptr - payload;
@ -210,7 +209,7 @@ private:
// Create response for template car_CellConfig_CNF(CellId_Type p_CellId) // Create response for template car_CellConfig_CNF(CellId_Type p_CellId)
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_name.GetString(), "Cell"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_name.GetString(), "Cell");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
} }
@ -232,10 +231,10 @@ private:
if (ttcn3_helpers::requires_confirm(document)) { if (ttcn3_helpers::requires_confirm(document)) {
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id, "Cell"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id, "Cell");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} else { } else {
log->info("Skipping response for request cell active message.\n"); logger.info("Skipping response for request cell active message.");
} }
} }
@ -314,7 +313,7 @@ private:
handle_request_cell_active(document, payload, len); handle_request_cell_active(document, payload, len);
} }
} else if (document["Request"]["Cell"].HasMember("Release")) { } else if (document["Request"]["Cell"].HasMember("Release")) {
log->info("Received cell release command\n"); logger.info("Received cell release command");
// do nothing more // do nothing more
} }
} }
@ -340,13 +339,13 @@ private:
if (mac_ind_ctrl.HasMember("HarqError")) { if (mac_ind_ctrl.HasMember("HarqError")) {
assert(mac_ind_ctrl["HarqError"].IsString()); assert(mac_ind_ctrl["HarqError"].IsString());
bool harq_error = (strcmp(mac_ind_ctrl["HarqError"].GetString(), "enable") == 0) ? true : false; bool harq_error = (strcmp(mac_ind_ctrl["HarqError"].GetString(), "enable") == 0) ? true : false;
log->info("Setting HarqError to %s\n", harq_error ? "True" : "False"); logger.info("Setting HarqError to %s", harq_error ? "True" : "False");
} }
if (ttcn3_helpers::requires_confirm(document)) { if (ttcn3_helpers::requires_confirm(document)) {
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "L1MacIndCtrl"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "L1MacIndCtrl");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
} }
@ -385,11 +384,11 @@ private:
const Value& dlcid = aor["Mac"]["TestMode"]["Info"]["DiffLogChId"]; const Value& dlcid = aor["Mac"]["TestMode"]["Info"]["DiffLogChId"];
assert(dlcid.HasMember("LogChId")); assert(dlcid.HasMember("LogChId"));
force_lcid = dlcid["LogChId"].GetInt(); force_lcid = dlcid["LogChId"].GetInt();
log->info("TestMode: lcid overridden: %d\n", force_lcid); logger.info("TestMode: lcid overridden: %d", force_lcid);
syssim->set_forced_lcid(force_lcid); syssim->set_forced_lcid(force_lcid);
} else { } else {
// Unset override function to use different lcid // Unset override function to use different lcid
log->info("TestMode: lcid reset\n"); logger.info("TestMode: lcid reset");
syssim->set_forced_lcid(-1); syssim->set_forced_lcid(-1);
} }
if (lcid > 0) { if (lcid > 0) {
@ -401,10 +400,10 @@ private:
uint32_t lcid = id["Srb"].GetInt(); uint32_t lcid = id["Srb"].GetInt();
syssim->del_srb(ttcn3_helpers::get_timing_info(document), ttcn3_helpers::get_cell_name(document), lcid); syssim->del_srb(ttcn3_helpers::get_timing_info(document), ttcn3_helpers::get_cell_name(document), lcid);
} else { } else {
log->error("Unknown config.\n"); logger.error("Unknown config.");
} }
} else if (id.HasMember("Drb")) { } else if (id.HasMember("Drb")) {
log->info("Configure DRB%d\n", id["Drb"].GetInt()); logger.info("Configure DRB%d", id["Drb"].GetInt());
const Value& config = (*itr)["Config"]; const Value& config = (*itr)["Config"];
if (config.HasMember("AddOrReconfigure")) { if (config.HasMember("AddOrReconfigure")) {
@ -421,7 +420,7 @@ private:
uint32_t lcid = id["Drb"].GetInt() + 2; uint32_t lcid = id["Drb"].GetInt() + 2;
syssim->del_drb(ttcn3_helpers::get_timing_info(document), ttcn3_helpers::get_cell_name(document), lcid); syssim->del_drb(ttcn3_helpers::get_timing_info(document), ttcn3_helpers::get_cell_name(document), lcid);
} else { } else {
log->error("Unknown config.\n"); logger.error("Unknown config.");
} }
} }
} }
@ -429,10 +428,10 @@ private:
if (ttcn3_helpers::requires_confirm(document)) { if (ttcn3_helpers::requires_confirm(document)) {
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "RadioBearerList"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "RadioBearerList");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} else { } else {
log->info("Skipping response for radio bearer list message.\n"); logger.info("Skipping response for radio bearer list message.");
} }
} }
@ -475,13 +474,13 @@ private:
} }
} }
log->info("Configuring attenuation of %s to %.2f dB\n", id.GetString(), att_value); logger.info("Configuring attenuation of %s to %.2f dB", id.GetString(), att_value);
syssim->set_cell_attenuation(ttcn3_helpers::get_timing_info(document), id.GetString(), att_value); syssim->set_cell_attenuation(ttcn3_helpers::get_timing_info(document), id.GetString(), att_value);
} }
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "CellAttenuationList"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "CellAttenuationList");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
@ -510,7 +509,7 @@ private:
std::string resp = ttcn3_helpers::get_pdcp_count_response( std::string resp = ttcn3_helpers::get_pdcp_count_response(
cell_id.GetString(), syssim->get_pdcp_count(ttcn3_helpers::get_cell_name(document))); cell_id.GetString(), syssim->get_pdcp_count(ttcn3_helpers::get_cell_name(document)));
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
@ -546,13 +545,13 @@ private:
} else if (int_algo_string == "eia2") { } else if (int_algo_string == "eia2") {
integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA2; integ_algo = srslte::INTEGRITY_ALGORITHM_ID_128_EIA2;
} else { } else {
log->error("Unsupported integrity algorithm %s\n", int_algo_string.c_str()); logger.error("Unsupported integrity algorithm %s", int_algo_string.c_str());
} }
// get integrity key // get integrity key
std::string integ_key_string = as_sec["StartRestart"]["Integrity"]["KRRCint"].GetString(); std::string integ_key_string = as_sec["StartRestart"]["Integrity"]["KRRCint"].GetString();
std::array<uint8_t, 32> k_rrc_int = get_key_from_string(integ_key_string); std::array<uint8_t, 32> k_rrc_int = get_key_from_string(integ_key_string);
log->debug_hex(k_rrc_int.data(), k_rrc_int.size(), "K_rrc_int"); logger.debug(k_rrc_int.data(), k_rrc_int.size(), "K_rrc_int");
// get enc algo // get enc algo
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo = {}; srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo = {};
@ -564,18 +563,18 @@ private:
} else if (cipher_algo_string == "eea2") { } else if (cipher_algo_string == "eea2") {
cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA2; cipher_algo = srslte::CIPHERING_ALGORITHM_ID_128_EEA2;
} else { } else {
log->error("Unsupported ciphering algorithm %s\n", cipher_algo_string.c_str()); logger.error("Unsupported ciphering algorithm %s", cipher_algo_string.c_str());
} }
// get cipher key // get cipher key
std::string cipher_key_string = as_sec["StartRestart"]["Ciphering"]["KRRCenc"].GetString(); std::string cipher_key_string = as_sec["StartRestart"]["Ciphering"]["KRRCenc"].GetString();
std::array<uint8_t, 32> k_rrc_enc = get_key_from_string(cipher_key_string); std::array<uint8_t, 32> k_rrc_enc = get_key_from_string(cipher_key_string);
log->debug_hex(k_rrc_enc.data(), k_rrc_enc.size(), "K_rrc_enc"); logger.debug(k_rrc_enc.data(), k_rrc_enc.size(), "K_rrc_enc");
// get UP enc key // get UP enc key
std::string up_enc_key_string = as_sec["StartRestart"]["Ciphering"]["KUPenc"].GetString(); std::string up_enc_key_string = as_sec["StartRestart"]["Ciphering"]["KUPenc"].GetString();
std::array<uint8_t, 32> k_up_enc = get_key_from_string(up_enc_key_string); std::array<uint8_t, 32> k_up_enc = get_key_from_string(up_enc_key_string);
log->debug_hex(k_up_enc.data(), k_up_enc.size(), "K_UP_enc"); logger.debug(k_up_enc.data(), k_up_enc.size(), "K_UP_enc");
// parse ActTimeList // parse ActTimeList
ttcn3_helpers::pdcp_count_map_t bearers; ttcn3_helpers::pdcp_count_map_t bearers;
@ -628,10 +627,10 @@ private:
if (config_flag.GetBool() == true) { if (config_flag.GetBool() == true) {
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "AS_Security"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "AS_Security");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} else { } else {
log->info("Skipping response for AS_Security message.\n"); logger.info("Skipping response for AS_Security message.");
} }
} }
@ -666,7 +665,7 @@ private:
std::string resp = std::string resp =
ttcn3_helpers::get_sys_req_cnf_with_time(cell_id.GetString(), "EnquireTiming", syssim->get_tti()); ttcn3_helpers::get_sys_req_cnf_with_time(cell_id.GetString(), "EnquireTiming", syssim->get_tti());
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
@ -701,16 +700,16 @@ private:
pch->N_bytes = tb_len; pch->N_bytes = tb_len;
// Push to main component // Push to main component
log->info_hex(pch->msg, pch->N_bytes, "Received PCH DL-SCH\n"); logger.info(pch->msg, pch->N_bytes, "Received PCH DL-SCH");
syssim->add_pch_pdu(std::move(pch)); syssim->add_pch_pdu(std::move(pch));
if (ttcn3_helpers::requires_confirm(document)) { if (ttcn3_helpers::requires_confirm(document)) {
std::string resp = ttcn3_helpers::get_sys_req_cnf_with_time(cell_id.GetString(), "Paging", syssim->get_tti()); std::string resp = ttcn3_helpers::get_sys_req_cnf_with_time(cell_id.GetString(), "Paging", syssim->get_tti());
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} else { } else {
log->info("Skipping response for Paging message.\n"); logger.info("Skipping response for Paging message.");
} }
} }
@ -742,7 +741,7 @@ private:
if (ttcn3_helpers::requires_confirm(document)) { if (ttcn3_helpers::requires_confirm(document)) {
std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "PdcpHandoverControl"); std::string resp = ttcn3_helpers::get_basic_sys_req_cnf(cell_id.GetString(), "PdcpHandoverControl");
log->info("Sending %s to tester (%zd B)\n", resp.c_str(), resp.length()); logger.info("Sending %s to tester (%zd B)", resp.c_str(), resp.length());
send((const uint8_t*)resp.c_str(), resp.length()); send((const uint8_t*)resp.c_str(), resp.length());
} }
} }

22
srsue/test/ttcn3/hdr/ttcn3_syssim.h
Unescape Escape View File

@ -193,6 +193,18 @@ public:
ttcn3_helpers::pdcp_count_map_t get_pdcp_count(const std::string cell_name); ttcn3_helpers::pdcp_count_map_t get_pdcp_count(const std::string cell_name);
private: private:
// Logging stuff.
srslog::basic_logger& logger;
srslog::basic_logger& ut_logger;
srslog::basic_logger& sys_logger;
srslog::basic_logger& ip_sock_logger;
srslog::basic_logger& ip_ctrl_logger;
srslog::basic_logger& srb_logger;
srslog::basic_logger& drb_logger;
srslog::basic_logger& ss_mac_logger;
srslog::basic_logger& ss_rlc_logger;
srslog::basic_logger& ss_pdcp_logger;
// SYS interface // SYS interface
ttcn3_ut_interface ut; ttcn3_ut_interface ut;
ttcn3_sys_interface sys; ttcn3_sys_interface sys;
@ -208,17 +220,11 @@ private:
epoll_timer_handler timer_handler; epoll_timer_handler timer_handler;
epoll_signal_handler signal_handler; epoll_signal_handler signal_handler;
// Logging stuff // Logging stuff (to be removed)
srslte::logger& logger_stdout; srslte::logger& logger_stdout;
srslte::logger& logger_file; srslte::logger& logger_file;
srslte::logger* logger = nullptr; srslte::logger* old_logger = nullptr;
srslte::log_ref log; srslte::log_ref log;
srslte::log_filter ut_log;
srslte::log_filter sys_log;
srslte::log_filter ip_sock_log;
srslte::log_filter ip_ctrl_log;
srslte::log_filter srb_log;
srslte::log_filter drb_log;
srslte::log_ref ss_mac_log{"SS-MAC"}; srslte::log_ref ss_mac_log{"SS-MAC"};
srslte::log_ref ss_rlc_log{"SS-RLC"}; srslte::log_ref ss_rlc_log{"SS-RLC"};
srslte::log_ref ss_pdcp_log{"SS-PDCP"}; srslte::log_ref ss_pdcp_log{"SS-PDCP"};

4
srsue/test/ttcn3/hdr/ttcn3_ue.h
Unescape Escape View File

@ -70,8 +70,8 @@ private:
std::unique_ptr<ue_stack_lte> stack; std::unique_ptr<ue_stack_lte> stack;
// Generic logger members // Generic logger members
srslte::logger* logger = nullptr; srslte::logger* old_logger = nullptr;
srslte::log_filter log; // Own logger for UE srslog::basic_logger& logger;
test_loop_mode_state_t test_loop_mode = TEST_LOOP_INACTIVE; test_loop_mode_state_t test_loop_mode = TEST_LOOP_INACTIVE;
srslte::timer_handler::unique_timer pdu_delay_timer; srslte::timer_handler::unique_timer pdu_delay_timer;

31
srsue/test/ttcn3/hdr/ttcn3_ut_interface.h
Unescape Escape View File

@ -25,13 +25,12 @@ using namespace rapidjson;
class ttcn3_ut_interface : public ttcn3_port_handler class ttcn3_ut_interface : public ttcn3_port_handler
{ {
public: public:
ttcn3_ut_interface() {} explicit ttcn3_ut_interface(srslog::basic_logger& logger) : ttcn3_port_handler(logger) {}
~ttcn3_ut_interface(){}; ~ttcn3_ut_interface(){};
int init(ss_ut_interface* syssim_, srslte::log* log_, std::string net_ip_, uint32_t net_port_) int init(ss_ut_interface* syssim_, std::string net_ip_, uint32_t net_port_)
{ {
syssim = syssim_; syssim = syssim_;
log = log_;
net_ip = net_ip_; net_ip = net_ip_;
net_port = net_port_; net_port = net_port_;
initialized = true; initialized = true;
@ -45,7 +44,7 @@ private:
{ {
Document document; Document document;
if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) { if (document.Parse((char*)rx_buf->begin()).HasParseError() || document.IsObject() == false) {
log->error_hex(rx_buf->begin(), n, "Error parsing incoming data.\n"); logger.error(rx_buf->begin(), n, "Error parsing incoming data.");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -53,7 +52,7 @@ private:
StringBuffer buffer; StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer); PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer); document.Accept(writer);
log->info("Received %d bytes\n%s\n", n, (char*)buffer.GetString()); logger.info("Received %d bytes\n%s.", n, (char*)buffer.GetString());
// check for command // check for command
assert(document.HasMember("Cmd")); assert(document.HasMember("Cmd"));
@ -77,30 +76,30 @@ private:
assert(document.HasMember("CnfRequired")); assert(document.HasMember("CnfRequired"));
if (strcmp(mmi_cmd.GetString(), "POWER_OFF") == 0) { if (strcmp(mmi_cmd.GetString(), "POWER_OFF") == 0) {
log->info("Received POWER_OFF command.\n"); logger.info("Received POWER_OFF command.");
handle_power_off(document); handle_power_off(document);
} else if (strcmp(mmi_cmd.GetString(), "SWITCH_ON") == 0) { } else if (strcmp(mmi_cmd.GetString(), "SWITCH_ON") == 0) {
log->info("Received SWITCH_ON command.\n"); logger.info("Received SWITCH_ON command.");
syssim->switch_on_ue(); syssim->switch_on_ue();
} else if (strcmp(mmi_cmd.GetString(), "SWITCH_OFF") == 0) { } else if (strcmp(mmi_cmd.GetString(), "SWITCH_OFF") == 0) {
log->info("Received SWITCH_OFF command.\n"); logger.info("Received SWITCH_OFF command.");
syssim->switch_off_ue(); syssim->switch_off_ue();
} else { } else {
log->error("Received unknown command: %s\n", mmi_cmd.GetString()); logger.error("Received unknown command: %s", mmi_cmd.GetString());
} }
} else if (a.HasMember("AT")) { } else if (a.HasMember("AT")) {
handle_at_command(document); handle_at_command(document);
} else if (a.HasMember("TC_START")) { } else if (a.HasMember("TC_START")) {
log->info("Received TC_START command.\n"); logger.info("Received TC_START command.");
const Value& cmd = a["TC_START"]; const Value& cmd = a["TC_START"];
assert(cmd.HasMember("Name")); assert(cmd.HasMember("Name"));
const Value& tc_name = cmd["Name"]; const Value& tc_name = cmd["Name"];
syssim->tc_start(tc_name.GetString()); syssim->tc_start(tc_name.GetString());
} else if (a.HasMember("TC_END")) { } else if (a.HasMember("TC_END")) {
log->info("Received TC_END command.\n"); logger.info("Received TC_END command.");
syssim->tc_end(); syssim->tc_end();
} else { } else {
log->error("Unknown command type.\n"); logger.error("Unknown command type.");
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -120,7 +119,7 @@ private:
Writer<StringBuffer> writer(buffer); Writer<StringBuffer> writer(buffer);
resp.Accept(writer); resp.Accept(writer);
log->info("Sending %s to tester (%zd B)\n", buffer.GetString(), buffer.GetSize()); logger.info("Sending %s to tester (%zd B)", buffer.GetString(), buffer.GetSize());
send((const uint8_t*)buffer.GetString(), buffer.GetSize()); send((const uint8_t*)buffer.GetString(), buffer.GetSize());
} }
@ -131,13 +130,13 @@ private:
// turn off data services // turn off data services
if (std::string(at.GetString()) == "AT+CGATT=0<CR>") { if (std::string(at.GetString()) == "AT+CGATT=0<CR>") {
log->info("Disabling data services\n"); logger.info("Disabling data services");
syssim->disable_data(); syssim->disable_data();
} else if (std::string(at.GetString()) == "AT+CGATT=1<CR>") { } else if (std::string(at.GetString()) == "AT+CGATT=1<CR>") {
log->info("Enabling data services\n"); logger.info("Enabling data services");
syssim->enable_data(); syssim->enable_data();
} else { } else {
log->error("Not handling AT command %s\n", at.GetString()); logger.error("Not handling AT command %s", at.GetString());
} }
} }

72
srsue/test/ttcn3/src/lte_ttcn3_phy.cc
Unescape Escape View File

@ -20,7 +20,7 @@ namespace srsue {
#define SUITABLE_NEIGHBOR_INTRAFREQ_RS_EPRE (-91) #define SUITABLE_NEIGHBOR_INTRAFREQ_RS_EPRE (-91)
#define DEFAULT_RSRQ (-3.0) #define DEFAULT_RSRQ (-3.0)
lte_ttcn3_phy::lte_ttcn3_phy(srslte::logger* logger_) : logger(logger_) {} lte_ttcn3_phy::lte_ttcn3_phy() : logger(srslog::fetch_basic_logger("PHY")) {}
int lte_ttcn3_phy::init(const phy_args_t& args_, stack_interface_phy_lte* stack_, syssim_interface_phy* syssim_) int lte_ttcn3_phy::init(const phy_args_t& args_, stack_interface_phy_lte* stack_, syssim_interface_phy* syssim_)
{ {
@ -38,8 +38,8 @@ int lte_ttcn3_phy::init(const phy_args_t& args_, stack_interface_phy_lte* stack_
// ue_phy_base interface // ue_phy_base interface
int lte_ttcn3_phy::init(const phy_args_t& args_) int lte_ttcn3_phy::init(const phy_args_t& args_)
{ {
log.init("PHY ", logger, true); logger.set_level(srslog::str_to_basic_level(args_.log.phy_level));
log.set_level(args_.log.phy_level); logger.set_hex_dump_max_size(-1);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
@ -63,29 +63,29 @@ void lte_ttcn3_phy::set_config_tdd(srslte_tdd_config_t& tdd_config) {}
void lte_ttcn3_phy::enable_pregen_signals(bool enable) void lte_ttcn3_phy::enable_pregen_signals(bool enable)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
void lte_ttcn3_phy::deactivate_scells() void lte_ttcn3_phy::deactivate_scells()
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
void lte_ttcn3_phy::set_activation_deactivation_scell(uint32_t cmd, uint32_t tti) void lte_ttcn3_phy::set_activation_deactivation_scell(uint32_t cmd, uint32_t tti)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
bool lte_ttcn3_phy::set_config(srslte::phy_cfg_t config, uint32_t cc_idx_) bool lte_ttcn3_phy::set_config(srslte::phy_cfg_t config, uint32_t cc_idx_)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
task_sched.defer_task([this]() { stack->set_config_complete(true); }); task_sched.defer_task([this]() { stack->set_config_complete(true); });
return true; return true;
} }
bool lte_ttcn3_phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn) bool lte_ttcn3_phy::set_scell(srslte_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
task_sched.defer_task([this]() { stack->set_scell_complete(true); }); task_sched.defer_task([this]() { stack->set_scell_complete(true); });
return true; return true;
} }
@ -102,7 +102,7 @@ bool lte_ttcn3_phy::cell_search()
{ {
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
log.info("Running cell search in PHY\n"); logger.info("Running cell search in PHY");
rrc_interface_phy_lte::cell_search_ret_t ret = {}; rrc_interface_phy_lte::cell_search_ret_t ret = {};
ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_NOT_FOUND; ret.found = rrc_interface_phy_lte::cell_search_ret_t::CELL_NOT_FOUND;
@ -111,7 +111,7 @@ bool lte_ttcn3_phy::cell_search()
if (not cells.empty() && cell_idx < cells.size()) { if (not cells.empty() && cell_idx < cells.size()) {
// only find suitable cells // only find suitable cells
if (cells[cell_idx].power >= SUITABLE_CELL_RS_EPRE) { if (cells[cell_idx].power >= SUITABLE_CELL_RS_EPRE) {
log.info("Found Cell: EARFCN=%d CellId=%d power=%.2f\n", logger.info("Found Cell: EARFCN=%d CellId=%d power=%.2f",
cells[cell_idx].earfcn, cells[cell_idx].earfcn,
cells[cell_idx].info.id, cells[cell_idx].info.id,
cells[cell_idx].power); cells[cell_idx].power);
@ -132,7 +132,7 @@ bool lte_ttcn3_phy::cell_search()
cell_idx = 0; cell_idx = 0;
} }
} else { } else {
log.warning("No cells configured yet.\n"); logger.warning("No cells configured yet.");
} }
stack->cell_search_complete(ret, found_cell); stack->cell_search_complete(ret, found_cell);
@ -149,10 +149,10 @@ bool lte_ttcn3_phy::cell_select(phy_cell_t rrc_cell)
pcell = cell; pcell = cell;
pcell_set = true; pcell_set = true;
syssim->select_cell(pcell.info); syssim->select_cell(pcell.info);
log.info("Select PCell with %.2f on PCI=%d on EARFCN=%d.\n", cell.power, rrc_cell.pci, rrc_cell.earfcn); logger.info("Select PCell with %.2f on PCI=%d on EARFCN=%d.", cell.power, rrc_cell.pci, rrc_cell.earfcn);
} else { } else {
pcell_set = false; pcell_set = false;
log.error("Power of selected cell too low (%.2f < %.2f)\n", cell.power, SUITABLE_CELL_RS_EPRE); logger.error("Power of selected cell too low (%.2f < %.2f)", cell.power, SUITABLE_CELL_RS_EPRE);
} }
stack->cell_select_complete(pcell_set); stack->cell_select_complete(pcell_set);
@ -160,14 +160,14 @@ bool lte_ttcn3_phy::cell_select(phy_cell_t rrc_cell)
} }
} }
log.error("Couldn't find RRC cell with PCI=%d on EARFCN=%d in cell map.\n", rrc_cell.pci, rrc_cell.earfcn); logger.error("Couldn't find RRC cell with PCI=%d on EARFCN=%d in cell map.", rrc_cell.pci, rrc_cell.earfcn);
return false; return false;
} }
bool lte_ttcn3_phy::cell_is_camping() bool lte_ttcn3_phy::cell_is_camping()
{ {
if (pcell_set) { if (pcell_set) {
log.info("pcell.power=%2.f\n", pcell.power); logger.info("pcell.power=%2.f", pcell.power);
return (pcell.power >= SUITABLE_CELL_RS_EPRE); return (pcell.power >= SUITABLE_CELL_RS_EPRE);
} }
return false; return false;
@ -178,7 +178,7 @@ bool lte_ttcn3_phy::cell_is_camping()
void lte_ttcn3_phy::prach_send(uint32_t preamble_idx, int allowed_subframe, float target_power_dbm, float ta_base_sec) void lte_ttcn3_phy::prach_send(uint32_t preamble_idx, int allowed_subframe, float target_power_dbm, float ta_base_sec)
{ {
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
log.info("Sending PRACH with preamble %d on PCID=%d\n", preamble_idx, pcell.info.id); logger.info("Sending PRACH with preamble %d on PCID=%d", preamble_idx, pcell.info.id);
prach_tti_tx = current_tti; prach_tti_tx = current_tti;
ra_trans_cnt++; ra_trans_cnt++;
@ -218,25 +218,25 @@ int lte_ttcn3_phy::sr_last_tx_tti()
/* Sets a C-RNTI allowing the PHY to pregenerate signals if necessary */ /* Sets a C-RNTI allowing the PHY to pregenerate signals if necessary */
void lte_ttcn3_phy::set_crnti(uint16_t rnti) void lte_ttcn3_phy::set_crnti(uint16_t rnti)
{ {
log.debug("Set Temp-RNTI=%d, pregen not used\n", rnti); logger.debug("Set Temp-RNTI=%d, pregen not used", rnti);
} }
/* Time advance commands */ /* Time advance commands */
void lte_ttcn3_phy::set_timeadv_rar(uint32_t ta_cmd) void lte_ttcn3_phy::set_timeadv_rar(uint32_t ta_cmd)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
void lte_ttcn3_phy::set_timeadv(uint32_t ta_cmd) void lte_ttcn3_phy::set_timeadv(uint32_t ta_cmd)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
// Sets RAR grant payload // Sets RAR grant payload
void lte_ttcn3_phy::set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRANT_LEN], uint16_t rnti) void lte_ttcn3_phy::set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRANT_LEN], uint16_t rnti)
{ {
// Empty, SYSSIM knows when to provide UL grant for Msg3 // Empty, SYSSIM knows when to provide UL grant for Msg3
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
// Called from the SYSSIM to configure the current TTI // Called from the SYSSIM to configure the current TTI
@ -256,13 +256,13 @@ uint32_t lte_ttcn3_phy::get_current_tti()
float lte_ttcn3_phy::get_phr() float lte_ttcn3_phy::get_phr()
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
return 0.1; return 0.1;
} }
float lte_ttcn3_phy::get_pathloss_db() float lte_ttcn3_phy::get_pathloss_db()
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
return 85.0; return 85.0;
} }
@ -289,7 +289,7 @@ void lte_ttcn3_phy::new_tb(const srsue::mac_interface_phy_lte::mac_grant_dl_t dl
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
if (data == nullptr) { if (data == nullptr) {
log.error("Invalid data buffer passed\n"); logger.error("Invalid data buffer passed");
return; return;
} }
@ -301,15 +301,15 @@ void lte_ttcn3_phy::new_tb(const srsue::mac_interface_phy_lte::mac_grant_dl_t dl
bool dl_ack[SRSLTE_MAX_CODEWORDS] = {}; bool dl_ack[SRSLTE_MAX_CODEWORDS] = {};
if (dl_action.tb[0].enabled && dl_action.tb[0].payload != nullptr) { if (dl_action.tb[0].enabled && dl_action.tb[0].payload != nullptr) {
log.info_hex(data, logger.info(data,
dl_grant.tb[0].tbs, dl_grant.tb[0].tbs,
"TB received rnti=%d, tti=%d, n_bytes=%d\n", "TB received rnti=%d, tti=%d, n_bytes=%d",
dl_grant.rnti, dl_grant.rnti,
current_tti, current_tti,
dl_grant.tb[0].tbs); dl_grant.tb[0].tbs);
if (dl_action.generate_ack) { if (dl_action.generate_ack) {
log.debug("Calling generate ACK callback\n"); logger.debug("Calling generate ACK callback");
// action.generate_ack_callback(action.generate_ack_callback_arg); // action.generate_ack_callback(action.generate_ack_callback_arg);
} }
memcpy(dl_action.tb->payload, data, dl_grant.tb[0].tbs); memcpy(dl_action.tb->payload, data, dl_grant.tb[0].tbs);
@ -317,9 +317,9 @@ void lte_ttcn3_phy::new_tb(const srsue::mac_interface_phy_lte::mac_grant_dl_t dl
// ACK first TB and pass up // ACK first TB and pass up
dl_ack[0] = true; dl_ack[0] = true;
log.info("TB processed correctly\n"); logger.info("TB processed correctly");
} else { } else {
log.error("Couldn't get buffer for TB\n"); logger.error("Couldn't get buffer for TB");
} }
stack->tb_decoded(cc_idx, dl_grant, dl_ack); stack->tb_decoded(cc_idx, dl_grant, dl_ack);
@ -327,12 +327,12 @@ void lte_ttcn3_phy::new_tb(const srsue::mac_interface_phy_lte::mac_grant_dl_t dl
void lte_ttcn3_phy::radio_overflow() void lte_ttcn3_phy::radio_overflow()
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
void lte_ttcn3_phy::radio_failure() void lte_ttcn3_phy::radio_failure()
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
// Calling function set_tti() is holding mutex // Calling function set_tti() is holding mutex
@ -350,10 +350,10 @@ void lte_ttcn3_phy::run_tti()
// Measurement for PCell needs to have EARFCN set to 0 // Measurement for PCell needs to have EARFCN set to 0
if (pcell_set && m.earfcn == pcell.earfcn && m.pci == pcell.info.id) { if (pcell_set && m.earfcn == pcell.earfcn && m.pci == pcell.info.id) {
log.debug("Creating Pcell measurement for PCI=%d, EARFCN=%d with RSRP=%.2f\n", m.pci, m.earfcn, m.rsrp); logger.debug("Creating Pcell measurement for PCI=%d, EARFCN=%d with RSRP=%.2f", m.pci, m.earfcn, m.rsrp);
m.earfcn = 0; m.earfcn = 0;
} else { } else {
log.debug("Create cell measurement for PCI=%d, EARFCN=%d with RSRP=%.2f\n", m.pci, m.earfcn, m.rsrp); logger.debug("Create cell measurement for PCI=%d, EARFCN=%d with RSRP=%.2f", m.pci, m.earfcn, m.rsrp);
} }
phy_meas.push_back(m); phy_meas.push_back(m);
} }
@ -369,10 +369,10 @@ void lte_ttcn3_phy::run_tti()
if (cell.info.id == pcell.info.id) { if (cell.info.id == pcell.info.id) {
// consider Pcell in-sync until reaching threshold // consider Pcell in-sync until reaching threshold
if (cell.power >= NON_SUITABLE_CELL_RS_EPRE) { if (cell.power >= NON_SUITABLE_CELL_RS_EPRE) {
log.debug("PCell id=%d power=%.2f -> sync\n", pcell.info.id, cell.power); logger.debug("PCell id=%d power=%.2f -> sync", pcell.info.id, cell.power);
stack->in_sync(); stack->in_sync();
} else { } else {
log.debug("PCell id=%d power=%.2f -> out of sync\n", pcell.info.id, cell.power); logger.debug("PCell id=%d power=%.2f -> out of sync", pcell.info.id, cell.power);
stack->out_of_sync(); stack->out_of_sync();
} }
break; // make sure to call stack only once break; // make sure to call stack only once
@ -380,7 +380,7 @@ void lte_ttcn3_phy::run_tti()
} }
} }
log.step(current_tti); logger.set_context(current_tti);
// Check for SR // Check for SR
if (sr_pending) { if (sr_pending) {
@ -394,7 +394,7 @@ void lte_ttcn3_phy::run_tti()
void lte_ttcn3_phy::set_cells_to_meas(uint32_t earfcn, const std::set<uint32_t>& pci) void lte_ttcn3_phy::set_cells_to_meas(uint32_t earfcn, const std::set<uint32_t>& pci)
{ {
log.debug("%s not implemented.\n", __FUNCTION__); logger.debug("%s not implemented.", __FUNCTION__);
} }
} // namespace srsue } // namespace srsue

311
srsue/test/ttcn3/src/ttcn3_syssim.cc
Unescape Escape View File

@ -30,19 +30,35 @@
#include <functional> #include <functional>
ttcn3_syssim::ttcn3_syssim(srslte::logger& logger_file_, srslte::logger& logger_stdout_, ttcn3_ue* ue_) : ttcn3_syssim::ttcn3_syssim(srslte::logger& logger_file_, srslte::logger& logger_stdout_, ttcn3_ue* ue_) :
logger(srslog::fetch_basic_logger("SS")),
ut_logger(srslog::fetch_basic_logger("UT", false)),
sys_logger(srslog::fetch_basic_logger("SYS", false)),
ip_sock_logger(srslog::fetch_basic_logger("IP_S", false)),
ip_ctrl_logger(srslog::fetch_basic_logger("IP_C", false)),
srb_logger(srslog::fetch_basic_logger("SRB", false)),
drb_logger(srslog::fetch_basic_logger("DRB", false)),
ss_mac_logger(srslog::fetch_basic_logger("SS-MAC", false)),
ss_rlc_logger(srslog::fetch_basic_logger("SS-RLC", false)),
ss_pdcp_logger(srslog::fetch_basic_logger("SS-PDCP", false)),
ut(ut_logger),
sys(sys_logger),
ip_sock(ip_sock_logger),
ip_ctrl(ip_ctrl_logger),
srb(srb_logger),
drb(drb_logger),
log{"SS "}, log{"SS "},
mac_msg_ul(20, ss_mac_log), mac_msg_ul(20, ss_mac_log),
mac_msg_dl(20, ss_mac_log), mac_msg_dl(20, ss_mac_log),
pdus(128), pdus(128),
logger_stdout(logger_stdout_), logger_stdout(logger_stdout_),
logger_file(logger_file_), logger_file(logger_file_),
logger(&logger_file), old_logger(&logger_file),
pool(byte_buffer_pool::get_instance()), pool(byte_buffer_pool::get_instance()),
ue(ue_), ue(ue_),
signal_handler(&running), signal_handler(&running),
timer_handler(create_tti_timer(), [&](uint64_t res) { new_tti_indication(res); }) timer_handler(create_tti_timer(), [&](uint64_t res) { new_tti_indication(res); })
{ {
if (ue->init(all_args_t{}, logger, this, "INIT_TEST") != SRSLTE_SUCCESS) { if (ue->init(all_args_t{}, old_logger, this, "INIT_TEST") != SRSLTE_SUCCESS) {
ue->stop(); ue->stop();
fprintf(stderr, "Couldn't initialize UE.\n"); fprintf(stderr, "Couldn't initialize UE.\n");
} }
@ -56,61 +72,73 @@ int ttcn3_syssim::init(const all_args_t& args_)
// Make sure to get SS logging as well // Make sure to get SS logging as well
if (args.log.filename == "stdout") { if (args.log.filename == "stdout") {
logger = &logger_stdout; old_logger = &logger_stdout;
auto* swp_sink = srslog::find_sink(swappable_sink::name());
if (!swp_sink) {
logger.error("Unable to find the swappable sink");
srslte::console("Unable to find the swappable sink\n");
return SRSLTE_ERROR;
} }
srslte::logmap::set_default_logger(logger); static_cast<swappable_sink*>(swp_sink)->swap_to_stdout();
}
srslte::logmap::set_default_logger(old_logger);
// init and configure logging // init and configure logging
srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS ", logger, true}}); srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS ", old_logger, true}});
ut_log.init("UT ", logger); srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS-RLC", old_logger}});
sys_log.init("SYS ", logger); srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS-PDCP", old_logger}});
ip_sock_log.init("IP_S", logger);
ip_ctrl_log.init("IP_C", logger);
srb_log.init("SRB ", logger);
drb_log.init("DRB ", logger);
srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS-RLC", logger}});
srslte::logmap::register_log(std::unique_ptr<srslte::log>{new log_filter{"SS-PDCP", logger}});
log->set_level(args.log.all_level); log->set_level(args.log.all_level);
ut_log.set_level(args.log.all_level);
sys_log.set_level(args.log.all_level);
ip_sock_log.set_level(args.log.all_level);
ip_ctrl_log.set_level(args.log.all_level);
srb_log.set_level(args.log.all_level);
drb_log.set_level(args.log.all_level);
ss_mac_log->set_level(args.log.all_level); ss_mac_log->set_level(args.log.all_level);
ss_rlc_log->set_level(args.log.all_level); ss_rlc_log->set_level(args.log.all_level);
ss_pdcp_log->set_level(args.log.all_level); ss_pdcp_log->set_level(args.log.all_level);
auto logger_lvl = srslog::str_to_basic_level(args.log.all_level);
logger.set_level(logger_lvl);
ut_logger.set_level(logger_lvl);
sys_logger.set_level(logger_lvl);
ip_sock_logger.set_level(logger_lvl);
ip_ctrl_logger.set_level(logger_lvl);
srb_logger.set_level(logger_lvl);
drb_logger.set_level(logger_lvl);
ss_mac_logger.set_level(logger_lvl);
ss_rlc_logger.set_level(logger_lvl);
ss_pdcp_logger.set_level(logger_lvl);
log->set_hex_limit(args.log.all_hex_limit); log->set_hex_limit(args.log.all_hex_limit);
ut_log.set_hex_limit(args.log.all_hex_limit);
sys_log.set_hex_limit(args.log.all_hex_limit);
ip_sock_log.set_hex_limit(args.log.all_hex_limit);
ip_ctrl_log.set_hex_limit(args.log.all_hex_limit);
srb_log.set_hex_limit(args.log.all_hex_limit);
drb_log.set_hex_limit(args.log.all_hex_limit);
ss_mac_log->set_hex_limit(args.log.all_hex_limit); ss_mac_log->set_hex_limit(args.log.all_hex_limit);
ss_rlc_log->set_hex_limit(args.log.all_hex_limit); ss_rlc_log->set_hex_limit(args.log.all_hex_limit);
ss_pdcp_log->set_hex_limit(args.log.all_hex_limit); ss_pdcp_log->set_hex_limit(args.log.all_hex_limit);
logger.set_hex_dump_max_size(args.log.all_hex_limit);
ut_logger.set_hex_dump_max_size(args.log.all_hex_limit);
sys_logger.set_hex_dump_max_size(args.log.all_hex_limit);
ip_sock_logger.set_hex_dump_max_size(args.log.all_hex_limit);
ip_ctrl_logger.set_hex_dump_max_size(args.log.all_hex_limit);
srb_logger.set_hex_dump_max_size(args.log.all_hex_limit);
drb_logger.set_hex_dump_max_size(args.log.all_hex_limit);
ss_mac_logger.set_hex_dump_max_size(args.log.all_hex_limit);
ss_rlc_logger.set_hex_dump_max_size(args.log.all_hex_limit);
ss_pdcp_logger.set_hex_dump_max_size(args.log.all_hex_limit);
// Init epoll socket and add FDs // Init epoll socket and add FDs
epoll_fd = epoll_create1(0); epoll_fd = epoll_create1(0);
if (epoll_fd == -1) { if (epoll_fd == -1) {
log->error("Error creating epoll\n"); logger.error("Error creating epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
// add signalfd // add signalfd
signal_fd = add_signalfd(); signal_fd = add_signalfd();
if (add_epoll(signal_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(signal_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding signalfd to epoll\n"); logger.error("Error while adding signalfd to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({signal_fd, &signal_handler}); event_handler.insert({signal_fd, &signal_handler});
// init system interfaces to tester // init system interfaces to tester
if (add_port_handler() != SRSLTE_SUCCESS) { if (add_port_handler() != SRSLTE_SUCCESS) {
log->error("Error creating port handlers\n"); logger.error("Error creating port handlers");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -128,54 +156,54 @@ void ttcn3_syssim::set_forced_lcid(int lcid)
int ttcn3_syssim::add_port_handler() int ttcn3_syssim::add_port_handler()
{ {
// UT port // UT port
int ut_fd = ut.init(this, &ut_log, listen_address, UT_PORT); int ut_fd = ut.init(this, listen_address, UT_PORT);
if (add_epoll(ut_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(ut_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding UT port to epoll\n"); logger.error("Error while adding UT port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({ut_fd, &ut}); event_handler.insert({ut_fd, &ut});
srslte::console("UT handler listening on SCTP port %d\n", UT_PORT); srslte::console("UT handler listening on SCTP port %d\n", UT_PORT);
// SYS port // SYS port
int sys_fd = sys.init(this, &sys_log, listen_address, SYS_PORT); int sys_fd = sys.init(this, listen_address, SYS_PORT);
if (add_epoll(sys_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(sys_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding SYS port to epoll\n"); logger.error("Error while adding SYS port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({sys_fd, &sys}); event_handler.insert({sys_fd, &sys});
srslte::console("SYS handler listening on SCTP port %d\n", SYS_PORT); srslte::console("SYS handler listening on SCTP port %d\n", SYS_PORT);
// IPsock port // IPsock port
int ip_sock_fd = ip_sock.init(&ip_sock_log, listen_address, IPSOCK_PORT); int ip_sock_fd = ip_sock.init(listen_address, IPSOCK_PORT);
if (add_epoll(ip_sock_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(ip_sock_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding IP sock port to epoll\n"); logger.error("Error while adding IP sock port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({ip_sock_fd, &ip_sock}); event_handler.insert({ip_sock_fd, &ip_sock});
srslte::console("IPSOCK handler listening on SCTP port %d\n", IPSOCK_PORT); srslte::console("IPSOCK handler listening on SCTP port %d\n", IPSOCK_PORT);
// IPctrl port // IPctrl port
int ip_ctrl_fd = ip_ctrl.init(&ip_ctrl_log, listen_address, IPCTRL_PORT); int ip_ctrl_fd = ip_ctrl.init(listen_address, IPCTRL_PORT);
if (add_epoll(ip_ctrl_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(ip_ctrl_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding IP ctrl port to epoll\n"); logger.error("Error while adding IP ctrl port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({ip_ctrl_fd, &ip_ctrl}); event_handler.insert({ip_ctrl_fd, &ip_ctrl});
srslte::console("IPCTRL handler listening on SCTP port %d\n", IPCTRL_PORT); srslte::console("IPCTRL handler listening on SCTP port %d\n", IPCTRL_PORT);
// add SRB fd // add SRB fd
int srb_fd = srb.init(this, &srb_log, listen_address, SRB_PORT); int srb_fd = srb.init(this, listen_address, SRB_PORT);
if (add_epoll(srb_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(srb_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding SRB port to epoll\n"); logger.error("Error while adding SRB port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({srb_fd, &srb}); event_handler.insert({srb_fd, &srb});
srslte::console("SRB handler listening on SCTP port %d\n", SRB_PORT); srslte::console("SRB handler listening on SCTP port %d\n", SRB_PORT);
// add DRB fd // add DRB fd
int drb_fd = drb.init(this, &drb_log, listen_address, DRB_PORT); int drb_fd = drb.init(this, listen_address, DRB_PORT);
if (add_epoll(drb_fd, epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(drb_fd, epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding DRB port to epoll\n"); logger.error("Error while adding DRB port to epoll");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
event_handler.insert({drb_fd, &drb}); event_handler.insert({drb_fd, &drb});
@ -190,7 +218,8 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
tti = (tti + 1) % 10240; tti = (tti + 1) % 10240;
log->step(tti); log->step(tti);
log->debug("Start TTI\n"); logger.set_context(tti);
logger.debug("Start TTI");
// Make sure to step SS // Make sure to step SS
step_stack(); step_stack();
@ -201,7 +230,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
// check scheduled actions for this TTI // check scheduled actions for this TTI
if (tti_actions.find(tti) != tti_actions.end()) { if (tti_actions.find(tti) != tti_actions.end()) {
while (!tti_actions[tti].empty()) { while (!tti_actions[tti].empty()) {
log->debug("Running scheduled action\n"); logger.debug("Running scheduled action");
move_task_t task = std::move(tti_actions[tti].front()); move_task_t task = std::move(tti_actions[tti].front());
task(); task();
tti_actions[tti].pop(); tti_actions[tti].pop();
@ -232,7 +261,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
} }
if (pcell_idx == -1) { if (pcell_idx == -1) {
log->debug("Skipping TTI. Pcell not yet selected.\n"); logger.debug("Skipping TTI. Pcell not yet selected.");
return; return;
} }
@ -247,7 +276,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
dl_grant.tb[0].tbs = cells[pcell_idx]->sibs[cells[pcell_idx]->sib_idx]->N_bytes; dl_grant.tb[0].tbs = cells[pcell_idx]->sibs[cells[pcell_idx]->sib_idx]->N_bytes;
dl_grant.tb[0].ndi = get_ndi_for_new_dl_tx(tti); dl_grant.tb[0].ndi = get_ndi_for_new_dl_tx(tti);
ue->new_tb(dl_grant, cells[pcell_idx]->sibs[cells[pcell_idx]->sib_idx]->msg); ue->new_tb(dl_grant, cells[pcell_idx]->sibs[cells[pcell_idx]->sib_idx]->msg);
log->info("Delivered SIB%d for pcell_idx=%d\n", cells[pcell_idx]->sib_idx, pcell_idx); logger.info("Delivered SIB%d for pcell_idx=%d", cells[pcell_idx]->sib_idx, pcell_idx);
cells[pcell_idx]->sib_idx = (cells[pcell_idx]->sib_idx + 1) % cells[pcell_idx]->sibs.size(); cells[pcell_idx]->sib_idx = (cells[pcell_idx]->sib_idx + 1) % cells[pcell_idx]->sibs.size();
} else if (SRSLTE_RNTI_ISRAR(dl_rnti)) { } else if (SRSLTE_RNTI_ISRAR(dl_rnti)) {
if (prach_tti != -1) { if (prach_tti != -1) {
@ -257,12 +286,12 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
} }
} }
} else if (SRSLTE_RNTI_ISPA(dl_rnti)) { } else if (SRSLTE_RNTI_ISPA(dl_rnti)) {
log->debug("Searching for paging RNTI\n"); logger.debug("Searching for paging RNTI");
// PCH will be triggered from SYSSIM after receiving Paging // PCH will be triggered from SYSSIM after receiving Paging
} else if (SRSLTE_RNTI_ISUSER(dl_rnti)) { } else if (SRSLTE_RNTI_ISUSER(dl_rnti)) {
// check if this is for contention resolution after PRACH/RAR // check if this is for contention resolution after PRACH/RAR
if (dl_rnti == cells[pcell_idx]->config.crnti) { if (dl_rnti == cells[pcell_idx]->config.crnti) {
log->debug("Searching for C-RNTI=0x%x\n", dl_rnti); logger.debug("Searching for C-RNTI=0x%x", dl_rnti);
if (rar_tti != -1) { if (rar_tti != -1) {
msg3_tti = (rar_tti + 3) % 10240; msg3_tti = (rar_tti + 3) % 10240;
@ -279,7 +308,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
} }
if (dl_rnti != SRSLTE_INVALID_RNTI) { if (dl_rnti != SRSLTE_INVALID_RNTI) {
log->debug("Searching for RNTI=0x%x\n", dl_rnti); logger.debug("Searching for RNTI=0x%x", dl_rnti);
// look for DL data to be send in each bearer and provide grant accordingly // look for DL data to be send in each bearer and provide grant accordingly
for (int lcid = 0; lcid < SRSLTE_N_RADIO_BEARERS; lcid++) { for (int lcid = 0; lcid < SRSLTE_N_RADIO_BEARERS; lcid++) {
@ -287,7 +316,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
// Schedule DL transmission if there is data in RLC buffer or we need to send Msg4 // Schedule DL transmission if there is data in RLC buffer or we need to send Msg4
if ((buf_state > 0 && cells[pcell_idx]->bearer_follow_on_map[lcid] == false) || if ((buf_state > 0 && cells[pcell_idx]->bearer_follow_on_map[lcid] == false) ||
(msg3_tti != -1 && conres_id != 0)) { (msg3_tti != -1 && conres_id != 0)) {
log->debug("LCID=%d, buffer_state=%d\n", lcid, buf_state); logger.debug("LCID=%d, buffer_state=%d", lcid, buf_state);
tx_payload_buffer.clear(); tx_payload_buffer.clear();
const uint32_t mac_header_size = 10; // Add MAC header (10 B for all subheaders, etc) const uint32_t mac_header_size = 10; // Add MAC header (10 B for all subheaders, etc)
@ -297,13 +326,13 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
if (msg3_tti != -1 && lcid == 0 && conres_id != 0) { if (msg3_tti != -1 && lcid == 0 && conres_id != 0) {
if (mac_msg_dl.new_subh()) { if (mac_msg_dl.new_subh()) {
if (mac_msg_dl.get()->set_con_res_id(conres_id)) { if (mac_msg_dl.get()->set_con_res_id(conres_id)) {
log->info("CE: Added Contention Resolution ID=0x%" PRIx64 "\n", conres_id); logger.info("CE: Added Contention Resolution ID=0x%" PRIx64 "", conres_id);
} else { } else {
log->error("CE: Setting Contention Resolution ID CE\n"); logger.error("CE: Setting Contention Resolution ID CE");
} }
conres_id = 0; // reset CR so it's not sent twice conres_id = 0; // reset CR so it's not sent twice
} else { } else {
log->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");
} }
msg3_tti = -1; msg3_tti = -1;
} }
@ -315,7 +344,7 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
if (mac_msg_dl.new_subh()) { if (mac_msg_dl.new_subh()) {
int n = mac_msg_dl.get()->set_sdu(lcid, buf_state, &cells[pcell_idx]->rlc); int n = mac_msg_dl.get()->set_sdu(lcid, buf_state, &cells[pcell_idx]->rlc);
if (n == -1) { if (n == -1) {
log->error("Error while adding SDU (%d B) to MAC PDU\n", buf_state); logger.error("Error while adding SDU (%d B) to MAC PDU", buf_state);
mac_msg_dl.del_subh(); mac_msg_dl.del_subh();
} }
@ -335,14 +364,14 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
if (mac_pdu_ptr != nullptr) { if (mac_pdu_ptr != nullptr) {
if (force_lcid != -1 && lcid == 0) { if (force_lcid != -1 && lcid == 0) {
if (has_single_sdu) { if (has_single_sdu) {
log->info("Patched lcid in mac header to: %d\n", force_lcid); logger.info("Patched lcid in mac header to: %d", force_lcid);
mac_pdu_ptr[0] = (mac_pdu_ptr[0] & 0xe0) | (force_lcid & 0x1f); mac_pdu_ptr[0] = (mac_pdu_ptr[0] & 0xe0) | (force_lcid & 0x1f);
} else if (mac_msg_dl.nof_subh() > 1) { } else if (mac_msg_dl.nof_subh() > 1) {
log->warning( logger.warning(
"Not patching lcid to %d in mac header (nof_subh == %d)\n", force_lcid, mac_msg_dl.nof_subh()); "Not patching lcid to %d in mac header (nof_subh == %d)", force_lcid, mac_msg_dl.nof_subh());
} }
} }
log->info_hex(mac_pdu_ptr, mac_msg_dl.get_pdu_len(), "DL MAC PDU (%d B):\n", mac_msg_dl.get_pdu_len()); logger.info(mac_pdu_ptr, mac_msg_dl.get_pdu_len(), "DL MAC PDU (%d B):", mac_msg_dl.get_pdu_len());
// Prepare MAC grant for CCCH // Prepare MAC grant for CCCH
mac_interface_phy_lte::mac_grant_dl_t dl_grant = {}; mac_interface_phy_lte::mac_grant_dl_t dl_grant = {};
@ -355,18 +384,18 @@ void ttcn3_syssim::new_tti_indication(uint64_t res)
ue->new_tb(dl_grant, (const uint8_t*)mac_pdu_ptr); ue->new_tb(dl_grant, (const uint8_t*)mac_pdu_ptr);
} else { } else {
log->error("Error writing DL MAC PDU\n"); logger.error("Error writing DL MAC PDU");
} }
mac_msg_dl.reset(); mac_msg_dl.reset();
} else if (cells[pcell_idx]->bearer_follow_on_map[lcid]) { } else if (cells[pcell_idx]->bearer_follow_on_map[lcid]) {
log->info("Waiting for more PDUs for transmission on LCID=%d\n", lcid); logger.info("Waiting for more PDUs for transmission on LCID=%d", lcid);
} }
} }
// Check if we need to provide a UL grant as well // Check if we need to provide a UL grant as well
} }
} else { } else {
log->debug("Not handling RNTI=%d\n", dl_rnti); logger.debug("Not handling RNTI=%d", dl_rnti);
} }
} }
@ -378,7 +407,7 @@ void ttcn3_syssim::stop()
void ttcn3_syssim::reset() void ttcn3_syssim::reset()
{ {
log->info("Resetting SS\n"); logger.info("Resetting SS");
cells.clear(); cells.clear();
pcell_idx = -1; pcell_idx = -1;
} }
@ -392,22 +421,24 @@ void ttcn3_syssim::tc_start(const char* name)
// Make a copy of the UE args for this run // Make a copy of the UE args for this run
all_args_t local_args = args; all_args_t local_args = args;
// set up logging
if (args.log.filename == "stdout") {
logger = &logger_stdout;
} else {
const std::string& file_tc_name = get_filename_with_tc_name(local_args.log.filename, run_id, tc_name);
auto* swp_sink = srslog::find_sink(swappable_sink::name()); auto* swp_sink = srslog::find_sink(swappable_sink::name());
if (!swp_sink) { if (!swp_sink) {
log->error("Unable to find the swappable sink\n"); logger.error("Unable to find the swappable sink");
srslte::console("Unable to find the swappable sink\n"); srslte::console("Unable to find the swappable sink\n");
return; return;
} }
// set up logging
if (args.log.filename == "stdout") {
old_logger = &logger_stdout;
static_cast<swappable_sink*>(swp_sink)->swap_to_stdout();
} else {
const std::string& file_tc_name = get_filename_with_tc_name(local_args.log.filename, run_id, tc_name);
static_cast<swappable_sink*>(swp_sink)->swap_sink(file_tc_name); static_cast<swappable_sink*>(swp_sink)->swap_sink(file_tc_name);
logger = &logger_file; old_logger = &logger_file;
} }
log->info("Initializing UE ID=%d for TC=%s\n", run_id, tc_name.c_str()); logger.info("Initializing UE ID=%d for TC=%s", run_id, tc_name.c_str());
srslte::console("Initializing UE ID=%d for TC=%s\n", run_id, tc_name.c_str()); srslte::console("Initializing UE ID=%d for TC=%s\n", run_id, tc_name.c_str());
// Patch UE config // Patch UE config
@ -415,17 +446,17 @@ void ttcn3_syssim::tc_start(const char* name)
local_args.stack.pcap.nas_filename = get_filename_with_tc_name(args.stack.pcap.nas_filename, run_id, tc_name); local_args.stack.pcap.nas_filename = get_filename_with_tc_name(args.stack.pcap.nas_filename, run_id, tc_name);
// bring up UE // bring up UE
if (ue->init(local_args, logger, this, tc_name)) { if (ue->init(local_args, old_logger, this, tc_name)) {
ue->stop(); ue->stop();
std::string err("Couldn't initialize UE.\n"); std::string err("Couldn't initialize UE.");
log->error("%s\n", err.c_str()); logger.error("%s", err.c_str());
srslte::console("%s\n", err.c_str()); srslte::console("%s\n", err.c_str());
return; return;
} }
// create and add TTI timer to epoll // create and add TTI timer to epoll
if (add_epoll(timer_handler.get_timer_fd(), epoll_fd) != SRSLTE_SUCCESS) { if (add_epoll(timer_handler.get_timer_fd(), epoll_fd) != SRSLTE_SUCCESS) {
log->error("Error while adding TTI timer to epoll\n"); logger.error("Error while adding TTI timer to epoll");
} }
event_handler.insert({timer_handler.get_timer_fd(), &timer_handler}); event_handler.insert({timer_handler.get_timer_fd(), &timer_handler});
} }
@ -433,7 +464,7 @@ void ttcn3_syssim::tc_start(const char* name)
// Called from UT to terminate the testcase // Called from UT to terminate the testcase
void ttcn3_syssim::tc_end() void ttcn3_syssim::tc_end()
{ {
log->info("Deinitializing UE ID=%d\n", run_id); logger.info("Deinitializing UE ID=%d", run_id);
srslte::console("Deinitializing UE ID=%d\n", run_id); srslte::console("Deinitializing UE ID=%d\n", run_id);
ue->stop(); ue->stop();
@ -477,8 +508,8 @@ void ttcn3_syssim::prach_indication(uint32_t preamble_index_, const uint32_t& ce
{ {
// verify that UE intends to send PRACH on current Pcell // verify that UE intends to send PRACH on current Pcell
if (cells[pcell_idx]->config.phy_cell.id != cell_id) { if (cells[pcell_idx]->config.phy_cell.id != cell_id) {
log->error( logger.error(
"UE is attempting to PRACH on pci=%d, current Pcell=%d\n", cell_id, cells[pcell_idx]->config.phy_cell.id); "UE is attempting to PRACH on pci=%d, current Pcell=%d", cell_id, cells[pcell_idx]->config.phy_cell.id);
return; return;
} }
@ -490,7 +521,7 @@ void ttcn3_syssim::prach_indication(uint32_t preamble_index_, const uint32_t& ce
// Called from PHY // Called from PHY
void ttcn3_syssim::sr_req(uint32_t tti_tx) void ttcn3_syssim::sr_req(uint32_t tti_tx)
{ {
log->info("Received SR from PHY\n"); logger.info("Received SR from PHY");
sr_tti = tti_tx; sr_tti = tti_tx;
} }
@ -498,16 +529,16 @@ void ttcn3_syssim::sr_req(uint32_t tti_tx)
void ttcn3_syssim::tx_pdu(const uint8_t* payload, const int len, const uint32_t tx_tti) void ttcn3_syssim::tx_pdu(const uint8_t* payload, const int len, const uint32_t tx_tti)
{ {
if (payload == NULL) { if (payload == NULL) {
ss_mac_log->error("Received NULL as PDU payload. Dropping.\n"); ss_mac_logger.error("Received NULL as PDU payload. Dropping.");
return; return;
} }
if (pcell_idx == -1) { if (pcell_idx == -1) {
log->debug("Skipping TTI. Pcell not yet selected.\n"); logger.debug("Skipping TTI. Pcell not yet selected.");
return; return;
} }
log->info_hex(payload, len, "UL MAC PDU (%d B):\n", len); logger.info(payload, len, "UL MAC PDU (%d B):", len);
// Parse MAC // Parse MAC
mac_msg_ul.init_rx(len, true); mac_msg_ul.init_rx(len, true);
@ -517,9 +548,9 @@ void ttcn3_syssim::tx_pdu(const uint8_t* payload, const int len, const uint32_t
assert(mac_msg_ul.get()); assert(mac_msg_ul.get());
if (mac_msg_ul.get()->is_sdu()) { if (mac_msg_ul.get()->is_sdu()) {
// Push PDU to our own RLC (needed to handle status reporting, etc. correctly // Push PDU to our own RLC (needed to handle status reporting, etc. correctly
ss_mac_log->info_hex(mac_msg_ul.get()->get_sdu_ptr(), ss_mac_logger.info(mac_msg_ul.get()->get_sdu_ptr(),
mac_msg_ul.get()->get_payload_size(), mac_msg_ul.get()->get_payload_size(),
"Route UL PDU to LCID=%d (%d B)\n", "Route UL PDU to LCID=%d (%d B)",
mac_msg_ul.get()->get_sdu_lcid(), mac_msg_ul.get()->get_sdu_lcid(),
mac_msg_ul.get()->get_payload_size()); mac_msg_ul.get()->get_payload_size());
cells[pcell_idx]->rlc.write_pdu( cells[pcell_idx]->rlc.write_pdu(
@ -534,9 +565,9 @@ void ttcn3_syssim::tx_pdu(const uint8_t* payload, const int len, const uint32_t
for (int i = 0; i < nbytes; i++) { for (int i = 0; i < nbytes; i++) {
ue_cri_ptr[nbytes - i - 1] = pkt_ptr[i]; ue_cri_ptr[nbytes - i - 1] = pkt_ptr[i];
} }
ss_mac_log->info_hex(ue_cri_ptr, nbytes, "Contention resolution ID:\n"); ss_mac_logger.info(ue_cri_ptr, nbytes, "Contention resolution ID:");
} else { } else {
ss_mac_log->error("Received CCCH UL message of invalid size=%d bytes\n", ss_mac_logger.error("Received CCCH UL message of invalid size=%d bytes",
mac_msg_ul.get()->get_payload_size()); mac_msg_ul.get()->get_payload_size());
} }
} }
@ -558,7 +589,7 @@ void ttcn3_syssim::tx_pdu(const uint8_t* payload, const int len, const uint32_t
// Internal function called from main thread // Internal function called from main thread
void ttcn3_syssim::send_rar(uint32_t preamble_index) void ttcn3_syssim::send_rar(uint32_t preamble_index)
{ {
log->info("Sending RAR for RAPID=%d\n", preamble_index); logger.info("Sending RAR for RAPID=%d", preamble_index);
// Prepare RAR grant // Prepare RAR grant
uint8_t grant_buffer[64] = {}; uint8_t grant_buffer[64] = {};
@ -600,7 +631,7 @@ void ttcn3_syssim::send_rar(uint32_t preamble_index)
// Internal function called from main thread // Internal function called from main thread
void ttcn3_syssim::send_msg3_grant() void ttcn3_syssim::send_msg3_grant()
{ {
log->info("Sending Msg3 grant for C-RNTI=0x%x\n", cells[pcell_idx]->config.crnti); logger.info("Sending Msg3 grant for C-RNTI=0x%x", cells[pcell_idx]->config.crnti);
mac_interface_phy_lte::mac_grant_ul_t ul_grant = {}; mac_interface_phy_lte::mac_grant_ul_t ul_grant = {};
ul_grant.tti_tx = (tti + 3) % 10240; ul_grant.tti_tx = (tti + 3) % 10240;
@ -645,20 +676,20 @@ bool ttcn3_syssim::process_ce(srslte::sch_subh* subh)
switch (subh->ul_sch_ce_type()) { switch (subh->ul_sch_ce_type()) {
case srslte::ul_sch_lcid::PHR_REPORT: case srslte::ul_sch_lcid::PHR_REPORT:
phr = subh->get_phr(); phr = subh->get_phr();
ss_mac_log->info("CE: Received PHR from rnti=0x%x, value=%.0f\n", rnti, phr); ss_mac_logger.info("CE: Received PHR from rnti=0x%x, value=%.0f", rnti, phr);
break; break;
case srslte::ul_sch_lcid::CRNTI: case srslte::ul_sch_lcid::CRNTI:
old_rnti = subh->get_c_rnti(); old_rnti = subh->get_c_rnti();
ss_mac_log->info("CE: Received C-RNTI from temp_rnti=0x%x, rnti=0x%x\n", rnti, old_rnti); ss_mac_logger.info("CE: Received C-RNTI from temp_rnti=0x%x, rnti=0x%x", rnti, old_rnti);
break; break;
case srslte::ul_sch_lcid::TRUNC_BSR: case srslte::ul_sch_lcid::TRUNC_BSR:
case srslte::ul_sch_lcid::SHORT_BSR: case srslte::ul_sch_lcid::SHORT_BSR:
idx = subh->get_bsr(buff_size_idx, buff_size_bytes); idx = subh->get_bsr(buff_size_idx, buff_size_bytes);
if (idx == -1) { if (idx == -1) {
ss_mac_log->error("Invalid Index Passed to lc groups\n"); ss_mac_logger.error("Invalid Index Passed to lc groups");
break; break;
} }
ss_mac_log->info("CE: Received %s BSR rnti=0x%x, lcg=%d, value=%d\n", ss_mac_logger.info("CE: Received %s BSR rnti=0x%x, lcg=%d, value=%d",
subh->ul_sch_ce_type() == srslte::ul_sch_lcid::SHORT_BSR ? "Short" : "Trunc", subh->ul_sch_ce_type() == srslte::ul_sch_lcid::SHORT_BSR ? "Short" : "Trunc",
rnti, rnti,
idx, idx,
@ -668,7 +699,7 @@ bool ttcn3_syssim::process_ce(srslte::sch_subh* subh)
case srslte::ul_sch_lcid::LONG_BSR: case srslte::ul_sch_lcid::LONG_BSR:
subh->get_bsr(buff_size_idx, buff_size_bytes); subh->get_bsr(buff_size_idx, buff_size_bytes);
is_bsr = true; is_bsr = true;
ss_mac_log->info("CE: Received Long BSR rnti=0x%x, value=%d,%d,%d,%d\n", ss_mac_logger.info("CE: Received Long BSR rnti=0x%x, value=%d,%d,%d,%d",
rnti, rnti,
buff_size_idx[0], buff_size_idx[0],
buff_size_idx[1], buff_size_idx[1],
@ -676,10 +707,10 @@ bool ttcn3_syssim::process_ce(srslte::sch_subh* subh)
buff_size_idx[3]); buff_size_idx[3]);
break; break;
case srslte::ul_sch_lcid::PADDING: case srslte::ul_sch_lcid::PADDING:
ss_mac_log->debug("CE: Received padding for rnti=0x%x\n", rnti); ss_mac_logger.debug("CE: Received padding for rnti=0x%x", rnti);
break; break;
default: default:
ss_mac_log->error("CE: Invalid lcid=0x%x\n", subh->lcid_value()); ss_mac_logger.error("CE: Invalid lcid=0x%x", subh->lcid_value());
break; break;
} }
return is_bsr; return is_bsr;
@ -695,7 +726,7 @@ bool ttcn3_syssim::get_ndi_for_new_ul_tx(const uint32_t tti_)
// toggle NDI to always create new Tx // toggle NDI to always create new Tx
const uint32_t pid = get_pid(tti_); const uint32_t pid = get_pid(tti_);
last_ul_ndi[pid] = !last_ul_ndi[pid]; last_ul_ndi[pid] = !last_ul_ndi[pid];
log->info("UL-PID=%d NDI=%s\n", pid, last_ul_ndi[pid] ? "1" : "0"); logger.info("UL-PID=%d NDI=%s", pid, last_ul_ndi[pid] ? "1" : "0");
return last_ul_ndi[pid]; return last_ul_ndi[pid];
} }
@ -704,7 +735,7 @@ bool ttcn3_syssim::get_ndi_for_new_dl_tx(const uint32_t tti_)
// toggle NDI to always create new Tx // toggle NDI to always create new Tx
const uint32_t pid = get_pid(tti_); const uint32_t pid = get_pid(tti_);
last_dl_ndi[pid] = !last_dl_ndi[pid]; last_dl_ndi[pid] = !last_dl_ndi[pid];
log->info("DL-PID=%d NDI=%s\n", pid, last_dl_ndi[pid] ? "1" : "0"); logger.info("DL-PID=%d NDI=%s", pid, last_dl_ndi[pid] ? "1" : "0");
return last_dl_ndi[pid]; return last_dl_ndi[pid];
} }
@ -758,7 +789,7 @@ void ttcn3_syssim::set_cell_config(const ttcn3_helpers::timing_info_t timing, co
if (timing.now) { if (timing.now) {
set_cell_config_impl(cell); set_cell_config_impl(cell);
} else { } else {
log->debug("Scheduling Cell configuration of %s for TTI=%d\n", cell.name.c_str(), timing.tti); logger.debug("Scheduling Cell configuration of %s for TTI=%d", cell.name.c_str(), timing.tti);
tti_actions[timing.tti].push([this, cell]() { set_cell_config_impl(cell); }); tti_actions[timing.tti].push([this, cell]() { set_cell_config_impl(cell); });
} }
} }
@ -768,7 +799,7 @@ void ttcn3_syssim::set_cell_config_impl(const cell_config_t config)
// check if cell already exists // check if cell already exists
if (not syssim_has_cell(config.name)) { if (not syssim_has_cell(config.name)) {
// insert new cell // insert new cell
log->info("Adding cell %s with cellId=%d and initial_power=%.2f dBm\n", logger.info("Adding cell %s with cellId=%d and initial_power=%.2f dBm",
config.name.c_str(), config.name.c_str(),
config.phy_cell.id, config.phy_cell.id,
config.initial_power); config.initial_power);
@ -782,7 +813,7 @@ void ttcn3_syssim::set_cell_config_impl(const cell_config_t config)
cells.push_back(std::move(cell)); cells.push_back(std::move(cell));
} else { } else {
// cell is already there // cell is already there
log->info("Cell already there, reconfigure\n"); logger.info("Cell already there, reconfigure");
// We only support (Temp-)CRNTI reconfiguration // We only support (Temp-)CRNTI reconfiguration
syssim_cell_t* ss_cell = get_cell(config.name); syssim_cell_t* ss_cell = get_cell(config.name);
if (config.crnti > 0) { if (config.crnti > 0) {
@ -824,7 +855,7 @@ void ttcn3_syssim::set_cell_attenuation(const ttcn3_helpers::timing_info_t timin
if (timing.now) { if (timing.now) {
set_cell_attenuation_impl(cell_name, value); set_cell_attenuation_impl(cell_name, value);
} else { } else {
log->debug("Scheduling Cell attenuation reconfiguration of %s for TTI=%d\n", cell_name.c_str(), timing.tti); logger.debug("Scheduling Cell attenuation reconfiguration of %s for TTI=%d", cell_name.c_str(), timing.tti);
tti_actions[timing.tti].push([this, cell_name, value]() { set_cell_attenuation_impl(cell_name, value); }); tti_actions[timing.tti].push([this, cell_name, value]() { set_cell_attenuation_impl(cell_name, value); });
} }
} }
@ -832,7 +863,7 @@ void ttcn3_syssim::set_cell_attenuation(const ttcn3_helpers::timing_info_t timin
void ttcn3_syssim::set_cell_attenuation_impl(const std::string cell_name, const float value) void ttcn3_syssim::set_cell_attenuation_impl(const std::string cell_name, const float value)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't set cell power. Cell not found.\n"); logger.error("Can't set cell power. Cell not found.");
return; return;
} }
@ -853,7 +884,7 @@ void ttcn3_syssim::update_cell_map()
phy_cell.info = ss_cell->config.phy_cell; phy_cell.info = ss_cell->config.phy_cell;
phy_cell.power = ss_cell->config.initial_power - ss_cell->config.attenuation; phy_cell.power = ss_cell->config.initial_power - ss_cell->config.attenuation;
phy_cell.earfcn = ss_cell->config.earfcn; phy_cell.earfcn = ss_cell->config.earfcn;
log->info("Configuring cell with PCI=%d with TxPower=%.2f\n", phy_cell.info.id, phy_cell.power); logger.info("Configuring cell with PCI=%d with TxPower=%.2f", phy_cell.info.id, phy_cell.power);
phy_cells.push_back(phy_cell); phy_cells.push_back(phy_cell);
} }
@ -869,7 +900,7 @@ bool ttcn3_syssim::have_valid_pcell()
void ttcn3_syssim::add_bcch_dlsch_pdu(const string cell_name, unique_byte_buffer_t pdu) void ttcn3_syssim::add_bcch_dlsch_pdu(const string cell_name, unique_byte_buffer_t pdu)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't add BCCH to cell. Cell not found.\n"); logger.error("Can't add BCCH to cell. Cell not found.");
return; return;
} }
@ -885,7 +916,7 @@ void ttcn3_syssim::add_ccch_pdu(const ttcn3_helpers::timing_info_t timing,
// Add to SRB0 Tx queue // Add to SRB0 Tx queue
add_ccch_pdu_impl(cell_name, std::move(pdu)); add_ccch_pdu_impl(cell_name, std::move(pdu));
} else { } else {
log->debug("Scheduling CCCH PDU for TTI=%d\n", timing.tti); logger.debug("Scheduling CCCH PDU for TTI=%d", timing.tti);
auto task = [this, cell_name](srslte::unique_byte_buffer_t& pdu) { add_ccch_pdu_impl(cell_name, std::move(pdu)); }; auto task = [this, cell_name](srslte::unique_byte_buffer_t& pdu) { add_ccch_pdu_impl(cell_name, std::move(pdu)); };
tti_actions[timing.tti].push(std::bind(task, std::move(pdu))); tti_actions[timing.tti].push(std::bind(task, std::move(pdu)));
} }
@ -894,7 +925,7 @@ void ttcn3_syssim::add_ccch_pdu(const ttcn3_helpers::timing_info_t timing,
void ttcn3_syssim::add_ccch_pdu_impl(const std::string cell_name, unique_byte_buffer_t pdu) void ttcn3_syssim::add_ccch_pdu_impl(const std::string cell_name, unique_byte_buffer_t pdu)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't add CCCH to cell. Cell not found.\n"); logger.error("Can't add CCCH to cell. Cell not found.");
return; return;
} }
@ -912,7 +943,7 @@ void ttcn3_syssim::add_dcch_pdu(const ttcn3_helpers::timing_info_t timing,
if (timing.now) { if (timing.now) {
add_dcch_pdu_impl(cell_name, lcid, std::move(pdu), follow_on_flag); add_dcch_pdu_impl(cell_name, lcid, std::move(pdu), follow_on_flag);
} else { } else {
log->debug("Scheduling DCCH PDU for TTI=%d\n", timing.tti); logger.debug("Scheduling DCCH PDU for TTI=%d", timing.tti);
auto task = [this, cell_name](uint32_t lcid, srslte::unique_byte_buffer_t& pdu, bool follow_on_flag) { auto task = [this, cell_name](uint32_t lcid, srslte::unique_byte_buffer_t& pdu, bool follow_on_flag) {
add_dcch_pdu_impl(cell_name, lcid, std::move(pdu), follow_on_flag); add_dcch_pdu_impl(cell_name, lcid, std::move(pdu), follow_on_flag);
}; };
@ -926,21 +957,21 @@ void ttcn3_syssim::add_dcch_pdu_impl(const std::string cell_name,
bool follow_on_flag) bool follow_on_flag)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't add CCCH to cell. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't add CCCH to cell. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
// push to PDCP and create DL grant for it // push to PDCP and create DL grant for it
log->info("Writing PDU (%d B) to LCID=%d\n", pdu->N_bytes, lcid); logger.info("Writing PDU (%d B) to LCID=%d", pdu->N_bytes, lcid);
cell->pdcp.write_sdu(lcid, std::move(pdu)); cell->pdcp.write_sdu(lcid, std::move(pdu));
cell->bearer_follow_on_map[lcid] = follow_on_flag; cell->bearer_follow_on_map[lcid] = follow_on_flag;
} }
void ttcn3_syssim::add_pch_pdu(unique_byte_buffer_t pdu) void ttcn3_syssim::add_pch_pdu(unique_byte_buffer_t pdu)
{ {
log->info("Received PCH PDU (%d B)\n", pdu->N_bytes); logger.info("Received PCH PDU (%d B)", pdu->N_bytes);
// Prepare MAC grant for PCH // Prepare MAC grant for PCH
mac_interface_phy_lte::mac_grant_dl_t dl_grant = {}; mac_interface_phy_lte::mac_grant_dl_t dl_grant = {};
@ -966,7 +997,7 @@ void ttcn3_syssim::add_srb(const ttcn3_helpers::timing_info_t timing,
if (timing.now) { if (timing.now) {
add_srb_impl(cell_name, lcid, pdcp_config); add_srb_impl(cell_name, lcid, pdcp_config);
} else { } else {
log->debug("Scheduling SRB%d addition for TTI=%d\n", lcid, timing.tti); logger.debug("Scheduling SRB%d addition for TTI=%d", lcid, timing.tti);
tti_actions[timing.tti].push( tti_actions[timing.tti].push(
[this, cell_name, lcid, pdcp_config]() { add_srb_impl(cell_name, lcid, pdcp_config); }); [this, cell_name, lcid, pdcp_config]() { add_srb_impl(cell_name, lcid, pdcp_config); });
} }
@ -975,13 +1006,13 @@ void ttcn3_syssim::add_srb(const ttcn3_helpers::timing_info_t timing,
void ttcn3_syssim::add_srb_impl(const std::string cell_name, const uint32_t lcid, const pdcp_config_t pdcp_config) void ttcn3_syssim::add_srb_impl(const std::string cell_name, const uint32_t lcid, const pdcp_config_t pdcp_config)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't add SRB to cell. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't add SRB to cell. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
log->info("Adding SRB%d\n", lcid); logger.info("Adding SRB%d", lcid);
cell->pdcp.add_bearer(lcid, pdcp_config); cell->pdcp.add_bearer(lcid, pdcp_config);
cell->rlc.add_bearer(lcid, srslte::rlc_config_t::srb_config(lcid)); cell->rlc.add_bearer(lcid, srslte::rlc_config_t::srb_config(lcid));
} }
@ -989,13 +1020,13 @@ void ttcn3_syssim::add_srb_impl(const std::string cell_name, const uint32_t lcid
void ttcn3_syssim::reestablish_bearer(const std::string cell_name, const uint32_t lcid) void ttcn3_syssim::reestablish_bearer(const std::string cell_name, const uint32_t lcid)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't reestablish bearer. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't reestablish bearer. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
log->info("Reestablishing LCID=%d\n", lcid); logger.info("Reestablishing LCID=%d", lcid);
cell->pdcp.reestablish(lcid); cell->pdcp.reestablish(lcid);
cell->rlc.reestablish(lcid); cell->rlc.reestablish(lcid);
} }
@ -1005,7 +1036,7 @@ void ttcn3_syssim::del_srb(const ttcn3_helpers::timing_info_t timing, const std:
if (timing.now) { if (timing.now) {
del_srb_impl(cell_name, lcid); del_srb_impl(cell_name, lcid);
} else { } else {
log->debug("Scheduling SRB%d deletion for TTI=%d\n", lcid, timing.tti); logger.debug("Scheduling SRB%d deletion for TTI=%d", lcid, timing.tti);
tti_actions[timing.tti].push([this, cell_name, lcid]() { del_srb_impl(cell_name, lcid); }); tti_actions[timing.tti].push([this, cell_name, lcid]() { del_srb_impl(cell_name, lcid); });
} }
} }
@ -1013,13 +1044,13 @@ void ttcn3_syssim::del_srb(const ttcn3_helpers::timing_info_t timing, const std:
void ttcn3_syssim::del_srb_impl(const std::string cell_name, const uint32_t lcid) void ttcn3_syssim::del_srb_impl(const std::string cell_name, const uint32_t lcid)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't delete bearer. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't delete bearer. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
log->info("Deleting SRB%d\n", lcid); logger.info("Deleting SRB%d", lcid);
// Only delete SRB1/2 // Only delete SRB1/2
if (lcid > 0) { if (lcid > 0) {
cell->pdcp.del_bearer(lcid); cell->pdcp.del_bearer(lcid);
@ -1035,7 +1066,7 @@ void ttcn3_syssim::add_drb(const ttcn3_helpers::timing_info_t timing,
if (timing.now) { if (timing.now) {
add_drb_impl(cell_name, lcid, pdcp_config); add_drb_impl(cell_name, lcid, pdcp_config);
} else { } else {
log->debug("Scheduling DRB%d addition for TTI=%d\n", lcid - 2, timing.tti); logger.debug("Scheduling DRB%d addition for TTI=%d", lcid - 2, timing.tti);
tti_actions[timing.tti].push( tti_actions[timing.tti].push(
[this, cell_name, lcid, pdcp_config]() { add_drb_impl(cell_name, lcid, pdcp_config); }); [this, cell_name, lcid, pdcp_config]() { add_drb_impl(cell_name, lcid, pdcp_config); });
} }
@ -1044,14 +1075,14 @@ void ttcn3_syssim::add_drb(const ttcn3_helpers::timing_info_t timing,
void ttcn3_syssim::add_drb_impl(const std::string cell_name, const uint32_t lcid, const pdcp_config_t pdcp_config) void ttcn3_syssim::add_drb_impl(const std::string cell_name, const uint32_t lcid, const pdcp_config_t pdcp_config)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't add DRB. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't add DRB. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
if (lcid > 2) { if (lcid > 2) {
log->info("Adding DRB%d\n", lcid - 2); logger.info("Adding DRB%d", lcid - 2);
cell->pdcp.add_bearer(lcid, pdcp_config); cell->pdcp.add_bearer(lcid, pdcp_config);
cell->rlc.add_bearer(lcid, srslte::rlc_config_t::default_rlc_am_config()); cell->rlc.add_bearer(lcid, srslte::rlc_config_t::default_rlc_am_config());
} }
@ -1062,7 +1093,7 @@ void ttcn3_syssim::del_drb(const ttcn3_helpers::timing_info_t timing, const std:
if (timing.now) { if (timing.now) {
del_drb_impl(cell_name, lcid); del_drb_impl(cell_name, lcid);
} else { } else {
log->debug("Scheduling DRB%d deletion for TTI=%d\n", lcid - 2, timing.tti); logger.debug("Scheduling DRB%d deletion for TTI=%d", lcid - 2, timing.tti);
tti_actions[timing.tti].push([this, cell_name, lcid]() { del_drb_impl(cell_name, lcid); }); tti_actions[timing.tti].push([this, cell_name, lcid]() { del_drb_impl(cell_name, lcid); });
} }
} }
@ -1070,7 +1101,7 @@ void ttcn3_syssim::del_drb(const ttcn3_helpers::timing_info_t timing, const std:
void ttcn3_syssim::del_drb_impl(const std::string cell_name, const uint32_t lcid) void ttcn3_syssim::del_drb_impl(const std::string cell_name, const uint32_t lcid)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't delete DRB. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't delete DRB. Cell %s not found.", cell_name.c_str());
return; return;
} }
@ -1078,7 +1109,7 @@ void ttcn3_syssim::del_drb_impl(const std::string cell_name, const uint32_t lcid
// Only delete DRB // Only delete DRB
if (lcid > 2) { if (lcid > 2) {
log->info("Deleting DRB%d\n", lcid - 2); logger.info("Deleting DRB%d", lcid - 2);
cell->pdcp.del_bearer(lcid); cell->pdcp.del_bearer(lcid);
cell->rlc.del_bearer(lcid); cell->rlc.del_bearer(lcid);
} }
@ -1087,9 +1118,9 @@ void ttcn3_syssim::del_drb_impl(const std::string cell_name, const uint32_t lcid
// RRC interface for PDCP, PDCP calls RRC to push RRC SDU // RRC interface for PDCP, PDCP calls RRC to push RRC SDU
void ttcn3_syssim::write_pdu(uint32_t lcid, unique_byte_buffer_t pdu) void ttcn3_syssim::write_pdu(uint32_t lcid, unique_byte_buffer_t pdu)
{ {
log->info_hex(pdu->msg, logger.info(pdu->msg,
pdu->N_bytes, pdu->N_bytes,
"RRC SDU received for LCID=%d cell_id=%d (%d B)\n", "RRC SDU received for LCID=%d cell_id=%d (%d B)",
lcid, lcid,
cells[pcell_idx]->config.phy_cell.id, cells[pcell_idx]->config.phy_cell.id,
pdu->N_bytes); pdu->N_bytes);
@ -1108,23 +1139,23 @@ void ttcn3_syssim::write_pdu(uint32_t lcid, unique_byte_buffer_t pdu)
// Not supported right now // Not supported right now
void ttcn3_syssim::write_pdu_bcch_bch(unique_byte_buffer_t pdu) void ttcn3_syssim::write_pdu_bcch_bch(unique_byte_buffer_t pdu)
{ {
log->error("%s not implemented.\n", __FUNCTION__); logger.error("%s not implemented.", __FUNCTION__);
} }
void ttcn3_syssim::write_pdu_bcch_dlsch(unique_byte_buffer_t pdu) void ttcn3_syssim::write_pdu_bcch_dlsch(unique_byte_buffer_t pdu)
{ {
log->error("%s not implemented.\n", __FUNCTION__); logger.error("%s not implemented.", __FUNCTION__);
} }
void ttcn3_syssim::write_pdu_pcch(unique_byte_buffer_t pdu) void ttcn3_syssim::write_pdu_pcch(unique_byte_buffer_t pdu)
{ {
log->error("%s not implemented.\n", __FUNCTION__); logger.error("%s not implemented.", __FUNCTION__);
} }
void ttcn3_syssim::write_pdu_mch(uint32_t lcid, unique_byte_buffer_t pdu) void ttcn3_syssim::write_pdu_mch(uint32_t lcid, unique_byte_buffer_t pdu)
{ {
log->error("%s not implemented.\n", __FUNCTION__); logger.error("%s not implemented.", __FUNCTION__);
} }
void ttcn3_syssim::max_retx_attempted() void ttcn3_syssim::max_retx_attempted()
{ {
log->error("%s not implemented.\n", __FUNCTION__); logger.error("%s not implemented.", __FUNCTION__);
} }
std::string ttcn3_syssim::get_rb_name(uint32_t lcid) std::string ttcn3_syssim::get_rb_name(uint32_t lcid)
@ -1137,10 +1168,10 @@ std::string ttcn3_syssim::get_rb_name(uint32_t lcid)
void ttcn3_syssim::write_sdu(uint32_t lcid, unique_byte_buffer_t sdu) void ttcn3_syssim::write_sdu(uint32_t lcid, unique_byte_buffer_t sdu)
{ {
log->info_hex(sdu->msg, sdu->N_bytes, "Received SDU on LCID=%d\n", lcid); logger.info(sdu->msg, sdu->N_bytes, "Received SDU on LCID=%d", lcid);
uint8_t* mac_pdu_ptr = mac_msg_dl.write_packet(log); uint8_t* mac_pdu_ptr = mac_msg_dl.write_packet(log);
log->info_hex(mac_pdu_ptr, mac_msg_dl.get_pdu_len(), "DL MAC PDU:\n"); logger.info(mac_pdu_ptr, mac_msg_dl.get_pdu_len(), "DL MAC PDU:");
// Prepare MAC grant for CCCH // Prepare MAC grant for CCCH
mac_interface_phy_lte::mac_grant_dl_t dl_grant = {}; mac_interface_phy_lte::mac_grant_dl_t dl_grant = {};
@ -1179,7 +1210,7 @@ void ttcn3_syssim::set_as_security(const ttcn3_helpers::timing_info_t tim
if (timing.now) { if (timing.now) {
set_as_security_impl(cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_); set_as_security_impl(cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_);
} else { } else {
log->debug("Scheduling AS security configuration for TTI=%d\n", timing.tti); logger.debug("Scheduling AS security configuration for TTI=%d", timing.tti);
tti_actions[timing.tti].push( tti_actions[timing.tti].push(
[this, cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_]() { [this, cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_]() {
set_as_security_impl(cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_); set_as_security_impl(cell_name, k_rrc_enc_, k_rrc_int_, k_up_enc_, cipher_algo_, integ_algo_, bearers_);
@ -1196,7 +1227,7 @@ void ttcn3_syssim::set_as_security_impl(const std::string
const ttcn3_helpers::pdcp_count_map_t bearers) const ttcn3_helpers::pdcp_count_map_t bearers)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't configure AS security. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't configure AS security. Cell %s not found.", cell_name.c_str());
return; return;
} }
@ -1213,10 +1244,10 @@ void ttcn3_syssim::set_as_security_impl(const std::string
for (auto& lcid : bearers) { for (auto& lcid : bearers) {
cell->pdcp.config_security(lcid.rb_id, cell->sec_cfg); cell->pdcp.config_security(lcid.rb_id, cell->sec_cfg);
log->info("Setting AS security for LCID=%d in DL direction from SN=%d onwards\n", lcid.rb_id, lcid.dl_value); logger.info("Setting AS security for LCID=%d in DL direction from SN=%d onwards", lcid.rb_id, lcid.dl_value);
cell->pdcp.enable_security_timed(lcid.rb_id, DIRECTION_TX, lcid.dl_value); cell->pdcp.enable_security_timed(lcid.rb_id, DIRECTION_TX, lcid.dl_value);
log->info("Setting AS security for LCID=%d in UL direction from SN=%d onwards\n", lcid.rb_id, lcid.ul_value); logger.info("Setting AS security for LCID=%d in UL direction from SN=%d onwards", lcid.rb_id, lcid.ul_value);
cell->pdcp.enable_security_timed(lcid.rb_id, DIRECTION_RX, lcid.ul_value); cell->pdcp.enable_security_timed(lcid.rb_id, DIRECTION_RX, lcid.ul_value);
} }
} }
@ -1226,7 +1257,7 @@ void ttcn3_syssim::release_as_security(const ttcn3_helpers::timing_info_t timing
if (timing.now) { if (timing.now) {
release_as_security_impl(cell_name); release_as_security_impl(cell_name);
} else { } else {
log->debug("Scheduling Release of AS security for TTI=%d\n", timing.tti); logger.debug("Scheduling Release of AS security for TTI=%d", timing.tti);
tti_actions[timing.tti].push([this, cell_name]() { release_as_security_impl(cell_name); }); tti_actions[timing.tti].push([this, cell_name]() { release_as_security_impl(cell_name); });
} }
} }
@ -1234,13 +1265,13 @@ void ttcn3_syssim::release_as_security(const ttcn3_helpers::timing_info_t timing
void ttcn3_syssim::release_as_security_impl(const std::string cell_name) void ttcn3_syssim::release_as_security_impl(const std::string cell_name)
{ {
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't release AS security. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't release AS security. Cell %s not found.", cell_name.c_str());
return; return;
} }
auto cell = get_cell(cell_name); auto cell = get_cell(cell_name);
log->info("Releasing AS security\n"); logger.info("Releasing AS security");
cell->pending_bearer_config.clear(); cell->pending_bearer_config.clear();
} }
@ -1250,7 +1281,7 @@ void ttcn3_syssim::select_cell(srslte_cell_t phy_cell)
for (uint32_t i = 0; i < cells.size(); ++i) { for (uint32_t i = 0; i < cells.size(); ++i) {
if (cells[i]->config.phy_cell.id == phy_cell.id) { if (cells[i]->config.phy_cell.id == phy_cell.id) {
pcell_idx = i; pcell_idx = i;
log->info("New PCell: PCI=%d\n", cells[pcell_idx]->config.phy_cell.id); logger.info("New PCell: PCI=%d", cells[pcell_idx]->config.phy_cell.id);
return; return;
} }
} }
@ -1262,7 +1293,7 @@ ttcn3_helpers::pdcp_count_map_t ttcn3_syssim::get_pdcp_count(const std::string c
std::vector<ttcn3_helpers::pdcp_count_t> bearers; std::vector<ttcn3_helpers::pdcp_count_t> bearers;
if (not syssim_has_cell(cell_name)) { if (not syssim_has_cell(cell_name)) {
log->error("Can't obtain PDCP count. Cell %s not found.\n", cell_name.c_str()); logger.error("Can't obtain PDCP count. Cell %s not found.", cell_name.c_str());
return bearers; return bearers;
} }
@ -1278,7 +1309,7 @@ ttcn3_helpers::pdcp_count_map_t ttcn3_syssim::get_pdcp_count(const std::string c
bearer.rb_id = i; bearer.rb_id = i;
bearer.dl_value = pdcp_state.next_pdcp_tx_sn; bearer.dl_value = pdcp_state.next_pdcp_tx_sn;
bearer.ul_value = pdcp_state.next_pdcp_rx_sn; bearer.ul_value = pdcp_state.next_pdcp_rx_sn;
log->debug("PDCP count lcid=%d, dl=%d, ul=%d\n", bearer.rb_id, bearer.dl_value, bearer.ul_value); logger.debug("PDCP count lcid=%d, dl=%d, ul=%d", bearer.rb_id, bearer.dl_value, bearer.ul_value);
bearers.push_back(bearer); bearers.push_back(bearer);
} }
} }

42
srsue/test/ttcn3/src/ttcn3_ue.cc
Unescape Escape View File

@ -20,16 +20,16 @@ SRSLTE_API char* srslte_get_build_info();
SRSLTE_API char* srslte_get_build_mode(); SRSLTE_API char* srslte_get_build_mode();
} }
ttcn3_ue::ttcn3_ue() : tft_matcher(&log) {} ttcn3_ue::ttcn3_ue() : logger(srslog::fetch_basic_logger("UE", false)), tft_matcher(logger) {}
int ttcn3_ue::init(all_args_t args, srslte::logger* logger_, syssim_interface_phy* syssim_, const std::string tc_name_) int ttcn3_ue::init(all_args_t args, srslte::logger* logger_, syssim_interface_phy* syssim_, const std::string tc_name_)
{ {
logger = logger_; old_logger = logger_;
// Init UE log // Init UE log
log.init("UE ", logger); logger.set_level(srslog::basic_levels::info);
log.set_level(srslte::LOG_LEVEL_INFO); logger.set_hex_dump_max_size(128);
log.info("Built in %s mode using %s.\n", srslte_get_build_mode(), srslte_get_build_info()); logger.info("Built in %s mode using %s.", srslte_get_build_mode(), srslte_get_build_info());
// Patch args // Patch args
args.stack.nas.force_imsi_attach = true; args.stack.nas.force_imsi_attach = true;
@ -57,13 +57,13 @@ int ttcn3_ue::init(all_args_t args, srslte::logger* logger_, syssim_interface_ph
// Instantiate layers and stack together our UE // Instantiate layers and stack together our UE
if (args.stack.type == "lte") { if (args.stack.type == "lte") {
stack = std::unique_ptr<ue_stack_lte>(new ue_stack_lte()); stack = std::unique_ptr<ue_stack_lte>(new ue_stack_lte(srslog::get_default_sink()));
if (!stack) { if (!stack) {
srslte::console("Error creating LTE stack instance.\n"); srslte::console("Error creating LTE stack instance.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
phy = std::unique_ptr<srsue::lte_ttcn3_phy>(new srsue::lte_ttcn3_phy(logger)); phy = std::unique_ptr<srsue::lte_ttcn3_phy>(new srsue::lte_ttcn3_phy);
if (!phy) { if (!phy) {
srslte::console("Error creating LTE PHY instance.\n"); srslte::console("Error creating LTE PHY instance.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
@ -79,7 +79,7 @@ int ttcn3_ue::init(all_args_t args, srslte::logger* logger_, syssim_interface_ph
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (stack->init(args.stack, logger, phy.get(), this)) { if (stack->init(args.stack, old_logger, phy.get(), this)) {
srslte::console("Error initializing stack.\n"); srslte::console("Error initializing stack.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -154,13 +154,13 @@ uint16_t ttcn3_ue::get_dl_sched_rnti(uint32_t tti)
void ttcn3_ue::add_mch_port(uint32_t lcid, uint32_t port) {} void ttcn3_ue::add_mch_port(uint32_t lcid, uint32_t port) {}
void ttcn3_ue::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) void ttcn3_ue::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
{ {
log.debug_hex(pdu->msg, pdu->N_bytes, "Rx PDU (%d B) on lcid=%d\n", pdu->N_bytes, lcid); logger.debug(pdu->msg, pdu->N_bytes, "Rx PDU (%d B) on lcid=%d", pdu->N_bytes, lcid);
switch (test_loop_mode) { switch (test_loop_mode) {
case TEST_LOOP_INACTIVE: case TEST_LOOP_INACTIVE:
log.warning("Test loop inactive. Dropping PDU.\n"); logger.warning("Test loop inactive. Dropping PDU.");
break; break;
case TEST_LOOP_MODE_A_ACTIVE: case TEST_LOOP_MODE_A_ACTIVE:
log.error("Test loop mode A not implemented. Dropping PDU.\n"); logger.error("Test loop mode A not implemented. Dropping PDU.");
break; break;
case TEST_LOOP_MODE_B_ACTIVE: case TEST_LOOP_MODE_B_ACTIVE:
// Section 5.4.4 in TS 36.509 // Section 5.4.4 in TS 36.509
@ -176,7 +176,7 @@ void ttcn3_ue::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu)
} }
break; break;
case TEST_LOOP_MODE_C_ACTIVE: case TEST_LOOP_MODE_C_ACTIVE:
log.error("Test loop mode C not implemented. Dropping PDU.\n"); logger.error("Test loop mode C not implemented. Dropping PDU.");
break; break;
} }
} }
@ -199,21 +199,21 @@ void ttcn3_ue::set_test_loop_mode(const test_loop_mode_state_t mode, const uint3
switch (test_loop_mode) { switch (test_loop_mode) {
case TEST_LOOP_INACTIVE: case TEST_LOOP_INACTIVE:
// deactivate timer // deactivate timer
log.info("Deactivating Test Loop Mode\n"); logger.info("Deactivating Test Loop Mode");
pdu_delay_timer.release(); pdu_delay_timer.release();
break; break;
case TEST_LOOP_MODE_A_ACTIVE: case TEST_LOOP_MODE_A_ACTIVE:
log.error("Test loop mode A not implemented\n"); logger.error("Test loop mode A not implemented");
break; break;
case TEST_LOOP_MODE_B_ACTIVE: case TEST_LOOP_MODE_B_ACTIVE:
log.info("Activating Test loop mode B with %d ms PDU delay\n", ip_pdu_delay_ms_); logger.info("Activating Test loop mode B with %d ms PDU delay", ip_pdu_delay_ms_);
pdu_delay_timer = stack->get_task_sched().get_unique_timer(); pdu_delay_timer = stack->get_task_sched().get_unique_timer();
if (ip_pdu_delay_ms_ > 0) { if (ip_pdu_delay_ms_ > 0) {
pdu_delay_timer.set(ip_pdu_delay_ms_, [this](uint32_t tid) { timer_expired(tid); }); pdu_delay_timer.set(ip_pdu_delay_ms_, [this](uint32_t tid) { timer_expired(tid); });
} }
break; break;
case TEST_LOOP_MODE_C_ACTIVE: case TEST_LOOP_MODE_C_ACTIVE:
log.error("Test loop mode A not implemented\n"); logger.error("Test loop mode A not implemented");
break; break;
} }
} }
@ -221,23 +221,23 @@ void ttcn3_ue::set_test_loop_mode(const test_loop_mode_state_t mode, const uint3
void ttcn3_ue::timer_expired(uint32_t timeout_id) void ttcn3_ue::timer_expired(uint32_t timeout_id)
{ {
if (timeout_id == pdu_delay_timer.id()) { if (timeout_id == pdu_delay_timer.id()) {
log.info("Testmode B PDU delay timer expired\n"); logger.info("Testmode B PDU delay timer expired");
send_queued_data(); send_queued_data();
} }
} }
void ttcn3_ue::send_queued_data() void ttcn3_ue::send_queued_data()
{ {
if (!stack->is_rrc_connected()) { if (!stack->is_rrc_connected()) {
log.info("RRC not connected, requesting NAS attach\n"); logger.info("RRC not connected, requesting NAS attach");
if (not stack->start_service_request()) { if (not stack->start_service_request()) {
log.warning("Could not reestablish the connection\n"); logger.warning("Could not reestablish the connection");
} }
stack->get_task_sched().defer_callback(500, [&]() { send_queued_data(); }); stack->get_task_sched().defer_callback(500, [&]() { send_queued_data(); });
return; return;
} }
for (auto& bearer_pdu_queue : pdu_queue) { for (auto& bearer_pdu_queue : pdu_queue) {
log.info("Delivering %zd buffered PDUs for LCID=%d\n", bearer_pdu_queue.second.size(), bearer_pdu_queue.first); logger.info("Delivering %zd buffered PDUs for LCID=%d", bearer_pdu_queue.second.size(), bearer_pdu_queue.first);
while (not bearer_pdu_queue.second.empty()) { while (not bearer_pdu_queue.second.empty()) {
srslte::unique_byte_buffer_t pdu; srslte::unique_byte_buffer_t pdu;
bearer_pdu_queue.second.try_pop(&pdu); bearer_pdu_queue.second.try_pop(&pdu);
@ -248,6 +248,6 @@ void ttcn3_ue::send_queued_data()
void ttcn3_ue::loop_back_pdu_with_tft(uint32_t input_lcid, srslte::unique_byte_buffer_t pdu) void ttcn3_ue::loop_back_pdu_with_tft(uint32_t input_lcid, srslte::unique_byte_buffer_t pdu)
{ {
log.info_hex(pdu->msg, pdu->N_bytes, "Rx PDU (%d B) on lcid=%d, looping back\n", pdu->N_bytes, input_lcid); logger.info(pdu->msg, pdu->N_bytes, "Rx PDU (%d B) on lcid=%d, looping back", pdu->N_bytes, input_lcid);
stack->write_sdu(input_lcid, std::move(pdu)); stack->write_sdu(input_lcid, std::move(pdu));
} }

11
srsue/test/ttcn3/test/ttcn3_if_handler_test.cc
Unescape Escape View File

@ -18,11 +18,12 @@
int if_handler_test() int if_handler_test()
{ {
ttcn3_ut_interface ut; auto& logger = srslog::fetch_basic_logger("TEST", false);
ttcn3_sys_interface sys; ttcn3_ut_interface ut(logger);
ttcn3_ip_sock_interface ip_sock; ttcn3_sys_interface sys(logger);
ttcn3_ip_ctrl_interface ip_ctrl; ttcn3_ip_sock_interface ip_sock(logger);
ttcn3_srb_interface srb; ttcn3_ip_ctrl_interface ip_ctrl(logger);
ttcn3_srb_interface srb(logger);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }

22
srsue/test/upper/nas_test.cc
Unescape Escape View File

@ -167,7 +167,6 @@ public:
running = false; running = false;
wait_thread_finish(); wait_thread_finish();
} }
srslte::log_ref stack_log{"STCK"};
pdcp_interface_gw* pdcp = nullptr; pdcp_interface_gw* pdcp = nullptr;
srsue::nas* nas = nullptr; srsue::nas* nas = nullptr;
bool running = false; bool running = false;
@ -218,7 +217,7 @@ int security_command_test()
args.using_op = true; args.using_op = true;
// init USIM // init USIM
srsue::usim usim(&usim_log); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim.init(&args); usim.init(&args);
{ {
@ -274,7 +273,7 @@ int mme_attach_request_test()
rrc_dummy rrc_dummy; rrc_dummy rrc_dummy;
pdcp_dummy pdcp_dummy; pdcp_dummy pdcp_dummy;
srsue::usim usim(&usim_log); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim_args_t args; usim_args_t args;
args.mode = "soft"; args.mode = "soft";
args.algo = "xor"; args.algo = "xor";
@ -358,7 +357,7 @@ int esm_info_request_test()
args.op = "63BFA50EE6523365FF14C1F45F88737D"; args.op = "63BFA50EE6523365FF14C1F45F88737D";
// init USIM // init USIM
srsue::usim usim(&usim_log); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim.init(&args); usim.init(&args);
srslte::byte_buffer_pool* pool; srslte::byte_buffer_pool* pool;
@ -410,7 +409,7 @@ int dedicated_eps_bearer_test()
args.op = "63BFA50EE6523365FF14C1F45F88737D"; args.op = "63BFA50EE6523365FF14C1F45F88737D";
// init USIM // init USIM
srsue::usim usim(&usim_log); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim.init(&args); usim.init(&args);
srslte::byte_buffer_pool* pool = byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = byte_buffer_pool::get_instance();
@ -476,6 +475,19 @@ int main(int argc, char** argv)
srslte::srslog_wrapper log_wrapper(*chan); srslte::srslog_wrapper log_wrapper(*chan);
g_logger = &log_wrapper; g_logger = &log_wrapper;
auto& rrc_logger = srslog::fetch_basic_logger("RRC", false);
rrc_logger.set_level(srslog::basic_levels::debug);
rrc_logger.set_hex_dump_max_size(100000);
auto& nas_logger = srslog::fetch_basic_logger("NAS", false);
nas_logger.set_level(srslog::basic_levels::debug);
nas_logger.set_hex_dump_max_size(100000);
auto& usim_logger = srslog::fetch_basic_logger("USIM", false);
usim_logger.set_level(srslog::basic_levels::debug);
usim_logger.set_hex_dump_max_size(100000);
auto& gw_logger = srslog::fetch_basic_logger("GW", false);
gw_logger.set_level(srslog::basic_levels::debug);
gw_logger.set_hex_dump_max_size(100000);
// Start the log backend. // Start the log backend.
srslog::init(); srslog::init();

14
srsue/test/upper/pcsc_usim_test.cc
Unescape Escape View File

@ -10,12 +10,10 @@
* *
*/ */
#include "srsue/hdr/stack/upper/pcsc_usim.h"
#include <assert.h> #include <assert.h>
#include <iostream> #include <iostream>
#include "srslte/common/log_filter.h"
#include "srsue/hdr/stack/upper/pcsc_usim.h"
using namespace srsue; using namespace srsue;
using namespace std; using namespace std;
@ -24,9 +22,11 @@ uint8_t autn_enb[] = {0x5a, 0x17, 0x77, 0x3c, 0x62, 0x57, 0x90, 0x01, 0xcf, 0x47
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
srslte::log_filter usim_log("USIM"); srslog::basic_logger& logger = srslog::fetch_basic_logger("USIM", false);
usim_log.set_level(srslte::LOG_LEVEL_DEBUG); logger.set_level(srslog::basic_levels::debug);
usim_log.set_hex_limit(100000); logger.set_hex_dump_max_size(100000);
srslog::init();
uint8_t res[16]; uint8_t res[16];
int res_len; int res_len;
uint8_t k_asme[32]; uint8_t k_asme[32];
@ -37,7 +37,7 @@ int main(int argc, char** argv)
args.pin = "6129"; args.pin = "6129";
args.imei = "353490069873319"; args.imei = "353490069873319";
srsue::pcsc_usim usim(&usim_log); srsue::pcsc_usim usim(logger);
if (usim.init(&args)) { if (usim.init(&args)) {
printf("Error initializing PC/SC USIM.\n"); printf("Error initializing PC/SC USIM.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;

79
srsue/test/upper/rrc_meas_test.cc
Unescape Escape View File

@ -489,6 +489,7 @@ int meas_obj_test()
srslte::log_ref log1("RRC_MEAS"); srslte::log_ref log1("RRC_MEAS");
log1->set_level(srslte::LOG_LEVEL_DEBUG); log1->set_level(srslte::LOG_LEVEL_DEBUG);
log1->set_hex_limit(-1); log1->set_hex_limit(-1);
auto& rrc_meas_logger = srslog::fetch_basic_logger("RRC_MEAS");
printf("==========================================================\n"); printf("==========================================================\n");
printf("====== Object Configuration Testing ===============\n"); printf("====== Object Configuration Testing ===============\n");
@ -506,7 +507,7 @@ int meas_obj_test()
rrc_conn_recfg.meas_cfg_present = true; rrc_conn_recfg.meas_cfg_present = true;
meas_cfg_s& meas_cfg = rrc_conn_recfg.meas_cfg; meas_cfg_s& meas_cfg = rrc_conn_recfg.meas_cfg;
log1->info("Test1: Remove non-existing measObject, reportConfig and measId\n"); rrc_meas_logger.info("Test1: Remove non-existing measObject, reportConfig and measId");
meas_cfg = {}; meas_cfg = {};
meas_cfg.meas_id_to_rem_list.push_back(3); meas_cfg.meas_id_to_rem_list.push_back(3);
meas_cfg.meas_obj_to_rem_list.push_back(3); meas_cfg.meas_obj_to_rem_list.push_back(3);
@ -518,7 +519,7 @@ int meas_obj_test()
TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg)); TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg));
TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0); TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0);
log1->info("Test2: Add measId pointing to non-existing measObject or reportConfig\n"); rrc_meas_logger.info("Test2: Add measId pointing to non-existing measObject or reportConfig");
meas_cfg = {}; meas_cfg = {};
meas_id_to_add_mod_s m = {}; meas_id_to_add_mod_s m = {};
m.meas_obj_id = 1; m.meas_obj_id = 1;
@ -531,7 +532,7 @@ int meas_obj_test()
TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg)); TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg));
TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0); TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0);
log1->info("Test3: Add meaObject and report of unsupported type. Setup a supported report for later use\n"); rrc_meas_logger.info("Test3: Add meaObject and report of unsupported type. Setup a supported report for later use");
meas_cfg = {}; meas_cfg = {};
meas_obj_to_add_mod_s obj = {}; meas_obj_to_add_mod_s obj = {};
obj.meas_obj.set_meas_obj_utra(); obj.meas_obj.set_meas_obj_utra();
@ -560,7 +561,7 @@ int meas_obj_test()
TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg)); TESTASSERT(rrctest.send_meas_cfg(rrc_conn_recfg));
TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0); TESTASSERT(rrctest.phytest.meas_nof_freqs() == 0);
log1->info("Test4: Add 2 measObjects and 2 measId both pointing to the same measObject \n"); rrc_meas_logger.info("Test4: Add 2 measObjects and 2 measId both pointing to the same measObject ");
meas_cfg = {}; meas_cfg = {};
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
m = {}; m = {};
@ -596,7 +597,7 @@ int meas_obj_test()
TESTASSERT(rrctest.phytest.meas_freq_started(100)); TESTASSERT(rrctest.phytest.meas_freq_started(100));
TESTASSERT(rrctest.phytest.meas_nof_cells(100) == 0); TESTASSERT(rrctest.phytest.meas_nof_cells(100) == 0);
log1->info("Test5: Add existing objects and measId. Now add measId for 2nd cell\n"); rrc_meas_logger.info("Test5: Add existing objects and measId. Now add measId for 2nd cell");
meas_cfg = {}; meas_cfg = {};
m = {}; m = {};
m.meas_obj_id = 2; // same object m.meas_obj_id = 2; // same object
@ -627,7 +628,7 @@ int meas_obj_test()
} }
// Reconfigure 2nd object only, we should see 8 cells now // Reconfigure 2nd object only, we should see 8 cells now
log1->info("Test6: Add 1 cell to 1st object. Mixed add/mod and removal command.\n"); rrc_meas_logger.info("Test6: Add 1 cell to 1st object. Mixed add/mod and removal command.");
meas_cfg = {}; meas_cfg = {};
meas_cfg.meas_obj_to_add_mod_list_present = true; meas_cfg.meas_obj_to_add_mod_list_present = true;
@ -681,7 +682,7 @@ int meas_obj_test()
TESTASSERT(rrctest.phytest.meas_cell_started(2, 23)); // was added TESTASSERT(rrctest.phytest.meas_cell_started(2, 23)); // was added
TESTASSERT(rrctest.phytest.meas_cell_started(2, 24)); // was added TESTASSERT(rrctest.phytest.meas_cell_started(2, 24)); // was added
log1->info("Test7: PHY finds new neighbours in frequency 1 and 2, check RRC instructs to search them\n"); rrc_meas_logger.info("Test7: PHY finds new neighbours in frequency 1 and 2, check RRC instructs to search them");
std::vector<phy_meas_t> phy_meas = {}; std::vector<phy_meas_t> phy_meas = {};
phy_meas.push_back({0, 0, 0.0f, 1, 31}); phy_meas.push_back({0, 0, 0.0f, 1, 31});
phy_meas.push_back({-1, 0, 0.0f, 1, 32}); phy_meas.push_back({-1, 0, 0.0f, 1, 32});
@ -717,13 +718,13 @@ int meas_obj_test()
TESTASSERT(rrctest.phytest.meas_cell_started(2, 24)); // was added TESTASSERT(rrctest.phytest.meas_cell_started(2, 24)); // was added
TESTASSERT(rrctest.phytest.meas_cell_started(2, 31)); TESTASSERT(rrctest.phytest.meas_cell_started(2, 31));
log1->info("Test8: Simulate a Release (reset() call) make sure resets correctly\n"); rrc_meas_logger.info("Test8: Simulate a Release (reset() call) make sure resets correctly");
rrctest.init(); rrctest.init();
rrctest.run_tti(1); rrctest.run_tti(1);
rrctest.connect(); rrctest.connect();
rrctest.run_tti(1); rrctest.run_tti(1);
log1->info("Test9: Config removal\n"); rrc_meas_logger.info("Test9: Config removal");
meas_cfg = {}; meas_cfg = {};
meas_cfg.meas_obj_to_rem_list.push_back(1); meas_cfg.meas_obj_to_rem_list.push_back(1);
meas_cfg.meas_obj_to_rem_list.push_back(2); meas_cfg.meas_obj_to_rem_list.push_back(2);
@ -916,6 +917,7 @@ int a1event_report_test(uint32_t a1_rsrp_th,
log1->set_hex_limit(-1); log1->set_hex_limit(-1);
rrc_log->set_level(srslte::LOG_LEVEL_DEBUG); rrc_log->set_level(srslte::LOG_LEVEL_DEBUG);
rrc_log->set_hex_limit(-1); rrc_log->set_hex_limit(-1);
auto& rrc_meas_logger = srslog::fetch_basic_logger("RRC_MEAS");
printf("==========================================================\n"); printf("==========================================================\n");
printf("============ Report Testing A1 ===============\n"); printf("============ Report Testing A1 ===============\n");
@ -947,20 +949,20 @@ int a1event_report_test(uint32_t a1_rsrp_th,
// Entering condition during half timeToTrigger, should not trigger measurement // Entering condition during half timeToTrigger, should not trigger measurement
for (int i = 0; i < ttt_iters / 2; i++) { for (int i = 0; i < ttt_iters / 2; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters / 2); rrc_meas_logger.info("Report %d/%d enter condition is true", i, ttt_iters / 2);
enter_condition(rrctest, event_id, hyst, 0, {1, 2}); enter_condition(rrctest, event_id, hyst, 0, {1, 2});
// Check doesn't generate measurement report // Check doesn't generate measurement report
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
} }
log1->info("Report leaving enter condition\n"); rrc_meas_logger.info("Report leaving enter condition");
// Not satisfy entering condition for 1 TTI // Not satisfy entering condition for 1 TTI
middle_condition(rrctest, event_id, hyst, 0, {1}); middle_condition(rrctest, event_id, hyst, 0, {1});
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
// Should go again all timeToTrigger, should not trigger measurement until end // Should go again all timeToTrigger, should not trigger measurement until end
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters); rrc_meas_logger.info("Report %d/%d enter condition is true", i, ttt_iters);
enter_condition(rrctest, event_id, hyst, 0, {1, 2}); enter_condition(rrctest, event_id, hyst, 0, {1, 2});
if (i < ttt_iters - 1) { if (i < ttt_iters - 1) {
// Check doesn't generate measurement report // Check doesn't generate measurement report
@ -980,14 +982,14 @@ int a1event_report_test(uint32_t a1_rsrp_th,
// Trigger again entering condition for the same cell it shouldn't trigger a new report, just keep sending the // Trigger again entering condition for the same cell it shouldn't trigger a new report, just keep sending the
// periodic reports without restarting counter // periodic reports without restarting counter
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters); rrc_meas_logger.info("Report %d/%d enter condition is true", i, ttt_iters);
enter_condition(rrctest, event_id, hyst, 0, {1}); enter_condition(rrctest, event_id, hyst, 0, {1});
} }
// Do not expect report if timer not expired // Do not expect report if timer not expired
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
// Wait to generate all reports // Wait to generate all reports
for (int i = 0; i < report_amount.to_number() - 1; i++) { for (int i = 0; i < report_amount.to_number() - 1; i++) {
log1->info("Testing report %d/%d\n", i, report_amount.to_number()); rrc_meas_logger.info("Testing report %d/%d", i, report_amount.to_number());
int interval = report_interv.to_number(); int interval = report_interv.to_number();
if (i == 0) { if (i == 0) {
// already stepped these iterations // already stepped these iterations
@ -998,7 +1000,7 @@ int a1event_report_test(uint32_t a1_rsrp_th,
// Exit the enter condition in the last one, should still send the last report // Exit the enter condition in the last one, should still send the last report
middle_condition(rrctest, event_id, hyst, 0, {1}); middle_condition(rrctest, event_id, hyst, 0, {1});
} else { } else {
log1->info("Stepping timer %d/%d\n", j, interval); rrc_meas_logger.info("Stepping timer %d/%d", j, interval);
rrctest.run_tti(1); rrctest.run_tti(1);
} }
if (j < interval - 1) { if (j < interval - 1) {
@ -1017,7 +1019,7 @@ int a1event_report_test(uint32_t a1_rsrp_th,
} }
// Trigger again condition // Trigger again condition
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters); rrc_meas_logger.info("Report %d/%d enter condition is true", i, ttt_iters);
enter_condition(rrctest, event_id, hyst, 0, {1}); enter_condition(rrctest, event_id, hyst, 0, {1});
} }
// Do not expect report // Do not expect report
@ -1025,14 +1027,14 @@ int a1event_report_test(uint32_t a1_rsrp_th,
// Leaving condition for timeToTrigger // Leaving condition for timeToTrigger
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d leaving condition is true\n", i, ttt_iters); rrc_meas_logger.info("Report %d/%d leaving condition is true", i, ttt_iters);
exit_condition(rrctest, event_id, hyst, 0, {1}); exit_condition(rrctest, event_id, hyst, 0, {1});
// Check doesn't generate measurement report // Check doesn't generate measurement report
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
} }
// Trigger again condition // Trigger again condition
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters); rrc_meas_logger.info("Report %d/%d enter condition is true", i, ttt_iters);
enter_condition(rrctest, event_id, hyst, 0, {1}); enter_condition(rrctest, event_id, hyst, 0, {1});
} }
// Expect report // Expect report
@ -1046,12 +1048,12 @@ int a1event_report_test(uint32_t a1_rsrp_th,
// Test A3-event reporting and management of report amount and interval // Test A3-event reporting and management of report amount and interval
int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave) int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave)
{ {
srslte::log_ref log1("RRC_MEAS"), rrc_log("RRC"); srslte::log_ref log1("RRC_MEAS"), rrc_log("RRC");
log1->set_level(srslte::LOG_LEVEL_DEBUG); log1->set_level(srslte::LOG_LEVEL_DEBUG);
log1->set_hex_limit(-1); log1->set_hex_limit(-1);
rrc_log->set_level(srslte::LOG_LEVEL_DEBUG); rrc_log->set_level(srslte::LOG_LEVEL_DEBUG);
rrc_log->set_hex_limit(-1); rrc_log->set_hex_limit(-1);
auto& rrc_meas_logger = srslog::fetch_basic_logger("RRC_MEAS");
printf("==========================================================\n"); printf("==========================================================\n");
printf("============ Report Testing A3 ===============\n"); printf("============ Report Testing A3 ===============\n");
@ -1084,14 +1086,14 @@ int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave)
meas_results_s meas_res = {}; meas_results_s meas_res = {};
log1->info("Test no-enter condition and no trigger report \n"); rrc_meas_logger.info("Test no-enter condition and no trigger report ");
no_condition(rrctest, {0}, {1}); no_condition(rrctest, {0}, {1});
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
no_condition(rrctest, {0, 1}, {1, 0}); no_condition(rrctest, {0, 1}, {1, 0});
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
log1->info("Test enter condition triggers report. 1 neighbour cell in enter + 1 in exit \n"); rrc_meas_logger.info("Test enter condition triggers report. 1 neighbour cell in enter + 1 in exit ");
float offset = 0.5 * event_id.event_a3().a3_offset; float offset = 0.5 * event_id.event_a3().a3_offset;
std::vector<float> rsrp = {}; std::vector<float> rsrp = {};
rsrp.push_back(-60 + offset + 0.5 * hyst + (float)1e-2); rsrp.push_back(-60 + offset + 0.5 * hyst + (float)1e-2);
@ -1110,11 +1112,11 @@ int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave)
81 + (hyst + a3_offset) / 2); 81 + (hyst + a3_offset) / 2);
// Next iteration in entering state does not trigger another report // Next iteration in entering state does not trigger another report
log1->info("Test enter condition for the same cell does not trigger report\n"); rrc_meas_logger.info("Test enter condition for the same cell does not trigger report");
rrctest.run_tti(1); rrctest.run_tti(1);
TESTASSERT(!rrctest.get_meas_res(meas_res)); TESTASSERT(!rrctest.get_meas_res(meas_res));
log1->info("Test enter condition for different earfcn triggers report\n"); rrc_meas_logger.info("Test enter condition for different earfcn triggers report");
enter_condition(rrctest, event_id, hyst, 2, {1, 3}); enter_condition(rrctest, event_id, hyst, 2, {1, 3});
TESTASSERT(rrctest.get_meas_res(meas_res)); TESTASSERT(rrctest.get_meas_res(meas_res));
TESTASSERT(meas_res.meas_id == 2); TESTASSERT(meas_res.meas_id == 2);
@ -1127,7 +1129,7 @@ int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave)
81 + (hyst + a3_offset) / 2); 81 + (hyst + a3_offset) / 2);
// if a new cell enters conditions then expect another report // if a new cell enters conditions then expect another report
log1->info("Test a new cell enter condition triggers report\n"); rrc_meas_logger.info("Test a new cell enter condition triggers report");
enter_condition(rrctest, event_id, hyst, 1, {1, 3}); enter_condition(rrctest, event_id, hyst, 1, {1, 3});
TESTASSERT(rrctest.get_meas_res(meas_res)); TESTASSERT(rrctest.get_meas_res(meas_res));
TESTASSERT(meas_res.meas_id == 1); TESTASSERT(meas_res.meas_id == 1);
@ -1141,14 +1143,14 @@ int a3event_report_test(uint32_t a3_offset, uint32_t hyst, bool report_on_leave)
81 + (hyst + a3_offset) / 2); 81 + (hyst + a3_offset) / 2);
// cell pci=0 exists condition // cell pci=0 exists condition
log1->info("Test exit condition\n"); rrc_meas_logger.info("Test exit condition");
exit_condition(rrctest, event_id, hyst, 1, {1, 0}); exit_condition(rrctest, event_id, hyst, 1, {1, 0});
if (report_on_leave) { if (report_on_leave) {
TESTASSERT(rrctest.get_meas_res(meas_res)); TESTASSERT(rrctest.get_meas_res(meas_res));
} }
// 2 enters again, now expect report again // 2 enters again, now expect report again
log1->info("Test trigger again the cell that exited\n"); rrc_meas_logger.info("Test trigger again the cell that exited");
enter_condition(rrctest, event_id, hyst, 1, {1, 0}); enter_condition(rrctest, event_id, hyst, 1, {1, 0});
TESTASSERT(rrctest.get_meas_res(meas_res)); TESTASSERT(rrctest.get_meas_res(meas_res));
TESTASSERT(meas_res.meas_id == 1); TESTASSERT(meas_res.meas_id == 1);
@ -1190,8 +1192,10 @@ int meas_obj_inter_rat_nr_test()
obj.meas_obj.meas_obj_nr_r15().ext = true; obj.meas_obj.meas_obj_nr_r15().ext = true;
obj.meas_obj.meas_obj_nr_r15().carrier_freq_r15 = 631680; obj.meas_obj.meas_obj_nr_r15().carrier_freq_r15 = 631680;
obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.meas_timing_cfg_r15.periodicity_and_offset_r15.set_sf20_r15(); obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.meas_timing_cfg_r15.periodicity_and_offset_r15.set_sf20_r15();
obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.meas_timing_cfg_r15.ssb_dur_r15 = asn1::rrc::mtc_ssb_nr_r15_s::ssb_dur_r15_opts::options::sf1; obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.meas_timing_cfg_r15.ssb_dur_r15 =
obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.subcarrier_spacing_ssb_r15 = asn1::rrc::rs_cfg_ssb_nr_r15_s::subcarrier_spacing_ssb_r15_opts::options::khz30; asn1::rrc::mtc_ssb_nr_r15_s::ssb_dur_r15_opts::options::sf1;
obj.meas_obj.meas_obj_nr_r15().rs_cfg_ssb_r15.subcarrier_spacing_ssb_r15 =
asn1::rrc::rs_cfg_ssb_nr_r15_s::subcarrier_spacing_ssb_r15_opts::options::khz30;
obj.meas_obj.meas_obj_nr_r15().quant_cfg_set_r15 = 1; obj.meas_obj.meas_obj_nr_r15().quant_cfg_set_r15 = 1;
obj.meas_obj.meas_obj_nr_r15().band_nr_r15.reset(new asn1::rrc::meas_obj_nr_r15_s::band_nr_r15_c_{}); obj.meas_obj.meas_obj_nr_r15().band_nr_r15.reset(new asn1::rrc::meas_obj_nr_r15_s::band_nr_r15_c_{});
obj.meas_obj.meas_obj_nr_r15().band_nr_r15->set_setup() = 78; obj.meas_obj.meas_obj_nr_r15().band_nr_r15->set_setup() = 78;
@ -1215,12 +1219,16 @@ int meas_obj_inter_rat_nr_test()
rep.report_cfg.report_cfg_inter_rat().ext = true; rep.report_cfg.report_cfg_inter_rat().ext = true;
rep.report_cfg.report_cfg_inter_rat().trigger_type.set_event(); rep.report_cfg.report_cfg_inter_rat().trigger_type.set_event();
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.set_event_b1_nr_r15(); rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.set_event_b1_nr_r15();
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.event_b1_nr_r15().b1_thres_nr_r15.set_nr_rsrp_r15(); rep.report_cfg.report_cfg_inter_rat()
.trigger_type.event()
.event_id.event_b1_nr_r15()
.b1_thres_nr_r15.set_nr_rsrp_r15();
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15() = rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.event_b1_nr_r15().b1_thres_nr_r15.nr_rsrp_r15() =
56; 56;
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.event_b1_nr_r15().report_on_leave_r15 = true; rep.report_cfg.report_cfg_inter_rat().trigger_type.event().event_id.event_b1_nr_r15().report_on_leave_r15 = true;
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().hysteresis = 0; rep.report_cfg.report_cfg_inter_rat().trigger_type.event().hysteresis = 0;
rep.report_cfg.report_cfg_inter_rat().trigger_type.event().time_to_trigger = asn1::rrc::time_to_trigger_opts::options::ms100; rep.report_cfg.report_cfg_inter_rat().trigger_type.event().time_to_trigger =
asn1::rrc::time_to_trigger_opts::options::ms100;
rep.report_cfg.report_cfg_inter_rat().max_report_cells = 8; rep.report_cfg.report_cfg_inter_rat().max_report_cells = 8;
rep.report_cfg.report_cfg_inter_rat().report_interv = asn1::rrc::report_interv_opts::options::ms120; rep.report_cfg.report_cfg_inter_rat().report_interv = asn1::rrc::report_interv_opts::options::ms120;
rep.report_cfg.report_cfg_inter_rat().report_amount = asn1::rrc::report_cfg_inter_rat_s::report_amount_opts::r1; rep.report_cfg.report_cfg_inter_rat().report_amount = asn1::rrc::report_cfg_inter_rat_s::report_amount_opts::r1;
@ -1251,7 +1259,7 @@ int meas_obj_inter_rat_nr_test()
int ttt_iters = 100 + 1; // 100 ms int ttt_iters = 100 + 1; // 100 ms
for (int i = 0; i < ttt_iters; i++) { for (int i = 0; i < ttt_iters; i++) {
log1->info("Report %d/%d enter condition is true\n", i, ttt_iters); srslog::fetch_basic_logger("RRC_MEAS").info("Report %d/%d enter condition is true", i, ttt_iters);
rrctest.add_neighbour_cell_nr(500, 631680, -60.0); rrctest.add_neighbour_cell_nr(500, 631680, -60.0);
} }
@ -1261,6 +1269,15 @@ int meas_obj_inter_rat_nr_test()
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
auto& rrc_meas_logger = srslog::fetch_basic_logger("RRC_MEAS", false);
rrc_meas_logger.set_level(srslog::basic_levels::debug);
rrc_meas_logger.set_hex_dump_max_size(-1);
auto& rrc_logger = srslog::fetch_basic_logger("RRC", false);
rrc_logger.set_level(srslog::basic_levels::debug);
rrc_logger.set_hex_dump_max_size(-1);
srslog::init();
TESTASSERT(cell_select_test() == SRSLTE_SUCCESS); TESTASSERT(cell_select_test() == SRSLTE_SUCCESS);
TESTASSERT(meas_obj_test() == SRSLTE_SUCCESS); TESTASSERT(meas_obj_test() == SRSLTE_SUCCESS);
TESTASSERT(meas_obj_inter_rat_nr_test() == SRSLTE_SUCCESS); TESTASSERT(meas_obj_inter_rat_nr_test() == SRSLTE_SUCCESS);

9
srsue/test/upper/rrc_reconfig_test.cc
Unescape Escape View File

@ -13,6 +13,7 @@
#include "srslte/asn1/liblte_mme.h" #include "srslte/asn1/liblte_mme.h"
#include "srslte/asn1/rrc/dl_dcch_msg.h" #include "srslte/asn1/rrc/dl_dcch_msg.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/srslog/srslog.h"
#include <iostream> #include <iostream>
#include <srslte/srslte.h> #include <srslte/srslte.h>
@ -146,6 +147,14 @@ int meas_obj_test()
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
auto& nas_logger = srslog::fetch_basic_logger("NAS", false);
nas_logger.set_level(srslog::basic_levels::debug);
nas_logger.set_hex_dump_max_size(-1);
auto& rrc_logger = srslog::fetch_basic_logger("RRC", false);
rrc_logger.set_level(srslog::basic_levels::debug);
rrc_logger.set_hex_dump_max_size(-1);
srslog::init();
TESTASSERT(meas_obj_test() == 0); TESTASSERT(meas_obj_test() == 0);
TESTASSERT(nas_test() == 0); TESTASSERT(nas_test() == 0);
} }

71
srsue/test/upper/tft_test.cc
Unescape Escape View File

@ -105,9 +105,7 @@ uint8_t ipv6_unmatched_packet_lport[] = {
int tft_filter_test_ipv6_combined() int tft_filter_test_ipv6_combined()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2, ip_msg3, ip_msg4, ip_msg5; srslte::unique_byte_buffer_t ip_msg1, ip_msg2, ip_msg3, ip_msg4, ip_msg5;
ip_msg1 = allocate_unique_buffer(*pool); ip_msg1 = allocate_unique_buffer(*pool);
@ -119,27 +117,27 @@ int tft_filter_test_ipv6_combined()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = sizeof(ipv6_matched_packet); ip_msg1->N_bytes = sizeof(ipv6_matched_packet);
memcpy(ip_msg1->msg, ipv6_matched_packet, sizeof(ipv6_matched_packet)); memcpy(ip_msg1->msg, ipv6_matched_packet, sizeof(ipv6_matched_packet));
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IPv6 test message - match\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IPv6 test message - match");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = sizeof(ipv6_unmatched_packet_tcp); ip_msg2->N_bytes = sizeof(ipv6_unmatched_packet_tcp);
memcpy(ip_msg2->msg, ipv6_unmatched_packet_tcp, sizeof(ipv6_unmatched_packet_tcp)); memcpy(ip_msg2->msg, ipv6_unmatched_packet_tcp, sizeof(ipv6_unmatched_packet_tcp));
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IPv6 test message - unmatched tcp\n"); logger.info(ip_msg2->msg, ip_msg2->N_bytes, "IPv6 test message - unmatched tcp");
// Set IP test message // Set IP test message
ip_msg3->N_bytes = sizeof(ipv6_unmatched_packet_daddr); ip_msg3->N_bytes = sizeof(ipv6_unmatched_packet_daddr);
memcpy(ip_msg3->msg, ipv6_unmatched_packet_daddr, sizeof(ipv6_unmatched_packet_daddr)); memcpy(ip_msg3->msg, ipv6_unmatched_packet_daddr, sizeof(ipv6_unmatched_packet_daddr));
log1.info_hex(ip_msg3->msg, ip_msg3->N_bytes, "IPv6 test message - unmatched daddr\n"); logger.info(ip_msg3->msg, ip_msg3->N_bytes, "IPv6 test message - unmatched daddr");
// Set IP test message // Set IP test message
ip_msg4->N_bytes = sizeof(ipv6_unmatched_packet_rport); ip_msg4->N_bytes = sizeof(ipv6_unmatched_packet_rport);
memcpy(ip_msg4->msg, ipv6_unmatched_packet_rport, sizeof(ipv6_unmatched_packet_rport)); memcpy(ip_msg4->msg, ipv6_unmatched_packet_rport, sizeof(ipv6_unmatched_packet_rport));
log1.info_hex(ip_msg4->msg, ip_msg4->N_bytes, "IPv6 test message - unmatched rport\n"); logger.info(ip_msg4->msg, ip_msg4->N_bytes, "IPv6 test message - unmatched rport");
// Set IP test message // Set IP test message
ip_msg5->N_bytes = sizeof(ipv6_unmatched_packet_lport); ip_msg5->N_bytes = sizeof(ipv6_unmatched_packet_lport);
memcpy(ip_msg5->msg, ipv6_unmatched_packet_lport, sizeof(ipv6_unmatched_packet_lport)); memcpy(ip_msg5->msg, ipv6_unmatched_packet_lport, sizeof(ipv6_unmatched_packet_lport));
log1.info_hex(ip_msg5->msg, ip_msg5->N_bytes, "IPv6 test message - unmatched lport\n"); logger.info(ip_msg5->msg, ip_msg5->N_bytes, "IPv6 test message - unmatched lport");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -150,7 +148,7 @@ int tft_filter_test_ipv6_combined()
packet_filter.filter_size = sizeof(ipv6_filter); packet_filter.filter_size = sizeof(ipv6_filter);
memcpy(packet_filter.filter, ipv6_filter, sizeof(ipv6_filter)); memcpy(packet_filter.filter, ipv6_filter, sizeof(ipv6_filter));
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -165,9 +163,7 @@ int tft_filter_test_ipv6_combined()
int tft_filter_test_single_local_port() int tft_filter_test_single_local_port()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
@ -184,12 +180,12 @@ int tft_filter_test_single_local_port()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = ip_message_len1; ip_msg1->N_bytes = ip_message_len1;
memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1); memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1);
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = ip_message_len2; ip_msg2->N_bytes = ip_message_len2;
memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len1); memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len1);
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IP test message\n"); logger.info(ip_msg2->msg, ip_msg2->N_bytes, "IP test message");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -200,7 +196,7 @@ int tft_filter_test_single_local_port()
packet_filter.filter_size = 3; packet_filter.filter_size = 3;
memcpy(packet_filter.filter, filter_message, 3); memcpy(packet_filter.filter, filter_message, 3);
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -212,9 +208,7 @@ int tft_filter_test_single_local_port()
int tft_filter_test_single_remote_port() int tft_filter_test_single_remote_port()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
@ -231,12 +225,12 @@ int tft_filter_test_single_remote_port()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = ip_message_len1; ip_msg1->N_bytes = ip_message_len1;
memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1); memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1);
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = ip_message_len2; ip_msg2->N_bytes = ip_message_len2;
memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len1); memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len1);
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IP test message\n"); logger.info(ip_msg2->msg, ip_msg2->N_bytes, "IP test message");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -247,7 +241,7 @@ int tft_filter_test_single_remote_port()
packet_filter.filter_size = 3; packet_filter.filter_size = 3;
memcpy(packet_filter.filter, filter_message, 3); memcpy(packet_filter.filter, filter_message, 3);
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -259,9 +253,7 @@ int tft_filter_test_single_remote_port()
int tft_filter_test_ipv4_local_addr() int tft_filter_test_ipv4_local_addr()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
@ -281,12 +273,12 @@ int tft_filter_test_ipv4_local_addr()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = ip_message_len1; ip_msg1->N_bytes = ip_message_len1;
memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1); memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1);
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = ip_message_len2; ip_msg2->N_bytes = ip_message_len2;
memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2); memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2);
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -297,7 +289,7 @@ int tft_filter_test_ipv4_local_addr()
packet_filter.filter_size = filter_size; packet_filter.filter_size = filter_size;
memcpy(packet_filter.filter, filter_message, filter_size); memcpy(packet_filter.filter, filter_message, filter_size);
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -309,9 +301,7 @@ int tft_filter_test_ipv4_local_addr()
int tft_filter_test_ipv4_remote_addr() int tft_filter_test_ipv4_remote_addr()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
@ -330,12 +320,12 @@ int tft_filter_test_ipv4_remote_addr()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = ip_message_len1; ip_msg1->N_bytes = ip_message_len1;
memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1); memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1);
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = ip_message_len2; ip_msg2->N_bytes = ip_message_len2;
memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2); memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2);
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IP test message\n"); logger.info(ip_msg2->msg, ip_msg2->N_bytes, "IP test message");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -346,7 +336,7 @@ int tft_filter_test_ipv4_remote_addr()
packet_filter.filter_size = filter_size; packet_filter.filter_size = filter_size;
memcpy(packet_filter.filter, filter_message, filter_size); memcpy(packet_filter.filter, filter_message, filter_size);
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -358,9 +348,7 @@ int tft_filter_test_ipv4_remote_addr()
int tft_filter_test_ipv4_tos() int tft_filter_test_ipv4_tos()
{ {
srslte::log_filter log1("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
@ -380,12 +368,12 @@ int tft_filter_test_ipv4_tos()
// Set IP test message // Set IP test message
ip_msg1->N_bytes = ip_message_len1; ip_msg1->N_bytes = ip_message_len1;
memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1); memcpy(ip_msg1->msg, ip_tst_message1, ip_message_len1);
log1.info_hex(ip_msg1->msg, ip_msg1->N_bytes, "IP test message\n"); logger.info(ip_msg1->msg, ip_msg1->N_bytes, "IP test message");
// Set IP test message // Set IP test message
ip_msg2->N_bytes = ip_message_len2; ip_msg2->N_bytes = ip_message_len2;
memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2); memcpy(ip_msg2->msg, ip_tst_message2, ip_message_len2);
log1.info_hex(ip_msg2->msg, ip_msg2->N_bytes, "IP test message\n"); logger.info(ip_msg2->msg, ip_msg2->N_bytes, "IP test message");
// Packet filter // Packet filter
LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter; LIBLTE_MME_PACKET_FILTER_STRUCT packet_filter;
@ -396,7 +384,7 @@ int tft_filter_test_ipv4_tos()
packet_filter.filter_size = filter_size; packet_filter.filter_size = filter_size;
memcpy(packet_filter.filter, filter_message, filter_size); memcpy(packet_filter.filter, filter_message, filter_size);
srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, &log1); srsue::tft_packet_filter_t filter(EPS_BEARER_ID, LCID, packet_filter, logger);
// Check filter // Check filter
TESTASSERT(filter.match(ip_msg1)); TESTASSERT(filter.match(ip_msg1));
@ -408,6 +396,11 @@ int tft_filter_test_ipv4_tos()
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT", false);
logger.set_level(srslog::basic_levels::debug);
logger.set_hex_dump_max_size(128);
srslog::init();
srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_pool::get_instance();
if (tft_filter_test_single_local_port()) { if (tft_filter_test_single_local_port()) {
return -1; return -1;

19
srsue/test/upper/usim_test.cc
Unescape Escape View File

@ -10,10 +10,8 @@
* *
*/ */
#include "srslte/common/log_filter.h"
#include "srslte/common/test_common.h" #include "srslte/common/test_common.h"
#include "srsue/hdr/stack/upper/usim.h" #include "srsue/hdr/stack/upper/usim.h"
#include <iostream>
using namespace srsue; using namespace srsue;
@ -45,15 +43,20 @@ AUTN : d7.44.51.9b.25.aa.80.00.84.ba.37.b0.f6.73.4d.d1.
KASME : a8.27.57.5e.ea.1a.10.17.3a.a1.bf.ce.4b.0c.21.85.e0.51.ef.bd.91.7f.fe.f5.1f.74.29.61.f9.03.7a.35. KASME : a8.27.57.5e.ea.1a.10.17.3a.a1.bf.ce.4b.0c.21.85.e0.51.ef.bd.91.7f.fe.f5.1f.74.29.61.f9.03.7a.35.
*/ */
uint8_t rand_enb[] = {0x88, 0x38, 0xc3, 0x55, 0xc8, 0x78, 0xaa, 0x57, 0x21, 0x49, 0xfe, 0x69, 0xdb, 0x68, 0x6b, 0x5a}; static uint8_t rand_enb[] =
uint8_t autn_enb[] = {0xd7, 0x44, 0x51, 0x9b, 0x25, 0xaa, 0x80, 0x00, 0x84, 0xba, 0x37, 0xb0, 0xf6, 0x73, 0x4d, 0xd1}; {0x88, 0x38, 0xc3, 0x55, 0xc8, 0x78, 0xaa, 0x57, 0x21, 0x49, 0xfe, 0x69, 0xdb, 0x68, 0x6b, 0x5a};
static uint8_t autn_enb[] =
{0xd7, 0x44, 0x51, 0x9b, 0x25, 0xaa, 0x80, 0x00, 0x84, 0xba, 0x37, 0xb0, 0xf6, 0x73, 0x4d, 0xd1};
uint16 mcc = 208; static constexpr uint16 mcc = 208;
uint16 mnc = 93; static constexpr uint16 mnc = 93;
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
srslte::log_filter usim_log("USIM"); auto& logger = srslog::fetch_basic_logger("USIM", false);
// Start the log backend.
srslog::init();
uint8_t res[16]; uint8_t res[16];
int res_len; int res_len;
uint8_t k_asme[32]; uint8_t k_asme[32];
@ -66,7 +69,7 @@ int main(int argc, char** argv)
args.using_op = true; args.using_op = true;
args.op = "11111111111111111111111111111111"; args.op = "11111111111111111111111111111111";
srsue::usim usim(&usim_log); srsue::usim usim(logger);
usim.init(&args); usim.init(&args);
TESTASSERT(usim.generate_authentication_response(rand_enb, autn_enb, mcc, mnc, res, &res_len, k_asme) == AUTH_OK); TESTASSERT(usim.generate_authentication_response(rand_enb, autn_enb, mcc, mnc, res, &res_len, k_asme) == AUTH_OK);

Write Preview
Loading…
Cancel
Save