From 0976ea6f274fc50790c2e3658f5f1dc190725064 Mon Sep 17 00:00:00 2001 From: Francisco Paisana Date: Mon, 29 Apr 2019 20:16:51 +0100 Subject: [PATCH] created a unique byte buffer that automatically deallocates --- lib/include/srslte/common/block_queue.h | 4 +- lib/include/srslte/common/buffer_pool.h | 19 +++ lib/include/srslte/common/common.h | 74 ++++++++++++ .../srslte/interfaces/enb_interfaces.h | 2 +- lib/include/srslte/interfaces/ue_interfaces.h | 34 +++--- lib/include/srslte/upper/pdcp.h | 14 +-- lib/include/srslte/upper/pdcp_entity.h | 4 +- lib/include/srslte/upper/pdcp_interface.h | 4 +- lib/include/srslte/upper/rlc.h | 4 +- lib/include/srslte/upper/rlc_am.h | 4 +- lib/include/srslte/upper/rlc_common.h | 2 +- lib/include/srslte/upper/rlc_tx_queue.h | 30 ++--- lib/src/upper/pdcp.cc | 32 +++-- lib/src/upper/pdcp_entity.cc | 23 ++-- lib/src/upper/rlc.cc | 7 +- lib/src/upper/rlc_am.cc | 14 +-- srsenb/hdr/upper/gtpu.h | 2 +- srsenb/hdr/upper/pdcp.h | 4 +- srsenb/src/upper/gtpu.cc | 40 +++---- srsenb/src/upper/pdcp.cc | 4 +- srsue/hdr/upper/nas.h | 2 +- srsue/hdr/upper/rrc.h | 35 +++--- srsue/src/upper/rrc.cc | 109 ++++++++---------- 23 files changed, 263 insertions(+), 204 deletions(-) diff --git a/lib/include/srslte/common/block_queue.h b/lib/include/srslte/common/block_queue.h index 7de092985..a461a0f7b 100644 --- a/lib/include/srslte/common/block_queue.h +++ b/lib/include/srslte/common/block_queue.h @@ -119,9 +119,7 @@ public: while (try_pop(item)); } - myobj front() { - return q.front(); - } + myobj& front() { return q.front(); } size_t size() { return q.size(); diff --git a/lib/include/srslte/common/buffer_pool.h b/lib/include/srslte/common/buffer_pool.h index eccc3b703..7b7f78cea 100644 --- a/lib/include/srslte/common/buffer_pool.h +++ b/lib/include/srslte/common/buffer_pool.h @@ -222,6 +222,25 @@ private: buffer_pool *pool; }; +inline bool byte_buffer_guard::allocate() +{ + deallocate(); + buf = pool->allocate(); + if (buf == nullptr) { + // allocation failed + pool = nullptr; + return false; + } + return true; +} + +inline void byte_buffer_guard::deallocate() +{ + if (buf != nullptr) { + pool->deallocate(buf); + buf = nullptr; + } +} } // namespace srsue diff --git a/lib/include/srslte/common/common.h b/lib/include/srslte/common/common.h index 438acd7ac..18d430abb 100644 --- a/lib/include/srslte/common/common.h +++ b/lib/include/srslte/common/common.h @@ -266,6 +266,80 @@ private: #endif }; +class byte_buffer_pool; +class byte_buffer_guard +{ +public: + byte_buffer_guard(byte_buffer_pool* pool_) : pool(pool_) {} + byte_buffer_guard(byte_buffer_t* buf_, byte_buffer_pool* pool_) : buf(buf_), pool(pool_) {} + byte_buffer_guard(const byte_buffer_guard& other) = delete; + byte_buffer_guard& operator=(const byte_buffer_guard& other) = delete; + // move ctor + byte_buffer_guard(byte_buffer_guard&& other) + { + printf("In move ctor\n"); + buf = other.buf; + pool = other.pool; + other.buf = nullptr; + } + + byte_buffer_guard& operator=(byte_buffer_guard&& other) noexcept + { + printf("in copy move ctor\n"); + if (this == &other) { + return *this; + } + this->buf = other.buf; + this->pool = other.pool; + other.buf = nullptr; + return *this; + } + + ~byte_buffer_guard() { deallocate(); } + + void set_pool(byte_buffer_pool* pool_) + { + deallocate(); + pool = pool_; + } + + // acquire already alloc buffer + void acquire(byte_buffer_t* buf_) { buf = buf_; } + // allocate buffer + // bool allocate() { + // deallocate(); + // buf = pool->allocate(); + // if(buf == nullptr) { + // // allocation failed + // pool = nullptr; + // return false; + // } + // return true; + // } + bool allocate(); + void deallocate(); + + byte_buffer_t* operator->() { return buf; } + const byte_buffer_t* operator->() const { return buf; } + + byte_buffer_t* get() { return buf; } + const byte_buffer_t* get() const { return buf; } + const byte_buffer_pool* get_pool() const { return pool; } + +private: + byte_buffer_t* buf = nullptr; + byte_buffer_pool* pool; + + // void deallocate() { + // if (buf != nullptr) { + // printf("called dealloc!\n"); + // pool->deallocate(buf); + // } + // } +}; + +typedef byte_buffer_guard unique_pool_buffer; + } // namespace srslte #endif // SRSLTE_COMMON_H diff --git a/lib/include/srslte/interfaces/enb_interfaces.h b/lib/include/srslte/interfaces/enb_interfaces.h index 7b55e9b04..7c77d71e5 100644 --- a/lib/include/srslte/interfaces/enb_interfaces.h +++ b/lib/include/srslte/interfaces/enb_interfaces.h @@ -199,7 +199,7 @@ public: class pdcp_interface_gtpu { public: - virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu) = 0; + virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_pool_buffer sdu) = 0; }; // PDCP interface for RRC diff --git a/lib/include/srslte/interfaces/ue_interfaces.h b/lib/include/srslte/interfaces/ue_interfaces.h index d8091d739..6d21bbdad 100644 --- a/lib/include/srslte/interfaces/ue_interfaces.h +++ b/lib/include/srslte/interfaces/ue_interfaces.h @@ -114,8 +114,8 @@ public: class gw_interface_pdcp { public: - virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0; - virtual void write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0; + virtual void write_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu) = 0; + virtual void write_pdu_mch(uint32_t lcid, srslte::unique_pool_buffer pdu) = 0; }; // NAS interface for RRC @@ -132,7 +132,7 @@ public: virtual void set_barring(barring_t barring) = 0; virtual void paging(asn1::rrc::s_tmsi_s* ue_identiy) = 0; virtual bool is_attached() = 0; - virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0; + virtual void write_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu) = 0; virtual uint32_t get_k_enb_count() = 0; virtual bool get_k_asme(uint8_t *k_asme_, uint32_t n) = 0; virtual uint32_t get_ipv4_addr() = 0; @@ -189,7 +189,7 @@ public: const static int MAX_FOUND_PLMNS = 16; - virtual void write_sdu(srslte::byte_buffer_t *sdu) = 0; + virtual void write_sdu(srslte::unique_pool_buffer sdu) = 0; virtual uint16_t get_mcc() = 0; virtual uint16_t get_mnc() = 0; virtual void enable_capabilities() = 0; @@ -205,11 +205,11 @@ public: class rrc_interface_pdcp { public: - virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0; - virtual void write_pdu_bcch_bch(srslte::byte_buffer_t *pdu) = 0; - virtual void write_pdu_bcch_dlsch(srslte::byte_buffer_t *pdu) = 0; - virtual void write_pdu_pcch(srslte::byte_buffer_t *pdu) = 0; - virtual void write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0; + virtual void write_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu) = 0; + virtual void write_pdu_bcch_bch(srslte::unique_pool_buffer pdu) = 0; + virtual void write_pdu_bcch_dlsch(srslte::unique_pool_buffer pdu) = 0; + virtual void write_pdu_pcch(srslte::unique_pool_buffer pdu) = 0; + virtual void write_pdu_mch(uint32_t lcid, srslte::unique_pool_buffer pdu) = 0; virtual std::string get_rb_name(uint32_t lcid) = 0; }; @@ -225,7 +225,7 @@ public: class pdcp_interface_gw { public: - virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu, bool blocking) = 0; + virtual void write_sdu(uint32_t lcid, srslte::unique_pool_buffer sdu, bool blocking) = 0; virtual bool is_lcid_enabled(uint32_t lcid) = 0; }; @@ -235,7 +235,7 @@ class pdcp_interface_rrc public: virtual void reestablish() = 0; virtual void reset() = 0; - virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu, bool blocking = true) = 0; + virtual void write_sdu(uint32_t lcid, srslte::unique_pool_buffer sdu, bool blocking = true) = 0; virtual void add_bearer(uint32_t lcid, srslte::srslte_pdcp_config_t cnfg = srslte::srslte_pdcp_config_t()) = 0; virtual void change_lcid(uint32_t old_lcid, uint32_t new_lcid) = 0; virtual void config_security(uint32_t lcid, @@ -260,11 +260,11 @@ class pdcp_interface_rlc { public: /* RLC calls PDCP to push a PDCP PDU. */ - virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0; - virtual void write_pdu_bcch_bch(srslte::byte_buffer_t *sdu) = 0; - virtual void write_pdu_bcch_dlsch(srslte::byte_buffer_t *sdu) = 0; - virtual void write_pdu_pcch(srslte::byte_buffer_t *sdu) = 0; - virtual void write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0; + virtual void write_pdu(uint32_t lcid, srslte::unique_pool_buffer sdu) = 0; + virtual void write_pdu_bcch_bch(srslte::unique_pool_buffer sdu) = 0; + virtual void write_pdu_bcch_dlsch(srslte::unique_pool_buffer sdu) = 0; + virtual void write_pdu_pcch(srslte::unique_pool_buffer sdu) = 0; + virtual void write_pdu_mch(uint32_t lcid, srslte::unique_pool_buffer sdu) = 0; }; // RLC interface for RRC @@ -289,7 +289,7 @@ class rlc_interface_pdcp public: /* PDCP calls RLC to push an RLC SDU. SDU gets placed into the RLC buffer and MAC pulls * RLC PDUs according to TB size. */ - virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu, bool blocking = true) = 0; + virtual void write_sdu(uint32_t lcid, srslte::unique_pool_buffer sdu, bool blocking = true) = 0; virtual bool rb_is_um(uint32_t lcid) = 0; }; diff --git a/lib/include/srslte/upper/pdcp.h b/lib/include/srslte/upper/pdcp.h index d2181ffd8..6c0268446 100644 --- a/lib/include/srslte/upper/pdcp.h +++ b/lib/include/srslte/upper/pdcp.h @@ -51,8 +51,8 @@ public: // RRC interface void reestablish(); void reset(); - void write_sdu(uint32_t lcid, byte_buffer_t *sdu, bool blocking = true); - void write_sdu_mch(uint32_t lcid, byte_buffer_t *sdu); + void write_sdu(uint32_t lcid, unique_pool_buffer sdu, bool blocking = true); + void write_sdu_mch(uint32_t lcid, unique_pool_buffer sdu); void add_bearer(uint32_t lcid, srslte_pdcp_config_t cnfg = srslte_pdcp_config_t()); void add_bearer_mrb(uint32_t lcid, srslte_pdcp_config_t cnfg = srslte_pdcp_config_t()); void del_bearer(uint32_t lcid); @@ -74,11 +74,11 @@ public: uint32_t get_ul_count(uint32_t lcid); // RLC interface - void write_pdu(uint32_t lcid, byte_buffer_t *sdu); - void write_pdu_mch(uint32_t lcid, byte_buffer_t *sdu); - void write_pdu_bcch_bch(byte_buffer_t *sdu); - void write_pdu_bcch_dlsch(byte_buffer_t *sdu); - void write_pdu_pcch(byte_buffer_t *sdu); + void write_pdu(uint32_t lcid, unique_pool_buffer sdu); + void write_pdu_mch(uint32_t lcid, unique_pool_buffer sdu); + void write_pdu_bcch_bch(unique_pool_buffer sdu); + void write_pdu_bcch_dlsch(unique_pool_buffer sdu); + void write_pdu_pcch(unique_pool_buffer sdu); private: srsue::rlc_interface_pdcp *rlc; diff --git a/lib/include/srslte/upper/pdcp_entity.h b/lib/include/srslte/upper/pdcp_entity.h index 687c60fa6..a60cca34d 100644 --- a/lib/include/srslte/upper/pdcp_entity.h +++ b/lib/include/srslte/upper/pdcp_entity.h @@ -72,7 +72,7 @@ public: bool is_active(); // RRC interface - void write_sdu(byte_buffer_t *sdu, bool blocking); + void write_sdu(unique_pool_buffer sdu, bool blocking); void config_security(uint8_t *k_rrc_enc_, uint8_t *k_rrc_int_, uint8_t *k_up_enc_, @@ -84,7 +84,7 @@ public: uint32_t get_ul_count(); // RLC interface - void write_pdu(byte_buffer_t *pdu); + void write_pdu(unique_pool_buffer pdu); private: byte_buffer_pool *pool; diff --git a/lib/include/srslte/upper/pdcp_interface.h b/lib/include/srslte/upper/pdcp_interface.h index 4679f5ad7..4380b3b07 100644 --- a/lib/include/srslte/upper/pdcp_interface.h +++ b/lib/include/srslte/upper/pdcp_interface.h @@ -50,7 +50,7 @@ public: virtual bool is_active() = 0; // RRC interface - virtual void write_sdu(byte_buffer_t *sdu, bool blocking) = 0; + virtual void write_sdu(unique_pool_buffer sdu, bool blocking) = 0; virtual void config_security(uint8_t *k_rrc_enc_, uint8_t *k_rrc_int_, uint8_t *k_up_enc_, @@ -62,7 +62,7 @@ public: virtual uint32_t get_ul_count() = 0; // RLC interface - virtual void write_pdu(byte_buffer_t *pdu) = 0; + virtual void write_pdu(unique_pool_buffer pdu) = 0; }; } // namespace srslte diff --git a/lib/include/srslte/upper/rlc.h b/lib/include/srslte/upper/rlc.h index ee5da3d18..b62b219a0 100644 --- a/lib/include/srslte/upper/rlc.h +++ b/lib/include/srslte/upper/rlc.h @@ -56,8 +56,8 @@ public: void get_metrics(rlc_metrics_t &m); // PDCP interface - void write_sdu(uint32_t lcid, byte_buffer_t *sdu, bool blocking = true); - void write_sdu_mch(uint32_t lcid, byte_buffer_t *sdu); + void write_sdu(uint32_t lcid, unique_pool_buffer sdu, bool blocking = true); + void write_sdu_mch(uint32_t lcid, unique_pool_buffer sdu); bool rb_is_um(uint32_t lcid); // MAC interface diff --git a/lib/include/srslte/upper/rlc_am.h b/lib/include/srslte/upper/rlc_am.h index 226fa035b..7576cf337 100644 --- a/lib/include/srslte/upper/rlc_am.h +++ b/lib/include/srslte/upper/rlc_am.h @@ -81,7 +81,7 @@ public: uint32_t get_bearer(); // PDCP interface - void write_sdu(byte_buffer_t *sdu, bool blocking = true); + void write_sdu(unique_pool_buffer sdu, bool blocking = true); // MAC interface bool has_data(); @@ -109,7 +109,7 @@ private: void reestablish(); void stop(); - void write_sdu(byte_buffer_t *sdu, bool blocking); + void write_sdu(unique_pool_buffer sdu, bool blocking); int read_pdu(uint8_t *payload, uint32_t nof_bytes); bool has_data(); diff --git a/lib/include/srslte/upper/rlc_common.h b/lib/include/srslte/upper/rlc_common.h index 6c69b92a1..cb0470406 100644 --- a/lib/include/srslte/upper/rlc_common.h +++ b/lib/include/srslte/upper/rlc_common.h @@ -161,7 +161,7 @@ public: virtual void reset_metrics() = 0; // PDCP interface - virtual void write_sdu(byte_buffer_t *sdu, bool blocking) = 0; + virtual void write_sdu(unique_pool_buffer sdu, bool blocking) = 0; // MAC interface virtual bool has_data() = 0; diff --git a/lib/include/srslte/upper/rlc_tx_queue.h b/lib/include/srslte/upper/rlc_tx_queue.h index 9eafa8326..11085c831 100644 --- a/lib/include/srslte/upper/rlc_tx_queue.h +++ b/lib/include/srslte/upper/rlc_tx_queue.h @@ -36,7 +36,7 @@ namespace srslte { -class rlc_tx_queue : public block_queue::call_mutexed_itf +class rlc_tx_queue : public block_queue::call_mutexed_itf { public: rlc_tx_queue(int capacity = 128) : queue(capacity) { @@ -54,26 +54,17 @@ public: unread_bytes = 0; } } - void write(byte_buffer_t *msg) - { - queue.push(msg); - } + void write(unique_pool_buffer msg) { queue.push(std::move(msg)); } - bool try_write(byte_buffer_t *msg) - { - return queue.try_push(msg); - } + bool try_write(unique_pool_buffer msg) { return queue.try_push(std::move(msg)); } - void read(byte_buffer_t **msg) + void read(unique_pool_buffer* msg) { - byte_buffer_t *m = queue.wait_pop(); - *msg = m; + unique_pool_buffer m = queue.wait_pop(); + *msg = std::move(m); } - bool try_read(byte_buffer_t **msg) - { - return queue.try_pop(msg); - } + bool try_read(unique_pool_buffer* msg) { return queue.try_pop(msg); } void resize(uint32_t capacity) { @@ -92,8 +83,8 @@ public: uint32_t size_tail_bytes() { if (!queue.empty()) { - byte_buffer_t *m = queue.front(); - if (m) { + unique_pool_buffer& m = queue.front(); + if (m.get()) { return m->N_bytes; } } @@ -110,8 +101,7 @@ public: } private: - - block_queue queue; + block_queue queue; uint32_t unread_bytes; }; diff --git a/lib/src/upper/pdcp.cc b/lib/src/upper/pdcp.cc index 940a90df2..e863d7bbd 100644 --- a/lib/src/upper/pdcp.cc +++ b/lib/src/upper/pdcp.cc @@ -117,23 +117,22 @@ bool pdcp::is_lcid_enabled(uint32_t lcid) return ret; } -void pdcp::write_sdu(uint32_t lcid, byte_buffer_t *sdu, bool blocking) +void pdcp::write_sdu(uint32_t lcid, unique_pool_buffer sdu, bool blocking) { pthread_rwlock_rdlock(&rwlock); if (valid_lcid(lcid)) { - pdcp_array.at(lcid)->write_sdu(sdu, blocking); + pdcp_array.at(lcid)->write_sdu(std::move(sdu), blocking); } else { pdcp_log->warning("Writing sdu: lcid=%d. Deallocating sdu\n", lcid); - byte_buffer_pool::get_instance()->deallocate(sdu); } pthread_rwlock_unlock(&rwlock); } -void pdcp::write_sdu_mch(uint32_t lcid, byte_buffer_t *sdu) +void pdcp::write_sdu_mch(uint32_t lcid, unique_pool_buffer sdu) { pthread_rwlock_rdlock(&rwlock); if (valid_mch_lcid(lcid)){ - pdcp_array_mrb.at(lcid)->write_sdu(sdu, true); + pdcp_array_mrb.at(lcid)->write_sdu(std::move(sdu), true); } pthread_rwlock_unlock(&rwlock); } @@ -277,39 +276,38 @@ uint32_t pdcp::get_ul_count(uint32_t lcid) /******************************************************************************* RLC interface *******************************************************************************/ -void pdcp::write_pdu(uint32_t lcid, byte_buffer_t *pdu) +void pdcp::write_pdu(uint32_t lcid, unique_pool_buffer pdu) { pthread_rwlock_rdlock(&rwlock); if (valid_lcid(lcid)) { - pdcp_array.at(lcid)->write_pdu(pdu); + pdcp_array.at(lcid)->write_pdu(std::move(pdu)); } else { pdcp_log->warning("Writing pdu: lcid=%d. Deallocating pdu\n", lcid); - byte_buffer_pool::get_instance()->deallocate(pdu); } pthread_rwlock_unlock(&rwlock); } -void pdcp::write_pdu_bcch_bch(byte_buffer_t *sdu) +void pdcp::write_pdu_bcch_bch(unique_pool_buffer sdu) { - rrc->write_pdu_bcch_bch(sdu); + rrc->write_pdu_bcch_bch(std::move(sdu)); } -void pdcp::write_pdu_bcch_dlsch(byte_buffer_t *sdu) +void pdcp::write_pdu_bcch_dlsch(unique_pool_buffer sdu) { - rrc->write_pdu_bcch_dlsch(sdu); + rrc->write_pdu_bcch_dlsch(std::move(sdu)); } -void pdcp::write_pdu_pcch(byte_buffer_t *sdu) +void pdcp::write_pdu_pcch(unique_pool_buffer sdu) { - rrc->write_pdu_pcch(sdu); + rrc->write_pdu_pcch(std::move(sdu)); } -void pdcp::write_pdu_mch(uint32_t lcid, byte_buffer_t *sdu) +void pdcp::write_pdu_mch(uint32_t lcid, unique_pool_buffer sdu) { if (0 == lcid) { - rrc->write_pdu_mch(lcid, sdu); + rrc->write_pdu_mch(lcid, std::move(sdu)); } else { - gw->write_pdu_mch(lcid, sdu); + gw->write_pdu_mch(lcid, std::move(sdu)); } } diff --git a/lib/src/upper/pdcp_entity.cc b/lib/src/upper/pdcp_entity.cc index e9bcec85f..ef1dccf80 100644 --- a/lib/src/upper/pdcp_entity.cc +++ b/lib/src/upper/pdcp_entity.cc @@ -112,7 +112,7 @@ bool pdcp_entity::is_active() } // GW/RRC interface -void pdcp_entity::write_sdu(byte_buffer_t *sdu, bool blocking) +void pdcp_entity::write_sdu(unique_pool_buffer sdu, bool blocking) { log->info_hex(sdu->msg, sdu->N_bytes, "TX %s SDU, SN: %d, do_integrity = %s, do_encryption = %s", @@ -122,7 +122,7 @@ void pdcp_entity::write_sdu(byte_buffer_t *sdu, bool blocking) pthread_mutex_lock(&mutex); if (cfg.is_control) { - pdcp_pack_control_pdu(tx_count, sdu); + pdcp_pack_control_pdu(tx_count, sdu.get()); if(do_integrity) { integrity_generate(sdu->msg, sdu->N_bytes-4, @@ -132,9 +132,9 @@ void pdcp_entity::write_sdu(byte_buffer_t *sdu, bool blocking) if (cfg.is_data) { if(12 == cfg.sn_len) { - pdcp_pack_data_pdu_long_sn(tx_count, sdu); + pdcp_pack_data_pdu_long_sn(tx_count, sdu.get()); } else { - pdcp_pack_data_pdu_short_sn(tx_count, sdu); + pdcp_pack_data_pdu_short_sn(tx_count, sdu.get()); } } @@ -148,7 +148,7 @@ void pdcp_entity::write_sdu(byte_buffer_t *sdu, bool blocking) pthread_mutex_unlock(&mutex); - rlc->write_sdu(lcid, sdu, blocking); + rlc->write_sdu(lcid, std::move(sdu), blocking); } void pdcp_entity::config_security(uint8_t *k_rrc_enc_, @@ -178,14 +178,13 @@ void pdcp_entity::enable_encryption() } // RLC interface -void pdcp_entity::write_pdu(byte_buffer_t *pdu) +void pdcp_entity::write_pdu(unique_pool_buffer pdu) { log->info_hex(pdu->msg, pdu->N_bytes, "RX %s PDU, do_integrity = %s, do_encryption = %s", rrc->get_rb_name(lcid).c_str(), (do_integrity) ? "true" : "false", (do_encryption) ? "true" : "false"); // Sanity check if(pdu->N_bytes <= sn_len_bytes) { - pool->deallocate(pdu); return; } @@ -203,12 +202,12 @@ void pdcp_entity::write_pdu(byte_buffer_t *pdu) } if(12 == cfg.sn_len) { - pdcp_unpack_data_pdu_long_sn(pdu, &sn); + pdcp_unpack_data_pdu_long_sn(pdu.get(), &sn); } else { - pdcp_unpack_data_pdu_short_sn(pdu, &sn); + pdcp_unpack_data_pdu_short_sn(pdu.get(), &sn); } log->info_hex(pdu->msg, pdu->N_bytes, "RX %s PDU SN: %d", rrc->get_rb_name(lcid).c_str(), sn); - gw->write_pdu(lcid, pdu); + gw->write_pdu(lcid, std::move(pdu)); } else { // Handle SRB messages if (cfg.is_control) { @@ -231,11 +230,11 @@ void pdcp_entity::write_pdu(byte_buffer_t *pdu) } } - pdcp_unpack_control_pdu(pdu, &sn); + pdcp_unpack_control_pdu(pdu.get(), &sn); log->info_hex(pdu->msg, pdu->N_bytes, "RX %s PDU SN: %d", rrc->get_rb_name(lcid).c_str(), sn); } // pass to RRC - rrc->write_pdu(lcid, pdu); + rrc->write_pdu(lcid, std::move(pdu)); } exit: rx_count++; diff --git a/lib/src/upper/rlc.cc b/lib/src/upper/rlc.cc index f33f63865..aa2830c30 100644 --- a/lib/src/upper/rlc.cc +++ b/lib/src/upper/rlc.cc @@ -199,12 +199,11 @@ void rlc::empty_queue() PDCP interface *******************************************************************************/ -void rlc::write_sdu(uint32_t lcid, byte_buffer_t *sdu, bool blocking) +void rlc::write_sdu(uint32_t lcid, unique_pool_buffer sdu, bool blocking) { // FIXME: rework build PDU logic to allow large SDUs (without concatenation) if (sdu->N_bytes > RLC_MAX_SDU_SIZE) { rlc_log->warning("Dropping too long SDU of size %d B (Max. size %d B).\n", sdu->N_bytes, RLC_MAX_SDU_SIZE); - pool->deallocate(sdu); return; } @@ -213,19 +212,17 @@ void rlc::write_sdu(uint32_t lcid, byte_buffer_t *sdu, bool blocking) rlc_array.at(lcid)->write_sdu(sdu, blocking); } else { rlc_log->warning("RLC LCID %d doesn't exist. Deallocating SDU\n", lcid); - byte_buffer_pool::get_instance()->deallocate(sdu); } pthread_rwlock_unlock(&rwlock); } -void rlc::write_sdu_mch(uint32_t lcid, byte_buffer_t *sdu) +void rlc::write_sdu_mch(uint32_t lcid, unique_pool_buffer sdu) { pthread_rwlock_rdlock(&rwlock); if (valid_lcid_mrb(lcid)) { rlc_array_mrb.at(lcid)->write_sdu(sdu, false); // write in non-blocking mode by default } else { rlc_log->warning("RLC LCID %d doesn't exist. Deallocating SDU\n", lcid); - byte_buffer_pool::get_instance()->deallocate(sdu); } pthread_rwlock_unlock(&rwlock); } diff --git a/lib/src/upper/rlc_am.cc b/lib/src/upper/rlc_am.cc index ac778d8bd..3ad1164dd 100644 --- a/lib/src/upper/rlc_am.cc +++ b/lib/src/upper/rlc_am.cc @@ -128,7 +128,7 @@ void rlc_am::reset_metrics() * PDCP interface ***************************************************************************/ -void rlc_am::write_sdu(byte_buffer_t *sdu, bool blocking) +void rlc_am::write_sdu(unique_pool_buffer sdu, bool blocking) { tx.write_sdu(sdu, blocking); } @@ -362,26 +362,24 @@ uint32_t rlc_am::rlc_am_tx::get_buffer_state() return n_bytes; } -void rlc_am::rlc_am_tx::write_sdu(byte_buffer_t *sdu, bool blocking) +void rlc_am::rlc_am_tx::write_sdu(unique_pool_buffer sdu, bool blocking) { if (!tx_enabled) { - byte_buffer_pool::get_instance()->deallocate(sdu); return; } - - if (sdu != NULL) { + + if (sdu.get() != NULL) { if (blocking) { // block on write to queue - tx_sdu_queue.write(sdu); + tx_sdu_queue.write(std::move(sdu)); log->info_hex(sdu->msg, sdu->N_bytes, "%s Tx SDU (%d B, tx_sdu_queue_len=%d)", RB_NAME, sdu->N_bytes, tx_sdu_queue.size()); } else { // non-blocking write - if (tx_sdu_queue.try_write(sdu)) { + if (tx_sdu_queue.try_write(std::move(sdu))) { log->info_hex(sdu->msg, sdu->N_bytes, "%s Tx SDU (%d B, tx_sdu_queue_len=%d)", RB_NAME, sdu->N_bytes, tx_sdu_queue.size()); } else { log->info_hex(sdu->msg, sdu->N_bytes, "[Dropped SDU] %s Tx SDU (%d B, tx_sdu_queue_len=%d)", RB_NAME, sdu->N_bytes, tx_sdu_queue.size()); - pool->deallocate(sdu); } } } else { diff --git a/srsenb/hdr/upper/gtpu.h b/srsenb/hdr/upper/gtpu.h index 4a12188fc..9c23fd8ef 100644 --- a/srsenb/hdr/upper/gtpu.h +++ b/srsenb/hdr/upper/gtpu.h @@ -53,7 +53,7 @@ public: void rem_user(uint16_t rnti); // gtpu_interface_pdcp - void write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *pdu); + void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_pool_buffer pdu); private: static const int THREAD_PRIO = 65; diff --git a/srsenb/hdr/upper/pdcp.h b/srsenb/hdr/upper/pdcp.h index f5510f7d8..a7e1b452b 100644 --- a/srsenb/hdr/upper/pdcp.h +++ b/srsenb/hdr/upper/pdcp.h @@ -45,8 +45,8 @@ public: // pdcp_interface_rrc void reset(uint16_t rnti); void add_user(uint16_t rnti); - void rem_user(uint16_t rnti); - void write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu); + void rem_user(uint16_t rnti); + void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_pool_buffer sdu); void add_bearer(uint16_t rnti, uint32_t lcid, srslte::srslte_pdcp_config_t cnfg); void config_security(uint16_t rnti, uint32_t lcid, diff --git a/srsenb/src/upper/gtpu.cc b/srsenb/src/upper/gtpu.cc index b11fce87a..b668bfadf 100644 --- a/srsenb/src/upper/gtpu.cc +++ b/srsenb/src/upper/gtpu.cc @@ -111,7 +111,7 @@ void gtpu::stop() } // gtpu_interface_pdcp -void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* pdu) +void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_pool_buffer pdu) { gtpu_log->info_hex(pdu->msg, pdu->N_bytes, "TX PDU, RNTI: 0x%x, LCID: %d, n_bytes=%d", rnti, lcid, pdu->N_bytes); gtpu_header_t header; @@ -125,7 +125,7 @@ void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* pdu) servaddr.sin_addr.s_addr = htonl(rnti_bearers[rnti].spgw_addrs[lcid]); servaddr.sin_port = htons(GTPU_PORT); - if(!gtpu_write_header(&header, pdu, gtpu_log)){ + if (!gtpu_write_header(&header, pdu.get(), gtpu_log)) { gtpu_log->error("Error writing GTP-U Header. Flags 0x%x, Message Type 0x%x\n", header.flags, header.message_type); return; } @@ -133,7 +133,6 @@ void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* pdu) perror("sendto"); } - pool->deallocate(pdu); } /* Warning: This function is called before calling gtpu::init() during MCCH initialization. @@ -192,9 +191,10 @@ void gtpu::rem_user(uint16_t rnti) void gtpu::run_thread() { - byte_buffer_t *pdu = pool_allocate; + unique_pool_buffer pdu(pool); + pdu.allocate(); - if (!pdu) { + if (!pdu.get()) { gtpu_log->error("Fatal Error: Couldn't allocate buffer in gtpu::run_thread().\n"); return; } @@ -222,7 +222,7 @@ void gtpu::run_thread() pdu->N_bytes = (uint32_t) n; gtpu_header_t header; - if(!gtpu_read_header(pdu, &header,gtpu_log)){ + if (!gtpu_read_header(pdu.get(), &header, gtpu_log)) { continue; } @@ -255,15 +255,15 @@ void gtpu::run_thread() gtpu_log->info_hex(pdu->msg, pdu->N_bytes, "RX GTPU PDU rnti=0x%x, lcid=%d, n_bytes=%d", rnti, lcid, pdu->N_bytes); - pdcp->write_sdu(rnti, lcid, pdu); + pdcp->write_sdu(rnti, lcid, std::move(pdu)); do { - pdu = pool_allocate; - if (!pdu) { + pdu.allocate(); + if (!pdu.get()) { gtpu_log->console("GTPU Buffer pool empty. Trying again...\n"); usleep(10000); } - } while(!pdu); + } while (!pdu.get()); break; } } @@ -275,7 +275,8 @@ void gtpu::echo_response(in_addr_t addr, in_port_t port, uint16_t seq) gtpu_log->info("TX GTPU Echo Response, Seq: %d\n", seq); gtpu_header_t header; - srslte::byte_buffer_t *pdu = pool_allocate; + unique_pool_buffer pdu(pool); + pdu.allocate(); //header header.flags = GTPU_FLAGS_VERSION_V1 | GTPU_FLAGS_GTP_PROTOCOL | GTPU_FLAGS_SEQUENCE; @@ -286,7 +287,7 @@ void gtpu::echo_response(in_addr_t addr, in_port_t port, uint16_t seq) header.n_pdu = 0; header.next_ext_hdr_type = 0; - gtpu_write_header(&header,pdu,gtpu_log); + gtpu_write_header(&header, pdu.get(), gtpu_log); struct sockaddr_in servaddr; servaddr.sin_family = AF_INET; @@ -294,7 +295,6 @@ void gtpu::echo_response(in_addr_t addr, in_port_t port, uint16_t seq) servaddr.sin_port = port; sendto(fd, pdu->msg, 12, MSG_EOR, (struct sockaddr*)&servaddr, sizeof(struct sockaddr_in)); - pool->deallocate(pdu); } /**************************************************************************** @@ -371,7 +371,7 @@ void gtpu::mch_thread::run_thread() return; } - byte_buffer_t *pdu; + unique_pool_buffer pdu(pool); int n; socklen_t addrlen; sockaddr_in src_addr; @@ -385,7 +385,7 @@ void gtpu::mch_thread::run_thread() run_enable = true; running=true; - pdu = pool->allocate(); + pdu.allocate(); // Warning: Use mutex here if creating multiple services each with a different thread uint16_t lcid = lcid_counter; @@ -402,15 +402,15 @@ void gtpu::mch_thread::run_thread() pdu->N_bytes = (uint32_t) n; gtpu_header_t header; - gtpu_read_header(pdu, &header, gtpu_log); - pdcp->write_sdu(SRSLTE_MRNTI, lcid, pdu); + gtpu_read_header(pdu.get(), &header, gtpu_log); + pdcp->write_sdu(SRSLTE_MRNTI, lcid, std::move(pdu)); do { - pdu = pool_allocate; - if (!pdu) { + pdu.allocate(); + if (!pdu.get()) { gtpu_log->console("GTPU Buffer pool empty. Trying again...\n"); usleep(10000); } - } while(!pdu); + } while (!pdu.get()); } running = false; } diff --git a/srsenb/src/upper/pdcp.cc b/srsenb/src/upper/pdcp.cc index 58c5a27f2..5a931b58b 100644 --- a/srsenb/src/upper/pdcp.cc +++ b/srsenb/src/upper/pdcp.cc @@ -141,7 +141,7 @@ void pdcp::write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* sdu) pthread_rwlock_unlock(&rwlock); } -void pdcp::write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* sdu) +void pdcp::write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_pool_buffer sdu) { pthread_rwlock_rdlock(&rwlock); if (users.count(rnti)) { @@ -150,8 +150,6 @@ void pdcp::write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t* sdu) }else { users[rnti].pdcp->write_sdu_mch(lcid, sdu); } - } else { - pool->deallocate(sdu); } pthread_rwlock_unlock(&rwlock); } diff --git a/srsue/hdr/upper/nas.h b/srsue/hdr/upper/nas.h index 4dc920f82..42eaa87a1 100644 --- a/srsue/hdr/upper/nas.h +++ b/srsue/hdr/upper/nas.h @@ -82,7 +82,7 @@ public: // RRC interface void paging(asn1::rrc::s_tmsi_s* ue_identiy); void set_barring(barring_t barring); - void write_pdu(uint32_t lcid, byte_buffer_t *pdu); + void write_pdu(uint32_t lcid, unique_pool_buffer pdu); uint32_t get_k_enb_count(); bool is_attached(); bool get_k_asme(uint8_t *k_asme_, uint32_t n); diff --git a/srsue/hdr/upper/rrc.h b/srsue/hdr/upper/rrc.h index 33261119f..546c6f13c 100644 --- a/srsue/hdr/upper/rrc.h +++ b/srsue/hdr/upper/rrc.h @@ -307,19 +307,20 @@ public: typedef enum { Rx = 0, Tx } direction_t; template - void log_rrc_message(const std::string source, const direction_t dir, const byte_buffer_t* pdu, const T& msg); + void + log_rrc_message(const std::string source, const direction_t dir, const srslte::unique_pool_buffer& pdu, const T& msg); void print_mbms(); bool mbms_service_start(uint32_t serv, uint32_t port); // NAS interface - void write_sdu(byte_buffer_t *sdu); + void write_sdu(srslte::unique_pool_buffer sdu); void enable_capabilities(); uint16_t get_mcc(); uint16_t get_mnc(); int plmn_search(found_plmn_t found_plmns[MAX_FOUND_PLMNS]); void plmn_select(asn1::rrc::plmn_id_s plmn_id); - bool connection_request(asn1::rrc::establishment_cause_e cause, srslte::byte_buffer_t* dedicated_info_nas); + bool connection_request(asn1::rrc::establishment_cause_e cause, srslte::unique_pool_buffer dedicated_info_nas); void set_ue_idenity(asn1::rrc::s_tmsi_s s_tmsi); // PHY interface @@ -338,11 +339,11 @@ public: bool have_drb(); // PDCP interface - void write_pdu(uint32_t lcid, byte_buffer_t *pdu); - void write_pdu_bcch_bch(byte_buffer_t *pdu); - void write_pdu_bcch_dlsch(byte_buffer_t *pdu); - void write_pdu_pcch(byte_buffer_t *pdu); - void write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *pdu); + void write_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu); + void write_pdu_bcch_bch(srslte::unique_pool_buffer pdu); + void write_pdu_bcch_dlsch(srslte::unique_pool_buffer pdu); + void write_pdu_pcch(srslte::unique_pool_buffer pdu); + void write_pdu_mch(uint32_t lcid, srslte::unique_pool_buffer pdu); private: @@ -352,7 +353,7 @@ private: PCCH, STOP } command; - byte_buffer_t *pdu; + srslte::unique_pool_buffer pdu; uint16_t lcid; } cmd_msg_t; @@ -360,7 +361,7 @@ private: srslte::block_queue cmd_q; void run_thread(); - void process_pcch(byte_buffer_t *pdu); + void process_pcch(srslte::unique_pool_buffer pdu); srslte::byte_buffer_pool *pool; srslte::log *rrc_log; @@ -372,7 +373,7 @@ private: usim_interface_rrc *usim; gw_interface_rrc *gw; - byte_buffer_t* dedicated_info_nas; + srslte::unique_pool_buffer dedicated_info_nas; void send_ul_ccch_msg(const asn1::rrc::ul_ccch_msg_s& msg); void send_ul_dcch_msg(uint32_t lcid, const asn1::rrc::ul_dcch_msg_s& msg); @@ -625,17 +626,17 @@ private: void send_con_request(asn1::rrc::establishment_cause_e cause); void send_con_restablish_request(asn1::rrc::reest_cause_e cause); void send_con_restablish_complete(); - void send_con_setup_complete(byte_buffer_t* nas_msg); - void send_ul_info_transfer(byte_buffer_t* nas_msg); + void send_con_setup_complete(srslte::unique_pool_buffer nas_msg); + void send_ul_info_transfer(srslte::unique_pool_buffer nas_msg); void send_security_mode_complete(); void send_rrc_con_reconfig_complete(); void send_rrc_ue_cap_info(); // Parsers - void process_pdu(uint32_t lcid, byte_buffer_t* pdu); - void parse_dl_ccch(byte_buffer_t* pdu); - void parse_dl_dcch(uint32_t lcid, byte_buffer_t* pdu); - void parse_dl_info_transfer(uint32_t lcid, byte_buffer_t* pdu); + void process_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu); + void parse_dl_ccch(srslte::unique_pool_buffer pdu); + void parse_dl_dcch(uint32_t lcid, srslte::unique_pool_buffer pdu); + void parse_dl_info_transfer(uint32_t lcid, srslte::unique_pool_buffer pdu); // Helpers bool con_reconfig(asn1::rrc::rrc_conn_recfg_s* reconfig); diff --git a/srsue/src/upper/rrc.cc b/srsue/src/upper/rrc.cc index 9173e5dc1..03f43426b 100644 --- a/srsue/src/upper/rrc.cc +++ b/srsue/src/upper/rrc.cc @@ -51,7 +51,8 @@ rrc::rrc() : last_state(RRC_STATE_CONNECTED), drb_up(false), rlc_flush_timeout(2000), - rlc_flush_counter(0) + rlc_flush_counter(0), + dedicated_info_nas(NULL) { n310_cnt = 0; n311_cnt = 0; @@ -96,7 +97,7 @@ void rrc::srslte_rrc_log(const char* str) } template -void rrc::log_rrc_message(const std::string source, const direction_t dir, const byte_buffer_t* pdu, const T& msg) +void rrc::log_rrc_message(const std::string source, const direction_t dir, const unique_pool_buffer& pdu, const T& msg) { if (rrc_log->get_level() == srslte::LOG_LEVEL_INFO) { rrc_log->info("%s - %s %s (%d B)\n", source.c_str(), (dir == Rx) ? "Rx" : "Tx", @@ -157,7 +158,7 @@ void rrc::init(phy_interface_rrc* phy_, t311 = mac_timers->timer_get_unique_id(); t304 = mac_timers->timer_get_unique_id(); - dedicated_info_nas = NULL; + dedicated_info_nas.set_pool(pool); ue_identity_configured = false; transaction_id = 0; @@ -218,10 +219,10 @@ void rrc::run_thread() { cmd_msg_t msg = cmd_q.wait_pop(); switch(msg.command) { case cmd_msg_t::PDU: - process_pdu(msg.lcid, msg.pdu); + process_pdu(msg.lcid, std::move(msg.pdu)); break; case cmd_msg_t::PCCH: - process_pcch(msg.pdu); + process_pcch(std::move(msg.pdu)); break; case cmd_msg_t::STOP: return; @@ -424,7 +425,7 @@ void rrc::plmn_select(asn1::rrc::plmn_id_s plmn_id) * it. Sends connectionRequest message and returns if message transmitted successfully. * It does not wait until completition of Connection Establishment procedure */ -bool rrc::connection_request(asn1::rrc::establishment_cause_e cause, srslte::byte_buffer_t* dedicated_info_nas) +bool rrc::connection_request(asn1::rrc::establishment_cause_e cause, srslte::unique_pool_buffer dedicated_info_nas) { if (!plmn_is_selected) { @@ -472,11 +473,10 @@ bool rrc::connection_request(asn1::rrc::establishment_cause_e cause, srslte::byt send_con_request(cause); // Save dedicatedInfoNAS SDU - if (this->dedicated_info_nas) { + if (this->dedicated_info_nas.get()) { rrc_log->warning("Received a new dedicatedInfoNAS SDU but there was one still in queue. Removing it\n"); - pool->deallocate(this->dedicated_info_nas); } - this->dedicated_info_nas = dedicated_info_nas; + this->dedicated_info_nas = std::move(dedicated_info_nas); // Wait until t300 stops due to RRCConnectionSetup/Reject or expiry while (mac_timers->timer_get(t300)->is_running()) { @@ -519,8 +519,7 @@ bool rrc::connection_request(asn1::rrc::establishment_cause_e cause, srslte::byt if (!ret) { rrc_log->warning("Could not establish connection. Deallocating dedicatedInfoNAS PDU\n"); - pool->deallocate(this->dedicated_info_nas); - this->dedicated_info_nas = NULL; + this->dedicated_info_nas.deallocate(); } pthread_mutex_unlock(&mutex); @@ -1433,7 +1432,8 @@ void rrc::send_con_restablish_complete() { send_ul_dcch_msg(RB_ID_SRB1, ul_dcch_msg); } -void rrc::send_con_setup_complete(byte_buffer_t *nas_msg) { +void rrc::send_con_setup_complete(srslte::unique_pool_buffer nas_msg) +{ rrc_log->debug("Preparing RRC Connection Setup Complete\n"); // Prepare ConnectionSetupComplete packet @@ -1447,11 +1447,10 @@ void rrc::send_con_setup_complete(byte_buffer_t *nas_msg) { rrc_conn_setup_complete->ded_info_nas.resize(nas_msg->N_bytes); memcpy(rrc_conn_setup_complete->ded_info_nas.data(), nas_msg->msg, nas_msg->N_bytes); // TODO Check! - pool->deallocate(nas_msg); send_ul_dcch_msg(RB_ID_SRB1, ul_dcch_msg); } -void rrc::send_ul_info_transfer(byte_buffer_t* nas_msg) +void rrc::send_ul_info_transfer(unique_pool_buffer nas_msg) { uint32_t lcid = rlc->has_bearer(RB_ID_SRB2) ? RB_ID_SRB2 : RB_ID_SRB1; @@ -1464,8 +1463,6 @@ void rrc::send_ul_info_transfer(byte_buffer_t* nas_msg) rrc_ul_info_transfer->ded_info_type.ded_info_nas().resize(nas_msg->N_bytes); memcpy(rrc_ul_info_transfer->ded_info_type.ded_info_nas().data(), nas_msg->msg, nas_msg->N_bytes); // TODO Check! - pool->deallocate(nas_msg); - send_ul_dcch_msg(lcid, ul_dcch_msg); } @@ -1662,13 +1659,13 @@ bool rrc::con_reconfig(asn1::rrc::rrc_conn_recfg_s* reconfig) send_rrc_con_reconfig_complete(); - byte_buffer_t *nas_sdu; + unique_pool_buffer nas_sdu(pool); for (uint32_t i = 0; i < reconfig_r8->ded_info_nas_list.size(); i++) { - nas_sdu = pool_allocate; - if (nas_sdu) { + nas_sdu.allocate(); + if (nas_sdu.get()) { memcpy(nas_sdu->msg, reconfig_r8->ded_info_nas_list[i].data(), reconfig_r8->ded_info_nas_list[i].size()); nas_sdu->N_bytes = reconfig_r8->ded_info_nas_list[i].size(); - nas->write_pdu(RB_ID_SRB1, nas_sdu); + nas->write_pdu(RB_ID_SRB1, std::move(nas_sdu)); } else { rrc_log->error("Fatal Error: Couldn't allocate PDU in handle_rrc_con_reconfig().\n"); return false; @@ -1770,14 +1767,14 @@ void rrc::stop_timers() * * *******************************************************************************/ -void rrc::write_pdu_bcch_bch(byte_buffer_t* pdu) +void rrc::write_pdu_bcch_bch(unique_pool_buffer pdu) { // Do we need to do something with BCH? rrc_log->info_hex(pdu->msg, pdu->N_bytes, "BCCH BCH message received."); - pool->deallocate(pdu); } -void rrc::write_pdu_bcch_dlsch(byte_buffer_t *pdu) { +void rrc::write_pdu_bcch_dlsch(unique_pool_buffer pdu) +{ // Stop BCCH search after successful reception of 1 BCCH block mac->bcch_stop_rx(); @@ -1790,7 +1787,6 @@ void rrc::write_pdu_bcch_dlsch(byte_buffer_t *pdu) { } log_rrc_message("BCCH", Rx, pdu, dlsch_msg); - pool->deallocate(pdu); 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"); @@ -1930,22 +1926,22 @@ void rrc::handle_sib13() * * *******************************************************************************/ -void rrc::write_pdu_pcch(byte_buffer_t* pdu) +void rrc::write_pdu_pcch(unique_pool_buffer pdu) { cmd_msg_t msg; - msg.pdu = pdu; + msg.pdu = std::move(pdu); msg.command = cmd_msg_t::PCCH; cmd_q.push(msg); } -void rrc::process_pcch(byte_buffer_t* pdu) +void rrc::process_pcch(unique_pool_buffer pdu) { if (pdu->N_bytes > 0 && pdu->N_bytes < SRSLTE_MAX_BUFFER_SIZE_BITS) { pcch_msg_s pcch_msg; asn1::bit_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) { rrc_log->error("Failed to unpack PCCH message\n"); - goto exit; + return; } log_rrc_message("PCCH", Rx, pdu, pcch_msg); @@ -1957,7 +1953,7 @@ void rrc::process_pcch(byte_buffer_t* pdu) if (not ue_identity_configured) { rrc_log->warning("Received paging message but no ue-Identity is configured\n"); - goto exit; + return; } s_tmsi_s* s_tmsi_paged; @@ -1992,11 +1988,9 @@ void rrc::process_pcch(byte_buffer_t* pdu) } else { rrc_log->error_hex(pdu->buffer, pdu->N_bytes, "Dropping PCCH message with %d B\n", pdu->N_bytes); } -exit: - pool->deallocate(pdu); } -void rrc::write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *pdu) +void rrc::write_pdu_mch(uint32_t lcid, srslte::unique_pool_buffer pdu) { if (pdu->N_bytes > 0 && pdu->N_bytes < SRSLTE_MAX_BUFFER_SIZE_BITS) { //TODO: handle MCCH notifications and update MCCH @@ -2005,15 +1999,13 @@ void rrc::write_pdu_mch(uint32_t lcid, srslte::byte_buffer_t *pdu) if (serving_cell->mcch.unpack(bref) != asn1::SRSASN_SUCCESS or serving_cell->mcch.msg.type().value != mcch_msg_type_c::types_opts::c1) { rrc_log->error("Failed to unpack MCCH message\n"); - goto exit; + return; } serving_cell->has_mcch = true; phy->set_config_mbsfn_mcch(&serving_cell->mcch); log_rrc_message("MCH", Rx, pdu, serving_cell->mcch); } } -exit: - pool->deallocate(pdu); } @@ -2032,8 +2024,8 @@ exit: void rrc::send_ul_ccch_msg(const asn1::rrc::ul_ccch_msg_s& msg) { // Reset and reuse sdu buffer if provided - byte_buffer_t *pdcp_buf = pool_allocate_blocking; - if (not pdcp_buf) { + unique_pool_buffer pdcp_buf(pool_allocate_blocking, pool); + if (not pdcp_buf.get()) { rrc_log->error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().\n"); return; } @@ -2058,14 +2050,14 @@ void rrc::send_ul_ccch_msg(const asn1::rrc::ul_ccch_msg_s& msg) uint32_t lcid = RB_ID_SRB0; log_rrc_message(get_rb_name(lcid).c_str(), Tx, pdcp_buf, msg); - pdcp->write_sdu(lcid, pdcp_buf); + pdcp->write_sdu(lcid, std::move(pdcp_buf)); } void rrc::send_ul_dcch_msg(uint32_t lcid, const asn1::rrc::ul_dcch_msg_s& msg) { // Reset and reuse sdu buffer if provided - byte_buffer_t* pdcp_buf = pool_allocate_blocking; - if (not pdcp_buf) { + unique_pool_buffer pdcp_buf(pool_allocate_blocking, pool); + if (not pdcp_buf.get()) { rrc_log->error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().\n"); return; } @@ -2078,19 +2070,20 @@ void rrc::send_ul_dcch_msg(uint32_t lcid, const asn1::rrc::ul_dcch_msg_s& msg) log_rrc_message(get_rb_name(lcid).c_str(), Tx, pdcp_buf, msg); - pdcp->write_sdu(lcid, pdcp_buf); + pdcp->write_sdu(lcid, std::move(pdcp_buf)); } -void rrc::write_sdu(byte_buffer_t *sdu) { +void rrc::write_sdu(srslte::unique_pool_buffer sdu) +{ if (state == RRC_STATE_IDLE) { rrc_log->warning("Received ULInformationTransfer SDU when in IDLE\n"); return; } - send_ul_info_transfer(sdu); + send_ul_info_transfer(std::move(sdu)); } -void rrc::write_pdu(uint32_t lcid, byte_buffer_t* pdu) +void rrc::write_pdu(uint32_t lcid, unique_pool_buffer pdu) { // If the message contains a ConnectionSetup, acknowledge the transmission to avoid blocking of paging procedure if (lcid == 0) { @@ -2100,7 +2093,6 @@ void rrc::write_pdu(uint32_t lcid, byte_buffer_t* pdu) if (dl_ccch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or dl_ccch_msg.msg.type().value != dl_ccch_msg_type_c::types_opts::c1) { rrc_log->error("Failed to unpack DL-CCCH message\n"); - pool->deallocate(pdu); return; } if (dl_ccch_msg.msg.c1().type() == dl_ccch_msg_type_c::c1_c_::types::rrc_conn_setup) { @@ -2115,21 +2107,21 @@ void rrc::write_pdu(uint32_t lcid, byte_buffer_t* pdu) // add PDU to command queue cmd_msg_t msg; - msg.pdu = pdu; + msg.pdu = std::move(pdu); msg.command = cmd_msg_t::PDU; msg.lcid = (uint16_t)lcid; cmd_q.push(msg); } -void rrc::process_pdu(uint32_t lcid, byte_buffer_t *pdu) +void rrc::process_pdu(uint32_t lcid, srslte::unique_pool_buffer pdu) { switch (lcid) { case RB_ID_SRB0: - parse_dl_ccch(pdu); + parse_dl_ccch(std::move(pdu)); break; case RB_ID_SRB1: case RB_ID_SRB2: - parse_dl_dcch(lcid, pdu); + parse_dl_dcch(lcid, std::move(pdu)); break; default: rrc_log->error("RX PDU with invalid bearer id: %d", lcid); @@ -2137,18 +2129,16 @@ void rrc::process_pdu(uint32_t lcid, byte_buffer_t *pdu) } } -void rrc::parse_dl_ccch(byte_buffer_t* pdu) +void rrc::parse_dl_ccch(unique_pool_buffer pdu) { asn1::bit_ref bref(pdu->msg, pdu->N_bytes); asn1::rrc::dl_ccch_msg_s dl_ccch_msg; if (dl_ccch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or dl_ccch_msg.msg.type().value != dl_ccch_msg_type_c::types_opts::c1) { rrc_log->error("Failed to unpack DL-CCCH message\n"); - pool->deallocate(pdu); return; } log_rrc_message(get_rb_name(RB_ID_SRB0).c_str(), Rx, pdu, dl_ccch_msg); - pool->deallocate(pdu); dl_ccch_msg_type_c::c1_c_* c1 = &dl_ccch_msg.msg.c1(); switch (dl_ccch_msg.msg.c1().type().value) { @@ -2190,31 +2180,29 @@ void rrc::parse_dl_ccch(byte_buffer_t* pdu) } } -void rrc::parse_dl_dcch(uint32_t lcid, byte_buffer_t* pdu) +void rrc::parse_dl_dcch(uint32_t lcid, unique_pool_buffer pdu) { asn1::bit_ref bref(pdu->msg, pdu->N_bytes); asn1::rrc::dl_dcch_msg_s dl_dcch_msg; if (dl_dcch_msg.unpack(bref) != asn1::SRSASN_SUCCESS or dl_dcch_msg.msg.type().value != dl_dcch_msg_type_c::types_opts::c1) { rrc_log->error("Failed to unpack DL-DCCH message\n"); - pool->deallocate(pdu); return; } log_rrc_message(get_rb_name(lcid).c_str(), Rx, pdu, dl_dcch_msg); - pool->deallocate(pdu); dl_dcch_msg_type_c::c1_c_* c1 = &dl_dcch_msg.msg.c1(); switch (dl_dcch_msg.msg.c1().type().value) { case dl_dcch_msg_type_c::c1_c_::types::dl_info_transfer: - pdu = pool_allocate_blocking; - if (!pdu) { + pdu = unique_pool_buffer(pool_allocate_blocking, pool); + if (!pdu.get()) { rrc_log->error("Fatal error: out of buffers in pool\n"); return; } pdu->N_bytes = c1->dl_info_transfer().crit_exts.c1().dl_info_transfer_r8().ded_info_type.ded_info_nas().size(); memcpy(pdu->msg, c1->dl_info_transfer().crit_exts.c1().dl_info_transfer_r8().ded_info_type.ded_info_nas().data(), pdu->N_bytes); - nas->write_pdu(lcid, pdu); + nas->write_pdu(lcid, std::move(pdu)); break; case dl_dcch_msg_type_c::c1_c_::types::security_mode_cmd: transaction_id = c1->security_mode_cmd().rrc_transaction_id; @@ -2825,9 +2813,8 @@ void rrc::handle_con_setup(rrc_conn_setup_s* setup) nas->set_barring(nas_interface_rrc::BARRING_NONE); - if (dedicated_info_nas) { - send_con_setup_complete(dedicated_info_nas); - dedicated_info_nas = NULL; // deallocated Inside! + if (dedicated_info_nas.get()) { + send_con_setup_complete(std::move(dedicated_info_nas)); } else { rrc_log->error("Pending to transmit a ConnectionSetupComplete but no dedicatedInfoNAS was in queue\n"); }