Merge remote-tracking branch 'origin/apply_new_CellGroup_later' into integration_2025_w52 (!3804)

gNB: apply new NR_CellGroupConfig when RRCReconfiguration is acknowledged

Currently part of the NR_CellGroupConfig is already applied when the
RRCReconfiguration message is created. This is not correct and this MR
fixes this by applying it when the RRCReconfiguration message is
acknowledged.

With this fixed, we also move disabling the feedback (in case
disable_harq is used) from the RRCSetup message to the
RRCReconfiguration message.

Closes: #1002

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_dlsch.c

@@ -596,17 +596,17 @@ static bool allocate_dl_retransmission(gNB_MAC_INST *nr_mac,
 
 static void ack_reconfig(gNB_MAC_INST *mac, NR_UE_info_t *UE)
 {
-  if (UE->reconfigSpCellConfig) {
+  if (!UE->reconfigCellGroup) {
-    // in case of reestablishment, the spCellConfig had to be released
+    LOG_W(NR_MAC, "Received ACK for RRCReconfiguration, but nothing to apply!\n");
-    // temporarily. Reapply now before doing the reconfiguration.
+    return;
-    UE->CellGroup->spCellConfig = UE->reconfigSpCellConfig;
-    // UE->reconfigSpCellConfig to be NULLed after receiving reconfiguration complete
   }
+  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
+  UE->CellGroup = UE->reconfigCellGroup;
+  UE->reconfigCellGroup = NULL;
   NR_ServingCellConfigCommon_t *scc = mac->common_channels[0].ServingCellConfigCommon;
   /* clean BWP structures */
   clean_bwp_structures(UE->CellGroup->spCellConfig);
   configure_UE_BWP(mac, scc, UE, false, NR_SearchSpace__searchSpaceType_PR_common, -1, -1);
-  UE->await_reconfig = false;
 }
 
 typedef struct UEsched_s {
@@ -886,7 +886,7 @@ static void pf_dl(gNB_MAC_INST *mac,
     sched_pdsch.action = NULL;
     int srb1 = 1;
     /* everything that's only 3 bytes is an ack. To be safe, use a bit more. */
-    if (iterator->UE->await_reconfig && sched_ctrl->rlc_status[srb1].bytes_in_buffer > 10)
+    if (iterator->UE->reconfigCellGroup && sched_ctrl->rlc_status[srb1].bytes_in_buffer > 10)
       sched_pdsch.action = ack_reconfig;
 
     // Fix me: currently, the RLC does not give us the total number of PDUs

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -2491,7 +2491,7 @@ NR_UE_info_t *find_ra_UE(NR_UEs_t *UEs, rnti_t rntiP)
 void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_allocator_t *uia)
 {
   ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
-  ASN_STRUCT_FREE(asn_DEF_NR_SpCellConfig, UE->reconfigSpCellConfig);
+  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->reconfigCellGroup);
   ASN_STRUCT_FREE(asn_DEF_NR_UE_NR_Capability, UE->capability);
   NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
   seq_arr_free(&sched_ctrl->lc_config, NULL);
@@ -2855,6 +2855,20 @@ void configure_UE_BWP(gNB_MAC_INST *nr_mac,
             sc_info->nrofHARQ_ProcessesForPUSCH_r17 = pusch_servingcellconfig->ext3->nrofHARQ_ProcessesForPUSCH_r17;
         }
       }
+    } else {
+      sc_info->csi_MeasConfig = NULL;
+      sc_info->nrofHARQ_ProcessesForPDSCH = NULL;
+      sc_info->maxMIMO_Layers_PDSCH = NULL;
+      sc_info->downlinkHARQ_FeedbackDisabled_r17 = NULL;
+      sc_info->pdsch_CGB_Transmission = NULL;
+      sc_info->nrofHARQ_ProcessesForPDSCH_v1700 = NULL;
+      sc_info->crossCarrierSchedulingConfig = NULL;
+      sc_info->supplementaryUplink = NULL;
+      sc_info->carrierSwitching = NULL;
+      sc_info->maxMIMO_Layers_PUSCH = NULL;
+      sc_info->rateMatching_PUSCH = NULL;
+      sc_info->pusch_CGB_Transmission = NULL;
+      sc_info->nrofHARQ_ProcessesForPUSCH_r17 = NULL;
     }
 
     if (CellGroup && CellGroup->physicalCellGroupConfig)
@@ -3942,7 +3956,8 @@ void nr_mac_trigger_reconfiguration(const gNB_MAC_INST *nrmac, NR_UE_info_t *UE,
                                                   buf,
                                                   sizeof(buf));
   AssertFatal(enc_rval.encoded > 0, "ASN1 encoding of CellGroupConfig failed, failed type %s\n", enc_rval.failed_type->name);
-  UE->await_reconfig = true;
+  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->reconfigCellGroup);
+  UE->reconfigCellGroup = cellGroup_for_UE;
   du_to_cu_rrc_information_t du2cu = {
     .cellGroupConfig = buf,
     .cellGroupConfig_length = (enc_rval.encoded + 7) >> 3,
@@ -3956,8 +3971,6 @@ void nr_mac_trigger_reconfiguration(const gNB_MAC_INST *nrmac, NR_UE_info_t *UE,
     .cause_value = F1AP_CauseRadioNetwork_action_desirable_for_radio_reasons,
   };
   nrmac->mac_rrc.ue_context_modification_required(&required);
-  if (cellGroup_for_UE)
-    free_cellGroupConfig(cellGroup_for_UE);
 }
 
 long get_lcid_from_drbid(int drb_id)

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -981,11 +981,6 @@ void handle_nr_uci_pucch_2_3_4(module_id_t mod_id, frame_t frame, slot_t slot, c
     return;
   }
 
