f1ap-cu: make creation of a ue in the cu-cp during the initial ul rrc message into a single step

Author: frankist

include/srsran/cu_cp/cu_cp_ue_messages.h

@@ -34,7 +34,7 @@ struct rrc_ue_transfer_context {
 /// \brief The UE creation is triggered from the F1AP.
 /// It carries an RRC container and the C-RNTI if the DU sent an Initial UL RRC transfer. If the user is created
 /// during handover the RNTI is only allocated after the Random Access.
-struct cu_cp_ue_creation_message {
+struct cu_cp_ue_creation_request {
   ue_index_t                        ue_index = ue_index_t::invalid;
   nr_cell_global_id_t               cgi;
   uint32_t                          tac;

include/srsran/f1ap/cu_cp/f1ap_cu.h

@@ -99,12 +99,8 @@ class f1ap_rrc_message_notifier
   virtual void on_ul_dcch_pdu(const srb_id_t srb_id, byte_buffer pdu) = 0;
 };
 
-struct f1ap_srb_creation_message {
-  ue_index_t ue_index = ue_index_t::invalid;
-  srb_id_t   srb_id   = srb_id_t::nulltype;
-};
-
-struct ue_creation_complete_message {
+/// Response provided by the CU-CP to the F1AP-CU when a UE context creation in the CU-CP is requested.
+struct cu_cp_ue_creation_response {
   ue_index_t                 ue_index          = ue_index_t::invalid;
   f1ap_rrc_message_notifier* f1ap_rrc_notifier = nullptr;
 };
@@ -129,13 +125,10 @@ class f1ap_du_processor_notifier : public du_setup_notifier
 public:
   virtual ~f1ap_du_processor_notifier() = default;
 
-  /// \brief Request allocation of a new UE index.
-  virtual ue_index_t on_new_ue_index_required() = 0;
-
   /// \brief Notifies the DU processor to create a UE.
   /// \param[in] msg The ue creation message.
   /// \return Returns a UE creation complete message containing the index of the created UE and its SRB notifiers.
-  virtual ue_creation_complete_message on_create_ue(const cu_cp_ue_creation_message& msg) = 0;
+  virtual cu_cp_ue_creation_response on_ue_creation_request(const cu_cp_ue_creation_request& msg) = 0;
 
   /// \brief Indicates the reception of a UE Context Release Request (gNB-DU initiated) as per TS 38.473
   /// section 8.3.2.

lib/cu_cp/adapters/f1ap_adapters.h

@@ -69,13 +69,7 @@ class f1ap_du_processor_adapter : public f1ap_du_processor_notifier
 
   du_index_t get_du_index() override { return du_f1ap_handler->get_du_index(); }
 
-  ue_index_t on_new_ue_index_required() override
-  {
-    srsran_assert(du_f1ap_handler != nullptr, "F1AP handler must not be nullptr");
-    return du_f1ap_handler->get_new_ue_index();
-  }
-
-  ue_creation_complete_message on_create_ue(const cu_cp_ue_creation_message& msg) override
+  cu_cp_ue_creation_response on_ue_creation_request(const cu_cp_ue_creation_request& msg) override
   {
     srsran_assert(du_f1ap_handler != nullptr, "F1AP handler must not be nullptr");
     return du_f1ap_handler->handle_ue_creation_request(msg);

lib/cu_cp/du_processor/du_processor_impl.cpp

@@ -245,55 +245,59 @@ bool du_processor_impl::create_rrc_ue(du_ue&                            ue,
   return true;
 }
 
-ue_creation_complete_message du_processor_impl::handle_ue_creation_request(const cu_cp_ue_creation_message& msg)
+cu_cp_ue_creation_response du_processor_impl::handle_ue_creation_request(const cu_cp_ue_creation_request& msg)
 {
-  srsran_assert(msg.ue_index != ue_index_t::invalid, "Invalid UE index", msg.ue_index);
-  srsran_assert(srsran::config_helpers::is_valid(msg.cgi), "ue={}: Invalid CGI", msg.ue_index);
+  srsran_assert(config_helpers::is_valid(msg.cgi), "ue={}: Invalid CGI", msg.ue_index);
   srsran_assert(msg.c_rnti != rnti_t::INVALID_RNTI, "ue={}: Invalid C-RNTI", msg.ue_index);
 
-  ue_creation_complete_message ue_creation_complete_msg = {};
-  ue_creation_complete_msg.ue_index                     = ue_index_t::invalid;
-
   // Check that creation message is valid
   du_cell_index_t pcell_index = find_cell(msg.cgi.nci);
   if (pcell_index == du_cell_index_t::invalid) {
     logger.warning("ue={}: Could not find cell with cell_id={}", msg.ue_index, msg.cgi.nci);
-    return ue_creation_complete_msg;
+    return {};
   }
-
-  // Check that the PCI is valid
-  pci_t pci = cell_db.at(pcell_index).pci;
-  if (pci == INVALID_PCI) {
-    logger.warning("ue={} pci={}: Invalid PCI", msg.ue_index, pci);
-    return ue_creation_complete_msg;
+  const pci_t pci = cell_db.at(pcell_index).pci;
+
+  // Allocate new UE index.
+  ue_index_t ue_index = msg.ue_index;
+  if (ue_index == ue_index_t::invalid) {
+    // It's a new UE. Allocate new UE index.
+    ue_index = get_new_ue_index();
+    if (ue_index == ue_index_t::invalid) {
+      logger.warning("ue={}: Could not create UE context", ue_index);
+      return {};
+    }
   }
 
   // Create new UE context
-  du_ue* ue = ue_manager.add_ue(msg.ue_index, context.id, pci, msg.c_rnti);
+  du_ue* ue = ue_manager.add_ue(ue_index, context.id, pci, msg.c_rnti);
   if (ue == nullptr) {
-    logger.warning("ue={}: Could not create UE context", msg.ue_index);
-    return ue_creation_complete_msg;
+    logger.warning("ue={}: Could not create UE context", ue_index);
+    return {};
   }
 
   // Set parameters from creation message
   ue->set_pcell_index(pcell_index);
 
   // Create RRC UE. If the DU-to-CU-RRC-Container is empty, the UE will be rejected.
-  if (create_rrc_ue(*ue, msg.c_rnti, msg.cgi, msg.du_to_cu_rrc_container.copy(), std::move(msg.rrc_context)) == false) {
-    logger.warning("ue={}: Could not create RRC UE object", msg.ue_index);
-    return ue_creation_complete_msg;
+  if (not create_rrc_ue(*ue, msg.c_rnti, msg.cgi, msg.du_to_cu_rrc_container.copy(), std::move(msg.rrc_context))) {
+    logger.warning("ue={}: Could not create RRC UE object", ue_index);
+    ue_manager.remove_ue(ue_index);
+    return {};
   }
-  rrc_ue_interface* rrc_ue           = rrc->find_ue(msg.ue_index);
-  f1ap_rrc_ue_adapters[msg.ue_index] = {};
-  f1ap_rrc_ue_adapters.at(msg.ue_index)
-      .connect_rrc_ue(rrc_ue->get_ul_ccch_pdu_handler(), rrc_ue->get_ul_dcch_pdu_handler());
-  ue_creation_complete_msg.f1ap_rrc_notifier = &f1ap_rrc_ue_adapters.at(msg.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());
 
-  logger.info("ue={} c-rnti={}: UE created", ue->get_ue_index(), msg.c_rnti);
+  // Signal back to F1AP that the UE was successfully created.
+  cu_cp_ue_creation_response response;
+  response.ue_index          = ue_index;
+  response.f1ap_rrc_notifier = &f1ap_rrc_ue_adapters.at(ue_index);
 
-  ue_creation_complete_msg.ue_index = ue->get_ue_index();
+  logger.info("ue={} c-rnti={}: UE created", ue->get_ue_index(), msg.c_rnti);
 
-  return ue_creation_complete_msg;
+  return response;
 }
 
 ue_update_complete_message du_processor_impl::handle_ue_update_request(const ue_update_message& msg)

lib/cu_cp/du_processor/du_processor_impl.h

@@ -55,9 +55,9 @@ class du_processor_impl : public du_processor_impl_interface, public du_setup_ha
   size_t get_nof_ues() const override { return ue_manager.get_nof_du_ues(context.du_index); };
 
   // du_processor_f1ap_interface
-  du_setup_result              handle_du_setup_request(const du_setup_request& req) override;
-  ue_index_t                   get_new_ue_index() override;
-  ue_creation_complete_message handle_ue_creation_request(const cu_cp_ue_creation_message& msg) override;
+  du_setup_result            handle_du_setup_request(const du_setup_request& req) override;
+  ue_index_t                 get_new_ue_index() override;
+  cu_cp_ue_creation_response handle_ue_creation_request(const cu_cp_ue_creation_request& msg) override;
   void handle_du_initiated_ue_context_release_request(const f1ap_ue_context_release_request& request) override;
   ue_update_complete_message handle_ue_update_request(const ue_update_message& msg) override;
 

lib/cu_cp/du_processor/du_processor_impl_interface.h

@@ -46,7 +46,7 @@ class du_processor_f1ap_interface
   /// \brief Create a new UE context.
   /// \param[in] msg The UE creation message.
   /// \return Returns a UE creation complete message containing the index of the created UE and its SRB notifiers.
-  virtual ue_creation_complete_message handle_ue_creation_request(const cu_cp_ue_creation_message& msg) = 0;
+  virtual cu_cp_ue_creation_response handle_ue_creation_request(const cu_cp_ue_creation_request& msg) = 0;
 
   /// \brief Update existing UE object.
   virtual ue_update_complete_message handle_ue_update_request(const ue_update_message& msg) = 0;

lib/f1ap/cu_cp/f1ap_cu_impl.cpp

@@ -35,7 +35,6 @@ f1ap_cu_impl::f1ap_cu_impl(f1ap_message_notifier&       f1ap_pdu_notifier_,
   pdu_notifier(f1ap_pdu_notifier_),
   du_processor_notifier(f1ap_du_processor_notifier_),
   du_management_notifier(f1ap_du_management_notifier_),
-  cu_cp_notifier(f1ap_cu_cp_notifier_),
   ctrl_exec(ctrl_exec_)
 {
 }
@@ -224,75 +223,68 @@ void f1ap_cu_impl::handle_f1_setup_request(const f1_setup_request_s& request)
 
 void f1ap_cu_impl::handle_initial_ul_rrc_message(const init_ul_rrc_msg_transfer_s& msg)
 {
+  const gnb_du_ue_f1ap_id_t du_ue_id = int_to_gnb_du_ue_f1ap_id(msg->gnb_du_ue_f1ap_id);
+
   nr_cell_global_id_t cgi = cgi_from_asn1(msg->nr_cgi);
-  if (not srsran::config_helpers::is_valid(cgi)) {
-    logger.warning("du_ue_f1ap_id={}: Dropping InitialUlRrcMessageTransfer. Invalid CGI", msg->gnb_du_ue_f1ap_id);
+  if (not config_helpers::is_valid(cgi)) {
+    logger.warning("du_ue_f1ap_id={}: Dropping InitialULRRCMessageTransfer. Invalid CGI", du_ue_id);
     return;
   }
 
   rnti_t crnti = to_rnti(msg->c_rnti);
   if (crnti == rnti_t::INVALID_RNTI) {
-    logger.warning("du_ue_f1ap_id={}: Dropping InitialUlRrcMessageTransfer. Invalid RNTI", msg->gnb_du_ue_f1ap_id);
+    logger.warning("du_ue_f1ap_id={}: Dropping InitialULRRCMessageTransfer. Cause: Invalid C-RNTI", du_ue_id);
     return;
   }
 
-  logger.debug("du_ue_f1ap_id={} nci={} crnti={} plmn={}: Received InitialUlRrcMessageTransfer",
-               msg->gnb_du_ue_f1ap_id,
+  logger.debug("du_ue_f1ap_id={} nci={} crnti={} plmn={}: Received InitialULRRCMessageTransfer",
+               du_ue_id,
                cgi.nci,
                crnti,
                cgi.plmn);
 
   if (msg->sul_access_ind_present) {
-    logger.debug("du_ue_f1ap_id={}: Ignoring SUL access indicator", msg->gnb_du_ue_f1ap_id);
+    logger.debug("du_ue_f1ap_id={}: Ignoring SUL access indicator", du_ue_id);
   }
 
-  gnb_cu_ue_f1ap_id_t cu_ue_f1ap_id = ue_ctxt_list.next_gnb_cu_ue_f1ap_id();
+  const gnb_cu_ue_f1ap_id_t cu_ue_f1ap_id = ue_ctxt_list.next_gnb_cu_ue_f1ap_id();
   if (cu_ue_f1ap_id == gnb_cu_ue_f1ap_id_t::invalid) {
-    logger.warning("du_ue_f1ap_id={}: Dropping InitialUlRrcMessageTransfer. No CU UE F1AP ID available",
-                   msg->gnb_du_ue_f1ap_id);
-    return;
-  }
-
-  // Request UE index allocation
-  ue_index_t ue_index = du_processor_notifier.on_new_ue_index_required();
-  if (ue_index == ue_index_t::invalid) {
-    logger.warning("du_ue_f1ap_id={}: Dropping InitialUlRrcMessageTransfer. No UE Index available",
-                   msg->gnb_du_ue_f1ap_id);
+    logger.warning("du_ue_f1ap_id={}: Dropping InitialULRRCMessageTransfer. Cause: Failed to allocate CU-UE-F1AP-ID",
+                   du_ue_id);
     return;
   }
 
-  // Request UE creation
-  cu_cp_ue_creation_message ue_creation_msg = {};
-  ue_creation_msg.ue_index                  = ue_index;
+  // Request UE context creation to CU-CP.
+  cu_cp_ue_creation_request ue_creation_msg = {};
+  ue_creation_msg.cgi                       = cgi;
   ue_creation_msg.c_rnti                    = crnti;
-  ue_creation_msg.cgi                       = cgi_from_asn1(msg->nr_cgi);
   if (msg->du_to_cu_rrc_container_present) {
     ue_creation_msg.du_to_cu_rrc_container = byte_buffer(msg->du_to_cu_rrc_container);
   } else {
     // Assume the DU can't serve the UE, so the CU-CP should reject the UE, see TS 38.473 section 8.4.1.2.
     // We will forward an empty container to the RRC UE, that will trigger an RRC Reject
     logger.debug("du_ue_f1ap_id={}: Forwarding InitialUlRrcMessageTransfer to RRC to reject the UE. Cause: Missing DU "
                  "to CU container",
-                 msg->gnb_du_ue_f1ap_id);
+                 du_ue_id);
     ue_creation_msg.du_to_cu_rrc_container = byte_buffer{};
   }
 
-  ue_creation_complete_message ue_creation_complete_msg = du_processor_notifier.on_create_ue(ue_creation_msg);
+  // Request the creation of a UE context in the CU-CP.
+  const cu_cp_ue_creation_response cu_cp_resp = du_processor_notifier.on_ue_creation_request(ue_creation_msg);
 
   // Remove the UE if the creation was not successful
-  if (ue_creation_complete_msg.ue_index == ue_index_t::invalid) {
+  if (cu_cp_resp.ue_index == ue_index_t::invalid) {
     logger.warning("du_ue_f1ap_id={}: Removing the UE. UE creation failed", msg->gnb_du_ue_f1ap_id);
-    cu_cp_notifier.on_ue_removal_required(ue_index);
     return;
   }
 
   // Create UE context and store it
-  ue_ctxt_list.add_ue(ue_index, cu_ue_f1ap_id);
-  ue_ctxt_list.add_du_ue_f1ap_id(cu_ue_f1ap_id, int_to_gnb_du_ue_f1ap_id(msg->gnb_du_ue_f1ap_id));
-  ue_ctxt_list.add_rrc_notifier(ue_creation_complete_msg.ue_index, ue_creation_complete_msg.f1ap_rrc_notifier);
+  ue_ctxt_list.add_ue(cu_cp_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(cu_cp_resp.ue_index, cu_cp_resp.f1ap_rrc_notifier);
   f1ap_ue_context& ue_ctxt = ue_ctxt_list[cu_ue_f1ap_id];
 
-  ue_ctxt.logger.log_debug("Added UE context");
+  ue_ctxt.logger.log_info("Added UE context");
 
   // Forward RRC container
   if (msg->rrc_container_rrc_setup_complete_present) {
@@ -302,7 +294,7 @@ void f1ap_cu_impl::handle_initial_ul_rrc_message(const init_ul_rrc_msg_transfer_
     return;
   }
 
-  // Pass container to RRC
+  // Pass RRC container to RRC
   ue_ctxt_list[cu_ue_f1ap_id].rrc_notifier->on_ul_ccch_pdu(msg->rrc_container.copy());
 }
 

lib/f1ap/cu_cp/f1ap_cu_impl.h

@@ -114,7 +114,6 @@ class f1ap_cu_impl final : public f1ap_cu
   f1ap_message_notifier&       pdu_notifier;
   f1ap_du_processor_notifier&  du_processor_notifier;
   f1ap_du_management_notifier& du_management_notifier;
-  f1ap_ue_removal_notifier&    cu_cp_notifier;
   task_executor&               ctrl_exec;
 
   unsigned current_transaction_id = 0; // store current F1AP transaction id

lib/f1ap/cu_cp/procedures/ue_context_setup_procedure.cpp

@@ -102,14 +102,14 @@ bool ue_context_setup_procedure::create_ue_context(const f1ap_ue_context_setup_r
 {
   // Request UE creation in target cell.
 
-  cu_cp_ue_creation_message ue_creation_msg;
+  cu_cp_ue_creation_request ue_creation_msg;
   ue_creation_msg.ue_index               = ue_ctxt_setup_resp.ue_index;
   ue_creation_msg.c_rnti                 = ue_ctxt_setup_resp.c_rnti.value();
   ue_creation_msg.cgi                    = request.sp_cell_id;
   ue_creation_msg.du_to_cu_rrc_container = ue_ctxt_setup_resp.du_to_cu_rrc_info.cell_group_cfg.copy();
   ue_creation_msg.rrc_context            = std::move(rrc_context);
 
-  ue_creation_complete_message ue_creation_complete_msg = du_processor_notifier.on_create_ue(ue_creation_msg);
+  cu_cp_ue_creation_response ue_creation_complete_msg = du_processor_notifier.on_ue_creation_request(ue_creation_msg);
   if (ue_creation_complete_msg.ue_index == ue_index_t::invalid) {
     logger.warning("Couldn't create UE in target cell");
     return false;