cu_cp,f1ap: refactor handling of initial ul rrc message

Author: FabianEckermann

include/srsran/f1ap/cu_cp/f1ap_cu.h

@@ -105,19 +105,22 @@ class f1ap_rrc_message_notifier
 /// This request should be made once the C-RNTI and cell of the UE is known. That generally corresponds to the moment
 /// a Initial UL RRC Message or a F1AP UE Context Setup Response are received.
 struct ue_rrc_context_creation_request {
-  ue_index_t                             ue_index;
-  rnti_t                                 c_rnti;
-  nr_cell_global_id_t                    cgi;
-  byte_buffer                            du_to_cu_rrc_container;
+  ue_index_t          ue_index = ue_index_t::invalid; ///> If this is invalid, a new UE will be created.
+  rnti_t              c_rnti;
+  nr_cell_global_id_t cgi;
+  byte_buffer         du_to_cu_rrc_container;
   std::optional<rrc_ue_transfer_context> prev_context;
 };
 
 /// \brief Response by CU-CP to F1AP-CU request to create UE RRC context.
 struct ue_rrc_context_creation_response {
+  ue_index_t ue_index = ue_index_t::invalid;
   /// Notifier to be used by the F1AP to push new RRC PDUs to the UE RRC layer.
   f1ap_rrc_message_notifier* f1ap_rrc_notifier = nullptr;
 };
 
+using ue_rrc_context_creation_outcome = expected<ue_rrc_context_creation_response, byte_buffer>;
+
 /// Notification from the F1AP that the loss of transaction reference information for some UEs has been lost.
 struct f1_ue_transaction_info_loss_event {
   std::vector<ue_index_t> ues_lost;
@@ -143,7 +146,7 @@ class f1ap_du_processor_notifier : public du_setup_notifier, public f1ap_common_
   virtual ue_index_t on_new_cu_cp_ue_required() = 0;
 
   /// \brief Notifies the CU-CP that an RRC context has been created for an existing CU-CP UE.
-  virtual ue_rrc_context_creation_response
+  virtual ue_rrc_context_creation_outcome
   on_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req) = 0;
 
   /// \brief Indicates the reception of a UE Context Release Request (gNB-DU initiated) as per TS 38.473

lib/cu_cp/adapters/du_processor_adapters.h

@@ -157,6 +157,12 @@ class du_processor_rrc_du_adapter : public du_processor_rrc_du_ue_notifier
     return rrc_du_cell_handler->handle_served_cell_list(served_cell_list);
   }
 
+  byte_buffer on_rrc_reject_required() override
+  {
+    srsran_assert(rrc_du_handler != nullptr, "RRC DU UE handler must not be nullptr");
+    return rrc_du_handler->get_rrc_reject();
+  }
+
   rrc_ue_interface* on_ue_creation_request(const rrc_ue_creation_message& msg) override
   {
     srsran_assert(rrc_du_handler != nullptr, "RRC DU UE handler must not be nullptr");

lib/cu_cp/adapters/f1ap_adapters.h

@@ -43,7 +43,7 @@ class f1ap_du_processor_adapter : public f1ap_du_processor_notifier
     return du_f1ap_handler->allocate_new_ue_index();
   }
 
-  ue_rrc_context_creation_response
+  ue_rrc_context_creation_outcome
   on_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req) override
   {
     srsran_assert(du_f1ap_handler != nullptr, "F1AP handler must not be nullptr");

lib/cu_cp/du_processor/du_processor.h

@@ -41,7 +41,7 @@ class du_processor_f1ap_interface
   /// This method should be called when a C-RNTI and PCell are assigned to a UE.
   /// \param req Request to setup a new UE RRC context.
   /// \return Response to whether the request was successful or failed.
-  virtual ue_rrc_context_creation_response
+  virtual ue_rrc_context_creation_outcome
   handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req) = 0;
 
   /// \brief Handle the reception of a F1AP UE Context Release Request and notify NGAP.
@@ -131,6 +131,10 @@ class du_processor_rrc_du_ue_notifier
   /// \return Returns true on success, false otherwise.
   virtual bool on_new_served_cell_list(const std::vector<cu_cp_du_served_cells_item>& served_cell_list) = 0;
 
+  /// \brief Notify RRC DU about a required RRCReject.
+  /// \return Returns a RRC Container containing the RRCReject.
+  virtual byte_buffer on_rrc_reject_required() = 0;
+
   /// \brief Notify RRC DU to create a UE.
   /// \param[in] msg The UE creation message.
   /// \return Returns a handle to the created UE.

lib/cu_cp/du_processor/du_processor_impl.cpp