-  NR_CSI_MeasConfig_t *csi_MeasConfig = UE->sc_info.csi_MeasConfig;
-  if (csi_MeasConfig == NULL) {
-    NR_SCHED_UNLOCK(&nrmac->sched_lock);
-    return;
-  }
   NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
 
   // tpc (power control)
@@ -1021,8 +1016,11 @@ void handle_nr_uci_pucch_2_3_4(module_id_t mod_id, frame_t frame, slot_t slot, c
   if ((uci_234->pduBitmap >> 2) & 0x01) {
     LOG_D(NR_MAC, "CSI CRC %d\n", uci_234->csi_part1.csi_part1_crc);
     if (uci_234->csi_part1.csi_part1_crc != 1) {
-      // API to parse the csi report and store it into sched_ctrl
+      NR_CSI_MeasConfig_t *csi_MeasConfig = UE->sc_info.csi_MeasConfig;
-      extract_pucch_csi_report(csi_MeasConfig, uci_234, frame, slot, UE, nrmac);
+      if (csi_MeasConfig != NULL) {
+        // API to parse the csi report and store it into sched_ctrl
+        extract_pucch_csi_report(csi_MeasConfig, uci_234, frame, slot, UE, nrmac);
+      }
     }
     free(uci_234->csi_part1.csi_part1_payload);
   }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -882,7 +882,7 @@ static void nr_rx_ra_sdu(const module_id_t mod_id,
 
     // Only trigger RRCReconfiguration if UE is not performing RRCReestablishment
     // The RRCReconfiguration will be triggered by the RRCReestablishmentComplete
-    if (!old_UE->reconfigSpCellConfig) {
+    if (!old_UE->reconfigCellGroup) {
       LOG_I(NR_MAC, "Received UL_SCH_LCID_C_RNTI with C-RNTI 0x%04x, triggering RRC Reconfiguration\n", crnti);
       // Trigger RRCReconfiguration
       nr_mac_trigger_reconfiguration(mac, old_UE, -1);

openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c

@@ -695,8 +695,8 @@ void ue_context_setup_request(const f1ap_ue_context_setup_req_t *req)
   cgc.len = (enc_rval.encoded + 7) >> 3;
   resp.du_to_cu_rrc_info.cell_group_config = cgc;
 
-  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
+  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->reconfigCellGroup);
-  UE->CellGroup = new_CellGroup;
+  UE->reconfigCellGroup = new_CellGroup;
   int ss_type = cg_configinfo ? NR_SearchSpace__searchSpaceType_PR_ue_Specific: NR_SearchSpace__searchSpaceType_PR_common;
   configure_UE_BWP(mac, scc, UE, false, ss_type, -1, -1);
 
@@ -770,19 +770,19 @@ void ue_context_modification_request(const f1ap_ue_context_mod_req_t *req)
           "RRC reconfiguration outcome unsuccessful, but no rollback mechanism implemented to come back to old configuration\n");
   } else if (req->reconfig_compl) {
     LOG_I(NR_MAC, "DU received confirmation of successful RRC Reconfiguration\n");
-    if (UE->reconfigSpCellConfig) {
+    if (UE->reconfigCellGroup) {
-      if (UE->await_reconfig) {
+      LOG_W(NR_MAC, "reconfigCellGroup still present, did we miss ACK for RRCReconfiguration?\n");
-        // in case of reestablishment, the spCellConfig had to be released
+      ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
-        // temporarily. Reapply now before doing the reconfiguration.
+      UE->CellGroup = UE->reconfigCellGroup;
-        UE->CellGroup->spCellConfig = UE->reconfigSpCellConfig;
+      UE->reconfigCellGroup = NULL;
-        UE->await_reconfig = false;
+    }
-      }
+    if (UE->reestablish_rlc) {
-      UE->reconfigSpCellConfig = NULL;
       for (int i = 1; i < seq_arr_size(&UE->UE_sched_ctrl.lc_config); ++i) {
         nr_lc_config_t *c = seq_arr_at(&UE->UE_sched_ctrl.lc_config, i);
         c->suspended = false;
         nr_rlc_reestablish_entity(req->gNB_DU_ue_id, c->lcid);
       }
+      UE->reestablish_rlc = false;
     }
     // we re-configure the BWP to apply the CellGroup and to use UE specific Search Space with DCIX1
     configure_UE_BWP(mac, scc, UE, false, NR_SearchSpace__searchSpaceType_PR_ue_Specific, -1, -1);
@@ -809,8 +809,8 @@ void ue_context_modification_request(const f1ap_ue_context_mod_req_t *req)
     cgc.len = (enc_rval.encoded + 7) >> 3;
     resp.du_to_cu_rrc_info->cell_group_config = cgc;
 
-    ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
+    ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->reconfigCellGroup);
-    UE->CellGroup = new_CellGroup;
+    UE->reconfigCellGroup = new_CellGroup;
     configure_UE_BWP(mac, scc, UE, false, NR_SearchSpace__searchSpaceType_PR_common, -1, -1);
   } else {
     ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, new_CellGroup); // we actually don't need it
@@ -966,16 +966,19 @@ void dl_rrc_message_transfer(const f1ap_dl_rrc_message_t *dl_rrc)
     ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
     UE->CellGroup = oldUE->CellGroup;
     oldUE->CellGroup = NULL;
+    ASN_STRUCT_FREE(asn_DEF_NR_UE_NR_Capability, UE->capability);
     UE->capability = oldUE->capability;
     oldUE->capability = NULL;
     UE->mac_stats = oldUE->mac_stats;
     UE->measgap_config = oldUE->measgap_config;
+    UE->local_bwp_id = oldUE->local_bwp_id;
     /* 38.331 5.3.7.2 says that the UE releases the spCellConfig, so we drop it
      * from the current configuration. It will be reapplied when the
      * reconfiguration has succeeded (indicated by the CU) */
-    UE->reconfigSpCellConfig = UE->CellGroup->spCellConfig;
+    asn_copy(&asn_DEF_NR_CellGroupConfig, (void **)&UE->reconfigCellGroup, UE->CellGroup);
+    ASN_STRUCT_FREE(asn_DEF_NR_SpCellConfig, UE->CellGroup->spCellConfig);
     UE->CellGroup->spCellConfig = NULL;
-    UE->await_reconfig = true;
+    UE->reestablish_rlc = true;
     mac_remove_nr_ue(mac, *dl_rrc->old_gNB_DU_ue_id);
     pthread_mutex_unlock(&mac->sched_lock);
     nr_rlc_remove_ue(dl_rrc->gNB_DU_ue_id);

openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h

@@ -787,9 +787,8 @@ typedef struct NR_UE_info {
   NR_mac_stats_t mac_stats;
   /// currently active CellGroupConfig
   NR_CellGroupConfig_t *CellGroup;
-  /// in case of reestablishment, old spCellConfig to apply after
+  /// in case of reconfiguration, new CellConfig to apply
-  /// reconfiguration
+  NR_CellGroupConfig_t *reconfigCellGroup;
-  NR_SpCellConfig_t *reconfigSpCellConfig;
   NR_UE_NR_Capability_t *capability;
   measgap_config_t measgap_config;
   // UE selected beam index
@@ -798,7 +797,7 @@ typedef struct NR_UE_info {
   float dl_thr_ue;
   long pdsch_HARQ_ACK_Codebook;
   bool is_redcap;
-  bool await_reconfig;
+  bool reestablish_rlc;
   NR_RA_t *ra;
   // 3GPP mandates that BWPs are enumerated consecutively, but we only send one (dedicated)
   // BWP to the UE (and modify that BWP on reconfiguration); consequently, the BWP ID for a

openair2/LAYER2/NR_MAC_gNB/nr_radio_config.c

@@ -3520,19 +3520,6 @@ static NR_SpCellConfig_t *get_initial_SpCellConfig(int uid,
   asn1cCallocOne(pdsch_servingcellconfig->nrofHARQ_ProcessesForPDSCH, NR_PDSCH_ServingCellConfig__nrofHARQ_ProcessesForPDSCH_n16);
   pdsch_servingcellconfig->pucch_Cell = NULL;
   set_dl_maxmimolayers(pdsch_servingcellconfig, scc, NULL, configuration->maxMIMO_layers);
-  if (configuration->disable_harq) {
-    if (!pdsch_servingcellconfig->ext3)
-      pdsch_servingcellconfig->ext3 = calloc(1, sizeof(*pdsch_servingcellconfig->ext3));
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17 = calloc(1, sizeof(*pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17));
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->present = NR_SetupRelease_DownlinkHARQ_FeedbackDisabled_r17_PR_setup;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf = calloc(4, sizeof(uint8_t));
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.size = 4;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.bits_unused = 0;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[0] = 0xFF;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[1] = 0xFF;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[2] = 0xFF;
-    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[3] = 0xFF;
-  }
 
   uint64_t bitmap = get_ssb_bitmap(scc);
   int first_active_bwp = 0;
@@ -3829,14 +3816,12 @@ NR_CellGroupConfig_t *update_cellGroupConfig_for_BWP_switch(NR_CellGroupConfig_t
 
   // we temporarily need to keep both the old and the new BWP in the CG used by the gNB
   // while removing the old from the CG sent to the UE
-  if (old_bwp > 0) {
+  NR_CellGroupConfig_t *clone_cg = NULL;
-    NR_CellGroupConfig_t *clone_cg = NULL;
+  const int copy_result = asn_copy(&asn_DEF_NR_CellGroupConfig, (void **)&clone_cg, cellGroupConfig);
-    const int copy_result = asn_copy(&asn_DEF_NR_CellGroupConfig, (void **)&clone_cg, cellGroupConfig);
+  AssertFatal(copy_result == 0, "unable to copy NR_CellGroupConfig for cloning\n");
-    AssertFatal(copy_result == 0, "unable to copy NR_CellGroupConfig for cloning\n");
+  if (old_bwp > 0)
     clean_bwp_structures(clone_cg->spCellConfig);
-    return clone_cg;
+  return clone_cg;
-  }
-  return NULL;
 }
 
 void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
@@ -3856,6 +3841,20 @@ void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
   NR_PDSCH_ServingCellConfig_t *pdsch_servingcellconfig = spCellConfigDedicated->pdsch_ServingCellConfig->choice.setup;
   set_dl_maxmimolayers(pdsch_servingcellconfig, scc, uecap, configuration->maxMIMO_layers);
 
+  if (configuration->disable_harq) {
+    if (!pdsch_servingcellconfig->ext3)
+      pdsch_servingcellconfig->ext3 = calloc(1, sizeof(*pdsch_servingcellconfig->ext3));
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17 = calloc(1, sizeof(*pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17));
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->present = NR_SetupRelease_DownlinkHARQ_FeedbackDisabled_r17_PR_setup;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf = calloc(4, sizeof(uint8_t));
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.size = 4;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.bits_unused = 0;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[0] = 0xFF;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[1] = 0xFF;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[2] = 0xFF;
+    pdsch_servingcellconfig->ext3->downlinkHARQ_FeedbackDisabled_r17->choice.setup.buf[3] = 0xFF;
+  }
+
   NR_CSI_MeasConfig_t *csi_MeasConfig = spCellConfigDedicated->csi_MeasConfig->choice.setup;
   for (int report = 0; report < csi_MeasConfig->csi_ReportConfigToAddModList->list.count; report++) {
     NR_CSI_ReportConfig_t *csirep = csi_MeasConfig->csi_ReportConfigToAddModList->list.array[report];
@@ -3935,11 +3934,6 @@ void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
   }
 }
 
-void free_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig)
-{
-  ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, cellGroupConfig);
-}
-
 int encode_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, uint8_t *buffer, int max_buffer_size)
 {
   asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_CellGroupConfig, NULL, cellGroupConfig, buffer, max_buffer_size);

openair2/LAYER2/NR_MAC_gNB/nr_radio_config.h

@@ -96,7 +96,6 @@ void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
                             const NR_UE_NR_Capability_t *uecap,
                             const nr_mac_config_t *configuration,
                             const NR_ServingCellConfigCommon_t *scc);
-void free_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig);
 int encode_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, uint8_t *buffer, int max_buffer_size);
 NR_CellGroupConfig_t *decode_cellGroupConfig(const uint8_t *buffer, int max_buffer_size);