cu: pass teid allocator to pdu_session so that pdu_session can de-allocated it's TEID on destruction

Author: alvasMan

include/srsran/gtpu/gtpu_teid_pool.h

@@ -28,9 +28,9 @@ class gtpu_teid_pool
 
   SRSRAN_NODISCARD virtual expected<gtpu_teid_t> request_teid() = 0;
 
-  SRSRAN_NODISCARD virtual bool release_teid(gtpu_teid_t teid) = 0;
+  virtual bool release_teid(gtpu_teid_t teid) = 0;
 
-  virtual bool full() const = 0;
+  [[nodiscard]] virtual bool full() const = 0;
 
   virtual uint32_t get_max_nof_teids() = 0;
 };

lib/cu_up/cu_up_impl.h

@@ -17,16 +17,12 @@
 #include "srsran/cu_up/cu_up.h"
 #include "srsran/cu_up/cu_up_configuration.h"
 #include "srsran/e1ap/cu_up/e1ap_cu_up.h"
-#include "srsran/gateways/udp_network_gateway.h"
 #include "srsran/gtpu/gtpu_echo.h"
 #include "srsran/gtpu/gtpu_teid_pool.h"
 #include "srsran/support/async/fifo_async_task_scheduler.h"
-#include "srsran/support/executors/task_executor.h"
 #include <memory>
-#include <unordered_map>
 
-namespace srsran {
-namespace srs_cu_up {
+namespace srsran::srs_cu_up {
 
 class cu_up final : public cu_up_interface
 {
@@ -96,5 +92,4 @@ class cu_up final : public cu_up_interface
   unique_timer statistics_report_timer;
 };
 
-} // namespace srs_cu_up
-} // namespace srsran
+} // namespace srsran::srs_cu_up

lib/cu_up/pdu_session.h

@@ -14,6 +14,7 @@
 #include "adapters/sdap_adapters.h"
 #include "drb_context.h"
 #include "srsran/gtpu/gtpu_demux.h"
+#include "srsran/gtpu/gtpu_teid_pool.h"
 #include "srsran/gtpu/gtpu_tunnel_ngu.h"
 #include "srsran/ran/up_transport_layer_info.h"
 