@@ -161,48 +161,62 @@ bool du_processor_impl::create_rrc_ue(cu_cp_ue&                              ue,
   return true;
 }
 
-ue_rrc_context_creation_response
+ue_rrc_context_creation_outcome
 du_processor_impl::handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req)
 {
-  srsran_assert(req.ue_index != ue_index_t::invalid, "Invalid UE index");
   srsran_assert(req.c_rnti != rnti_t::INVALID_RNTI, "ue={}: Invalid C-RNTI", req.ue_index);
 
+  ue_index_t ue_index = req.ue_index;
+
+  if (ue_index == ue_index_t::invalid) {
+    // Add new CU-CP UE
+    ue_index = ue_mng.add_ue(cfg.du_index);
+    if (ue_index == ue_index_t::invalid) {
+      logger.warning("CU-CP UE creation failed");
+      return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
+    }
+
+    /// NOTE: From this point on the UE exists in the UE manager and must be removed if any error occurs.
+  }
+
+  // Lambda, that removes the UE from the UE manager and returns a RRCReject container.
+  auto return_failure = [this](ue_index_t ue_id) {
+    // Remove the UE from the UE manager
+    ue_mng.remove_ue(ue_id);
+    // Return the RRCReject container
+    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
+  };
+
   // Check that creation message is valid
   const du_cell_configuration* pcell = cfg.du_cfg_hdlr->get_context().find_cell(req.cgi);
   if (pcell == nullptr) {
-    srsran_assert(ue_mng.find_ue_task_scheduler(req.ue_index) != nullptr, "ue={}: Could not find UE", req.ue_index);
-    logger.warning("ue={}: Could not find cell with NCI={}", req.ue_index, req.cgi.nci);
-    ue_mng.find_ue_task_scheduler(req.ue_index)
-        ->schedule_async_task(cu_cp_notifier.on_ue_removal_required(req.ue_index));
-    return {};
+    logger.warning("ue={}: Could not find cell with NCI={}", ue_index, req.cgi.nci);
+    return return_failure(ue_index);
   }
   const pci_t pci = pcell->pci;
 
   // Create new UE RRC context
-  cu_cp_ue* ue = ue_mng.set_ue_du_context(req.ue_index, cfg.du_cfg_hdlr->get_context().id, pci, req.c_rnti);
+  cu_cp_ue* ue = ue_mng.set_ue_du_context(ue_index, cfg.du_cfg_hdlr->get_context().id, pci, req.c_rnti);
   if (ue == nullptr) {
-    logger.warning("ue={}: Could not create UE context", req.ue_index);
-    return {};
+    logger.warning("ue={}: Could not create UE context", ue_index);
+    // A UE with the same PCI and RNTI already exists, so we don't remove it and only reject the new UE.
+    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
   }
   ue->set_pcell_index(pcell->cell_index);
 
   // Create RRC UE. If the DU-to-CU-RRC-Container is empty, the UE will be rejected.
   if (not create_rrc_ue(*ue, req.c_rnti, req.cgi, req.du_to_cu_rrc_container.copy(), std::move(req.prev_context))) {
-    logger.warning("ue={}: Could not create RRC UE object", req.ue_index);
-    return {};
+    logger.warning("ue={}: Could not create RRC UE object", ue_index);
+    return return_failure(ue_index);
   }
-  rrc_ue_interface* rrc_ue           = rrc->find_ue(req.ue_index);
-  f1ap_rrc_ue_adapters[req.ue_index] = {};
-  f1ap_rrc_ue_adapters.at(req.ue_index)
-      .connect_rrc_ue(rrc_ue->get_ul_ccch_pdu_handler(), rrc_ue->get_ul_dcch_pdu_handler());
-
-  // Signal back to F1AP that the UE was successfully created.
-  ue_rrc_context_creation_response response;
-  response.f1ap_rrc_notifier = &f1ap_rrc_ue_adapters.at(req.ue_index);
+  rrc_ue_interface* rrc_ue       = rrc->find_ue(ue_index);
+  f1ap_rrc_ue_adapters[ue_index] = {};
+  f1ap_rrc_ue_adapters.at(ue_index).connect_rrc_ue(rrc_ue->get_ul_ccch_pdu_handler(),
+                                                   rrc_ue->get_ul_dcch_pdu_handler());
 
+  // Signal back that the UE was successfully created.
   logger.info("ue={} c-rnti={}: UE created", ue->get_ue_index(), req.c_rnti);
-
-  return response;
+  return ue_rrc_context_creation_response{ue_index, &f1ap_rrc_ue_adapters.at(ue_index)};
 }
 
 void du_processor_impl::handle_du_initiated_ue_context_release_request(const f1ap_ue_context_release_request& request)

