cu-cp: refactor ue rrc context update in the CU-CP

Author: frankist

include/srsran/cu_cp/cu_cp_ue_messages.h

@@ -31,17 +31,5 @@ struct rrc_ue_transfer_context {
   bool                                  is_inter_cu_handover = false;
 };
 
-/// \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_request {
-  ue_index_t                        ue_index = ue_index_t::invalid;
-  nr_cell_global_id_t               cgi;
-  uint32_t                          tac;
-  byte_buffer                       du_to_cu_rrc_container;
-  rnti_t                            c_rnti;
-  optional<rrc_ue_transfer_context> rrc_context;
-};
-
 } // namespace srs_cu_cp
 } // namespace srsran

include/srsran/f1ap/cu_cp/f1ap_cu.h

@@ -99,9 +99,21 @@ class f1ap_rrc_message_notifier
   virtual void on_ul_dcch_pdu(const srb_id_t srb_id, byte_buffer pdu) = 0;
 };
 
-/// 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;
+/// \brief Request made by the F1AP-CU to create a RRC context for an existing UE context in the CU-CP.
+///
+/// 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;
+  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 {
+  /// 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;
 };
 
@@ -125,10 +137,12 @@ class f1ap_du_processor_notifier : public du_setup_notifier
 public:
   virtual ~f1ap_du_processor_notifier() = default;
 
-  /// \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 cu_cp_ue_creation_response on_ue_creation_request(const cu_cp_ue_creation_request& msg) = 0;
+  /// \brief Notifies the CU-CP to create a new UE instance.
+  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
+  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
   /// section 8.3.2.

lib/cu_cp/adapters/f1ap_adapters.h

@@ -69,10 +69,17 @@ class f1ap_du_processor_adapter : public f1ap_du_processor_notifier
 
   du_index_t get_du_index() override { return du_f1ap_handler->get_du_index(); }
 
-  cu_cp_ue_creation_response on_ue_creation_request(const cu_cp_ue_creation_request& msg) override
+  ue_index_t on_new_cu_cp_ue_required() override
   {
     srsran_assert(du_f1ap_handler != nullptr, "F1AP handler must not be nullptr");
-    return du_f1ap_handler->handle_ue_creation_request(msg);
+    return du_f1ap_handler->allocate_new_ue_index();
+  }
+
+  ue_rrc_context_creation_response
+  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");
+    return du_f1ap_handler->handle_ue_rrc_context_creation_request(req);
   }
 
   void on_du_initiated_ue_context_release_request(const f1ap_ue_context_release_request& req) override

lib/cu_cp/du_processor/du_processor_impl.cpp

@@ -245,57 +245,45 @@ bool du_processor_impl::create_rrc_ue(du_ue&                            ue,
   return true;
 }
 
-cu_cp_ue_creation_response du_processor_impl::handle_ue_creation_request(const cu_cp_ue_creation_request& msg)
+ue_rrc_context_creation_response
+du_processor_impl::handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req)
 {
-  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);
+  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);
+  srsran_assert(config_helpers::is_valid(req.cgi), "ue={}: Invalid CGI", req.ue_index);
 
   // Check that creation message is valid
-  du_cell_index_t pcell_index = find_cell(msg.cgi.nci);
+  du_cell_index_t pcell_index = find_cell(req.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);
+    logger.warning("ue={}: Could not find cell with NCI={}", req.ue_index, req.cgi.nci);
+    cu_cp_notifier.on_ue_removal_required(req.ue_index);
     return {};
   }
   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 = allocate_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.set_ue_du_context(ue_index, context.id, pci, msg.c_rnti);
+  // Create new UE RRC context
+  du_ue* ue = ue_manager.set_ue_du_context(req.ue_index, context.id, pci, req.c_rnti);
   if (ue == nullptr) {
-    logger.warning("ue={}: Could not create UE context", ue_index);
+    logger.warning("ue={}: Could not create UE context", req.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 (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);
+  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 {};
   }
-  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());
+  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.
-  cu_cp_ue_creation_response response;
-  response.ue_index          = ue_index;
-  response.f1ap_rrc_notifier = &f1ap_rrc_ue_adapters.at(ue_index);
+  ue_rrc_context_creation_response response;
+  response.f1ap_rrc_notifier = &f1ap_rrc_ue_adapters.at(req.ue_index);
 
-  logger.info("ue={} c-rnti={}: UE created", ue->get_ue_index(), msg.c_rnti);
+  logger.info("ue={} c-rnti={}: UE created", ue->get_ue_index(), req.c_rnti);
 
   return response;
 }

lib/cu_cp/du_processor/du_processor_impl.h

@@ -55,9 +55,10 @@ 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                 allocate_new_ue_index() override;
-  cu_cp_ue_creation_response handle_ue_creation_request(const cu_cp_ue_creation_request& msg) override;
+  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
+       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;
   ue_update_complete_message handle_ue_update_request(const ue_update_message& msg) override;
 

lib/cu_cp/du_processor/du_processor_impl_interface.h

@@ -43,10 +43,13 @@ class du_processor_f1ap_interface
   /// \brief Allocate a new UE index.
   virtual ue_index_t allocate_new_ue_index() = 0;
 
