From 9c0d90a014a68e32e5256d372bce76848e5b28a1 Mon Sep 17 00:00:00 2001 From: Laurent THOMAS Date: Wed, 13 Nov 2024 19:06:35 +0100 Subject: [PATCH] Introduce UE RCC to MAC ITTI queue Reduce race conditions through a itti queue, such that RRC-initiated MAC memory modifications happen at the same time as MAC thread writes. However, it doesn't resolve the problem of exact slot we should apply the new cell configurtion. --- executables/nr-ue.c | 20 +++++++- openair2/COMMON/as_message.h | 15 +++++- openair2/COMMON/rrc_messages_def.h | 6 +++ openair2/COMMON/rrc_messages_types.h | 7 ++- openair2/LAYER2/NR_MAC_UE/config_ue.c | 14 +++--- openair2/LAYER2/NR_MAC_UE/mac_proto.h | 6 +-- openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c | 8 +++ .../LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c | 10 +++- openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c | 7 ++- openair2/RRC/NR_UE/L2_interface_ue.c | 25 ++++++++++ openair2/RRC/NR_UE/L2_interface_ue.h | 1 + openair2/RRC/NR_UE/rrc_UE.c | 49 +++++++++++++------ 12 files changed, 133 insertions(+), 35 deletions(-) diff --git a/executables/nr-ue.c b/executables/nr-ue.c index 78abb7b081..fe072a7275 100644 --- a/executables/nr-ue.c +++ b/executables/nr-ue.c @@ -631,6 +631,14 @@ static int UE_dl_preprocessing(PHY_VARS_NR_UE *UE, if (UE->sl_mode == 2) fp = &UE->SL_UE_PHY_PARAMS.sl_frame_params; + // process what RRC thread sent to MAC + MessageDef *msg = NULL; + do { + itti_poll_msg(TASK_MAC_UE, &msg); + if (msg) + process_msg_rcc_to_mac(msg); + } while (msg); + if (IS_SOFTMODEM_NOS1 || IS_SA_MODE(get_softmodem_params())) { /* send tick to RLC and PDCP every ms */ if (proc->nr_slot_rx % fp->slots_per_subframe == 0) { @@ -875,10 +883,18 @@ void *UE_thread(void *arg) syncRunning = false; if (UE->is_synchronized) { UE->synch_request.received_synch_request = 0; - if (UE->sl_mode == 2) + if (UE->sl_mode == SL_MODE2_SUPPORTED) decoded_frame_rx = UE->SL_UE_PHY_PARAMS.sync_params.DFN; - else + else { + // We must wait the RRC layer decoded the MIB and sent us the frame number + MessageDef *msg = NULL; + itti_receive_msg(TASK_MAC_UE, &msg); + if (msg) + process_msg_rcc_to_mac(msg); + else + LOG_E(PHY, "It seems we arbort while trying to sync\n"); decoded_frame_rx = mac->mib_frame; + } LOG_A(PHY, "UE synchronized! decoded_frame_rx=%d UE->init_sync_frame=%d trashed_frames=%d\n", decoded_frame_rx, diff --git a/openair2/COMMON/as_message.h b/openair2/COMMON/as_message.h index e4061f5c3d..af927f6dab 100644 --- a/openair2/COMMON/as_message.h +++ b/openair2/COMMON/as_message.h @@ -43,7 +43,6 @@ Description Defines the messages supported by the Access Stratum sublayer #include "commonDef.h" #include "networkDef.h" - /****************************************************************************/ /********************* G L O B A L C O N S T A N T S *******************/ /****************************************************************************/ @@ -582,6 +581,20 @@ typedef struct as_message_s { } __attribute__((__packed__)) msg; } as_message_t; +typedef struct { + NR_ReestablishmentCause_t cause; +} nr_mac_rrc_config_reset_t; +typedef struct { + NR_CellGroupConfig_t* cellGroupConfig; + NR_UE_NR_Capability_t* UE_NR_Capability; +} nr_mac_rrc_config_cg_t; +typedef struct { + NR_BCCH_BCH_Message_t* bcch; + int get_sib; +} nr_mac_rrc_config_mib_t; +typedef struct { + NR_SIB1_t* sib1; +} nr_mac_rrc_config_sib1_t; /****************************************************************************/ /******************** G L O B A L V A R I A B L E S ********************/ /****************************************************************************/ diff --git a/openair2/COMMON/rrc_messages_def.h b/openair2/COMMON/rrc_messages_def.h index fb94aeb29e..81359f8a64 100644 --- a/openair2/COMMON/rrc_messages_def.h +++ b/openair2/COMMON/rrc_messages_def.h @@ -82,6 +82,12 @@ MESSAGE_DEF(NAS_DOWNLINK_DATA_IND, MESSAGE_PRIORITY_MED, dl_info_transfer_ind_t, MESSAGE_DEF(RRC_SUBFRAME_PROCESS, MESSAGE_PRIORITY_MED, RrcSubframeProcess, rrc_subframe_process) MESSAGE_DEF(NRRRC_FRAME_PROCESS, MESSAGE_PRIORITY_MED, NRRrcFrameProcess, nr_rrc_frame_process) +// UE: RRC -> MAC messages +MESSAGE_DEF(NR_MAC_RRC_CONFIG_RESET, MESSAGE_PRIORITY_MED, nr_mac_rrc_config_reset_t, nr_mac_rrc_config_reset) +MESSAGE_DEF(NR_MAC_RRC_CONFIG_CG, MESSAGE_PRIORITY_MED, nr_mac_rrc_config_cg_t, nr_mac_rrc_config_cg) +MESSAGE_DEF(NR_MAC_RRC_CONFIG_MIB, MESSAGE_PRIORITY_MED, nr_mac_rrc_config_mib_t, nr_mac_rrc_config_mib) +MESSAGE_DEF(NR_MAC_RRC_CONFIG_SIB1, MESSAGE_PRIORITY_MED, nr_mac_rrc_config_sib1_t, nr_mac_rrc_config_sib1) + // eNB: RLC -> RRC messages MESSAGE_DEF(RLC_SDU_INDICATION, MESSAGE_PRIORITY_MED, RlcSduIndication, rlc_sdu_indication) MESSAGE_DEF(NAS_PDU_SESSION_REQ, MESSAGE_PRIORITY_MED, nas_pdu_session_req_t, nas_pdu_session_req) diff --git a/openair2/COMMON/rrc_messages_types.h b/openair2/COMMON/rrc_messages_types.h index 0e57120ee4..3c1c710260 100644 --- a/openair2/COMMON/rrc_messages_types.h +++ b/openair2/COMMON/rrc_messages_types.h @@ -96,12 +96,15 @@ #define NAS_OAI_TUN_NSA(mSGpTR) (mSGpTR)->ittiMsg.nas_oai_tun_nsa #define NAS_PDU_SESSION_REQ(mSGpTR) (mSGpTR)->ittiMsg.nas_pdu_session_req +#define NR_MAC_RRC_CONFIG_RESET(mSGpTR) (mSGpTR)->ittiMsg.nr_mac_rrc_config_reset +#define NR_MAC_RRC_CONFIG_CG(mSGpTR) (mSGpTR)->ittiMsg.nr_mac_rrc_config_cg +#define NR_MAC_RRC_CONFIG_MIB(mSGpTR) (mSGpTR)->ittiMsg.nr_mac_rrc_config_mib +#define NR_MAC_RRC_CONFIG_SIB1(mSGpTR) (mSGpTR)->ittiMsg.nr_mac_rrc_config_sib1 #define NR_RRC_RLC_MAXRTX(mSGpTR) (mSGpTR)->ittiMsg.nr_rlc_maxrtx_indication -//-------------------------------------------------------------------------------------------// typedef struct RrcStateInd_s { - Rrc_State_t state; + Rrc_State_t state; Rrc_Sub_State_t sub_state; } RrcStateInd; diff --git a/openair2/LAYER2/NR_MAC_UE/config_ue.c b/openair2/LAYER2/NR_MAC_UE/config_ue.c index a4161dbd61..c557cd36f3 100644 --- a/openair2/LAYER2/NR_MAC_UE/config_ue.c +++ b/openair2/LAYER2/NR_MAC_UE/config_ue.c @@ -1704,17 +1704,19 @@ static void configure_si_schedulingInfo(NR_UE_MAC_INST_t *mac, } } -void nr_rrc_mac_config_req_sib1(module_id_t module_id, - int cc_idP, - NR_SI_SchedulingInfo_t *si_SchedulingInfo, - NR_SI_SchedulingInfo_v1700_t *si_SchedulingInfo_v1700, - NR_ServingCellConfigCommonSIB_t *scc) +void nr_rrc_mac_config_req_sib1(module_id_t module_id, int cc_idP, NR_SIB1_t *sib1) { NR_UE_MAC_INST_t *mac = get_mac_inst(module_id); int ret = pthread_mutex_lock(&mac->if_mutex); AssertFatal(!ret, "mutex failed %d\n", ret); + NR_SI_SchedulingInfo_t *si_SchedulingInfo = sib1->si_SchedulingInfo; + NR_SI_SchedulingInfo_v1700_t *si_SchedulingInfo_v1700 = NULL; + if (sib1->nonCriticalExtension && sib1->nonCriticalExtension->nonCriticalExtension + && sib1->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension) { + si_SchedulingInfo_v1700 = sib1->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->si_SchedulingInfo_v1700; + } + NR_ServingCellConfigCommonSIB_t *scc = sib1->servingCellConfigCommon; AssertFatal(scc, "SIB1 SCC should not be NULL\n"); - UPDATE_IE(mac->tdd_UL_DL_ConfigurationCommon, scc->tdd_UL_DL_ConfigurationCommon, NR_TDD_UL_DL_ConfigCommon_t); configure_si_schedulingInfo(mac, si_SchedulingInfo, si_SchedulingInfo_v1700); mac->n_ta_offset = get_ta_offset(scc->n_TimingAdvanceOffset); diff --git a/openair2/LAYER2/NR_MAC_UE/mac_proto.h b/openair2/LAYER2/NR_MAC_UE/mac_proto.h index 6558370479..e217192d82 100644 --- a/openair2/LAYER2/NR_MAC_UE/mac_proto.h +++ b/openair2/LAYER2/NR_MAC_UE/mac_proto.h @@ -85,11 +85,7 @@ void nr_rrc_mac_config_req_mib(module_id_t module_id, NR_MIB_t *mibP, int sched_sib1); -void nr_rrc_mac_config_req_sib1(module_id_t module_id, - int cc_idP, - NR_SI_SchedulingInfo_t *si_SchedulingInfo, - NR_SI_SchedulingInfo_v1700_t *si_SchedulingInfo_v1700, - NR_ServingCellConfigCommonSIB_t *scc); +void nr_rrc_mac_config_req_sib1(module_id_t module_id, int cc_idP, NR_SIB1_t *sib1); struct position; /* forward declaration */ void nr_rrc_mac_config_req_sib19_r17(module_id_t module_id, const struct position *pos, NR_SIB19_r17_t *sib19_r17); diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c index 8a46ad9a25..7c1efd129e 100644 --- a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c +++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c @@ -615,6 +615,14 @@ static int nr_ue_process_dci_ul_01(NR_UE_MAC_INST_t *mac, dci_ind->rnti, dci_ind->ss_type, NR_UL_DCI_FORMAT_0_1); + LOG_D(NR_MAC_DCI, + "add ul dci harq %d for %d.%d %d.%d round %d\n", + pdu->pusch_config_pdu.pusch_data.harq_process_id, + frame, + slot, + frame_tx, + slot_tx, + 0); if (ret != 0) remove_ul_config_last_item(pdu); release_ul_config(pdu, false); diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c index 7f849253da..ac2d966f1d 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c @@ -2573,7 +2573,15 @@ void nr_schedule_ulsch(module_id_t module_id, frame_t frame, sub_frame_t slot, n dci_pdu_rel15_t uldci_payload; memset(&uldci_payload, 0, sizeof(uldci_payload)); - + if (current_BWP->dci_format == NR_UL_DCI_FORMAT_0_1) + LOG_D(NR_MAC_DCI, + "add ul dci harq %d for %d.%d %d.%d round %d\n", + harq_id, + frame, + slot, + sched_pusch->frame, + sched_pusch->slot, + sched_ctrl->ul_harq_processes[harq_id].round); config_uldci(&UE->sc_info, pusch_pdu, &uldci_payload, diff --git a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c index 44118704a4..9bd5d16fc1 100644 --- a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c +++ b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c @@ -1206,11 +1206,10 @@ int nr_ue_ul_indication(nr_uplink_indication_t *ul_info) return 0; } -static uint32_t nr_ue_dl_processing(nr_downlink_indication_t *dl_info) +static uint32_t nr_ue_dl_processing(NR_UE_MAC_INST_t *mac, nr_downlink_indication_t *dl_info) { uint32_t ret_mask = 0x0; - DevAssert(dl_info != NULL); - NR_UE_MAC_INST_t *mac = get_mac_inst(dl_info->module_id); + DevAssert(mac != NULL && dl_info != NULL); // DL indication after reception of DCI or DL PDU if (dl_info->dci_ind && dl_info->dci_ind->number_of_dcis) { @@ -1322,7 +1321,7 @@ int nr_ue_dl_indication(nr_downlink_indication_t *dl_info) nr_ue_dl_scheduler(mac, dl_info); else // DL indication to process data channels - ret2 = nr_ue_dl_processing(dl_info); + ret2 = nr_ue_dl_processing(mac, dl_info); ret = pthread_mutex_unlock(&mac->if_mutex); AssertFatal(!ret, "mutex failed %d\n", ret); return ret2; diff --git a/openair2/RRC/NR_UE/L2_interface_ue.c b/openair2/RRC/NR_UE/L2_interface_ue.c index b2b4914c22..81b857df0b 100644 --- a/openair2/RRC/NR_UE/L2_interface_ue.c +++ b/openair2/RRC/NR_UE/L2_interface_ue.c @@ -121,6 +121,31 @@ void nr_mac_rrc_data_ind_ue(const module_id_t module_id, } } +void process_msg_rcc_to_mac(MessageDef *msg) +{ + instance_t ue_id = ITTI_MSG_DESTINATION_INSTANCE(msg); + switch (ITTI_MSG_ID(msg)) { + case NR_MAC_RRC_CONFIG_RESET: + nr_rrc_mac_config_req_reset(ue_id, NR_MAC_RRC_CONFIG_RESET(msg).cause); + break; + case NR_MAC_RRC_CONFIG_CG: + nr_rrc_mac_config_req_cg(ue_id, 0, NR_MAC_RRC_CONFIG_CG(msg).cellGroupConfig, NR_MAC_RRC_CONFIG_CG(msg).UE_NR_Capability); + asn1cFreeStruc(asn_DEF_NR_CellGroupConfig, NR_MAC_RRC_CONFIG_CG(msg).cellGroupConfig); + break; + case NR_MAC_RRC_CONFIG_MIB: + nr_rrc_mac_config_req_mib(ue_id, 0, NR_MAC_RRC_CONFIG_MIB(msg).bcch->message.choice.mib, NR_MAC_RRC_CONFIG_MIB(msg).get_sib); + ASN_STRUCT_FREE(asn_DEF_NR_BCCH_BCH_Message, NR_MAC_RRC_CONFIG_MIB(msg).bcch); + break; + case NR_MAC_RRC_CONFIG_SIB1: { + NR_SIB1_t *sib1 = NR_MAC_RRC_CONFIG_SIB1(msg).sib1; + nr_rrc_mac_config_req_sib1(ue_id, 0, sib1); + SEQUENCE_free(&asn_DEF_NR_SIB1, NR_MAC_RRC_CONFIG_SIB1(msg).sib1, ASFM_FREE_EVERYTHING); + } break; + default: + LOG_E(NR_MAC, "Unexpected msg from RRC: %d\n", ITTI_MSG_ID(msg)); + } +} + void nr_mac_rrc_inactivity_timer_ind(const module_id_t mod_id) { MessageDef *message_p = itti_alloc_new_message(TASK_MAC_UE, 0, NR_RRC_MAC_INAC_IND); diff --git a/openair2/RRC/NR_UE/L2_interface_ue.h b/openair2/RRC/NR_UE/L2_interface_ue.h index 708633b413..05888cbc0e 100644 --- a/openair2/RRC/NR_UE/L2_interface_ue.h +++ b/openair2/RRC/NR_UE/L2_interface_ue.h @@ -41,5 +41,6 @@ void nr_mac_rrc_msg3_ind(const module_id_t mod_id, const int rnti, int gnb_id); void nr_ue_rrc_timer_trigger(int instance, int frame, int gnb_id); void nr_mac_rrc_ra_ind(const module_id_t mod_id, int frame, bool success); void nsa_sendmsg_to_lte_ue(const void *message, size_t msg_len, Rrc_Msg_Type_t msg_type); +void process_msg_rcc_to_mac(MessageDef *msg); #endif diff --git a/openair2/RRC/NR_UE/rrc_UE.c b/openair2/RRC/NR_UE/rrc_UE.c index b59067430d..bba75ffa67 100644 --- a/openair2/RRC/NR_UE/rrc_UE.c +++ b/openair2/RRC/NR_UE/rrc_UE.c @@ -335,8 +335,9 @@ static void nr_rrc_process_sib1(NR_UE_RRC_INST_t *rrc, NR_UE_RRC_SI_INFO *SI_inf nr_rrc_set_sib1_timers_and_constants(&rrc->timers_and_constants, sib1); // RRC storage of SIB1 timers and constants (eg needed in re-establishment) UPDATE_IE(rrc->timers_and_constants.sib1_TimersAndConstants, sib1->ue_TimersAndConstants, NR_UE_TimersAndConstants_t); - - nr_rrc_mac_config_req_sib1(rrc->ue_id, 0, sib1->si_SchedulingInfo, si_SchedInfo_v1700, sib1->servingCellConfigCommon); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_SIB1); + NR_MAC_RRC_CONFIG_SIB1(msg).sib1 = sib1; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); } static void nr_rrc_process_reconfiguration_v1530(NR_UE_RRC_INST_t *rrc, NR_RRCReconfiguration_v1530_IEs_t *rec_1530, int gNB_index) @@ -378,6 +379,7 @@ static void nr_rrc_process_reconfiguration_v1530(NR_UE_RRC_INST_t *rrc, NR_RRCRe LOG_E(NR_RRC, "dedicatedSIB1-Delivery decode error\n"); SEQUENCE_free(&asn_DEF_NR_SIB1, sib1, 1); } else { + // mac layer will free sib1 nr_rrc_process_sib1(rrc, SI_info, sib1); } } @@ -474,8 +476,12 @@ static void nr_rrc_ue_process_rrcReconfiguration(NR_UE_RRC_INST_t *rrc, int gNB_ nr_rrc_cellgroup_configuration(rrc, cellGroupConfig); AssertFatal(!IS_SA_MODE(get_softmodem_params()), "secondaryCellGroup only used in NSA for now\n"); - nr_rrc_mac_config_req_cg(rrc->ue_id, 0, cellGroupConfig, rrc->UECap.UE_NR_Capability); - asn1cFreeStruc(asn_DEF_NR_CellGroupConfig, cellGroupConfig); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_CG); + // cellGroupConfig will be managed by MAC + NR_MAC_RRC_CONFIG_CG(msg).cellGroupConfig = cellGroupConfig; + // UE_NR_Capability remain a race condition between this rrc thread and mac thread + NR_MAC_RRC_CONFIG_CG(msg).UE_NR_Capability = rrc->UECap.UE_NR_Capability; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); } if (ie->measConfig) { LOG_I(NR_RRC, "RRCReconfiguration includes Measurement Configuration\n"); @@ -807,11 +813,16 @@ static void nr_rrc_ue_decode_NR_BCCH_BCH_Message(NR_UE_RRC_INST_t *rrc, // to schedule MAC to get SI if required get_sib = check_si_status(SI_info); } - if (bcch_message->message.present == NR_BCCH_BCH_MessageType_PR_mib) - nr_rrc_mac_config_req_mib(rrc->ue_id, 0, bcch_message->message.choice.mib, get_sib); - else + if (bcch_message->message.present == NR_BCCH_BCH_MessageType_PR_mib) { + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_MIB); + // mac will manage the pointer + NR_MAC_RRC_CONFIG_MIB(msg).bcch = bcch_message; + NR_MAC_RRC_CONFIG_MIB(msg).get_sib = get_sib; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); + } else { LOG_E(NR_RRC, "RRC-received BCCH message is not a MIB\n"); - ASN_STRUCT_FREE(asn_DEF_NR_BCCH_BCH_Message, bcch_message); + ASN_STRUCT_FREE(asn_DEF_NR_BCCH_BCH_Message, bcch_message); + } return; } @@ -900,6 +911,8 @@ static int8_t nr_rrc_ue_decode_NR_BCCH_DL_SCH_Message(NR_UE_RRC_INST_t *rrc, switch (bcch_message->message.choice.c1->present) { case NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1: nr_rrc_process_sib1(rrc, SI_info, bcch_message->message.choice.c1->choice.systemInformationBlockType1); + // mac layer will free after usage the sib1 + bcch_message->message.choice.c1->choice.systemInformationBlockType1 = NULL; break; case NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformation: LOG_I(NR_RRC, "[UE %ld] Decoding SI\n", rrc->ue_id); @@ -1036,9 +1049,11 @@ static void nr_rrc_ue_process_masterCellGroup(NR_UE_RRC_INST_t *rrc, nr_rrc_cellgroup_configuration(rrc, cellGroupConfig); - LOG_D(RRC,"Sending CellGroupConfig to MAC\n"); - nr_rrc_mac_config_req_cg(rrc->ue_id, 0, cellGroupConfig, rrc->UECap.UE_NR_Capability); - asn1cFreeStruc(asn_DEF_NR_CellGroupConfig, cellGroupConfig); + LOG_D(RRC, "Sending CellGroupConfig to MAC the pointer will be managed by mac\n"); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_CG); + NR_MAC_RRC_CONFIG_CG(msg).cellGroupConfig = cellGroupConfig; + NR_MAC_RRC_CONFIG_CG(msg).UE_NR_Capability = rrc->UECap.UE_NR_Capability; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); } static void rrc_ue_generate_RRCSetupComplete(const NR_UE_RRC_INST_t *rrc, const uint8_t Transaction_id) @@ -2126,7 +2141,9 @@ static void nr_rrc_initiate_rrcReestablishment(NR_UE_RRC_INST_t *rrc, NR_Reestab // reset MAC // release spCellConfig, if configured // perform cell selection in accordance with the cell selection process - nr_rrc_mac_config_req_reset(rrc->ue_id, RE_ESTABLISHMENT); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_RESET); + NR_MAC_RRC_CONFIG_RESET(msg).cause = RE_ESTABLISHMENT; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); } static void nr_rrc_ue_generate_rrcReestablishmentComplete(const NR_UE_RRC_INST_t *rrc, @@ -2495,7 +2512,9 @@ void nr_rrc_going_to_IDLE(NR_UE_RRC_INST_t *rrc, // reset MAC NR_UE_MAC_reset_cause_t cause = (rrc->nrRrcState == RRC_STATE_DETACH_NR) ? DETACH : GO_TO_IDLE; - nr_rrc_mac_config_req_reset(rrc->ue_id, cause); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_RESET); + NR_MAC_RRC_CONFIG_RESET(msg).cause = cause; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); // enter RRC_IDLE LOG_I(NR_RRC, "RRC moved into IDLE state\n"); @@ -2517,7 +2536,9 @@ void handle_t300_expiry(NR_UE_RRC_INST_t *rrc) // reset MAC, release the MAC configuration NR_UE_MAC_reset_cause_t cause = T300_EXPIRY; - nr_rrc_mac_config_req_reset(rrc->ue_id, cause); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_RESET); + NR_MAC_RRC_CONFIG_RESET(msg).cause = cause; + itti_send_msg_to_task(TASK_MAC_UE, rrc->ue_id, msg); // TODO handle connEstFailureControl // TODO inform upper layers about the failure to establish the RRC connection }