lib/cu_cp/du_processor/du_processor_impl.h

@@ -62,7 +62,7 @@ class du_processor_impl : public du_processor,
   // du_processor_f1ap_interface
   du_setup_result handle_du_setup_request(const du_setup_request& req) override;
   ue_index_t      allocate_new_ue_index() override;
-  ue_rrc_context_creation_response
+  ue_rrc_context_creation_outcome
        handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req) override;
   void handle_du_initiated_ue_context_release_request(const f1ap_ue_context_release_request& request) override;
   async_task<void> handle_ue_transaction_info_loss(const f1_ue_transaction_info_loss_event& request) override;

lib/f1ap/cu_cp/f1ap_cu_impl.cpp

@@ -239,25 +239,20 @@ void f1ap_cu_impl::handle_initial_ul_rrc_message(const init_ul_rrc_msg_transfer_
     logger.debug("du_ue={}: Ignoring SUL access indicator", du_ue_id);
   }
 
+  if (msg->rrc_container_rrc_setup_complete_present) {
+    logger.debug("du_ue={}: Ignoring RRC Container RRCSetupComplete", du_ue_id);
+  }
+
   const gnb_cu_ue_f1ap_id_t cu_ue_f1ap_id = ue_ctxt_list.allocate_gnb_cu_ue_f1ap_id();
   if (cu_ue_f1ap_id == gnb_cu_ue_f1ap_id_t::invalid) {
     logger.warning("du_ue={}: Dropping InitialULRRCMessageTransfer. Cause: Failed to allocate CU-UE-F1AP-ID", du_ue_id);
     return;
   }
 
-  // Create CU-CP UE instance.
-  const ue_index_t ue_index = du_processor_notifier.on_new_cu_cp_ue_required();
-  if (ue_index == ue_index_t::invalid) {
-    logger.warning("du_ue={}: Dropping InitialULRRCMessageTransfer. Cause: CU-CP UE creation failed",
-                   msg->gnb_du_ue_f1ap_id);
-    return;
-  }
-
-  // Update the UE RRC context (e.g. C-RNTI, PCell) in the CU-CP.
+  // Request RRC UE creation in the DU processor.
   ue_rrc_context_creation_request req;
-  req.ue_index = ue_index;
-  req.c_rnti   = crnti;
-  req.cgi      = cgi.value();
+  req.c_rnti = crnti;
+  req.cgi    = cgi.value();
   if (msg->du_to_cu_rrc_container_present) {
     req.du_to_cu_rrc_container = byte_buffer(msg->du_to_cu_rrc_container);
   } else {
@@ -268,33 +263,37 @@ void f1ap_cu_impl::handle_initial_ul_rrc_message(const init_ul_rrc_msg_transfer_
                  du_ue_id);
     req.du_to_cu_rrc_container = byte_buffer{};
   }
-  const ue_rrc_context_creation_response resp = du_processor_notifier.on_ue_rrc_context_creation_request(req);
-
-  // Remove the UE if the creation was not successful
-  if (resp.f1ap_rrc_notifier == nullptr) {
-    logger.warning("du_ue={}: Dropping InitialULRRCMessageTransfer. Cause: UE RRC context creation failed",
-                   msg->gnb_du_ue_f1ap_id);
+  ue_rrc_context_creation_outcome resp = du_processor_notifier.on_ue_rrc_context_creation_request(req);
+
+  // Reject the UE if the creation was not successful
+  if (not resp.has_value()) {
+    asn1::f1ap::dl_rrc_msg_transfer_s dl_rrc_msg = {};
+    dl_rrc_msg->gnb_cu_ue_f1ap_id                = gnb_cu_ue_f1ap_id_to_uint(cu_ue_f1ap_id);
+    dl_rrc_msg->gnb_du_ue_f1ap_id                = gnb_du_ue_f1ap_id_to_uint(du_ue_id);
+    dl_rrc_msg->srb_id                           = srb_id_to_uint(srb_id_t::srb0);
+    dl_rrc_msg->rrc_container                    = resp.error().copy();
+
+    // Pack message into PDU
+    f1ap_message f1ap_dl_rrc_msg;
+    f1ap_dl_rrc_msg.pdu.set_init_msg();
+    f1ap_dl_rrc_msg.pdu.init_msg().load_info_obj(ASN1_F1AP_ID_DL_RRC_MSG_TRANSFER);
+    f1ap_dl_rrc_msg.pdu.init_msg().value.dl_rrc_msg_transfer() = std::move(dl_rrc_msg);
+
+    // send DL RRC message
+    tx_pdu_notifier.on_new_message(f1ap_dl_rrc_msg);
     return;
   }
 
   // Create UE context and store it
-  ue_ctxt_list.add_ue(ue_index, cu_ue_f1ap_id);
+  ue_ctxt_list.add_ue(resp->ue_index, cu_ue_f1ap_id);
   ue_ctxt_list.add_du_ue_f1ap_id(cu_ue_f1ap_id, du_ue_id);
-  ue_ctxt_list.add_rrc_notifier(ue_index, resp.f1ap_rrc_notifier);
+  ue_ctxt_list.add_rrc_notifier(resp->ue_index, resp->f1ap_rrc_notifier);
   f1ap_ue_context& ue_ctxt = ue_ctxt_list[cu_ue_f1ap_id];
 
   ue_ctxt.logger.log_info("Added UE context");
 
-  // Forward RRC container
-  if (msg->rrc_container_rrc_setup_complete_present) {
-    // RRC setup complete over SRB1
-    ue_ctxt_list[cu_ue_f1ap_id].rrc_notifier->on_ul_dcch_pdu(srb_id_t::srb1,
-                                                             msg->rrc_container_rrc_setup_complete.copy());
-    return;
-  }
-
-  // Pass RRC container to RRC
-  ue_ctxt_list[cu_ue_f1ap_id].rrc_notifier->on_ul_ccch_pdu(msg->rrc_container.copy());
+  // Forward RRC container to RRC UE
+  ue_ctxt.rrc_notifier->on_ul_ccch_pdu(byte_buffer(msg->rrc_container));
 }
 
 void f1ap_cu_impl::handle_ul_rrc_message(const ul_rrc_msg_transfer_s& msg)