-  /// \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 cu_cp_ue_creation_response handle_ue_creation_request(const cu_cp_ue_creation_request& msg) = 0;
+  /// \brief Request to create a new UE RRC context.
+  ///
+  /// This method should be called when a C-RNTI and PCell are assigned to a UE.
+  /// \param req
+  /// \return
+  virtual ue_rrc_context_creation_response
+  handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req) = 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

@@ -254,34 +254,42 @@ void f1ap_cu_impl::handle_initial_ul_rrc_message(const init_ul_rrc_msg_transfer_
     return;
   }
 
-  // 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;
+  // 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_f1ap_id={}: 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.
+  ue_rrc_context_creation_request req;
+  req.ue_index = ue_index;
+  req.c_rnti   = crnti;
+  req.cgi      = 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);
+    req.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 "
+    logger.debug("du_ue_f1ap_id={}: Forwarding InitialULRRCMessageTransfer to RRC to reject the UE. Cause: Missing DU "
                  "to CU container",
                  du_ue_id);
-    ue_creation_msg.du_to_cu_rrc_container = byte_buffer{};
+    req.du_to_cu_rrc_container = byte_buffer{};
   }
-
-  // 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);
+  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 (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);
+  if (resp.f1ap_rrc_notifier == nullptr) {
+    logger.warning("du_ue_f1ap_id={}: Dropping InitialULRRCMessageTransfer. Cause: UE RRC context creation failed",
+                   msg->gnb_du_ue_f1ap_id);
     return;
   }
 
   // Create UE context and store it
-  ue_ctxt_list.add_ue(cu_cp_resp.ue_index, cu_ue_f1ap_id);
+  ue_ctxt_list.add_ue(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);
+  ue_ctxt_list.add_rrc_notifier(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");

lib/f1ap/cu_cp/procedures/ue_context_setup_procedure.cpp

@@ -98,27 +98,34 @@ bool ue_context_setup_procedure::allocate_cu_ue_id()
   return true;
 }
 
-bool ue_context_setup_procedure::create_ue_context(const f1ap_ue_context_setup_response& ue_ctxt_setup_resp)
+bool ue_context_setup_procedure::create_ue_rrc_context(const f1ap_ue_context_setup_response& ue_ctxt_setup_resp)
 {
-  // Request UE creation in target cell.
-
-  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);
-
-  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) {
+  if (not ue_ctxt_setup_resp.success or ue_ctxt_setup_resp.ue_index == ue_index_t::invalid) {
     logger.warning("Couldn't create UE in target cell");
     return false;
   }
 
-  // Add F1AP to RRC UE notifier to UE context.
-  ue_ctxt_list.add_rrc_notifier(ue_creation_complete_msg.ue_index, ue_creation_complete_msg.f1ap_rrc_notifier);
+  if (ue_ctxt_setup_resp.c_rnti.has_value()) {
+    // An C-RNTI has been allocated by the DU. In such case, we need to create a new UE RRC context in the CU-CP.
+
+    ue_rrc_context_creation_request req;
+    req.ue_index               = ue_ctxt_setup_resp.ue_index;
+    req.c_rnti                 = ue_ctxt_setup_resp.c_rnti.value();
+    req.cgi                    = request.sp_cell_id;
+    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) {
+      logger.warning("Couldn't create UE RRC context in target cell");
+      return false;
+    }
 
-  logger.debug("ue={} Added RRC UE notifier", ue_creation_complete_msg.ue_index);
+    // Add RRC notifier to F1AP UE context.
+    ue_ctxt_list.add_rrc_notifier(req.ue_index, resp.f1ap_rrc_notifier);
+
+    logger.debug("ue={} Added RRC UE notifier", req.ue_index);
+  }
 
   return true;
 }
@@ -167,8 +174,12 @@ void ue_context_setup_procedure::create_ue_context_setup_result()
                  ue_ctxt.ue_ids.cu_ue_f1ap_id,
                  ue_ctxt.ue_ids.du_ue_f1ap_id);
 
+    // Prepare procedure response.
     fill_f1ap_ue_context_setup_response(response, new_ue_index, transaction_sink.response());
-    response.success = create_ue_context(response);
+
+    // Create UE RRC context in CU-CP, if required.
+    response.success = create_ue_rrc_context(response);
+
   } else if (transaction_sink.failed()) {
     logger.debug("Received UeContextSetupFailure cause={}", get_cause_str(transaction_sink.failure()->cause));
     fill_f1ap_ue_context_setup_response(response, transaction_sink.failure());

lib/f1ap/cu_cp/procedures/ue_context_setup_procedure.h

@@ -38,7 +38,7 @@ class ue_context_setup_procedure
   /// Allocate F1AP CU UE ID.
   bool allocate_cu_ue_id();
 
-  bool create_ue_context(const f1ap_ue_context_setup_response& ue_ctxt_setup_resp);
+  bool create_ue_rrc_context(const f1ap_ue_context_setup_response& ue_ctxt_setup_resp);
 
   /// Send F1 UE Context Setup Request to DU.
   void send_ue_context_setup_request();