cu_cp,e1ap: release bearer context if last pdu session is released

Author: FabianEckermann

lib/cu_cp/routines/pdu_session_resource_release_routine.cpp

@@ -67,8 +67,18 @@ void pdu_session_resource_release_routine::operator()(
     next_config = up_resource_mng.calculate_update(release_cmd);
   }
 
-  // Inform CU-UP about the release of a bearer
-  {
+  // Inform the CU-UP about the release of the bearer context
+  if (next_config.pdu_sessions_to_remove_list.size() == up_resource_mng.get_nof_pdu_sessions()) {
+    bearer_context_release_command.ue_index = release_cmd.ue_index;
+    bearer_context_release_command.cause    = e1ap_cause_radio_network_t::unspecified;
+
+    /// NOTE: Only the Bearer Context at the CU-UP will be released. We don't want to release the UE.
+
+    // Request BearerContextRelease
+    CORO_AWAIT(e1ap_bearer_ctxt_mng.handle_bearer_context_release_command(bearer_context_release_command));
+
+  } else { // Inform CU-UP about the release of a bearer
+
     // prepare BearerContextModificationRequest and call e1 notifier
     bearer_context_modification_request.ue_index = release_cmd.ue_index;
 

lib/e1ap/cu_cp/e1ap_cu_cp_impl.cpp

@@ -94,7 +94,16 @@ e1ap_cu_cp_impl::handle_bearer_context_setup_request(const e1ap_bearer_context_s
   }
 
   // add new e1ap_ue_context
-  ue_ctxt_list.add_ue(request.ue_index, cu_cp_ue_e1ap_id);
+  if (ue_ctxt_list.add_ue(request.ue_index, cu_cp_ue_e1ap_id) == nullptr) {
+    logger.warning("Bearer Context Setup failed. Cause: bearer context already exists");
+    return launch_async([](coro_context<async_task<e1ap_bearer_context_setup_response>>& ctx) mutable {
+      CORO_BEGIN(ctx);
+      e1ap_bearer_context_setup_response res;
+      res.success = false;
+      CORO_RETURN(res);
+    });
+  }
+
   e1ap_ue_context& ue_ctxt = ue_ctxt_list[cu_cp_ue_e1ap_id];
 
   e1ap_message e1ap_msg;
@@ -162,7 +171,7 @@ e1ap_cu_cp_impl::handle_bearer_context_release_command(const e1ap_bearer_context
 
   fill_asn1_bearer_context_release_command(bearer_context_release_cmd, command);
 
-  return launch_async<bearer_context_release_procedure>(e1ap_msg, ue_ctxt.bearer_ev_mng, pdu_notifier, ue_ctxt.logger);
+  return launch_async<bearer_context_release_procedure>(e1ap_msg, command.ue_index, ue_ctxt_list, pdu_notifier);
 }
 
 void e1ap_cu_cp_impl::handle_message(const e1ap_message& msg)

lib/e1ap/cu_cp/procedures/bearer_context_release_procedure.cpp

@@ -11,29 +11,33 @@
 #include "bearer_context_release_procedure.h"
 #include "cu_cp/e1ap_cu_cp_impl.h"
 #include "cu_cp/ue_context/e1ap_bearer_transaction_manager.h"
+#include "cu_cp/ue_context/e1ap_cu_cp_ue_context.h"
+#include "srsran/support/srsran_assert.h"
 
 using namespace srsran;
 using namespace srsran::srs_cu_cp;
 using namespace asn1::e1ap;
 
 constexpr std::chrono::milliseconds bearer_context_release_response_timeout{5000};
 
-bearer_context_release_procedure::bearer_context_release_procedure(const e1ap_message&              command_,
-                                                                   e1ap_bearer_transaction_manager& ev_mng_,
-                                                                   e1ap_message_notifier&           e1ap_notif_,
-                                                                   e1ap_ue_logger&                  logger_) :
-  command(command_), ev_mng(ev_mng_), e1ap_notifier(e1ap_notif_), logger(logger_)
+bearer_context_release_procedure::bearer_context_release_procedure(const e1ap_message&    command_,
+                                                                   ue_index_t             ue_index_,
+                                                                   e1ap_ue_context_list&  ue_ctxt_list_,
+                                                                   e1ap_message_notifier& e1ap_notif_) :
+  command(command_), ue_index(ue_index_), ue_ctxt_list(ue_ctxt_list_), e1ap_notifier(e1ap_notif_)
 {
+  srsran_assert(ue_ctxt_list.contains(ue_index), "Bearer context does not exist in UE context list.");
 }
 
 void bearer_context_release_procedure::operator()(coro_context<async_task<void>>& ctx)
 {
   CORO_BEGIN(ctx);
 
-  logger.log_debug("\"{}\" initialized", name());
+  ue_ctxt_list[ue_index].logger.log_debug("\"{}\" initialized", name());
 
   // Subscribe to respective publisher to receive BEARER CONTEXT RELEASE COMPLETE message.
-  transaction_sink.subscribe_to(ev_mng.context_release_complete, bearer_context_release_response_timeout);
+  transaction_sink.subscribe_to(ue_ctxt_list[ue_index].bearer_ev_mng.context_release_complete,
+                                bearer_context_release_response_timeout);
 
   // Send command to CU-UP.
   send_bearer_context_release_command();
@@ -43,6 +47,8 @@ void bearer_context_release_procedure::operator()(coro_context<async_task<void>>
 
   handle_bearer_context_release_complete();
 
+  /// NOTE: From this point on the UE context is removed and only locally stored variables can be used.
+
   // Handle response from CU-UP and return bearer index
   CORO_RETURN();
 }
@@ -56,10 +62,13 @@ void bearer_context_release_procedure::send_bearer_context_release_command()
 void bearer_context_release_procedure::handle_bearer_context_release_complete()
 {
   if (transaction_sink.successful()) {
-    logger.log_debug("\"{}\" finalized", name());
+    ue_ctxt_list[ue_index].logger.log_debug("\"{}\" finalized", name());
 
   } else {
-    logger.log_warning("BearerContextReleaseComplete timeout");
-    logger.log_error("\"{}\" failed", name());
+    ue_ctxt_list[ue_index].logger.log_warning("BearerContextReleaseComplete timeout");
+    ue_ctxt_list[ue_index].logger.log_error("\"{}\" failed", name());
   }
+
+  // Remove UE context
+  ue_ctxt_list.remove_ue(ue_index);
 }

lib/e1ap/cu_cp/procedures/bearer_context_release_procedure.h

@@ -23,10 +23,10 @@ namespace srs_cu_cp {
 class bearer_context_release_procedure
 {
 public:
-  bearer_context_release_procedure(const e1ap_message&              command_,
-                                   e1ap_bearer_transaction_manager& ev_mng_,
-                                   e1ap_message_notifier&           e1ap_notif_,
-                                   e1ap_ue_logger&                  logger_);
+  bearer_context_release_procedure(const e1ap_message&    command_,
+                                   ue_index_t             ue_index_,
+                                   e1ap_ue_context_list&  ue_ctxt_list_,
+                                   e1ap_message_notifier& e1ap_notif_);
 
   void operator()(coro_context<async_task<void>>& ctx);
 
@@ -39,10 +39,10 @@ class bearer_context_release_procedure
   /// Handles procedure result and returns back to procedure caller.
   void handle_bearer_context_release_complete();
 
-  const e1ap_message               command;
-  e1ap_bearer_transaction_manager& ev_mng;
-  e1ap_message_notifier&           e1ap_notifier;
-  e1ap_ue_logger&                  logger;
+  const e1ap_message     command;
+  ue_index_t             ue_index;
+  e1ap_ue_context_list&  ue_ctxt_list;
+  e1ap_message_notifier& e1ap_notifier;
 
   protocol_transaction_outcome_observer<asn1::e1ap::bearer_context_release_complete_s> transaction_sink;
 };

lib/e1ap/cu_cp/ue_context/e1ap_cu_cp_ue_context.cpp

@@ -19,6 +19,11 @@ e1ap_ue_context* e1ap_ue_context_list::add_ue(ue_index_t ue_index, gnb_cu_cp_ue_
   srsran_assert(ue_index != ue_index_t::invalid, "Invalid ue_index={}", ue_index);
   srsran_assert(cu_cp_ue_e1ap_id != gnb_cu_cp_ue_e1ap_id_t::invalid, "Invalid cu_cp_ue_e1ap_id={}", cu_cp_ue_e1ap_id);
 
+  if (ue_index_to_ue_e1ap_id.find(ue_index) != ue_index_to_ue_e1ap_id.end()) {
+    logger.error("ue={}: UE already exists", ue_index);
+    return nullptr;
+  }
+
   auto ret = ues.emplace(std::piecewise_construct,
                          std::forward_as_tuple(cu_cp_ue_e1ap_id),
                          std::forward_as_tuple(ue_index, cu_cp_ue_e1ap_id, timers));

tests/unittests/cu_cp/cu_cp_test.cpp

@@ -263,8 +263,7 @@ TEST_F(cu_cp_test, when_unsupported_inactivity_message_received_then_ue_context_
 /* AMF initiated PDU Session Release                                                */
 //////////////////////////////////////////////////////////////////////////////////////
 
-// Bearer Context Release is not sent even if last PDU session is removed. Only NGAP UE context release triggers Bearer
-// Context Release.
+// When multiple PDU sessions exist and not all of them are released, a BearerContextModification is sent to the CU-UP
 TEST_F(cu_cp_test, when_pdu_session_resource_release_command_received_then_modification_request_is_sent)
 {
   // Test preamble
@@ -275,15 +274,16 @@ TEST_F(cu_cp_test, when_pdu_session_resource_release_command_received_then_modif
   pci_t               pci       = 1;
   amf_ue_id_t         amf_ue_id = uint_to_amf_ue_id(
       test_rgen::uniform_int<uint64_t>(amf_ue_id_to_uint(amf_ue_id_t::min), amf_ue_id_to_uint(amf_ue_id_t::max)));
-  ran_ue_id_t            ran_ue_id        = uint_to_ran_ue_id(0);
-  gnb_cu_cp_ue_e1ap_id_t cu_cp_ue_e1ap_id = int_to_gnb_cu_cp_ue_e1ap_id(0);
-  gnb_cu_up_ue_e1ap_id_t cu_up_ue_e1ap_id = int_to_gnb_cu_up_ue_e1ap_id(0);
+  ran_ue_id_t                   ran_ue_id        = uint_to_ran_ue_id(0);
+  std::vector<pdu_session_id_t> psis             = {uint_to_pdu_session_id(1), uint_to_pdu_session_id(2)};
+  gnb_cu_cp_ue_e1ap_id_t        cu_cp_ue_e1ap_id = int_to_gnb_cu_cp_ue_e1ap_id(0);
+  gnb_cu_up_ue_e1ap_id_t        cu_up_ue_e1ap_id = int_to_gnb_cu_up_ue_e1ap_id(0);
 
   // Connect AMF, DU, CU-UP
   test_preamble_all_connected(du_index, pci);
   // Attach UE
   test_preamble_ue_full_attach(
-      du_index, du_ue_id, cu_ue_id, crnti, amf_ue_id, ran_ue_id, cu_cp_ue_e1ap_id, cu_up_ue_e1ap_id);
+      du_index, du_ue_id, cu_ue_id, crnti, amf_ue_id, ran_ue_id, psis, cu_cp_ue_e1ap_id, cu_up_ue_e1ap_id);
 
   // Inject PduSessionResourceReleaseCommand
   cu_cp_obj->get_ngap_message_handler().handle_message(
@@ -295,6 +295,41 @@ TEST_F(cu_cp_test, when_pdu_session_resource_release_command_received_then_modif
             asn1::e1ap::e1ap_elem_procs_o::init_msg_c::types_opts::bearer_context_mod_request);
 }
 
+// When all active PDU sessions are released a BearerContextReleaseCommand is sent to the CU-UP
+TEST_F(cu_cp_test, when_all_pdu_sessions_get_released_then_bearer_context_release_command_is_sent)
+{
+  // Test preamble
+  du_index_t          du_index  = uint_to_du_index(0);
+  gnb_cu_ue_f1ap_id_t cu_ue_id  = int_to_gnb_cu_ue_f1ap_id(0);
+  gnb_du_ue_f1ap_id_t du_ue_id  = int_to_gnb_du_ue_f1ap_id(0);
+  rnti_t              crnti     = to_rnti(0x4601);
+  pci_t               pci       = 1;
+  amf_ue_id_t         amf_ue_id = uint_to_amf_ue_id(
+      test_rgen::uniform_int<uint64_t>(amf_ue_id_to_uint(amf_ue_id_t::min), amf_ue_id_to_uint(amf_ue_id_t::max)));
+  ran_ue_id_t                   ran_ue_id        = uint_to_ran_ue_id(0);
+  std::vector<pdu_session_id_t> psis             = {uint_to_pdu_session_id(1)};
+  gnb_cu_cp_ue_e1ap_id_t        cu_cp_ue_e1ap_id = int_to_gnb_cu_cp_ue_e1ap_id(0);
+  gnb_cu_up_ue_e1ap_id_t        cu_up_ue_e1ap_id = int_to_gnb_cu_up_ue_e1ap_id(0);
+
+  // Connect AMF, DU, CU-UP
+  test_preamble_all_connected(du_index, pci);
+  // Attach UE
+  test_preamble_ue_full_attach(
+      du_index, du_ue_id, cu_ue_id, crnti, amf_ue_id, ran_ue_id, psis, cu_cp_ue_e1ap_id, cu_up_ue_e1ap_id);
+
+  // Inject PduSessionResourceReleaseCommand
+  cu_cp_obj->get_ngap_message_handler().handle_message(
+      generate_valid_pdu_session_resource_release_command(amf_ue_id, ran_ue_id, uint_to_pdu_session_id(1)));
+
+  // Check that the Bearer Context Release was sent to the CU-UP
+  ASSERT_EQ(e1ap_gw.last_tx_pdus(0).back().pdu.type(), asn1::e1ap::e1ap_pdu_c::types_opts::options::init_msg);
+  ASSERT_EQ(e1ap_gw.last_tx_pdus(0).back().pdu.init_msg().value.type().value,
+            asn1::e1ap::e1ap_elem_procs_o::init_msg_c::types_opts::bearer_context_release_cmd);
+
+  // Check that no UE Context Release Request was sent to the AMF
+  ASSERT_NE(n2_gw.last_ngap_msgs.back().pdu.type(), asn1::ngap::ngap_pdu_c::types_opts::options::init_msg);
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 /* AMF initiated UE Context Release                                                 */
 //////////////////////////////////////////////////////////////////////////////////////