X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_msg_hdl.c;h=38bc4b5310b63c09e900be34018ce540a387be8c;hb=a14bf79bbc001990f96e01ada0dd291bcc9ddcad;hp=f8b909e0e3ecec9a8808936451117c086f411437;hpb=3364273455756ae289662a274d5bcbf391ecd58e;p=o-du%2Fl2.git diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index f8b909e0e..38bc4b531 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -19,6 +19,7 @@ /* This file contains message handling functionality for DU APP */ #include "common_def.h" #include "lrg.h" +#include "du_tmr.h" #include "legtp.h" #include "lkw.h" #include "kwu.h" @@ -27,6 +28,7 @@ #include "kwu.x" #include "du_app_mac_inf.h" #include "du_app_rlc_inf.h" +#include "du_e2ap_mgr.h" #include "du_cfg.h" #include "du_app_rlc_inf.h" #include "du_mgr.h" @@ -42,7 +44,8 @@ #ifdef O1_ENABLE #include "AlarmInterface.h" -#include "ConfigInterface.h" +#include "CmInterface.h" +#include "PmInterface.h" #endif @@ -57,7 +60,6 @@ DuCfgParams duCfgParam; uint8_t packRlcConfigReq(Pst *pst, RlcMngmt *cfg); uint8_t cmPkLkwCntrlReq(Pst *pst, RlcMngmt *cfg); uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg); -uint8_t BuildAndSendE2SetupReq(); uint8_t egtpHdlDatInd(EgtpMsg egtpMsg); uint8_t BuildAndSendDUConfigUpdate(); uint16_t getTransId(); @@ -93,12 +95,20 @@ DuMacSliceCfgReq packMacSliceCfgReqOpts[] = }; -DuMacSliceRecfgReq packMacSliceReCfgReqOpts[] = +DuMacSliceRecfgReq packMacSliceRecfgReqOpts[] = { - packDuMacSliceRecfgReq, /* Loose coupling */ - MacProcSliceReCfgReq, /* TIght coupling */ - packDuMacSliceRecfgReq /* Light weight-loose coupling */ + packDuMacSliceRecfgReq, /* Loose coupling */ + MacProcSliceRecfgReq, /* TIght coupling */ + packDuMacSliceRecfgReq /* Light weight-loose coupling */ }; + +DuMacStatsReqFunc packMacStatsReqOpts[]= +{ + packDuMacStatsReq, /* Loose Coupling */ + MacProcStatsReq, /* Tight Coupling */ + packDuMacStatsReq /* Light weight-loose coupling */ +}; + /************************************************************************** * @brief Function to fill configs required by RLC * @@ -344,7 +354,6 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) uint8_t duProcCfgComplete() { uint8_t ret = ROK; - uint16_t cellId = 0; uint16_t idx; for(idx=0; idx< DEFAULT_CELLS; idx++) { @@ -359,29 +368,30 @@ uint8_t duProcCfgComplete() { uint8_t idx1=0; memset(cell, 0, sizeof(DuCellCb)); - cell->cellId = ++cellId; + cell->cellId = NR_CELL_ID; //++cellId; memset(&cell->cellInfo.nrEcgi.plmn, 0, sizeof(Plmn)); - cell->cellInfo.nrEcgi.plmn.mcc[0] = PLMN_MCC0; - cell->cellInfo.nrEcgi.plmn.mcc[1] = PLMN_MCC1; - cell->cellInfo.nrEcgi.plmn.mcc[2] = PLMN_MCC2; - cell->cellInfo.nrEcgi.plmn.mnc[0] = PLMN_MNC0; - cell->cellInfo.nrEcgi.plmn.mnc[1] = PLMN_MNC1; + cell->cellInfo.nrEcgi.plmn.mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0]; + cell->cellInfo.nrEcgi.plmn.mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1]; + cell->cellInfo.nrEcgi.plmn.mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2]; + cell->cellInfo.nrEcgi.plmn.mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0]; + cell->cellInfo.nrEcgi.plmn.mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1]; + cell->cellInfo.nrEcgi.plmn.mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2]; cell->cellInfo.nrEcgi.cellId = cell->cellId; - cell->cellInfo.nrPci = NR_PCI; - cell->cellInfo.fiveGsTac = DU_TAC; + cell->cellInfo.nrPci = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci; + cell->cellInfo.fiveGsTac = duCfgParam.srvdCellLst[0].duCellInfo.tac; memset(&cell->cellInfo.plmn[idx1], 0, sizeof(Plmn)); for(idx1=0; idx1cellInfo.plmn[idx1].mcc[0] = PLMN_MCC0; - cell->cellInfo.plmn[idx1].mcc[1] = PLMN_MCC1; - cell->cellInfo.plmn[idx1].mcc[2] = PLMN_MCC2; - cell->cellInfo.plmn[idx1].mnc[0] = PLMN_MNC0; - cell->cellInfo.plmn[idx1].mnc[1] = PLMN_MNC1; + cell->cellInfo.plmn[idx1].mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0]; + cell->cellInfo.plmn[idx1].mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1]; + cell->cellInfo.plmn[idx1].mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2]; + cell->cellInfo.plmn[idx1].mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0]; + cell->cellInfo.plmn[idx1].mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1]; + cell->cellInfo.plmn[idx1].mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2]; } cell->cellInfo.maxUe = duCfgParam.maxUe; cell->cellStatus = CELL_OUT_OF_SERVICE; gCellStatus = CELL_DOWN; - cell->gnbDuUeF1apIdGenerator = 0; duCb.cfgCellLst[duCb.numCfgCells] = cell; duCb.numCfgCells++; } @@ -724,7 +734,7 @@ uint8_t duBuildMacGenCfg() /*----------- Fill General Configuration Parameters ---------*/ genCfg->mem.region = MAC_MEM_REGION; genCfg->mem.pool = MAC_POOL; - genCfg->tmrRes = 10; + genCfg->tmrRes = 1; genCfg->numRguSaps = 2; genCfg->lmPst.dstProcId = DU_PROC; @@ -978,15 +988,12 @@ uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) { if(BuildAndSendF1SetupReq() != ROK) { - return RFAILED; + return RFAILED; } } else if(ricParams.assocId == ntfy->u.assocChange.assocId) { - if(BuildAndSendE2SetupReq() != ROK) - { - return RFAILED; - } + return ROK; } else { @@ -1300,7 +1307,7 @@ uint8_t duSendSchCfg() /* Filling of Gen config */ cfg->genCfg.mem.region = MAC_MEM_REGION; cfg->genCfg.mem.pool = MAC_POOL; - cfg->genCfg.tmrRes = 10; + cfg->genCfg.tmrRes = 1; #ifdef LTE_ADV cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE; @@ -1452,7 +1459,13 @@ uint8_t duBuildAndSendMacCellCfg(uint16_t cellId) } /* store the address in the duCellCb so that we can free on confirm msg */ - duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg; + if(duCb.actvCellLst[cellId-1]) + duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg; + else + { + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duMacCellCfg, sizeof(MacCellCfg)); + return RFAILED; + } /* copy the mac config structure from duCfgParams */ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg)); @@ -1486,7 +1499,7 @@ uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm) for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++) { - if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId) + if((duCb.actvCellLst[actvCellIdx]) && (macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)) { duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP; } @@ -1529,28 +1542,28 @@ uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm) uint8_t duBuildAndSendMacCellStart() { Pst pst; - OduCellId *cellId = NULL; + CellStartInfo *cellStart = NULL; DU_LOG("\nINFO --> DU APP : Building and Sending cell start request to MAC"); /* Send Cell Start Request to MAC */ - DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId)); - if(!cellId) + DU_ALLOC_SHRABL_BUF(cellStart, sizeof(CellStartInfo)); + if(!cellStart) { DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request"); return RFAILED; } - for(uint8_t id = 0; id < duCb.numActvCells; id++) + for(uint8_t id = 0; id < MAX_NUM_CELL; id++) { if(duCb.actvCellLst[id]) { - cellId->cellId = duCb.actvCellLst[id]->cellId; + cellStart->cellId = duCb.actvCellLst[id]->cellId; - /* Fill Pst */ - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START); + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START); - return (*packMacCellStartOpts[pst.selector])(&pst, cellId); + return (*packMacCellStartOpts[pst.selector])(&pst, cellStart); } } return ROK; @@ -1576,27 +1589,27 @@ uint8_t duBuildAndSendMacCellStop(uint16_t cellId) { Pst pst; uint16_t cellIdx=0; - OduCellId *oduCellId = NULL; - + CellStopInfo *cellStop = NULL; + DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC"); GET_CELL_IDX(cellId, cellIdx); if(duCb.actvCellLst[cellIdx] != NULLP) { /* Send Cell Stop Request to MAC */ - DU_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId)); - if(!oduCellId) + DU_ALLOC_SHRABL_BUF(cellStop, sizeof(CellStopInfo)); + if(!cellStop) { - DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): Memory allocation failed "); + DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request"); return RFAILED; } - memset(oduCellId, 0, sizeof(OduCellId)); - oduCellId->cellId = duCb.actvCellLst[cellIdx]->cellId; + memset(cellStop, 0, sizeof(CellStopInfo)); + cellStop->cellId = duCb.actvCellLst[cellIdx]->cellId; /* Fill Pst */ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP); - return (*packMacCellStopOpts[pst.selector])(&pst, oduCellId); + return (*packMacCellStopOpts[pst.selector])(&pst, cellStop); } else { @@ -1704,23 +1717,63 @@ uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo) * ****************************************************************/ uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) { + uint8_t ret = ROK; DuCellCb *cellCb = NULLP; - DuUeCb ueCb ={0}; + DuUeCb *ueCb = NULLP; - if(duGetCellCb(ulRrcMsgInfo->cellId, &cellCb) != ROK) - return RFAILED; - if(ulRrcMsgInfo->ueIdx > 0) + duGetCellCb(ulRrcMsgInfo->cellId, &cellCb); + if(cellCb) { - ueCb = cellCb->ueCb[ulRrcMsgInfo->ueIdx -1]; + if(ulRrcMsgInfo->ueId > 0) + { + if(cellCb->ueCb[ulRrcMsgInfo->ueId -1].gnbDuUeF1apId == ulRrcMsgInfo->ueId) + ueCb = &cellCb->ueCb[ulRrcMsgInfo->ueId -1]; + if(ueCb) + { + /* If UL message is received for a UE in handover, it signifies that UE is now + * attached to GNB. Hence marking this UE as active and requesting MAC to + * release the dedicated RACH resources */ + if(ueCb->ueState == UE_HANDIN_IN_PROGRESS) + { + ueCb->ueState = UE_ACTIVE; + cellCb->numActvUes++; + + /* Release RACH resources */ + memset(&ueCb->cfraResource, 0, sizeof(MacCfraResource)); + if(duBuildAndSendRachRsrcRelToMac(ulRrcMsgInfo->cellId, ueCb) != ROK) + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to send RACH resource release to MAC"); + } + } - BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \ - ulRrcMsgInfo->rrcMsg); + if(BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, ulRrcMsgInfo->rrcMsg) != ROK) + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to build and send UL RRC Message Transfer"); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : UE ID [%d] not found", ulRrcMsgInfo->ueId); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Invalid UE ID [%d]", ulRrcMsgInfo->ueId); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Cell ID [%d] not found", ulRrcMsgInfo->cellId); + ret = RFAILED; + } DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen); DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo)); - } - return ROK; + return ret; } /******************************************************************* @@ -1748,7 +1801,7 @@ uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryRepor if(duGetCellCb(rrcDeliveryReport->cellId, &cellCb) != ROK) return RFAILED; - ueCb = cellCb->ueCb[rrcDeliveryReport->ueIdx -1]; + ueCb = cellCb->ueCb[rrcDeliveryReport->ueId -1]; ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport); DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport)); @@ -1773,7 +1826,7 @@ uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryRepor * ****************************************************************/ uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData) { - uint8_t rbIdx; + uint8_t teIdx = 0; EgtpMsg egtpMsg; Buffer *mBuf; @@ -1787,14 +1840,15 @@ uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData) egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE; /* Fetch EGTP tunnel info */ - for(rbIdx = 0; rbIdx < duCb.numDrb; rbIdx++) + for(teIdx = 0; teIdx < duCb.numTeId; teIdx++) { - if((duCb.upTnlCfg[rbIdx] != NULLP) && (duCb.upTnlCfg[rbIdx]->ueIdx == ulUserData->ueIdx) && \ - (duCb.upTnlCfg[rbIdx]->drbId == ulUserData->rbId)) + /*TODO: If multiple Cell Support is enables then CellId also needs to be validated alongwith ueId and DrbId*/ + if((duCb.upTnlCfg[teIdx] != NULLP) && (duCb.upTnlCfg[teIdx]->ueId == ulUserData->ueId) && \ + (duCb.upTnlCfg[teIdx]->drbId == ulUserData->rbId)) { - if(duCb.upTnlCfg[rbIdx]->tnlCfg1) + if(duCb.upTnlCfg[teIdx]->tnlCfg1) { - egtpMsg.msgHdr.teId = duCb.upTnlCfg[rbIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/ + egtpMsg.msgHdr.teId = duCb.upTnlCfg[teIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/ break; } } @@ -1819,319 +1873,391 @@ uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData) /******************************************************************* * - * @brief Free tempSLiceCfg stored in duCfgParams + * @brief process the slice cfg rsp received from MAC * * @details * - * Function : duFreeTempSliceCfg + * Function : DuProcMacSliceCfgRsp * - * Functionality: Free tempSLiceCfg stored in duCfgParams + * Functionality: process the slice cfg rsp received from MAC * - * @params[in] Post structure, + * @params[in] Post structure, MacSliceCfgRsp *cfgRsp * - * @return Void + * @return ROK - success + * RFAILED - failure * - * ****************************************************************/ - -void duFreeTempSliceCfg() + **********************************************************************/ +uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp) { - uint8_t policyIdx = 0, memberListTdx =0; - CopyOfRecvdSliceCfg *tempSliceCfg = &duCfgParam.tempSliceCfg; - - if(tempSliceCfg->totalRrmPolicy) + if(cfgRsp) { - for(policyIdx = 0; policyIdxtotalRrmPolicy; policyIdx++) + if(cfgRsp->rsp == MAC_DU_APP_RSP_OK) + { + duCb.sliceState = SLICE_CONFIGURED; + DU_LOG("\nINFO --> DU_APP : Slice configured successfully "); + } + else { - if(tempSliceCfg->rrmPolicy[policyIdx]->numMemberList) - { - for(memberListTdx = 0; memberListTdxrrmPolicy[policyIdx]->numMemberList; memberListTdx++) - { - DU_FREE(tempSliceCfg->rrmPolicy[policyIdx]->memberList[memberListTdx], sizeof(PolicyMemberList)); - } - DU_FREE(tempSliceCfg->rrmPolicy[policyIdx]->memberList, (tempSliceCfg->rrmPolicy[policyIdx]->numMemberList) * sizeof(PolicyMemberList*)); - } - DU_FREE(tempSliceCfg->rrmPolicy[policyIdx], sizeof(RrmPolicy)); + DU_LOG("\nERROR --> DU_APP : Slice not available"); } - DU_FREE(tempSliceCfg->rrmPolicy, tempSliceCfg->totalRrmPolicy* sizeof(RrmPolicy*)); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp)); } - memset(tempSliceCfg, 0, sizeof(CopyOfRecvdSliceCfg)); + return ROK; } /******************************************************************* * - * @brief free the slice cfg rsp + * @brief Fill the slice configration and rrm policy related + * information received form O1 * * @details * - * Function : duFreeSliceCfgRsp + * Function : BuildAndSendSliceConfigReq * - * Functionality: free the slice cfg rsp + * Functionality: Fill the slice configration and rrm policy related * - * @params[in] Post structure, MacSliceCfgRsp *cfgRsp + * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t + * totalSliceCnt * * @return ROK - success * RFAILED - failure * - **********************************************************************/ -void duFreeSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp) + * ****************************************************************/ +uint8_t BuildAndSendSliceConfigReq() { - uint8_t cfgIdx; + Pst pst; + MacSliceCfgReq *sliceCfgReq; - if(cfgRsp) + DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq)); + if(sliceCfgReq == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq"); + return RFAILED; + } + else { - if(cfgRsp->numSliceCfgRsp) + memcpy(sliceCfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceCfgReq)); + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ); + + DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC "); + if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED) { - for(cfgIdx = 0; cfgIdxnumSliceCfgRsp; cfgIdx++) - { - DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(MacSliceRsp)); - } - DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp->listOfSliceCfgRsp, cfgRsp->numSliceCfgRsp * sizeof(MacSliceRsp*)); + DU_LOG("\nERROR --> DU_APP : Failed to send Slice Cfg Req to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceCfgReq, sizeof(MacSliceCfgReq)); } - DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp)); } - return ROK; + return ROK; } /******************************************************************* * - * @brief process the slice cfg rsp received from MAC + * @brief Fill the slice configration and rrm policy related + * information received form O1 * * @details * - * Function : DuProcMacSliceCfgRsp + * Function : BuildAndSendSliceRecfgReq * - * Functionality: process the slice cfg rsp received from MAC + * Functionality: Fill the slice configration and rrm policy related * - * @params[in] Post structure, MacSliceCfgRsp *cfgRsp + * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount * * @return ROK - success * RFAILED - failure * - **********************************************************************/ -uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp) + * ****************************************************************/ +uint8_t BuildAndSendSliceRecfgReq() { - uint8_t cfgIdx = 0; - - if(cfgRsp) - { - if(cfgRsp->listOfSliceCfgRsp) - { - for(cfgIdx = 0; cfgIdxnumSliceCfgRsp; cfgIdx++) - { - if(cfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == MAC_DU_APP_RSP_OK) - { - duCb.sliceState = SLICE_CONFIGURED; - } - } - DU_LOG("\nINFO --> DU_APP : Slice Configuration is done sucessfully "); - } - duFreeSliceCfgRsp(pst, cfgRsp); - } - duFreeTempSliceCfg(); -} + Pst pst; + MacSliceRecfgReq *sliceRecfgReq = NULLP; + + DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received"); + DU_ALLOC_SHRABL_BUF(sliceRecfgReq, sizeof(MacSliceRecfgReq)); + if(sliceRecfgReq == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq"); + return RFAILED; + } + else + { + memcpy(sliceRecfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceRecfgReq)); + + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ); + + DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC "); + if( (*packMacSliceRecfgReqOpts[pst.selector])(&pst, sliceRecfgReq) == RFAILED) + { + DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceRecfgReq, sizeof(MacSliceRecfgReq)); + } + } + return ROK; +} /******************************************************************* * - * @brief Fill the slice configration and rrm policy ratio - * information received form O1 + * @brief process the slice ReCfg rsp received from MAC * * @details * - * Function : fillSliceCfgReCfgInfo + * Function : DuProcMacSliceRecfgRsp * - * Functionality: Fill the slice configration and recfg info + * Functionality: process the slice ReCfg rsp received from MAC * - * @params[in] Post structure + * @params[in] Post structure, MacSliceRecfgRsp *ReCfgRsp * * @return ROK - success * RFAILED - failure * - * ****************************************************************/ - -uint8_t fillSliceCfgReCfgInfo(MacSliceCfgReq *sliceCfgReq, RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount) + **********************************************************************/ +uint8_t DuProcMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *recfgRsp) { - uint8_t sliceIdx = 0, cfgIdx = 0, memberListIdx = 0; - - if(totalRrmPolicy) + if(recfgRsp) { - DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg, totalSliceCount*sizeof(MacSliceRrmPolicy*)); - if(sliceCfgReq->listOfSliceCfg == NULLP) + if(recfgRsp->rsp == MAC_DU_APP_RSP_OK) { - DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo"); - return RFAILED; + duCb.sliceState = SLICE_RECONFIGURED; + DU_LOG("\nINFO --> DU_APP : Slice Reconfigured successfully "); } - - for(sliceIdx = 0; sliceIdxnumMemberList; memberListIdx++) - { - DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy)); - if(sliceCfgReq->listOfSliceCfg[cfgIdx] == NULLP) - { - DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo"); - return RFAILED; - } + DU_LOG("\nERROR --> DU_APP : Slice not available"); + } + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, recfgRsp, sizeof(MacSliceCfgRsp)); + } + return ROK; +} +/******************************************************************* +* +* @brief Handles received Slice Metrics from RLC and forward it to O1 +* +* @details +* +* Function : DuProcRlcSliceMetrics +* +* Functionality: +* Handles received Slice Metrics from RLC and forward it to O1 +* +* @params[in] Post structure pointer +* SlicePmList *sliceStats +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t DuProcRlcSliceMetrics(Pst *pst, SlicePmList *sliceStats) +{ + uint8_t sliceRecord = 0; - memcpy(&sliceCfgReq->listOfSliceCfg[cfgIdx]->snssai, &rrmPolicy[sliceIdx]->memberList[memberListIdx]->snssai, sizeof(Snssai)); + DU_LOG("\nDEBUG --> DU APP : Received Slice Metrics"); + if(sliceStats == NULLP) + { + DU_LOG("\nERROR --> DU APP : Empty Metrics"); + return RFAILED; + } + + for(sliceRecord = 0; sliceRecord < sliceStats->numSlice; sliceRecord++) + { + DU_LOG("\nINFO --> DU_APP: SliceId[SST-SD]:%d-%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sst,\ + sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sd,sliceStats->sliceRecord[sliceRecord].ThpDl,\ + sliceStats->sliceRecord[sliceRecord].ThpUl); + } +#ifdef O1_ENABLE + if(sliceStats) + { + sendSliceMetric((SliceMetricList*) sliceStats); + } +#endif - DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio)); - if(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio == NULLP) - { - DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo"); - return RFAILED; - } + DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats->sliceRecord, (sliceStats->numSlice) * (sizeof(SlicePm))); + DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats, sizeof(SlicePmList)); - sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMaxRatio = rrmPolicy[sliceIdx]->policyMaxRatio; - sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMinRatio = rrmPolicy[sliceIdx]->policyMinRatio; - sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyDedicatedRatio = rrmPolicy[sliceIdx]->policyDedicatedRatio; - sliceCfgReq->numOfConfiguredSlice++; - cfgIdx++; - } - } - } return ROK; } + /******************************************************************* * - * @brief Fill the slice configration and rrm policy related - * information received form O1 + * @brief Send Statistics request to MAC * * @details * - * Function : BuildAndSendSliceConfigReq + * Function : BuildAndSendStatsReqToMac() * - * Functionality: Fill the slice configration and rrm policy related + * Functionality: Send Statistics Request To Mac * - * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t - * totalSliceCnt + * @params[in] * * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCnt) +uint8_t BuildAndSendStatsReqToMac(MacStatsReq duMacStatsReq) { Pst pst; - MacSliceCfgReq *sliceCfgReq; + MacStatsReq *macStatsReq = NULLP; + + DU_LOG("\nINFO --> DU_APP : Builds Statistics Request to send to MAC"); - DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq)); - if(sliceCfgReq == NULLP) + DU_ALLOC_SHRABL_BUF(macStatsReq, sizeof(MacStatsReq)); + if(macStatsReq == NULLP) { - DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq"); + DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsReq in BuildAndSendStatsReqToMac"); return RFAILED; } else { - if(fillSliceCfgReCfgInfo(sliceCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCnt) != ROK) - { - DU_LOG("\nERROR --> DU_APP : Failed to fill slice Configuration info in MacSliceCfgReq"); - return RFAILED; - } - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ); + memcpy(macStatsReq, &duMacStatsReq, sizeof(MacStatsReq)); - DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC "); - if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED) + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATISTICS_REQ); + + DU_LOG("\nDEBUG --> DU_APP: Sending Statistics Request to MAC "); + if( (*packMacStatsReqOpts[pst.selector])(&pst, macStatsReq) == RFAILED) { - DU_LOG("\nERROR --> DU_APP : Failed to send Slice Cfg Req to MAC"); - DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceCfgReq, sizeof(MacSliceCfgReq)); + DU_LOG("\nERROR --> DU_APP: Failed to send Statistics Request to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsReq, sizeof(MacStatsReq)); + return RFAILED; } } return ROK; } +/******************************************************************* + * + * @brief Fetch statistics details from Action Definition Format 1 + * + * @details + * + * Function : FetchStatsFromActionDefFormat1() + * + * Functionality: Fetch statistics details from Action + * Definition Format 1 received in an E2 message from + * RIC. + * + * @params[in] ActionDefFormat1 + * + * @return Statistics + * + * ****************************************************************/ +Statistics FetchStatsFromActionDefFormat1(ActionDefFormat1 format1) +{ + Statistics stats; + + /* TODO : When E2AP subscription procedure is implemented: + * Measurement info list is traveresed + * Based on KPI type, stats.macStatsReq or stats.rlcstatsReq is filled */ + + /* Hardcoding values for now for testing purpose + * Will be removed in next gerrit */ + stats.macStatsReq.numStats = 2; + stats.macStatsReq.statsList[0].type = MAC_DL_TOTAL_PRB_USAGE; + stats.macStatsReq.statsList[0].periodicity = 100; + stats.macStatsReq.statsList[1].type = MAC_UL_TOTAL_PRB_USAGE; + stats.macStatsReq.statsList[1].periodicity = 100; + + return stats; +} /******************************************************************* * - * @brief Fill the slice configration and rrm policy related - * information received form O1 + * @brief Send Statistics request to DU layers * * @details * - * Function : BuildAndSendSliceReCfgReq + * Function : BuildAndSendStatsReq() * - * Functionality: Fill the slice configration and rrm policy related + * Functionality: Check if there is an update in statistics + * reporting configuration. If so, send the update to + * respective layer. * - * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount + * @params[in] * * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount) +uint8_t BuildAndSendStatsReq(ActionDefinition subscribedAction) { - Pst pst; - MacSliceCfgReq *sliceReCfgReq = NULLP; - - DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received"); + Statistics stats; - DU_ALLOC_SHRABL_BUF(sliceReCfgReq, sizeof(MacSliceCfgReq)); - if(sliceReCfgReq == NULLP) + switch(subscribedAction.styleType) { - DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceReCfgReq"); - return RFAILED; + case 1: + stats = FetchStatsFromActionDefFormat1(subscribedAction.choice.format1); + case 2: + case 3: + case 4: + case 5: + default: + break; } - else + + if(BuildAndSendStatsReqToMac(stats.macStatsReq) != ROK) { - if(fillSliceCfgReCfgInfo(sliceReCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCount) != ROK) - { - DU_LOG("\nERROR --> DU_APP: Failed to fill slice cfg request info"); - return RFAILED; - } - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ); + DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToMac()"); + return RFAILED; + } - DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC "); - if( (*packMacSliceReCfgReqOpts[pst.selector])(&pst, sliceReCfgReq) == RFAILED) - { - DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC"); - DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceReCfgReq, sizeof(MacSliceCfgReq)); - } +/* TODO : When KPI collection from RLC will be supported, this function will be + * called to configure KPIs to be colled */ +#if 0 + if(BuildAndSendStatsReqToRlc(macStatsReq->rlcStatsReq) != ROK) + { + DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToRlc()"); + return RFAILED; } - return ROK; +#endif + + /* TODO : In the caller of this function, change ActionDefinition->action + * from CONFIG_ADD to CONFIG_UNKNOWN once configuration is sent + * To be done in next gerrit*/ + + + return ROK; } + /******************************************************************* * - * @brief process the slice ReCfg rsp received from MAC + * @brief Process statistics response from MAC * * @details * - * Function : DuProcMacSliceReCfgRsp + * Function : DuProcMacStatsRsp * - * Functionality: process the slice ReCfg rsp received from MAC + * Functionality: Processes statistics configuration response + * from MAC. If configuration is succsessful, DUAPP starts + * reporting period timer for this subscription request + * from RIC + * + * @params[in] * - * @params[in] Post structure, MacSliceCfgRsp *ReCfgRsp - * * @return ROK - success * RFAILED - failure * - **********************************************************************/ -uint8_t DuProcMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *reCfgRsp) + * ****************************************************************/ +uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp) { - uint8_t cfgIdx = 0, sliceIdx =0; - - if(reCfgRsp) + if(statsRsp) { - if(reCfgRsp->listOfSliceCfgRsp) + if(statsRsp->rsp == MAC_DU_APP_RSP_OK) { - for(cfgIdx = 0; cfgIdx < reCfgRsp->numSliceCfgRsp; cfgIdx++) - { - if(reCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == MAC_DU_APP_RSP_OK) - { - duCb.sliceState = SLICE_RECONFIGURED; - } - else - { - DU_LOG("\nERROR --> DU_APP : Slice not available"); - } - } - DU_LOG("\nINFO --> DU_APP : Slice ReCOnfiguration response received"); + DU_LOG("\nINFO --> DU_APP : Statistics configured successfully"); + /* TODO : Start Reporting period timer for this subscription request + * To be handled in next gerrit */ + } + else + { + DU_LOG("\nERROR --> DU_APP : Statistics configuration failed with cause [%d]", statsRsp->cause); } - duFreeSliceCfgRsp(pst, reCfgRsp); + DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp)); + return ROK; } - duFreeTempSliceCfg(); - return ROK; + + DU_LOG("\nINFO --> DU_APP : DuProcMacStatsRsp: Received NULL Pointer"); + return RFAILED; } + /********************************************************************** End of file **********************************************************************/