lib/f1ap/cu_cp/procedures/ue_context_setup_procedure.cpp

@@ -124,16 +124,16 @@ bool ue_context_setup_procedure::create_ue_rrc_context(const f1ap_ue_context_set
     req.du_to_cu_rrc_container = ue_ctxt_setup_resp.du_to_cu_rrc_info.cell_group_cfg.copy();
     req.prev_context           = std::move(rrc_context);
 
-    ue_rrc_context_creation_response resp = du_processor_notifier.on_ue_rrc_context_creation_request(req);
-    if (resp.f1ap_rrc_notifier == nullptr) {
+    ue_rrc_context_creation_outcome outcome = du_processor_notifier.on_ue_rrc_context_creation_request(req);
+    if (not outcome.has_value()) {
       logger.warning("Couldn't create UE RRC context in target cell");
       return false;
     }
 
     // Add RRC notifier to F1AP UE context.
-    ue_ctxt_list.add_rrc_notifier(req.ue_index, resp.f1ap_rrc_notifier);
+    ue_ctxt_list.add_rrc_notifier(outcome->ue_index, outcome->f1ap_rrc_notifier);
 
-    logger.debug("ue={} Added RRC UE notifier", req.ue_index);
+    logger.debug("ue={} Added RRC UE notifier", outcome->ue_index);
   }
 
   return true;

tests/unittests/cu_cp/du_processor/du_processor_test.cpp

@@ -98,14 +98,13 @@ TEST_F(du_processor_test, when_ue_creation_msg_valid_then_ue_added)
       test_helpers::generate_f1_setup_request());
 
   // Generate ue_creation message
-  ue_index_t                      ue_index = du_processor_obj->get_f1ap_interface().allocate_new_ue_index();
-  ue_rrc_context_creation_request req      = generate_ue_rrc_context_creation_request(
-      ue_index, rnti_t::MIN_CRNTI, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
+  ue_rrc_context_creation_request req = generate_ue_rrc_context_creation_request(
+      ue_index_t::invalid, rnti_t::MIN_CRNTI, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
 
   // Pass message to DU processor
-  ue_rrc_context_creation_response resp =
+  ue_rrc_context_creation_outcome outcome =
       du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
-  ASSERT_NE(resp.f1ap_rrc_notifier, nullptr);
+  ASSERT_TRUE(outcome.has_value());
 
   ASSERT_EQ(du_processor_obj->get_statistics_handler().get_nof_ues(), 1);
 }
@@ -117,14 +116,13 @@ TEST_F(du_processor_test, when_cell_id_invalid_then_ue_creation_fails)
       test_helpers::generate_f1_setup_request());
 
   // Generate ue_creation message
-  ue_index_t                      ue_index = du_processor_obj->get_f1ap_interface().allocate_new_ue_index();
-  ue_rrc_context_creation_request req =
-      generate_ue_rrc_context_creation_request(ue_index, rnti_t::MIN_CRNTI, nr_cell_identity::create(1).value());
+  ue_rrc_context_creation_request req = generate_ue_rrc_context_creation_request(
+      ue_index_t::invalid, rnti_t::MIN_CRNTI, nr_cell_identity::create(1).value());
 
   // Pass message to DU processor
