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

turn PDCP array into map

Browse Source
master
Andre Puschmann 7 years ago
parent b257204471
commit 93c11e4416
4 changed files with 100 additions and 54 deletions
Show Stats Download Patch File Download Diff File

17
lib/include/srslte/upper/pdcp.h
Unescape Escape View File

@ -41,7 +41,7 @@ class pdcp
{
public:
pdcp();
virtual ~pdcp(){}
~pdcp();
void init(srsue::rlc_interface_pdcp *rlc_,
srsue::rrc_interface_pdcp *rrc_,
srsue::gw_interface_pdcp *gw_,
@ -79,17 +79,20 @@ public:
void write_pdu_bcch_dlsch(byte_buffer_t *sdu);
void write_pdu_pcch(byte_buffer_t *sdu);
private:
srsue::rlc_interface_pdcp *rlc;
srsue::rrc_interface_pdcp *rrc;
srsue::gw_interface_pdcp *gw;
log *pdcp_log;
pdcp_entity pdcp_array[SRSLTE_N_RADIO_BEARERS];
pdcp_entity pdcp_array_mrb[SRSLTE_N_MCH_LCIDS];
uint32_t lcid; // default LCID that is maintained active by PDCP instance
uint8_t direction;
typedef std::map<uint16_t, pdcp_entity_interface*> pdcp_map_t;
typedef std::pair<uint16_t, pdcp_entity_interface*> pdcp_map_pair_t;
log *pdcp_log;
pdcp_map_t pdcp_array, pdcp_array_mrb;
// default PDCP entity that is maintained active by PDCP instance
srslte_pdcp_config_t default_cnfg;
uint32_t default_lcid;
bool valid_lcid(uint32_t lcid);
bool valid_mch_lcid(uint32_t lcid);

3
lib/include/srslte/upper/pdcp_entity.h
Unescape Escape View File

@ -33,6 +33,7 @@
#include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/security.h"
#include "srslte/common/threads.h"
#include "pdcp_interface.h"
namespace srslte {
@ -59,7 +60,7 @@ static const char pdcp_d_c_text[PDCP_D_C_N_ITEMS][20] = {"Control PDU",
* PDCP Entity interface
* Common interface for all PDCP entities
***************************************************************************/
class pdcp_entity
class pdcp_entity : public pdcp_entity_interface
{
public:
pdcp_entity();

1
lib/include/srslte/upper/pdcp_interface.h
Unescape Escape View File

@ -43,6 +43,7 @@ namespace srslte {
class pdcp_entity_interface
{
public:
virtual ~pdcp_entity_interface() {};
virtual void init(srsue::rlc_interface_pdcp *rlc_,
srsue::rrc_interface_pdcp *rrc_,
srsue::gw_interface_pdcp *gw_,

133
lib/src/upper/pdcp.cc
Unescape Escape View File

@ -35,47 +35,69 @@ pdcp::pdcp()
rrc = NULL;
gw = NULL;
pdcp_log = NULL;
lcid = 0;
direction = 0;
default_lcid = 0;
}
pdcp::~pdcp()
{
// destroy all remaining entities
for (pdcp_map_t::iterator it = pdcp_array.begin(); it != pdcp_array.end(); ++it) {
delete(it->second);
}
pdcp_array.clear();
}
void pdcp::init(srsue::rlc_interface_pdcp *rlc_, srsue::rrc_interface_pdcp *rrc_, srsue::gw_interface_pdcp *gw_, log *pdcp_log_, uint32_t lcid_, uint8_t direction_)
{
rlc = rlc_;
rrc = rrc_;
gw = gw_;
pdcp_log = pdcp_log_;
lcid = lcid_;
direction = direction_;
rlc = rlc_;
rrc = rrc_;
gw = gw_;
pdcp_log = pdcp_log_;
default_lcid = lcid_;
// Default config
srslte_pdcp_config_t cnfg;
cnfg.is_control = false;
cnfg.is_data = false;
cnfg.direction = direction_;
default_cnfg.is_control = false;
default_cnfg.is_data = false;
default_cnfg.direction = direction_;
pdcp_array[0].init(rlc, rrc, gw, pdcp_log, lcid, cnfg);
// create default PDCP entity for SRB0
if (not pdcp_array.insert(pdcp_map_pair_t(0, new pdcp_entity())).second) {
pdcp_log->error("Error inserting PDCP entity in to array\n.");
return;
}
pdcp_array.at(0)->init(rlc, rrc, gw, pdcp_log, default_lcid, default_cnfg);
}
void pdcp::stop()
{
// destroy default entity
if (valid_lcid(0)) {
pdcp_map_t::iterator it;
it = pdcp_array.find(0);
delete(it->second);
pdcp_array.erase(it);
}
}
void pdcp::reestablish() {
for(uint32_t i=0;i<SRSLTE_N_RADIO_BEARERS;i++) {
if (pdcp_array[i].is_active()) {
pdcp_array[i].reestablish();
for (uint32_t i = 0; i < SRSLTE_N_RADIO_BEARERS; i++) {
if (valid_lcid(i)) {
pdcp_array.at(i)->reestablish();
}
}
}
void pdcp::reset()
{
for(uint32_t i=0;i<SRSLTE_N_RADIO_BEARERS;i++) {
pdcp_array[i].reset();
for (uint32_t i = 0; i < SRSLTE_N_RADIO_BEARERS; i++) {
if (valid_lcid(i)) {
pdcp_array.at(i)->reset();
}
}
pdcp_array[0].init(rlc, rrc, gw, pdcp_log, lcid, direction);
if (valid_lcid(0)) {
pdcp_array.at(0)->init(rlc, rrc, gw, pdcp_log, default_lcid, default_cnfg);
}
}
/*******************************************************************************
@ -83,17 +105,20 @@ void pdcp::reset()
*******************************************************************************/
bool pdcp::is_drb_enabled(uint32_t lcid)
{
if(lcid >= SRSLTE_N_RADIO_BEARERS) {
if (lcid >= SRSLTE_N_RADIO_BEARERS) {
pdcp_log->error("Radio bearer id must be in [0:%d] - %d\n", SRSLTE_N_RADIO_BEARERS, lcid);
return false;
}
return pdcp_array[lcid].is_active();
if (pdcp_array.find(lcid) == pdcp_array.end()) {
return false;
}
return pdcp_array.at(lcid)->is_active();
}
void pdcp::write_sdu(uint32_t lcid, byte_buffer_t *sdu)
{
if(valid_lcid(lcid)) {
pdcp_array[lcid].write_sdu(sdu);
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->write_sdu(sdu);
} else {
pdcp_log->warning("Writing sdu: lcid=%d. Deallocating sdu\n", lcid);
byte_buffer_pool::get_instance()->deallocate(sdu);
@ -102,18 +127,23 @@ void pdcp::write_sdu(uint32_t lcid, byte_buffer_t *sdu)
void pdcp::write_sdu_mch(uint32_t lcid, byte_buffer_t *sdu)
{
if(valid_mch_lcid(lcid)){
pdcp_array_mrb[lcid].write_sdu(sdu);
if (valid_mch_lcid(lcid)){
pdcp_array_mrb.at(lcid)->write_sdu(sdu);
}
}
void pdcp::add_bearer(uint32_t lcid, srslte_pdcp_config_t cfg)
{
if(lcid >= SRSLTE_N_RADIO_BEARERS) {
if (lcid >= SRSLTE_N_RADIO_BEARERS) {
pdcp_log->error("Radio bearer id must be in [0:%d] - %d\n", SRSLTE_N_RADIO_BEARERS, lcid);
return;
}
if (!pdcp_array[lcid].is_active()) {
pdcp_array[lcid].init(rlc, rrc, gw, pdcp_log, lcid, cfg);
if (not valid_lcid(lcid)) {
if (not pdcp_array.insert(pdcp_map_pair_t(lcid, new pdcp_entity())).second) {
pdcp_log->error("Error inserting PDCP entity in to array\n.");
return;
}
pdcp_array.at(lcid)->init(rlc, rrc, gw, pdcp_log, lcid, cfg);
pdcp_log->info("Added bearer %s\n", rrc->get_rb_name(lcid).c_str());
} else {
pdcp_log->warning("Bearer %s already configured. Reconfiguration not supported\n", rrc->get_rb_name(lcid).c_str());
@ -123,12 +153,16 @@ void pdcp::add_bearer(uint32_t lcid, srslte_pdcp_config_t cfg)
void pdcp::add_bearer_mrb(uint32_t lcid, srslte_pdcp_config_t cfg)
{
if(lcid >= SRSLTE_N_RADIO_BEARERS) {
if (lcid >= SRSLTE_N_RADIO_BEARERS) {
pdcp_log->error("Radio bearer id must be in [0:%d] - %d\n", SRSLTE_N_RADIO_BEARERS, lcid);
return;
}
if (!pdcp_array_mrb[lcid].is_active()) {
pdcp_array_mrb[lcid].init(rlc, rrc, gw, pdcp_log, lcid, cfg);
if (not valid_mch_lcid(lcid)) {
if (pdcp_array_mrb.insert(pdcp_map_pair_t(lcid, new pdcp_entity())).second) {
pdcp_log->error("Error inserting PDCP entity in to array\n.");
return;
}
pdcp_array_mrb.at(lcid)->init(rlc, rrc, gw, pdcp_log, lcid, cfg);
pdcp_log->info("Added bearer %s\n", rrc->get_rb_name(lcid).c_str());
} else {
pdcp_log->warning("Bearer %s already configured. Reconfiguration not supported\n", rrc->get_rb_name(lcid).c_str());
@ -141,8 +175,9 @@ void pdcp::config_security(uint32_t lcid,
CIPHERING_ALGORITHM_ID_ENUM cipher_algo,
INTEGRITY_ALGORITHM_ID_ENUM integ_algo)
{
if(valid_lcid(lcid))
pdcp_array[lcid].config_security(k_enc, k_int, cipher_algo, integ_algo);
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->config_security(k_enc, k_int, cipher_algo, integ_algo);
}
}
void pdcp::config_security_all(uint8_t *k_enc,
@ -151,22 +186,24 @@ void pdcp::config_security_all(uint8_t *k_enc,
INTEGRITY_ALGORITHM_ID_ENUM integ_algo)
{
for(uint32_t i=0;i<SRSLTE_N_RADIO_BEARERS;i++) {
if (pdcp_array[i].is_active()) {
pdcp_array[i].config_security(k_enc, k_int, cipher_algo, integ_algo);
if (pdcp_array.at(i)->is_active()) {
pdcp_array.at(i)->config_security(k_enc, k_int, cipher_algo, integ_algo);
}
}
}
void pdcp::enable_integrity(uint32_t lcid)
{
if(valid_lcid(lcid))
pdcp_array[lcid].enable_integrity();
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->enable_integrity();
}
}
void pdcp::enable_encryption(uint32_t lcid)
{
if(valid_lcid(lcid))
pdcp_array[lcid].enable_encryption();
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->enable_encryption();
}
}
/*******************************************************************************
@ -174,8 +211,8 @@ void pdcp::enable_encryption(uint32_t lcid)
*******************************************************************************/
void pdcp::write_pdu(uint32_t lcid, byte_buffer_t *pdu)
{
if(valid_lcid(lcid)) {
pdcp_array[lcid].write_pdu(pdu);
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->write_pdu(pdu);
} else {
pdcp_log->warning("Writing pdu: lcid=%d. Deallocating pdu\n", lcid);
byte_buffer_pool::get_instance()->deallocate(pdu);
@ -198,7 +235,7 @@ void pdcp::write_pdu_pcch(byte_buffer_t *sdu)
void pdcp::write_pdu_mch(uint32_t lcid, byte_buffer_t *sdu)
{
if(0 == lcid) {
if (0 == lcid) {
rrc->write_pdu_mch(lcid, sdu);
} else {
gw->write_pdu_mch(lcid, sdu);
@ -210,27 +247,31 @@ void pdcp::write_pdu_mch(uint32_t lcid, byte_buffer_t *sdu)
*******************************************************************************/
bool pdcp::valid_lcid(uint32_t lcid)
{
if(lcid >= SRSLTE_N_RADIO_BEARERS) {
if (lcid >= SRSLTE_N_RADIO_BEARERS) {
pdcp_log->error("Radio bearer id must be in [0:%d] - %d", SRSLTE_N_RADIO_BEARERS, lcid);
return false;
}
if(!pdcp_array[lcid].is_active()) {
if (pdcp_array.find(lcid) == pdcp_array.end()) {
pdcp_log->error("PDCP entity for logical channel %d has not been activated\n", lcid);
return false;
}
return true;
}
bool pdcp::valid_mch_lcid(uint32_t lcid)
{
if(lcid >= SRSLTE_N_MCH_LCIDS) {
if (lcid >= SRSLTE_N_MCH_LCIDS) {
pdcp_log->error("Radio bearer id must be in [0:%d] - %d", SRSLTE_N_RADIO_BEARERS, lcid);
return false;
}
if(!pdcp_array_mrb[lcid].is_active()) {
if (pdcp_array_mrb.find(lcid) == pdcp_array_mrb.end()) {
pdcp_log->error("PDCP entity for logical channel %d has not been activated\n", lcid);
return false;
}
return true;
}

Write Preview
Loading…
Cancel
Save