@@ -24,13 +25,16 @@ namespace srs_cu_up {
 
 /// \brief Context for PDU session with session-wide parameters and all contained DRBs.
 struct pdu_session {
-  pdu_session(const e1ap_pdu_session_res_to_setup_item& session, gtpu_demux_ctrl& gtpu_rx_demux_) :
+  pdu_session(const e1ap_pdu_session_res_to_setup_item& session,
+              gtpu_demux_ctrl&                          gtpu_rx_demux_,
+              gtpu_teid_pool&                           n3_teid_allocator_) :
     pdu_session_id(session.pdu_session_id),
     session_type(session.pdu_session_type),
     snssai(session.snssai),
     security_ind(session.security_ind),
     ul_tunnel_info(session.ng_ul_up_tnl_info),
-    gtpu_rx_demux(gtpu_rx_demux_)
+    gtpu_rx_demux(gtpu_rx_demux_),
+    n3_teid_allocator(n3_teid_allocator_)
   {
     if (session.pdu_session_res_dl_ambr.has_value()) {
       pdu_session_res_ambr = session.pdu_session_res_dl_ambr.value();
@@ -41,7 +45,10 @@ struct pdu_session {
   void stop()
   {
     if (not stopped) {
-      gtpu_rx_demux.remove_tunnel(local_teid);
+      if (local_teid.has_value()) {
+        gtpu_rx_demux.remove_tunnel(local_teid.value());
+        n3_teid_allocator.release_teid(local_teid.value());
+      }
 
       gtpu->stop();
 
@@ -70,9 +77,10 @@ struct pdu_session {
   uint64_t              pdu_session_res_ambr = 0;
 
   // Tunneling info used by all DRBs/QoS flows in this PDU session
-  up_transport_layer_info ul_tunnel_info; // the peer GTP-U address and TEID
-  gtpu_teid_t             local_teid;     // the local teid used by the gNB for this PDU session
-  gtpu_demux_ctrl&        gtpu_rx_demux;  // The demux entity to register/remove the tunnel.
+  up_transport_layer_info    ul_tunnel_info;    // the peer GTP-U address and TEID
+  std::optional<gtpu_teid_t> local_teid;        // the local teid used by the gNB for this PDU session
+  gtpu_demux_ctrl&           gtpu_rx_demux;     // The demux entity to register/remove the tunnel.
+  gtpu_teid_pool&            n3_teid_allocator; // Pool to de-allocate TEID on release
 
   drb_context* default_drb = nullptr; // non-owning pointer to default DRB, if any
 

lib/cu_up/pdu_session_manager_impl.cpp

@@ -53,6 +53,7 @@ pdu_session_manager_impl::pdu_session_manager_impl(ue_index_t
   ue_ul_timer_factory(ue_ul_timer_factory_),
   ue_ctrl_timer_factory(ue_ctrl_timer_factory_),
   gtpu_tx_notifier(gtpu_tx_notifier_),
+  n3_teid_allocator(n3_teid_allocator_),
   f1u_teid_allocator(f1u_teid_allocator_),
   gtpu_rx_demux(gtpu_rx_demux_),
   ue_dl_exec(ue_dl_exec_),
@@ -82,26 +83,31 @@ pdu_session_setup_result pdu_session_manager_impl::setup_pdu_session(const e1ap_
     return pdu_session_result;
   }
 
-  pdu_sessions.emplace(session.pdu_session_id, std::make_unique<pdu_session>(session, gtpu_rx_demux));
-  std::unique_ptr<pdu_session>& new_session    = pdu_sessions.at(session.pdu_session_id);
-  const auto&                   ul_tunnel_info = new_session->ul_tunnel_info;
+  // Allocate local TEID
+  expected<gtpu_teid_t> ret = n3_teid_allocator.request_teid();
+  if (ret.is_error()) {
+    logger.log_warning("Failed to create PDU session. Cause: could not allocate local TEID. {}",
+                       session.pdu_session_id);
+    return pdu_session_result;
+  }
+
+  std::unique_ptr<pdu_session> new_session = std::make_unique<pdu_session>(session, gtpu_rx_demux, n3_teid_allocator);
+  const auto&                  ul_tunnel_info = new_session->ul_tunnel_info;
+  new_session->local_teid                     = ret.value();
 
   // Get uplink transport address
-  logger.log_debug("PDU session uplink tunnel info: {} teid={} addr={}",
+  logger.log_debug("PDU session uplink tunnel info: {} local_teid={} peer_teid={} peer_addr={}",
                    session.pdu_session_id,
+                   new_session->local_teid,
                    ul_tunnel_info.gtp_teid.value(),
                    ul_tunnel_info.tp_address);
 
-  // Allocate local TEID
-  // TODO
-  // new_session->local_teid = allocate_local_teid(new_session->pdu_session_id);
-
   // Advertise either local or external IP address of N3 interface
   const std::string& n3_addr = net_config.n3_ext_addr.empty() || net_config.n3_ext_addr == "auto"
                                    ? net_config.n3_bind_addr
                                    : net_config.n3_ext_addr;
   pdu_session_result.gtp_tunnel =
-      up_transport_layer_info(transport_layer_address::create_from_string(n3_addr), new_session->local_teid);
+      up_transport_layer_info(transport_layer_address::create_from_string(n3_addr), *new_session->local_teid);
 
   // Create SDAP entity
   sdap_entity_creation_message sdap_msg = {ue_index, session.pdu_session_id, &new_session->sdap_to_gtpu_adapter};
@@ -113,7 +119,7 @@ pdu_session_setup_result pdu_session_manager_impl::setup_pdu_session(const e1ap_
   msg.cfg.tx.peer_teid                 = int_to_gtpu_teid(ul_tunnel_info.gtp_teid.value());
   msg.cfg.tx.peer_addr                 = ul_tunnel_info.tp_address.to_string();
   msg.cfg.tx.peer_port                 = net_config.upf_port;
-  msg.cfg.rx.local_teid                = new_session->local_teid;
+  msg.cfg.rx.local_teid                = *new_session->local_teid;
   msg.cfg.rx.t_reordering              = n3_config.gtpu_reordering_timer;
   msg.cfg.rx.warn_expired_t_reordering = n3_config.warn_on_drop;
   msg.rx_lower                         = &new_session->gtpu_to_sdap_adapter;
@@ -128,7 +134,7 @@ pdu_session_setup_result pdu_session_manager_impl::setup_pdu_session(const e1ap_
 
   // Register tunnel at demux
   if (!gtpu_rx_demux.add_tunnel(
-          new_session->local_teid, ue_dl_exec, new_session->gtpu->get_rx_upper_layer_interface())) {
+          *new_session->local_teid, ue_dl_exec, new_session->gtpu->get_rx_upper_layer_interface())) {
     logger.log_error(
         "PDU Session {} cannot be created. TEID {} already exists", session.pdu_session_id, new_session->local_teid);
     return pdu_session_result;
@@ -160,6 +166,9 @@ pdu_session_setup_result pdu_session_manager_impl::setup_pdu_session(const e1ap_
             ? confidentiality_protection_result_t::not_performed
             : confidentiality_protection_result_t::performed;
   }
+
+  // PDU session creation was successful, store PDU session.
+  pdu_sessions.emplace(session.pdu_session_id, std::move(new_session));
   pdu_session_result.success = true;
   return pdu_session_result;
 }

lib/cu_up/pdu_session_manager_impl.h

@@ -83,6 +83,7 @@ class pdu_session_manager_impl final : public pdu_session_manager_ctrl
   timer_factory                                            ue_ul_timer_factory;
   timer_factory                                            ue_ctrl_timer_factory;
   gtpu_tunnel_common_tx_upper_layer_notifier&              gtpu_tx_notifier;
+  gtpu_teid_pool&                                          n3_teid_allocator;
   gtpu_teid_pool&                                          f1u_teid_allocator;
   gtpu_demux_ctrl&                                         gtpu_rx_demux;
   task_executor&                                           ue_dl_exec;

lib/gtpu/gtpu_teid_pool_impl.h

@@ -10,9 +10,9 @@
 
 #pragma once
 
-#include "srsran/adt/expected.h"
-#include "srsran/gtpu/gtpu_teid.h"
 #include "srsran/gtpu/gtpu_teid_pool.h"
+#include "srsran/srslog/logger.h"
+#include "srsran/srslog/srslog.h"
 #include "srsran/support/compiler.h"
 #include <vector>
 
@@ -21,7 +21,10 @@ namespace srsran {
 class gtpu_teid_pool_impl final : public gtpu_teid_pool
 {
 public:
-  explicit gtpu_teid_pool_impl(uint32_t max_nof_teids_) : max_nof_teids(max_nof_teids_), teid_pool(max_nof_teids_) {}
+  explicit gtpu_teid_pool_impl(uint32_t max_nof_teids_) :
+    max_nof_teids(max_nof_teids_), teid_pool(max_nof_teids_), logger(srslog::fetch_basic_logger("GTPU"))
+  {
+  }
 
   SRSRAN_NODISCARD expected<gtpu_teid_t> request_teid() override
   {
@@ -53,19 +56,19 @@ class gtpu_teid_pool_impl final : public gtpu_teid_pool
     return teid;
   }
 
-  SRSRAN_NODISCARD bool release_teid(gtpu_teid_t teid) override
+  bool release_teid(gtpu_teid_t teid) override
   {
     uint32_t teid_idx = teid.value() - GTPU_TEID_MIN.value();
     if (not teid_pool[teid_idx]) {
-      // trying to free non-allocated TEID
+      logger.error("Trying to free non-allocated TEID. teid={}", teid);
       return false;
     }
     teid_pool[teid_idx] = false;
     nof_teids--;
     return true;
   }
 
-  bool full() const override { return nof_teids >= max_nof_teids; }
+  [[nodiscard]] bool full() const override { return nof_teids >= max_nof_teids; }
 
   uint32_t get_max_nof_teids() override { return max_nof_teids; }
 
@@ -75,5 +78,7 @@ class gtpu_teid_pool_impl final : public gtpu_teid_pool
   const uint32_t max_nof_teids;
 
   std::vector<bool> teid_pool;
+
+  srslog::basic_logger& logger;
 };
 } // namespace srsran

tests/unittests/cu_up/cu_up_test.cpp

@@ -213,7 +213,7 @@ TEST_F(cu_up_test, dl_data_flow)
 
   // teid=2, qfi=1
   const uint8_t gtpu_ping_vec[] = {
-      0x34, 0xff, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x01, 0x00, 0x45,
+      0x34, 0xff, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x01, 0x00, 0x45,
       0x00, 0x00, 0x54, 0x9b, 0xfb, 0x00, 0x00, 0x40, 0x01, 0x56, 0x5a, 0xc0, 0xa8, 0x04, 0x01, 0xc0, 0xa8,
       0x03, 0x02, 0x00, 0x00, 0xb8, 0xc0, 0x00, 0x02, 0x00, 0x01, 0x5d, 0x26, 0x77, 0x64, 0x00, 0x00, 0x00,
       0x00, 0xb1, 0xde, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

tests/unittests/cu_up/cu_up_test_helpers.h

@@ -106,7 +106,7 @@ class dummy_gtpu_teid_pool final : public gtpu_teid_pool
 
   uint32_t get_max_nof_teids() override { return UINT32_MAX; }
 
-  uint32_t next_teid = 0;
+  uint32_t next_teid = 1;
 };
 
 /// Dummy adapter between GTP-U and Network Gateway

tests/unittests/cu_up/pdu_session_manager_test.cpp

@@ -39,7 +39,7 @@ TEST_P(pdu_session_manager_test_set_n3_ext_addr, when_valid_pdu_session_setup_it
                                             ? net_config.n3_bind_addr
                                             : net_config.n3_ext_addr;
   ASSERT_EQ(setup_result.gtp_tunnel.tp_address.to_string(), tp_address_expect);
-  ASSERT_EQ(setup_result.drb_setup_results[0].gtp_tunnel.gtp_teid.value(), 0);
+  ASSERT_EQ(setup_result.drb_setup_results[0].gtp_tunnel.gtp_teid.value(), 1);
   ASSERT_EQ(pdu_session_mng->get_nof_pdu_sessions(), 1);
 
   // attempt to remove non-existing session
@@ -378,15 +378,15 @@ TEST_F(pdu_session_manager_test, when_new_ul_info_is_requested_f1u_is_disconnect
   pdu_session_setup_result set_result = pdu_session_mng->setup_pdu_session(pdu_session_setup_item);
   ASSERT_EQ(pdu_session_mng->get_nof_pdu_sessions(), 1);
   drb_setup_result drb_setup_res = set_result.drb_setup_results[0];
-  ASSERT_EQ(drb_setup_res.gtp_tunnel.gtp_teid, 0x0);
+  ASSERT_EQ(drb_setup_res.gtp_tunnel.gtp_teid, 0x1);
 
   // prepare modification request (request new UL TNL info)
   e1ap_pdu_session_res_to_modify_item pdu_session_modify_item =
       generate_pdu_session_res_to_modify_item_to_modify_drb(psi, drb_id);
 
   pdu_session_modification_result mod_result  = pdu_session_mng->modify_pdu_session(pdu_session_modify_item, true);
   drb_setup_result                drb_mod_res = mod_result.drb_modification_results[0];
-  ASSERT_EQ(drb_mod_res.gtp_tunnel.gtp_teid, 0x1);
+  ASSERT_EQ(drb_mod_res.gtp_tunnel.gtp_teid, 0x2);
 
   ASSERT_EQ(pdu_session_mng->get_nof_pdu_sessions(), 1);
 }

tests/unittests/cu_up/pdu_session_manager_test.h

@@ -37,6 +37,7 @@ class pdu_session_manager_test_base
     gtpu_rx_demux    = std::make_unique<dummy_gtpu_demux_ctrl>();
     gtpu_tx_notifier = std::make_unique<dummy_gtpu_network_gateway_adapter>();
     f1u_gw           = std::make_unique<dummy_f1u_gateway>(f1u_bearer);
+    n3_allocator     = std::make_unique<dummy_gtpu_teid_pool>();
     f1u_allocator    = std::make_unique<dummy_gtpu_teid_pool>();
 
     // create DUT object