-  ue_rrc_context_creation_response resp =
+  ue_rrc_context_creation_outcome outcome =
       du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
-  ASSERT_EQ(resp.f1ap_rrc_notifier, nullptr);
+  ASSERT_TRUE(not outcome.has_value());
 }
 
 TEST_F(du_processor_test, when_ue_rrc_context_exists_then_new_ue_rrc_context_not_added)
@@ -138,20 +136,21 @@ TEST_F(du_processor_test, when_ue_rrc_context_exists_then_new_ue_rrc_context_not
       test_helpers::generate_f1_setup_request());
 
   // Generate ue_creation message
-  ue_index_t                      ue_index = du_processor_obj->get_f1ap_interface().allocate_new_ue_index();
-  ue_rrc_context_creation_request req      = generate_ue_rrc_context_creation_request(
-      ue_index, rnti_t::MIN_CRNTI, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
+  ue_rrc_context_creation_request req = generate_ue_rrc_context_creation_request(
+      ue_index_t::invalid, rnti_t::MIN_CRNTI, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
 
   // Pass message to DU processor
-  ue_rrc_context_creation_response resp =
+  ue_rrc_context_creation_outcome outcome =
       du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
-  ASSERT_NE(resp.f1ap_rrc_notifier, nullptr);
+  ASSERT_TRUE(outcome.has_value());
 
   ASSERT_EQ(du_processor_obj->get_statistics_handler().get_nof_ues(), 1);
 
   // Pass same message to DU processor again
-  resp = du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
-  ASSERT_EQ(resp.f1ap_rrc_notifier, nullptr);
+  req.ue_index = outcome->ue_index;
+  ue_rrc_context_creation_outcome outcome2 =
+      du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
+  ASSERT_TRUE(not outcome2.has_value());
 
   ASSERT_EQ(du_processor_obj->get_statistics_handler().get_nof_ues(), 1);
 }
@@ -171,15 +170,14 @@ TEST_F(du_processor_test, when_max_nof_ues_exceeded_then_ue_not_added)
   // Add the maximum number of UEs
   for (unsigned it = 0; it < ue_mng.get_ue_config().max_nof_supported_ues; it++) {
     // Generate ue_creation message
-    rnti_t                          c_rnti   = to_rnti(it + 1); // 0 is not a valid RNTI
-    ue_index_t                      ue_index = du_processor_obj->get_f1ap_interface().allocate_new_ue_index();
-    ue_rrc_context_creation_request req      = generate_ue_rrc_context_creation_request(
-        ue_index, c_rnti, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
+    rnti_t                          c_rnti = to_rnti(it + 1); // 0 is not a valid RNTI
+    ue_rrc_context_creation_request req    = generate_ue_rrc_context_creation_request(
+        ue_index_t::invalid, c_rnti, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
 
     // Pass message to DU processor
-    ue_rrc_context_creation_response resp =
+    ue_rrc_context_creation_outcome outcome =
         du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
-    ASSERT_NE(resp.f1ap_rrc_notifier, nullptr);
+    ASSERT_TRUE(outcome.has_value());
   }
 
   // Reset logger loglevel
@@ -190,9 +188,13 @@ TEST_F(du_processor_test, when_max_nof_ues_exceeded_then_ue_not_added)
 
   ASSERT_EQ(du_processor_obj->get_statistics_handler().get_nof_ues(), ue_mng.get_ue_config().max_nof_supported_ues);
 
-  // Try to allocate additional UE index
-  ue_index_t ue_index = du_processor_obj->get_f1ap_interface().allocate_new_ue_index();
-  ASSERT_EQ(ue_index, ue_index_t::invalid);
+  // Try to add additional UE
+  rnti_t                          c_rnti = to_rnti(ue_mng.get_ue_config().max_nof_supported_ues + 1);
+  ue_rrc_context_creation_request req    = generate_ue_rrc_context_creation_request(
+      ue_index_t::invalid, c_rnti, nr_cell_identity::create(gnb_id_t{411, 22}, 0).value());
+  ue_rrc_context_creation_outcome outcome =
+      du_processor_obj->get_f1ap_interface().handle_ue_rrc_context_creation_request(req);
+  ASSERT_TRUE(not outcome.has_value());
 
   ASSERT_EQ(du_processor_obj->get_statistics_handler().get_nof_ues(), ue_mng.get_ue_config().max_nof_supported_ues);
 }