}
else
{
- DU_LOG("\nDU APP : No Cell found for NCI %d", nci);
+ DU_LOG("\nERROR --> DU APP : No Cell found for NCI %d", nci);
return RFAILED;
}
}
if(duBuildAndSendMacCellCfg(cellCb->cellId) != ROK)
{
- DU_LOG("\nDU APP : macCellCfg build and send failed");
+ DU_LOG("\nERROR --> DU APP : macCellCfg build and send failed");
/* Delete cell from actvCellList */
duCb.actvCellLst[--(duCb.numActvCells)] = NULLP;
ret = RFAILED;
******************************************************************/
void duProcF1SetupRsp()
{
- DU_LOG("\nDU_APP : F1 Setup Response received");
+ DU_LOG("\nINFO --> DU_APP : F1 Setup Response received");
duCb.f1Status = TRUE; //Set F1 status as true
}
******************************************************************/
void duProcGnbDuCfgUpdAckMsg()
{
- DU_LOG("\nDU APP: GNB-DU config update Ack received ");
+ DU_LOG("\nINFO --> DU APP: GNB-DU config update Ack received ");
}
/*******************************************************************
*
if(!*cellCb)
{
- DU_LOG("\nDU APP : Cell Id %d not found in DU APP", cellId);
+ DU_LOG("\nERROR --> DU APP : Cell Id %d not found in DU APP", cellId);
return RFAILED;
}
if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
{
- DU_LOG("\nDU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId);
+ DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId);
return RFAILED;
}
if((cellCb != NULL) && (cellCb->cellStatus == ACTIVATION_IN_PROGRESS))
{
- DU_LOG("\nDU APP : 5G-NR Cell %d is UP", cellId->cellId);
+ DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is UP", cellId->cellId);
cellCb->cellStatus = ACTIVATED;
#ifdef O1_ENABLE
- DU_LOG("\nDU APP : Raise cell UP alarm for cell id=%d", cellId->cellId);
+ DU_LOG("\nINFO --> DU APP : Raise cell UP alarm for cell id=%d", cellId->cellId);
raiseCellAlrm(CELL_UP_ALARM_ID, cellId->cellId);
#endif
}
duCfgParam.macCellCfg.ssbCfg.ssbMask[1] = 0;
if(BuildMibPdu() != ROK)
{
- DU_LOG("\nFailed to build MIB PDU");
+ DU_LOG("\nERROR --> Failed to build MIB PDU");
memset(&duCfgParam.macCellCfg.ssbCfg.mibPdu, 0, 3*sizeof(uint8_t));
}
else
NUM_UNUSED_ROOT_SEQ * sizeof(uint8_t));
if(duCfgParam.macCellCfg.prachCfg.fdm[0].unsuedRootSeq == NULLP)
{
- DU_LOG("\nDU_APP : Memory allocation failed");
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed at readMacCfg");
return RFAILED;
}
*(duCfgParam.macCellCfg.prachCfg.fdm[0].unsuedRootSeq) = UNUSED_ROOT_SEQ;
strlen(encBuf));
if(!(duCfgParam.srvdCellLst[i].duSysInfo.mibMsg))
{
- DU_LOG("\nDU_APP: Memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failure at readCfg");
return RFAILED;
}
strcpy((char *)duCfgParam.srvdCellLst[i].duSysInfo.mibMsg, encBuf);
encBufSize);
if(!(duCfgParam.srvdCellLst[i].duSysInfo.sib1Msg))
{
- DU_LOG("\nDU_APP: Memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failure at readCfg");
return RFAILED;
}
memcpy(duCfgParam.srvdCellLst[i].duSysInfo.sib1Msg,\
if(readMacCfg() != ROK)
{
- DU_LOG("\nDU_APP : Failed while reading MAC config");
+ DU_LOG("\nERROR --> DU_APP : Failed while reading MAC config");
return RFAILED;
}
//Read configs into duCfgParams
if(readCfg() != ROK)
{
- DU_LOG("\nDU_APP : Reading configuration failed");
+ DU_LOG("\nERROR --> DU_APP : Reading configuration failed");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, DU_POOL, &mBuf) != ROK)
{
- DU_LOG("\nDU_APP : Memory allocation failed in duReadCfg");
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in duReadCfg");
return RFAILED;
}
if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nDU_APP : ODU_POST_TASK failed in duReadCfg");
+ DU_LOG("\nERROR --> DU_APP : ODU_POST_TASK failed in duReadCfg");
return RFAILED;
}
DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
{
- DU_LOG("\nE2AP: Memory allocation failed for Plmn buffer");
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
ret = RFAILED;
}
else
gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
{
- DU_LOG("\nE2AP: Memory allocation failed for gnb buffer");
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
ret = RFAILED;
}
else
(*e2SetupReq)->protocolIEs.list.size);
if((*e2SetupReq)->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation failed for array elements");
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
ret = RFAILED;
}
else
sizeof(E2setupRequestIEs_t));
if((*e2SetupReq)->protocolIEs.list.array[*idx] == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation failed for arrayidx [%d]", *idx);
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayidx [%d]", *idx);
ret = RFAILED;
}
else
if((*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
GlobalE2node_ID.choice.gNB == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation failed for gNbId");
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
ret = RFAILED;
}
else
else
{
ret = RFAILED;
- DU_LOG("\nE2AP : Passed e2SetupReq is NULL");
+ DU_LOG("\nERROR --> E2AP : received e2SetupReq is NULL");
}
return ret;
}
E2setupRequest_t *e2SetupReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nE2AP : Building E2 Setup Request\n");
+ DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
return RFAILED;
}
ret = fillE2SetupReq(&e2SetupReq, &idx);
if(ret != ROK)
{
- DU_LOG("\nE2AP : fillE2SetupReq() failed");
+ DU_LOG("\nERROR --> E2AP : fillE2SetupReq() failed");
break;
}
/* Prints the Msg formed */
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nE2AP : Could not encode E2SetupRequest structure (at %s)\n",\
+ DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nE2AP : Created APER encoded buffer for E2SetupRequest\n");
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nE2AP : Sending E2 Setup request failed");
+ DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
}
break;
break;
}
default:
- DU_LOG("\n E2AP: Invalid event at e2SetupRequet %ld ",\
+ DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
(e2SetupReq->protocolIEs.list.array[idx2]->id));
break;
}
if(admitListPtr == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
ret = RFAILED;
}
else
DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
if(admitListPtr->list.array == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
ret = RFAILED;
}
else
ricSubscriptionRsp->protocolIEs.list.size);
if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for FillRicSubscriptionRsp failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
ret = RFAILED;
}
else
while(true)
{
- DU_LOG("\nE2AP : Building RIC Subscription Response\n");
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
if(e2apRicMsg == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apRicMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for Ric subscription Response failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
break;
}
FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
if(FillRicricSubscriptionRspret != ROK)
{
- DU_LOG("\nE2AP : Memory allocation for RICsubscriptionResponseIE failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
break;
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nE2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
+ DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nE2AP : Created APER encoded buffer for RIC subscription response \n");
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nE2AP : Sending RIC Subscription Response failed");
+ DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
break;
}
uint32_t recvBufLen;
E2setupResponse_t *e2SetRspMsg;
- DU_LOG("\nE2AP : E2 Setup Response received");
+ DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
duCb.e2Status = TRUE; //Set E2 status as true
e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
break;
}
default:
- DU_LOG("\nE2AP : Invalid IE received in E2SetupRsp:%ld",
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
e2SetRspMsg->protocolIEs.list.array[idx]->id);
break;
}
RICsubscriptionRequest_t *ricSubsReq;
RICaction_ToBeSetup_ItemIEs_t *actionItem;
- DU_LOG("\nE2AP : Ric Subscription request received");
+ DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
break;
}
default:
- DU_LOG("\nE2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
break;
}
free(actionItem);
}
default:
- DU_LOG("\nE2AP : Invalid IE received in Ric SubsReq:%ld",
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
ricSubsReq->protocolIEs.list.array[idx]->id);
break;
}
ricIndicationMsg->protocolIEs.list.size);
if(ricIndicationMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
ret = RFAILED;
}
else
sizeof(RICindication_IEs_t));
if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
ret = RFAILED;
}
}
ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
ret = RFAILED;
}
else
ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
ret = RFAILED;
}
else
while(true)
{
- DU_LOG("\nE2AP : Building Ric Indication Message\n");
+ DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nE2AP : Could not encode RIC Indication Message (at %s)\n",\
+ DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nE2AP : Created APER encoded buffer for RIC Indication Message \n");
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nE2AP : Sending RIC Indication Message");
+ DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
}
ret = ROK;
if(sctpSend(mBuf, E2_INTERFACE) != ROK)
{
- DU_LOG("\nE2AP : SCTP Send for E2 failed");
+ DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nE2AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nE2AP : Failed to allocate memory");
+ DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
return RFAILED;
}
asn_dec_rval_t rval ={0}; /* Decoder return value */
E2AP_PDU_t e2apasnmsg={0} ;
- DU_LOG("\nE2AP : Received E2AP message buffer");
+ DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
if(recvBuf == NULLP)
{
- DU_LOG("\nE2AP : Memory allocation failed");
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
+ DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
return;
}
- printf("\nE2AP : Received flat buffer to be decoded : ");
+ printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
for(i=0; i< recvBufLen; i++)
{
printf("%x",recvBuf[i]);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nE2AP : ASN decode failed");
+ DU_LOG("\nERROR --> E2AP : ASN decode failed");
return;
}
printf("\n");
{
if(!duCb.e2Status)
{
- DU_LOG("\nE2AP : Store E2 setup response Params");
+ DU_LOG("\nDEBUG --> E2AP : Store E2 setup response Params");
procE2SetupRsp(e2apMsg);
}
break;
}
default:
{
- DU_LOG("\nE2AP : Invalid type of sucessful message [%d]", e2apMsg->choice.successfulOutcome->value.present);
+ DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
+ e2apMsg->choice.successfulOutcome->value.present);
return;
}
}/* End of switch(successfulOutcome) */
{
case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
{
- DU_LOG("\nE2AP : Calling RIC Subscription Response");
if(procRicSubsReq(e2apMsg) == ROK)
{
BuildAndSendRicIndication();
}
default:
{
- DU_LOG("\nE2AP : Invalid type of intiating message [%d]", e2apMsg->choice.initiatingMessage->value.present);
+ DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
+ e2apMsg->choice.initiatingMessage->value.present);
return;
}
}/* End of switch(initiatingMessage) */
}
default:
{
- DU_LOG("\nE2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
+ DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
return;
}
free(e2apMsg);
***************************************************************************/
uint8_t egtpActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
- DU_LOG("\n\nEGTP : Initializing");
+ DU_LOG("\n\nDEBUG --> EGTP : Initializing");
memset (&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
}
default:
{
- DU_LOG("\nEGTP : Invalid event %d", pst->event);
+ DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
{
case EVTSTARTPOLL:
{
- DU_LOG("\nEGTP : Starting Socket Polling");
+ DU_LOG("\nDEBUG --> EGTP : Starting Socket Polling");
egtpRecvMsg();
ODU_PUT_MSG_BUF(mBuf);
break;
}
default:
{
- DU_LOG("\nEGTP : Invalid event %d", pst->event);
+ DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nEGTP : Invalid event %d", pst->event);
+ DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
ret = RFAILED;
}
}
}
default:
{
- DU_LOG("\nEGTP : Invalid source entity %d", pst->srcEnt);
+ DU_LOG("\nERROR --> EGTP : Invalid source entity %d", pst->srcEnt);
ret = RFAILED;
}
}
if(ret != ROK)
{
- DU_LOG("\nEGTP : TeId hash list initialization failed");
+ DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
cfgCfm.status = LCM_PRIM_NOK;
cfgCfm.reason = LCM_REASON_HASHING_FAILED;
}
else
{
- DU_LOG("\nEGTP : EGTP configuration successful");
+ DU_LOG("\nDEBUG --> EGTP : EGTP configuration successful");
cfgCfm.status = LCM_PRIM_OK;
cfgCfm.reason = LCM_REASON_NOT_APPL;
}
CmStatus cfm; /* Confirmation status */
uint8_t sockType; /* Socket type */
- DU_LOG("\nEGTP : Received EGTP open server request");
+ DU_LOG("\nDEBUG --> EGTP : Received EGTP open server request");
sockType = CM_INET_DGRAM;
ret = egtpSrvOpenPrc(sockType, &(egtpCb.recvTptSrvr));
/* Opening and Binding receiver socket */
if(ret != ROK)
{
- DU_LOG("\nEGTP : Failed while opening receiver transport server");
+ DU_LOG("\nERROR --> EGTP : Failed while opening receiver transport server");
return ret;
}
/* Opening and Binding sender socket */
ret = egtpSrvOpenPrc(sockType, &(egtpCb.dstCb.sendTptSrvr));
if(ret != ROK)
{
- DU_LOG("\nEGTP : Failed while opening sender transport server");
+ DU_LOG("\nERROR --> EGTP : Failed while opening sender transport server");
return ret;
}
- DU_LOG("\nEGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd, egtpCb.dstCb.sendTptSrvr.sockFd.fd);
+ DU_LOG("\nDEBUG --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\
+ egtpCb.dstCb.sendTptSrvr.sockFd.fd);
/* Start Socket polling */
memset(&egtpPst, 0, sizeof(egtpPst));
ret = cmInetSocket(sockType, &(server->sockFd), protType);
if(ret != ROK)
{
- DU_LOG("\nEGTP : Failed to open UDP socket");
+ DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
return ret;
}
ret = cmInetBind(&(server->sockFd), &(server->addr));
if(ret != ROK)
{
- DU_LOG("\nEGTP : Failed to bind socket");
+ DU_LOG("\nERROR --> EGTP : Failed to bind socket");
return ret;
}
{
S8 ret;
- DU_LOG("\nEGTP : Received tunnel management request");
+ DU_LOG("\nDEBUG --> EGTP : Received tunnel management request");
switch(tnlEvt.action)
{
case EGTP_TNL_MGMT_ADD:
}
default:
{
- DU_LOG("\nEGTP : Invalid tunnel management action[%d]", tnlEvt.action);
+ DU_LOG("\nERROR --> EGTP : Invalid tunnel management action[%d]", tnlEvt.action);
ret = LCM_REASON_INVALID_ACTION;
}
}
tnlEvt.cfmStatus.reason = ret;
}
- DU_LOG("\nEGTP : Sending Tunnel management confirmation");
+ DU_LOG("\nDEBUG --> EGTP : Sending Tunnel management confirmation");
duHdlEgtpTnlMgmtCfm(tnlEvt);
return ROK;
EgtpTeIdCb *teidCb; /* Tunnel endpoint control block */
EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
- DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("\nINFO --> EGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
DU_ALLOC(teidCb, sizeof(EgtpTeIdCb));
if(teidCb == NULLP)
{
- DU_LOG("\nEGTP : Memory allocation failed");
+ DU_LOG("\nERROR --> EGTP : Memory allocation failed");
return LCM_REASON_MEM_NOAVAIL;
}
ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
- DU_LOG("\nEGTP : Failed to insert in hash list");
+ DU_LOG("\nERROR --> EGTP : Failed to insert in hash list");
DU_FREE(teidCb, sizeof(EgtpTeIdCb));
return LCM_REASON_HASHING_FAILED;
}
uint8_t ret;
EgtpTeIdCb *teidCb = NULLP;
- printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("\nINFO --> Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- printf("\nTunnel id not found");
+ DU_LOG("\nERROR --> Tunnel id not found");
return RFAILED;
}
teidCb->teId = tnlEvt.lclTeid;
+ DU_LOG("\nINFO --> Tunnel id is" , teidCb->teId);
teidCb->remTeId = tnlEvt.remTeid;
#endif
return ROK;
{
EgtpTeIdCb *teidCb = NULLP;
- DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("\nINFO --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
+ DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
return LCM_REASON_INVALID_PAR_VAL;
}
uint32_t msgLen;
EgtpMsgHdr *msgHdr;
- DU_LOG("\nEGTP : Received Data Indication");
+ DU_LOG("\nDEBUG --> EGTP : Received Data Indication");
cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg.msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg.msgHdr.teId);
+ DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg.msgHdr.teId);
return LCM_REASON_INVALID_PAR_VAL;
}
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT2);
}
- DU_LOG("\nEGTP : UL Data buffer before encoding header");
+ DU_LOG("\nDEBUG --> EGTP : UL Data buffer before encoding header");
ODU_PRINT_MSG(egtpMsg.msg, 0, 0);
ODU_ADD_PRE_MSG_MULT(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg.msg);
- DU_LOG("\nEGTP : UL Data buffer after encoding header");
+ DU_LOG("\nDEBUG --> EGTP : UL Data buffer after encoding header");
ODU_PRINT_MSG(egtpMsg.msg, 0, 0);
/* Send over UDP */
mBuf, (int16_t *)&txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nEGTP : Failed sending the message");
+ DU_LOG("\nERROR --> EGTP : Failed sending the message");
return RFAILED;
}
- DU_LOG("\nEGTP : Message Sent");
+ DU_LOG("\nDEBUG --> EGTP : Message Sent");
return ROK;
}
&recvBuf, (int16_t *)&bufLen, CM_INET_NO_FLAG);
if(ret == ROK && recvBuf != NULLP)
{
- DU_LOG("\nEGTP : Received DL Message[%d]\n", nMsg+1);
+ DU_LOG("\nDEBUG --> EGTP : Received DL Message[%d]\n", nMsg+1);
ODU_PRINT_MSG(recvBuf, 0 ,0);
egtpHdlRecvData(recvBuf);
}
/* Extracting version fro 1st byte */
version = tmpByte[0] >> 5;
- DU_LOG("\nEGTP : Version %d", version);
+ DU_LOG("\nDEBUG --> EGTP : Version %d", version);
/* Decode message type */
ODU_REM_PRE_MSG((Data*)&(egtpMsg->msgHdr.msgType), mBuf);
- DU_LOG("\nEGTP : msgType %d", egtpMsg->msgHdr.msgType);
+ DU_LOG("\nDEBUG --> EGTP : msgType %d", egtpMsg->msgHdr.msgType);
/****************************************************************************
* Message length param is 2 bytes. So decode next 2 bytes from msg hdr and
ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
msgLen = (tmpByte[1] << 8) | tmpByte[2];
- DU_LOG("\nEGTP : msgLen %d", msgLen);
+ DU_LOG("\nDEBUG --> EGTP : msgLen %d", msgLen);
/****************************************************************************
ODU_REM_PRE_MSG(&tmpByte[3], mBuf);
ODU_REM_PRE_MSG(&tmpByte[4], mBuf);
egtpMsg->msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4];
- DU_LOG("\nEGTP : teId %d",egtpMsg->msgHdr.teId);
+ DU_LOG("\nDEBUG --> EGTP : teId %d",egtpMsg->msgHdr.teId);
/* If any one of S, E or PN flag is set, set extension present as true. */
egtpMsg->msg = mBuf;
- DU_LOG("\nEGTP : DL Data Buffer after decoding header ");
+ DU_LOG("\nDEBUG --> EGTP : DL Data Buffer after decoding header ");
ODU_PRINT_MSG(mBuf, 0, 0);
/* Forward the data to duApp/RLC */
if(sctpSend(mBuf, F1_INTERFACE) != ROK)
{
- DU_LOG("\nF1AP : SCTP Send failed");
+ DU_LOG("\nERROR --> F1AP : SCTP Send failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("\nERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nF1AP : Failed to allocate memory");
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory");
return RFAILED;
}
return ROK;
FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
break;
default:
- DU_LOG("\nInvalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
break;
}
}
asn_enc_rval_t encRetVal; /* Encoder return value */
ret= RFAILED;
- DU_LOG("\nF1AP : Building F1 Setup Request\n");
+ DU_LOG("\nINFO --> F1AP : Building F1 Setup Request\n");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nF1AP : Could not encode F1SetupRequest structure (at %s)\n",\
+ DU_LOG("\nERROR --> F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupRequest\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1SetupRequest\n");
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
printf("%x",encBuf[ieIdx]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nF1AP : Sending F1 Setup request failed");
+ DU_LOG("\nERROR --> F1AP : Sending F1 Setup request failed");
break;
}
while(true)
{
- DU_LOG("\nF1AP : Building DU config update\n");
+ DU_LOG("\nINFO --> F1AP : Building DU config update\n");
/* Allocate the memory for F1DuCfg */
DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
if(f1apDuCfg == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
if(f1apDuCfg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
if(duCfgUpdate->protocolIEs.list.array == NULLP)
{
- DU_LOG("F1AP : Memory allocation for F1RequestIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1RequestIEs failed");
break;
}
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
/* Checking encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("F1AP : Could not encode DUConfigUpdate structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ DU_LOG("ERROR --> F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for DUConfigUpdate\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DUConfigUpdate\n");
for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
{
printf("%x",encBuf[ieIdx]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nF1AP : Sending GND-DU Config Update failed");
+ DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update failed");
break;
}
while(true)
{
- DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
+ DU_LOG("\n INFO --> F1AP : Building UL RRC Message Transfer Message\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
if(ulRRCMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
break;
}
for(idx=0; idx<elementCnt; idx++)
ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
{
- DU_LOG(" F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
break;
}
memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
+ DU_LOG( "\nERROR --> F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
{
- DU_LOG("\n F1AP : Sending UL RRC Message Transfer Failed");
+ DU_LOG("\nERROR --> F1AP : Sending UL RRC Message Transfer Failed");
break;
}
ret = ROK;
DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
if(!tagConfig->tag_ToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
DU_ALLOC(tagList->list.array, tagList->list.size);
if(!tagList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
if(!tagList->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
}
DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
if(!phrConfig->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
return RFAILED;
}
sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
if(!schedulingRequestConfig->schedulingRequestToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
DU_ALLOC(schReqList->list.array, schReqList->list.size);
if(!schReqList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
if(!schReqList->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
}
DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
if(!schReqList->list.array[idx]->sr_ProhibitTimer)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
*(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
if(!rlcConfig->choice.am)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
if(!macLcConfig->ul_SpecificParameters)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
*(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
*(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
if(!rlcBearerList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
if(!rlcBearerList->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
}
sizeof(struct RLC_BearerConfig__servedRadioBearer));
if(!rlcBearerList->list.array[idx]->servedRadioBearer)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
{
- DU_LOG("\nF1AP : BuildRlcConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
return RFAILED;
}
sizeof(struct LogicalChannelConfig));
if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildMacLCConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
return RFAILED;
}
DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
if(!controlRSetList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
if(!controlRSetList->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
controlRSet->frequencyDomainResources.size);
if(!controlRSet->frequencyDomainResources.buf)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
if(!controlRset->tci_StatesPDCCH_ToAddList)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
controlRset->tci_StatesPDCCH_ToAddList->list.size)
if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
if(!controlRset->tci_PresentInDCI)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
/* TODO */
DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
if(!controlRSet->pdcch_DMRS_ScramblingID)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
*(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
if(!searchSpcList->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
if(!searchSpcList->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
}
DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
if(!searchSpc->controlResourceSetId)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
*(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
if(!searchSpc->monitoringSlotPeriodicityAndOffset)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
searchSpc->monitoringSlotPeriodicityAndOffset->present = \
DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
if(!searchSpc->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
searchSpc->monitoringSymbolsWithinSlot->size);
if(!searchSpc->monitoringSymbolsWithinSlot->buf)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpc->nrofCandidates)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
if(!searchSpc->searchSpaceType)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
if(!searchSpc->searchSpaceType->choice.ue_Specific)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
if(!pdcchCfg->controlResourceSetToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
sizeof(struct PDCCH_Config__searchSpacesToAddModList));
if(!pdcchCfg->searchSpacesToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
if(!dmrsDlCfg->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
return RFAILED;
}
*(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
sizeof(struct PDSCH_TimeDomainResourceAllocationList));
if(!timeDomAllocList->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
sizeof(struct PDSCH_TimeDomainResourceAllocation));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
}
sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
if(!prbBndlType->choice.staticBundling)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
return RFAILED;
}
prbBndlType->choice.staticBundling->bundleSize = NULLP;
sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
if(!pdschCfg->tci_StatesToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
if(!pdschCfg->pdsch_TimeDomainAllocationList)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
*(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
if(!dlBwp->pdcch_Config)
{
- DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
if(!dlBwp->pdcch_Config->choice.setup)
{
- DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
if(!dlBwp->pdsch_Config)
{
- DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
if(!dlBwp->pdsch_Config->choice.setup)
{
- DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
if(!dmrsUlCfg->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
*(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
sizeof(long));
if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
*(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
sizeof(struct PUSCH_TimeDomainResourceAllocationList));
if(!timeDomAllocList->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
sizeof(PUSCH_TimeDomainResourceAllocation_t));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
}
DU_ALLOC(timeDomAlloc->k2, sizeof(long));
if(!timeDomAlloc->k2)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k2) = PUSCH_K2;
DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
if(!puschCfg->dataScramblingIdentityPUSCH)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
*(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
if(!puschCfg->pusch_TimeDomainAllocationList)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
if(!puschCfg->transformPrecoder)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
*(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
DU_ALLOC(resourceList->list.array, resourceList->list.size);
if(!resourceList->list.array)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
if(!resourceList->list.array[rsrcIdx])
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
}
sizeof(struct SRS_Resource__transmissionComb__n2));
if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
sizeof(struct SRS_Resource__resourceType__aperiodic));
if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
if(!rsrcSetList->list.array)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
if(!rsrcSetList->list.array[rSetIdx])
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
if(!rsrcIdList->list.array)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
if(!rsrcIdList->list.array[rsrcIdx])
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
if(!srsCfg->srs_ResourceSetToAddModList)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
return RFAILED;
}
if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
sizeof(struct SRS_Config__srs_ResourceToAddModList));
if(!srsCfg->srs_ResourceToAddModList)
{
- DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
if(!puschCfg->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
if(!puschCfg->choice.setup->ext1)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
*(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
if(!puschCfg->choice.setup->ext1->processingType2Enabled)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
*(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
if(!ulBwp->pusch_Config)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
if(!ulBwp->pusch_Config->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
if(!ulBwp->srs_Config)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
if(!ulBwp->srs_Config->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
if(!ulCfg->initialUplinkBWP)
{
- DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
if(!ulCfg->firstActiveUplinkBWP_Id)
{
- DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
*(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
sizeof(struct UplinkConfig__pusch_ServingCellConfig));
if(!ulCfg->pusch_ServingCellConfig)
{
- DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
if(!pdschCfg->choice.setup)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
*(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
if(!srvCellCfg->initialDownlinkBWP)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
{
- DU_LOG("\nF1AP : BuildInitialDlBWP failed");
+ DU_LOG("\nERROR --> F1AP : BuildInitialDlBWP failed");
return RFAILED;
}
srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->firstActiveDownlinkBWP_Id)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
*(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->defaultDownlinkBWP_Id)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
*(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
if(!srvCellCfg->uplinkConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildUlCfg failed");
+ DU_LOG("\nERROR --> F1AP : BuildUlCfg failed");
return RFAILED;
}
srvCellCfg->supplementaryUplink = NULLP;
DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
if(!srvCellCfg->pdsch_ServingCellConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
+ DU_LOG("\nERROR --> F1AP : BuildPdschSrvCellCfg failed");
return RFAILED;
}
DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
if(!srvCellCfg->csi_MeasConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
if(!spCellCfg->servCellIndex)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
*(spCellCfg->servCellIndex) = SERV_CELL_IDX;
DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
*(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
if(!spCellCfg->spCellConfigDedicated)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
{
- DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
+ DU_LOG("\nERROR --> F1AP : BuildSpCellCfgDed failed");
return RFAILED;
}
return ROK;
DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
if(!phyCellGrpCfg->p_NR_FR1)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
return RFAILED;
}
*(phyCellGrpCfg->p_NR_FR1) = P_NR_FR1;
DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
if(!macCellGrpCfg->schedulingRequestConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildSchedulingReqConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
if(!macCellGrpCfg->bsr_Config)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
{
- DU_LOG("\nF1AP : BuildBsrConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildBsrConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
if(!macCellGrpCfg->tag_Config)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
{
- DU_LOG("\nF1AP : BuildTagConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildTagConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
if(!macCellGrpCfg->phr_Config)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
{
- DU_LOG("\nF1AP : BuildPhrConfig failed");
+ DU_LOG("\nERROR --> F1AP : BuildPhrConfig failed");
return RFAILED;
}
DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
if(!cellGrpCfg.rlc_BearerToAddModList)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
{
- DU_LOG("\nF1AP : BuildRlcBearerToAddModList failed");
+ DU_LOG("\nERROR --> F1AP : BuildRlcBearerToAddModList failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
if(!cellGrpCfg.mac_CellGroupConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
+ DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
if(!cellGrpCfg.physicalCellGroupConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
+ DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
if(!cellGrpCfg.spCellConfig)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildSpCellCfg failed");
+ DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
ret = RFAILED;
break;
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
+ DU_LOG( "\nERROR --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
ret = RFAILED;
break;
}
else
{
- DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
if(!duToCuRrcContainer->buf)
{
- DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nDU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
+ DU_LOG("\nERROR --> DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
return RFAILED;
}
return ROK;
while(true)
{
- DU_LOG("\n F1AP : Building RRC Setup Request\n");
+ DU_LOG("\n INFO --> F1AP : Building RRC Setup Request\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode =\
DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
if(initULRRCMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for\
+ DU_LOG(" ERROR --> F1AP : Memory allocation for\
RRCSetupRequestMessageTransferIEs failed");
break;
}
initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
{
- DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
break;
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer\
+ DU_LOG( "\nERROR --> F1AP : Could not encode Initial UL RRC Message Transfer\
structure (at %s)\n",encRetVal.failed_type ? \
encRetVal.failed_type->name : "unknown");
ret = RFAILED;
else
{
- DU_LOG("\n F1AP : Created APER encoded buffer for Initial UL RRC\
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Initial UL RRC\
Message transfer\n");
for(int i=0; i< encBufSize; i++)
{
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
{
- DU_LOG("\n F1AP : Sending Initial UL RRC Message Transfer Failed");
+ DU_LOG("\nERROR --> F1AP : Sending Initial UL RRC Message Transfer Failed");
ret = RFAILED;
break;
}
break;
}
default:
- DU_LOG("\nDU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
+ DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
break;
}
memset(lcCfg, 0, sizeof(LcCfg));
break;
}
default:
- DU_LOG("\nDUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
+ DU_LOG("\nERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
break;
}
}
DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
if(macLcToAdd->drbQos == NULLP)
{
- DU_LOG("\n DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
+ DU_LOG("\nERROR --> DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
if(macLcToAdd->snssai == NULLP)
{
- DU_LOG("\n DUAPP:Memory failed at allocating SNSSAI at extractDrbCfg()");
+ DU_LOG("\nERROR --> DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
return RFAILED;
}
}
ret = extractDrbCfg(drbCfg, lcCfg);
if(ret == RFAILED)
{
- DU_LOG("F1AP: Failed to build Drb Qos at extractMacRbCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to build Drb Qos at extractMacRbCfg()");
return ret;
}
}
}
else
{
- DU_LOG("\n No components present in Bearer config to ADD/MOD");
+ DU_LOG("\nERROR --> No components present in Bearer config to ADD/MOD");
return RFAILED;
}
/* MAC UL LC Config */
}
else
{
- DU_LOG("\nDUAPP: Received RadioBearer config is NULL");
+ DU_LOG("\nERROR --> DUAPP: Received RadioBearer config is NULL");
return RFAILED;
}
/* RLC Mode Config */
ret = procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx]);
if(ret == RFAILED)
{
- DU_LOG("\nDUAPP: Failed while filling MAC LC config at extractRlcCfgToAddMod()");
+ DU_LOG("\nERROR --> DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
return ret;
}
(ueCfgDb->numRlcLcs)++;
}
else
{
- DU_LOG("\nDUAPP: Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nDUAPP: Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nDUAPP: Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nDUAPP: Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
return RFAILED;
}
}
break;
}
default :
- DU_LOG("\nERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
+ DU_LOG("\nERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
}
}
}
break;
default:
- DU_LOG("\nF1AP:Invalid Event type %ld at FreeCuToDuInfo()", \
+ DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
rrcMsg->iE_Extensions->list.array[ieIdx]->id);
break;
}
cellGrp = (CellGroupConfigRrc_t *)cellInfo;
ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
if(ret == RFAILED)
- DU_LOG("\nF1AP: Failed at procUeReCfgCellInfo()");
+ DU_LOG("\nERROR --> F1AP : Failed at procUeReCfgCellInfo()");
}
if(ret == RFAILED)
{
}
default:
{
- DU_LOG("\nDU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
+ DU_LOG("\nERROR --> DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
break;
}
}
default:
{
- DU_LOG("\nDU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
+ DU_LOG("\nERROR --> DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
break;
}
extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
return NULLP;
}
xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
break;
}
default:
- DU_LOG("\nF1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
+ DU_LOG("\nERROR --> F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
break;
}
}
ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL, NULL, macLcToAdd);
if(ret == RFAILED)
{
- DU_LOG("\nF1AP:Failed at MAC LC Cfg in procSrbListToSetup()");
+ DU_LOG("\nERROR --> F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
return ret;
}
return ret;
srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
if(ueCfgDb->numMacLcs > MAX_NUM_LC)
{
- DU_LOG("\nF1AP: MAX LC Reached in MAC");
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in MAC");
ret = RFAILED;
break;
}
if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
{
- DU_LOG("\nF1AP: MAX LC Reached in RLC");
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in RLC");
ret = RFAILED;
break;
}
ueCfgDb->numMacLcs++;
if(ret == RFAILED)
{
- DU_LOG("\nF1AP: Failed at extractSrbListToSetup()");
+ DU_LOG("\nERROR --> F1AP: Failed at extractSrbListToSetup()");
break;
}
}
ret = procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, macLcToAdd);
if(ret == RFAILED)
{
- DU_LOG("\nF1AP:Failed at RLC LC Cfg in extractDrbListToSetup()");
+ DU_LOG("\nERROR --> F1AP : Failed at RLC LC Cfg in extractDrbListToSetup()");
return ret;
}
drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
if(ueCfgDb->numMacLcs > MAX_NUM_LC)
{
- DU_LOG("\nF1AP: MAX LC Reached in MAC ");
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in MAC ");
ret = RFAILED;
break;
}
if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
{
- DU_LOG("\nF1AP: MAX LC Reached in RLC");
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in RLC");
ret = RFAILED;
break;
}
ueCfgDb->numMacLcs++;
if(ret == RFAILED)
{
- DU_LOG("\nF1AP: Failed at extractDrbListToSetup()");
+ DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToSetup()");
break;
}
}
DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
if(!dlRrcMsg->rrcMsgPdu)
{
- DU_LOG("\nDU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
ret = RFAILED;
}
else
DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
if(!ueCapRatContList)
{
- DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in extractUeCapability");
return NULLP;
}
memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
ueCapablityListBuf->buf, recvBufLen, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
return NULLP;
}
xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
if(!ueNrCap)
{
- DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in extractUeCapability");
DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
return NULLP;
}
ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
return NULLP;
}
xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
break;
}
default:
- printf("\nF1AP: Invalid event type %ld",ueSetReq->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("\nERROR --> F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
}
free(ueSetReq->protocolIEs.list.array[ieIdx]);
}
}
else
{
- DU_LOG("\nF1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
+ DU_LOG("\nERROR --> F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
ret = RFAILED;
}
}
}
if(!ueCbFound)
{
- DU_LOG("\nF1AP: DuUeCb is not found at procF1UeContextSetupReq()");
+ DU_LOG("\nERROR --> F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
ret = RFAILED;
}
break;
value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
{
- DU_LOG("\n F1AP: Failed to extract cell Grp Info");
+ DU_LOG("\nERROR --> F1AP: Failed to extract cell Grp Info");
//TODO: Update the failure cause in ue context Setup Response
ret = RFAILED;
}
}
case ProtocolIE_ID_id_SCell_ToBeSetup_List:
{
- DU_LOG("\nDU_APP: Received SCell to be added");
- DU_LOG("\nDU_APP: Not processing the SCell_ToBeSetup_List");
+ DU_LOG("\nINFO --> DU_APP: Received SCell_ToBeSetup_List but Not processing the list");
break;
}
case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
&duUeCb->f1UeDb->duUeCfg))
{
- DU_LOG("\nDU_APP: Failed at extractSrbListToSetup()");
+ DU_LOG("\nERROR --> DU APP : Failed at extractSrbListToSetup()");
//TODO: Update the failure cause in ue context Setup Response
ret = RFAILED;
}
if(extractDrbListToSetup(lcId, &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List,\
&duUeCb->f1UeDb->duUeCfg))
{
- DU_LOG("\nDU_APP: Failed at extractDrbListToSetup()");
+ DU_LOG("\nERROR --> DU APP : Failed at extractDrbListToSetup()");
//TODO: Update the failure cause in ue context Setup Response
ret = RFAILED;
}
DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
if(!duUeCb->f1UeDb->dlRrcMsg)
{
- DU_LOG("\nDU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nIgnoring delivery report, since rrcContainer is not present");
+ DU_LOG("\nERROR --> Ignoring delivery report, since rrcContainer is not present");
}
break;
}
DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
{
- DU_LOG("\nDU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
ret = RFAILED;
}
else
{
/*TODO : Negative case*/
// BuildAndSendUeContextSetupRsp(ueIdx, cellId);
- DU_LOG("F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
+ DU_LOG("\nERROR --> F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
}
else
ret = duProcUeContextSetupRequest(duUeCb);
break;
}
default:
- DU_LOG("\nDUAPP: Invalid Id %ld at FreeUeContextSetupRsp()", ueSetRsp->protocolIEs.list.array[idx]->id);
+ DU_LOG("\nERROR --> DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
+ ueSetRsp->protocolIEs.list.array[idx]->id);
break;
}
DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\n F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
+ DU_LOG( "\nERROR --> F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
{
- DU_LOG("\n F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
if(!duToCuCellGrp->buf)
{
- DU_LOG("\nF1AP : Memory allocation failed in UeCntxtDuToCuInfo");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
}
memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
return ROK;
CellGroupConfigRrc_t *cellGrpCfg = NULLP;
DuUeCb *ueCb = NULLP;
- DU_LOG("\n F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
+ DU_LOG("\n INFO --> F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
while(true)
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
ret = RFAILED;
break;
}
sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
ret = RFAILED;
break;
}
ueSetRsp->protocolIEs.list.size);
if(ueSetRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for UE Setup Response failed");
ret = RFAILED;
break;
}
sizeof(UEContextSetupResponseIEs_t));
if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for UE Setup Response failed");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nF1AP: Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
+ DU_LOG("\nERROR --> F1AP: Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
ret = RFAILED;
}
if(ret == RFAILED)
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
ret = RFAILED;
break;
}
else
{
- DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UE Context Setup Request\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
{
- DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
+ DU_LOG("\nERROR --> F1AP : Sending UE Context Setup Request Failed");
ret = RFAILED;
break;
}
//TODO: Build Ue context Modification Rsp
break;
default:
- DU_LOG("F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
+ DU_LOG("ERROR --> F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
break;
}
Reset_t *f1ResetMsg = NULLP;
F1AP_PDU_t *f1apMsg = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nF1AP : Building F1 Reset request \n");
+ DU_LOG("\nINFO --> F1AP : Building F1 Reset request \n");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nF1AP : Could not encode F1Reset structure (at %s)\n",\
+ DU_LOG("\nERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for F1Reset\n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
for(idx=0; idx< encBufSize; idx++)
{
printf("%x",encBuf[idx]);
if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nF1AP : Sending F1 Reset request failed");
+ DU_LOG("\nERROR --> F1AP : Sending F1 Reset request failed");
break;
}
F1AP_PDU_t *f1apMsg = NULL;
ResetAcknowledge_t *f1ResetAck = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
+ DU_LOG("\nINFO --> F1AP : Building F1 Reset Acknowledgment \n");
do{
/* Allocate the memory for F1ResetRequest_t */
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
if(f1ResetAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
+ DU_LOG("\nERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck\n");
+ DU_LOG("\nDUBUG --> F1AP : Created APER encoded buffer for F1ResetAck\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nF1AP : Sending F1 Reset Acknowledgement failed");
+ DU_LOG("\nERROR --> F1AP : Sending F1 Reset Acknowledgement failed");
break;
}
uint8_t ret = ROK;
Reset_t *f1ResetMsg = NULLP;
- DU_LOG("\nProcessing F1 reset request");
+ DU_LOG("\nINFO --> Processing F1 reset request");
f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
case ProtocolIE_ID_id_ResetType:
{
- DU_LOG("\nReceived F1 Reset request");
break;
}
}
}
ret = BuildAndSendF1ResetAck();
- DU_LOG("\nUE release is not supported for now");
+ DU_LOG("\nINFO --> UE release is not supported for now");
freeAperDecodeF1ResetMsg(f1ResetMsg);
do{
- DU_LOG("\nF1AP : Building RRC delivery Message Transfer Message\n");
+ DU_LOG("\nINFO --> F1AP : Building RRC delivery Message Transfer Message\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
{
- DU_LOG(" F1AP : Memory allocation for RRC Delivery failed");
+ DU_LOG(" ERROR --> F1AP : Memory allocation for RRC Delivery failed");
break;
}
for(idx =0 ;idx <elementCnt; idx++)
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nF1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
+ DU_LOG("\nERROR --> F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for RRC Delivery Msg \n");
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
for(idx=0; idx< encBufSize; idx++)
{
printf("%x",encBuf[idx]);
/* Sending msg */
if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
{
- DU_LOG("\nF1AP : Sending RRC delivery msg request failed");
+ DU_LOG("\nERROR --> F1AP : Sending RRC delivery msg request failed");
break;
}
ret = ROK;
}
default:
{
- DU_LOG("\nDU_APP : Invalid IE received in F1SetupRsp:%ld",
+ DU_LOG("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
}
}
memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
- DU_LOG("\nF1AP : F1 Setup Response received");
+ DU_LOG("\nINFO --> F1AP : F1 Setup Response received");
f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
break;
}
default:
- DU_LOG("\nDU_APP : Invalid IE received in F1SetupRsp:%ld",
+ DU_LOG("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
f1SetRspMsg->protocolIEs.list.array[idx]->id);
}
duProcF1SetupRsp();
* ****************************************************************/
uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
{
- uint8_t ieIdx, transId;
+ uint8_t ieIdx;
GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
-
+
+ DU_LOG("\nINFO --> F1AP : GNB-DU config update acknowledgment");
gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
{
case ProtocolIE_ID_id_TransactionID:
- transId = gnbDuAck->protocolIEs.list.array[ieIdx]->\
- value.choice.TransactionID;
- DU_LOG("\nF1AP : GNB-DU config update acknowledgment received for transId %d", transId);
break;
case ProtocolIE_ID_id_Cells_to_be_Activated_List:
break;
default :
- DU_LOG("\nF1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
+ DU_LOG("\nERROR --> F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
gnbDuAck->protocolIEs.list.array[ieIdx]->id);
break;
}
F1DlRrcMsg dlMsg;
memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
- DU_LOG("\nDU_APP : DL RRC message transfer Recevied");
+ DU_LOG("\nINFO --> DU_APP : DL RRC message transfer Recevied");
f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
ret = ROK;
}
else
{
- DU_LOG("\nDU_APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
+ DU_LOG("\nERROR --> DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
return RFAILED;
}
}
else
{
- DU_LOG("\nDU_APP : RRC Container Size is invalid:%ld",\
+ DU_LOG("\nERROR --> DU_APP : RRC Container Size is invalid:%ld",\
f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
return RFAILED;
}
break;
}
default:
- DU_LOG("\nDU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
+ DU_LOG("\nERROR --> DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
f1DlRrcMsg->protocolIEs.list.array[idx]->id);
}
}
F1AP_PDU_t *f1apMsg =NULLP;
asn_dec_rval_t rval; /* Decoder return value */
F1AP_PDU_t f1apasnmsg ;
- DU_LOG("\nF1AP : Received F1AP message buffer");
+ DU_LOG("\nINFO --> F1AP : Received F1AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
if(recvBuf == NULLP)
{
- DU_LOG("\nF1AP : Memory allocation failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
+ DU_LOG("\nERROR --> F1AP : Failed while copying %d", copyCnt);
return;
}
- printf("\nF1AP : Received flat buffer to be decoded : ");
+ printf("\nDEBUG --> F1AP : Received flat buffer to be decoded : ");
for(i=0; i< recvBufLen; i++)
{
printf("%x",recvBuf[i]);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nF1AP : ASN decode failed");
+ DU_LOG("\nERROR --> F1AP : ASN decode failed");
return;
}
printf("\n");
{
case SuccessfulOutcome__value_PR_ResetAcknowledge:
{
- DU_LOG("\nF1AP : F1ResetAcknowledge is received successfully ");
+ DU_LOG("\nINFO --> F1AP : F1ResetAcknowledge is received successfully ");
break;
}
case SuccessfulOutcome__value_PR_F1SetupResponse:
default:
{
- DU_LOG("\nF1AP : Invalid type of successful outcome [%d]", f1apMsg->choice.successfulOutcome->value.present);
+ DU_LOG("\nERROR --> F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
+ f1apMsg->choice.successfulOutcome->value.present);
return;
}
}/* End of switch(successfulOutcome) */
{
case InitiatingMessage__value_PR_Reset:
{
- DU_LOG("\nF1AP : F1 reset request received");
procF1ResetReq(f1apMsg);
break;
}
}
default:
{
- DU_LOG("\nF1AP : Invalid type of initiating message[%d]",
+ DU_LOG("\nERROR --> F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
f1apMsg->choice.initiatingMessage->value.present);
return;
}
default:
{
- DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
+ DU_LOG("\nERROR --> F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
return;
}
free(f1apMsg);
}
default:
{
- DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTDUAPP");
+ DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTDUAPP");
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nDU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
+ DU_LOG("\nERROR --> DU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
default:
{
- DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTMAC");
+ DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTMAC");
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTSCTP");
+ DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTSCTP");
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nDU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
+ DU_LOG("\nERROR --> DU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
ret = RFAILED;
}
}
}
default:
{
- DU_LOG("\nDU_APP : DU APP can not process message from Entity %d", pst->srcEnt);
+ DU_LOG("\nERROR --> DU_APP : DU APP can not process message from Entity %d", pst->srcEnt);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
return RFAILED;
}
- DU_LOG("\nDU_APP : DU APP created and registered \
+ DU_LOG("\nINFO --> DU_APP : DU APP created and registered \
to %d sys task", sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nDU_APP : EGTP created and registered \
+ DU_LOG("\nINFO --> DU_APP : EGTP created and registered \
to %d sys task", sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nDU_APP : SCTP TAPA task created and registered to %d sys task",
+ DU_LOG("\nINFO --> DU_APP : SCTP TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nDU_APP : RLC DL and MAC TAPA task created and registered to \
+ DU_LOG("\nINFO --> DU_APP : RLC DL and MAC TAPA task created and registered to \
%d sys task", sysTskId);
return ROK;
}
{
return RFAILED;
}
- DU_LOG("\nDU_APP : RLC UL TAPA task created and registered to \
+ DU_LOG("\nINFO --> DU_APP : RLC UL TAPA task created and registered to \
%d sys task", sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nDU_APP : LWR MAC TAPA task created and registered to %d sys task",
+ DU_LOG("\nINFO --> DU_APP : LWR MAC TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
/* system task for DU APP */
if(ODU_CREATE_TASK(PRIOR0, &du_app_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for DU APP failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for DU APP failed");
return RFAILED;
}
ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 15, 0);
/* system task for EGTP */
if(ODU_CREATE_TASK(PRIOR0, &egtp_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for EGTP failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for EGTP failed");
return RFAILED;
}
ODU_SET_THREAD_AFFINITY(&egtp_stsk, SS_AFFINITY_MODE_EXCL, 16, 0);
/* system task for RLC_DL and MAC */
if(ODU_CREATE_TASK(PRIOR0, &rlc_mac_cl_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for RLC DL/MAC failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for RLC DL/MAC failed");
return RFAILED;
}
pthread_attr_init(&attr);
/* system task for RLC UL */
if(ODU_CREATE_TASK(PRIOR1, &rlc_ul_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for RLC UL failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for RLC UL failed");
return RFAILED;
}
ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 18, 0);
/* system task for SCTP receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &sctp_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for SCTP failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for SCTP failed");
return RFAILED;
}
ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 19, 0);
/* system task for lower-mac receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &lwr_mac_stsk) != ROK)
{
- DU_LOG("\nDU_APP : System Task creation for Lower MAC failed");
+ DU_LOG("\nERROR --> DU_APP : System Task creation for Lower MAC failed");
return RFAILED;
}
ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 20, 0);
/* Create TAPA tasks */
if(duAppInit(du_app_stsk) != ROK)
{
- DU_LOG("\nDU_APP : DU APP TAPA Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : DU APP TAPA Task initialization failed");
return RFAILED;
}
if(egtpInit(egtp_stsk) != ROK)
{
- DU_LOG("\nDU_APP : EGTP TAPA Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : EGTP TAPA Task initialization failed");
return RFAILED;
}
if(sctpInit(sctp_stsk) != ROK)
{
- DU_LOG("\nDU_APP : SCTP TAPA Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : SCTP TAPA Task initialization failed");
return RFAILED;
}
if(rlcDlInit(rlc_mac_cl_stsk) != ROK)
{
- DU_LOG("\nDU_APP : RLC DL Tapa Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : RLC DL Tapa Task initialization failed");
return RFAILED;
}
if(rlcUlInit(rlc_ul_stsk) != ROK)
{
- DU_LOG("\nDU_APP : RLC UL Tapa Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : RLC UL Tapa Task initialization failed");
return RFAILED;
}
if(lwrMacInit(lwr_mac_stsk) != ROK)
{
- DU_LOG("\nDU_APP : Lower MAC Tapa Task initialization failed");
+ DU_LOG("\nERROR --> DU_APP : Lower MAC Tapa Task initialization failed");
return RFAILED;
}
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst);
+ DU_LOG("\nDEBUG --> DU_APP : RLC Gen Cfg Req sent for inst %d", inst);
/* Send the request to RLC */
packRlcConfigReq(&pst, &rlcMngmt);
lSap->sapId = lsapInst; /* SapId will be stored as suId in MAC */
lSap->selector = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC;
rlcMngmt.hdr.elmId.elmnt = STRGUSAP;
- DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("\nDEBUG --> DU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
}
else
lSap->sapId = 0;
lSap->selector = ODU_SELECTOR_LC;
rlcMngmt.hdr.elmId.elmnt = STUDXSAP;
- DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("\nDEBUG --> DU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
}
packRlcConfigReq(&pst, &rlcMngmt);
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("\nDEBUG --> DU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
DU_ALLOC(cell, sizeof(DuCellCb))
if(cell == NULLP)
{
- DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete");
+ DU_LOG("\nERROR --> DU_APP : Memory Allocation failed in duProcCfgComplete");
ret = RFAILED;
}
else
{
if (pst->srcInst == RLC_DL_INST)
{
- DU_LOG("\nDU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL");
+ DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL");
macCfgInst++;
if(macCfgInst < DEFAULT_CELLS)
{
}
else
{
- DU_LOG("\nDU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
+ DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
macCfgInst++;
if(macCfgInst < DEFAULT_CELLS)
{
{
uint8_t ret;
- DU_LOG("\nDU_APP : RLC UL Cfg Status %d", cfm->cfm.status);
+ DU_LOG("\nDEBUG --> DU_APP : RLC UL Cfg Status %d", cfm->cfm.status);
if (cfm->cfm.status == LCM_PRIM_OK)
{
switch(cfm->hdr.elmId.elmnt)
default:
break;
}
- DU_LOG("\nDU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> DU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
if(rlcUlCfg == DU_RLC_UL_CONFIGURED)
{
rlcUlCfg = 0;
}
else
{
- DU_LOG("\nDU_APP : Config confirm NOK from RLC UL");
+ DU_LOG("\nERROR --> DU_APP : Config confirm NOK from RLC UL");
ret = RFAILED;
}
return ret;
***************************************************************************/
uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm)
{
- DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
+ DU_LOG("\nDEBUG --> DU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
if (cfm->cfm.status == LCM_PRIM_OK)
{
switch(cfm->hdr.elmId.elmnt)
break;
}
- DU_LOG("\nDU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> DU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
if(rlcDlCfg == DU_RLC_DL_CONFIGURED)
{
rlcDlCfg = 0;
}
else
{
- DU_LOG("\nDU_APP : Config confirm NOK from RLC DL");
+ DU_LOG("\nERROR --> DU_APP : Config confirm NOK from RLC DL");
}
return ROK;
}
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDU_APP : MAC Gen Cfg Req sent");
+ DU_LOG("\nDEBUG --> DU_APP : MAC Gen Cfg Req sent");
/* Send the request to MAC */
cmPkLrgCfgReq(&pst, &rgMngmt);
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDU_APP : MAC Rgu USap Cfg Req sent");
+ DU_LOG("\nDEBUG --> DU_APP : MAC Rgu USap Cfg Req sent");
/* Send the request to MAC */
cmPkLrgCfgReq(&pst, &rgMngmt);
default:
break;
}
- DU_LOG("\nDU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> DU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
if(macCfg == MAC_CONFIGURED && numRlcMacSaps == MAX_MAC_SAP)
{
macCfg = 0;
- DU_LOG("\nDU_APP : Completed sending Configs");
+ DU_LOG("\nDEBUG --> DU_APP : Completed sending Configs");
macCfgInst = 0;
duBindUnbindRlcToMacSap(RLC_DL_INST, ABND);
}
}
else
{
- DU_LOG("\nDU_APP : Config confirm NOK from MAC");
+ DU_LOG("\nERROR --> DU_APP : Config confirm NOK from MAC");
ret = RFAILED;
}
return ret;
if (action == ABND)
{
- DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst);
+ DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst);
}
else
{
- DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
+ DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
}
cntrl = &(rlcMngmt.t.cntrl);
}
else
{
- DU_LOG("\nDU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
+ DU_LOG("\nERROR --> DU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
return RFAILED;
}
return ROK;
Pst pst;
EgtpConfig egtpCfg;
- DU_LOG("\nDU_APP : Sending EGTP config request");
+ DU_LOG("\nDEBUG --> DU_APP : Sending EGTP config request");
memset(&egtpCfg, 0, sizeof(EgtpConfig));
memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig));
if(cfm.status == LCM_PRIM_OK)
{
- DU_LOG("\nDU_APP : EGTP configuraton complete");
+ DU_LOG("\nDEBUG --> DU_APP : EGTP configuraton complete");
#ifdef EGTP_TEST
duSendEgtpSrvOpenReq();
#endif
}
else
{
- DU_LOG("\nDU_APP : EGTP configuraton failed");
+ DU_LOG("\nERROR --> DU_APP : EGTP configuraton failed");
ret = RFAILED;
}
{
Pst pst;
- DU_LOG("\nDU_APP : Sending EGTP server open request");
+ DU_LOG("\nDEBUG --> DU_APP : Sending EGTP server open request");
duFillEgtpPst(&pst, EVTSRVOPENREQ);
packEgtpSrvOpenReq(&pst);
if(cfm.status == LCM_PRIM_OK)
{
- DU_LOG("\nDU_APP : EGTP server opened successfully");
+ DU_LOG("\nDEBUG --> DU_APP : EGTP server opened successfully");
#ifdef EGTP_TEST
duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID);
#endif
}
else
{
- DU_LOG("\nDU_APP : EGTP server opening failed");
+ DU_LOG("\nERROR --> DU_APP : EGTP server opening failed");
ret = RFAILED;
}
tnlEvt.lclTeid = lclTeid;
tnlEvt.remTeid = remTeid;
- DU_LOG("\nDU_APP : Sending EGTP tunnel management request");
+ DU_LOG("\nDEBUG --> DU_APP : Sending EGTP tunnel management request");
duFillEgtpPst(&pst, EVTTNLMGMTREQ);
egtpTnlMgmtReq(&pst, tnlEvt);
return ROK;
if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
{
- DU_LOG("\nDU_APP : Tunnel management confirm OK");
+ DU_LOG("\nDEBUG --> DU_APP : Tunnel management confirm OK");
#ifdef EGTP_TEST
duSendEgtpTestData();
#endif
}
else
{
- DU_LOG("\nDU_APP : Tunnel management failed");
+ DU_LOG("\nERROR --> DU_APP : Tunnel management failed");
ret = RFAILED;
}
{
if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
{
- DU_LOG("\nDU_APP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("\nERROR --> DU_APP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nDU_APP : Failed to allocate memory");
+ DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
pst.region = duCb.init.region;
pst.event = (Event) EVTMACSCHGENCFGREQ;
- DU_LOG("\nDU_APP : MAC Sch Cfg sent");
+ DU_LOG("\nDEBUG --> DU_APP : MAC Sch Cfg sent");
/* Send the request to MAC */
cmPkLrgSchCfgReq(&pst, &rgMngmt);
{
uint8_t ret = ROK;
- DU_LOG("\nDU_APP : Configuring all Layer is complete");
+ DU_LOG("\nINFO --> DU_APP : Configuring all Layer is complete");
if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
{
- DU_LOG("\nDU_APP : Failed configuring Sctp Params");
+ DU_LOG("\nERROR --> DU_APP : Failed configuring Sctp Params");
ret = RFAILED;
}
if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
{
- DU_LOG("\nDU_APP : Failed to send AssocReq F1");
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq F1");
ret = RFAILED;
}
if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
{
- DU_LOG("\nDU_APP : Failed to send AssocReq E2");
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq E2");
ret = RFAILED;
}
{
case STSCHINST:
{
- DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP");
+ DU_LOG("\nDEBUG --> DU_APP : Received SCH CFG CFM at DU APP");
break;
}
default:
/* TODO : Action to be taken if cell configuration fails.
* Should CU be informed? */
- DU_LOG("\nMac cell cfg failed");
+ DU_LOG("\nERROR --> DU_APP : Mac cell cfg failed");
ret = RFAILED;
}
return ret;
Pst pst;
OduCellId *cellId = NULL;
- DU_LOG("\nDU APP : Building and Sending cell start request to MAC");
+ 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_LOG("\nDU APP : Memory alloc failed while building cell start request");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request");
return RFAILED;
}
Pst pst;
OduCellId *cellId = NULL;
- DU_LOG("\nDU APP : Building and Sending cell stop request to MAC");
+ DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC");
/* Send Cell Stop Request to MAC */
DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId));
if(!cellId)
{
- DU_LOG("\nDU APP : Memory alloc failed while building cell stop request");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request");
return RFAILED;
}
cellId->cellId = duCb.actvCellLst[0]->cellId;
if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
{
- DU_LOG("\nDU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
+ DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
}
if(duGetCellCb(cellId->cellId, &cellCb) != ROK)
if((cellCb->cellStatus == ACTIVATED))
{
- DU_LOG("\nDU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
+ DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
cellCb->cellStatus = DELETION_IN_PROGRESS;
#ifdef O1_ENABLE
- DU_LOG("\nDU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
+ DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
raiseCellAlrm(CELL_DOWN_ALARM_ID, cellId->cellId);
#endif
}
uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
{
- DU_LOG("\nDU APP : UL CCCH Indication received");
+ DU_LOG("\nINFO --> DU APP : UL CCCH Indication received");
return (duProcUlCcchInd(ulCcchIndInfo));
}
***************************************************************************/
uint8_t sctpActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
- DU_LOG("\n\nSCTP : Initializing");
+ DU_LOG("\n\nDEBUG --> SCTP : Initializing");
ODU_SET_PROC_ID(DU_PROC);
connUp = FALSE;
f1Params.assocId = -1;
uint8_t ret = ROK;
if(cfm->status != LCM_PRIM_OK)
{
- DU_LOG("\nDU_APP : Failed to process the request successfully");
+ DU_LOG("\nERROR --> DU_APP : Failed to process the request successfully");
ret = RFAILED;
}
return (ret);
if((ret = cmInetSocket(socket_type, ¶mPtr->sockFd, IPPROTO_SCTP)) != ROK)
{
- DU_LOG("\nSCTP : Failed while opening a socket in ODU");
+ DU_LOG("\nERROR --> SCTP : Failed while opening a socket in ODU");
}
else if((ret = cmInetSctpBindx(¶mPtr->sockFd, &localAddrLst, paramPtr->srcPort)) != ROK)
{
- DU_LOG("\nSCTP: Failed during Binding in ODU");
+ DU_LOG("\nERROR --> SCTP: Failed during Binding in ODU");
}
else if((ret = sctpSetSockOpts(¶mPtr->sockFd)) != ROK)
{
- DU_LOG("\nSCTP : Failed to set Socket Opt in ODU");
+ DU_LOG("\nERROR --> SCTP : Failed to set Socket Opt in ODU");
}
else
{
if(ret != ROK)
{
- DU_LOG("\nSCTP : Failed while establishing Req at DU");
+ DU_LOG("\nERROR --> SCTP : Failed while establishing Req at DU");
ret = RFAILED;
}
else
DU_ALLOC(paramPtr, sizeof(DuSctpDestCb));
if(paramPtr == NULLP)
{
- printf("\nDU_APP : Failed to allocate memory");
+ DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
switch(itfType)
}
default:
{
- DU_LOG("\nSCTP : Invalid Interface Type");
+ DU_LOG("\nERROR --> SCTP : Invalid Interface Type %d", itfType);
break;
}
}
if(ret != ROK)
{
- DU_LOG("\nSCTP : ASSOC Req Failed.");
+ DU_LOG("\nERROR --> SCTP : ASSOC Req Failed.");
cfm.status = LCM_PRIM_NOK;
cfm.reason = LCM_REASON_NOT_APPL;
}
Buffer *mBuf;
if(ODU_GET_MSG_BUF(DFLT_REGION, DU_POOL, &mBuf) != ROK)
{
- printf("\nDU_APP : Failed to allocate memory");
+ DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
memset(pst, 0, sizeof(Pst));
void sendToDuApp(Buffer *mBuf, Event event)
{
Pst pst;
- DU_LOG("\nSCTP : Forwarding received message to duApp");
+ DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp");
ODU_PRINT_MSG(mBuf, 0, 0);
if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nSCTP : ODU_POST_TASK failed in duReadCfg");
+ DU_LOG("\nERROR --> SCTP : ODU_POST_TASK failed in duReadCfg");
}
}
switch(ntfy->header.nType)
{
case CM_INET_SCTP_ASSOC_CHANGE :
- DU_LOG("\nSCTP : Assoc change notification received");
+ DU_LOG("\nDEBUG --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
- DU_LOG("Event : COMMUNICATION UP");
+ DU_LOG("INFO --> Event : COMMUNICATION UP");
*itfState = DU_SCTP_UP;
break;
case CM_INET_SCTP_COMM_LOST:
- DU_LOG("Event : COMMUNICATION LOST");
+ DU_LOG("INFO --> Event : COMMUNICATION LOST");
*itfState = DU_SCTP_DOWN;
break;
case CM_INET_SCTP_RESTART:
- DU_LOG("Event : SCTP RESTART");
+ DU_LOG("INFO --> Event : SCTP RESTART");
*itfState = DU_SCTP_DOWN;
break;
case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */
- DU_LOG("Event : SHUTDOWN COMPLETE");
+ DU_LOG("INFO --> Event : SHUTDOWN COMPLETE");
*itfState = DU_SCTP_DOWN;
break;
case CM_INET_SCTP_CANT_STR_ASSOC:
- DU_LOG("Event : CANT START ASSOC");
+ DU_LOG("INFO --> Event : CANT START ASSOC");
*itfState = DU_SCTP_DOWN;
break;
default:
- DU_LOG("\nInvalid event");
+ DU_LOG("\nERROR --> Invalid event %d", ntfy->u.assocChange.state);
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nSCTP : Peer Address Change notificarion received");
+ DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nSCTP : Remote Error notification received");
+ DU_LOG("\nINFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nSCTP : Send Failed notification received\n");
+ DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
- DU_LOG("\nSCTP : Shutdown Event notification received\n");
+ DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n");
*itfState = DU_SCTP_DOWN;
exit(0);
break;
case CM_INET_SCTP_ADAPTATION_INDICATION :
- DU_LOG("\nSCTP : Adaptation Indication received\n");
+ DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nSCTP : Partial Delivery Event received\n");
+ DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nSCTP : Invalid sctp notification type\n");
+ DU_LOG("\nERROR --> SCTP : Invalid sctp notification type %d", ntfy->header.nType);
break;
}
/* Pack notification and send to APP */
- DU_LOG("\nSCTP : Forwarding received message to duApp");
+ DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp");
memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
if(cmPkSctpNtfy(&pst, ntfy) != ROK)
{
- DU_LOG("\nSCTP : Failed to pack SCTP notification");
+ DU_LOG("\nERROR --> SCTP : Failed to pack SCTP notification");
return RFAILED;
}
return ROK;
if(ret != ROK)
{
- DU_LOG("\n SCTP: Failed to receive sctp msg for sockFd[%d]\n", sockFd->fd);
+ DU_LOG("\nERROR --> SCTP: Failed to receive sctp msg for sockFd[%d]\n", sockFd->fd);
recvMsgSet = RFAILED;
}
else
if(pollParams->port == f1Params.destPort)
{
f1Params.assocId = pollParams->ntfy.u.assocChange.assocId;
- DU_LOG("\nSCTP : AssocId assigned to F1Params from PollParams [%d]\n", f1Params.assocId);
+ DU_LOG("\nDEBUG --> SCTP : AssocId assigned to F1Params from PollParams [%d]\n", f1Params.assocId);
ret = sctpNtfyHdlr(&pollParams->ntfy, &f1Params.itfState);
}
else if(pollParams->port == ricParams.destPort)
{
ricParams.assocId = pollParams->ntfy.u.assocChange.assocId;
- DU_LOG("\nSCTP : AssocId assigned to ricParams from PollParams [%d]\n", ricParams.assocId);
+ DU_LOG("\nDEBUG --> SCTP : AssocId assigned to ricParams from PollParams [%d]\n", ricParams.assocId);
ret = sctpNtfyHdlr(&pollParams->ntfy, &ricParams.itfState);
}
else
{
- DU_LOG("\nSCTP : Failed to fill AssocId\n");
+ DU_LOG("\nERROR --> SCTP : Failed to fill AssocId\n");
return RFAILED;
}
if(ret != ROK)
{
- DU_LOG("\nSCTP : Failed to process sctp notify msg\n");
+ DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
}
}
else if(f1Params.itfState & (pollParams->port == f1Params.destPort))
CM_INET_FD_ZERO(&f1PollParams.readFd);
CM_INET_FD_ZERO(&e2PollParams.readFd);
- DU_LOG("\nSCTP : Polling started at DU\n");
+ DU_LOG("\nINFO --> SCTP : Polling started at DU\n");
while(true)
{
if(f1Params.itfState)
{
if((ret = processPolling(&f1PollParams, &f1Params.sockFd, timeout_Ptr, &memInfo, f1Params.recvMsgSet)) != ROK)
{
- DU_LOG("\nSCTP : Failed to RecvMsg for F1\n");
+ DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1\n");
}
}
if(ricParams.itfState)
{
if((ret = processPolling(&e2PollParams, &ricParams.sockFd, timeout_Ptr, &memInfo, ricParams.recvMsgSet)) != ROK)
{
- DU_LOG("\nSCTP : Failed to RecvMsg for E2\n");
+ DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for E2\n");
}
}
};
if(itfType == F1_INTERFACE)
{
- DU_LOG("\nSCTP : sending the message to DuApp");
+ DU_LOG("\nDEBUG --> SCTP : sending the message to DuApp");
ret = cmInetSctpSendMsg(&f1Params.sockFd, &f1Params.destIpNetAddr, f1Params.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
if(itfType == E2_INTERFACE)
{
- DU_LOG("\nSCTP : sending the message to ric");
+ DU_LOG("\nDEBUG --> SCTP : sending the message to ric");
ret = cmInetSctpSendMsg(&ricParams.sockFd, &ricParams.destIpNetAddr, ricParams.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nSCTP : Failed sending the message");
+ DU_LOG("\nERROR --> SCTP : Failed sending the message");
return RFAILED;
}
DU_ALLOC(mib->systemFrameNumber.buf, mib->systemFrameNumber.size);
if(!(mib->systemFrameNumber.buf))
{
- DU_LOG("DU APP: MIB msg memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: MIB msg memory allocation failure");
return RFAILED;
}
DU_ALLOC(mib->spare.buf, mib->spare.size);
if(!mib->spare.buf)
{
- DU_LOG("DU APP: MIB msg memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: MIB msg memory allocation failure");
return RFAILED;
}
*(mib->spare.buf) = SPARE;
DU_ALLOC(bcchMsg, sizeof(BCCH_BCH_Message_t));
if(!bcchMsg)
{
- DU_LOG("\nMemory allocation failure in BuildMibPdu");
+ DU_LOG("\nERROR --> Memory allocation failure in BuildMibPdu");
break;
}
DU_ALLOC(bcchMsg->message.choice.mib, sizeof(MIB_t));
if(!bcchMsg->message.choice.mib)
{
- DU_LOG("\nMemory allocation failure in BuildMibPdu");
+ DU_LOG("\nERROR --> Memory allocation failure in BuildMibPdu");
break;
}
BuildMibret = BuildMib(bcchMsg->message.choice.mib);
printf("\nencbufSize:%d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nDU APP: Could not encode BCCH BCH Message Type structure(at %s)\n",
+ DU_LOG("\nERROR --> DU APP: Could not encode BCCH BCH Message Type structure(at %s)\n",
encRetVal.failed_type?\
encRetVal.failed_type->name
:"unknown");
DU_ALLOC(mibMsg, sizeof(MIB_t));
if(!mibMsg)
{
- DU_LOG("DU APP: MIB msg memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: MIB msg memory allocation failure");
return RFAILED;
}
BuildMibret = BuildMib(mibMsg);
printf("\nencbufSize:%d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nDU APP: Could not encode MIB structure(at %s)\n",
+ DU_LOG("\nERROR --> DU APP: Could not encode MIB structure(at %s)\n",
encRetVal.failed_type?\
encRetVal.failed_type->name
:"unknown");
DU_ALLOC(cellIdentity->buf, cellIdentity->size);
if(!cellIdentity->buf)
{
- DU_LOG("DU APP: CellIdentity memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: CellIdentity memory allocation failure");
return RFAILED;
}
*cellIdentity->buf = duCfgParam.sib1Params.cellIdentity;
DU_ALLOC(ranac, sizeof(RAN_AreaCode_t));
if(!ranac)
{
- DU_LOG("DU APP: RANAC memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: RANAC memory allocation failure");
return RFAILED;
}
*ranac = duCfgParam.sib1Params.ranac;
DU_ALLOC(tac, sizeof(TrackingAreaCode_t));
if(!tac)
{
- DU_LOG("DU APP: TAC memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: TAC memory allocation failure");
return RFAILED;
}
DU_ALLOC(tac->buf, tac->size);
if(!tac->buf)
{
- DU_LOG("DU APP: TAC memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: TAC memory allocation failure");
return RFAILED;
}
*(tac->buf) = duCfgParam.sib1Params.tac;
cellAccessInfo->plmn_IdentityList.list.size);
if(!cellAccessInfo->plmn_IdentityList.list.array)
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
elementCnt = cellAccessInfo->plmn_IdentityList.list.count;
sizeof(PLMN_IdentityInfo_t));
if(!cellAccessInfo->plmn_IdentityList.list.array[idx])
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(plmnIdInfo->list.array, plmnIdInfo->list.size);
if(!plmnIdInfo->list.array)
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
sizeof(PLMN_IdentitY_t));
if(!(plmnIdInfo->list.array[idx1]))
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
}
sizeof(MCC_t));
if(!plmnIdInfo->list.array[idx1]->mcc)
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
plmnIdInfo->list.array[idx1]->mcc->list.size)
if(!(plmnIdInfo->list.array[idx1]->mcc->list.array))
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
for(idx2=0; idx2<elementCnt; idx2++)
sizeof(MCC_MNC_Digit_t));
if(!plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
*(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])=\
plmnIdInfo->list.array[idx1]->mnc.list.size);
if(!plmnIdInfo->list.array[idx1]->mnc.list.array)
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
for(idx2=0; idx2<elementCnt; idx2++)
sizeof(MCC_MNC_Digit_t));
if(!plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])
{
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
*(plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])=\
DU_ALLOC(sibMapInfo->list.array, sibMapInfo->list.size);
if(!sibMapInfo->list.array)
{
- DU_LOG("DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
return RFAILED;
}
DU_ALLOC(sibMapInfo->list.array[itr], sizeof(SIB_TypeInfo_t));
if(!sibMapInfo->list.array[itr])
{
- DU_LOG("DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(sibTypeInfo->valueTag, sizeof(long));
if(!sibTypeInfo->valueTag)
{
- DU_LOG("DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
return RFAILED;
}
DU_ALLOC(si_SchedulingInfoList->list.array, si_SchedulingInfoList->list.size);
if(!si_SchedulingInfoList->list.array)
{
- DU_LOG("DU APP: BuildSiSchedInfoList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildSiSchedInfoList memory allocation failure");
return RFAILED;
}
DU_ALLOC(si_SchedulingInfoList->list.array[itr], sizeof(struct SchedulingInfo));
if(!si_SchedulingInfoList->list.array[itr])
{
- DU_LOG("DU APP: BuildSiSchedInfoList memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: BuildSiSchedInfoList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
DU_ALLOC(scsCarrierList->list.array[idx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[idx])
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
}
DU_ALLOC(searchSpclist->list.array, searchSpclist->list.size)
if(!searchSpclist->list.array)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
DU_ALLOC(searchSpclist->list.array[idx], sizeof(SearchSpace_t));
if(!searchSpclist->list.array[idx])
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(searchSpace->controlResourceSetId, sizeof(ControlResourceSetId_t));
if(!searchSpace->controlResourceSetId)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
*searchSpace->controlResourceSetId = duPdcchCfg.ctrlRsrcSetId;
sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
if(!searchSpace->monitoringSlotPeriodicityAndOffset)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSlotPeriodicityAndOffset->present = \
}
default:
{
- DU_LOG("\nDU APP : Invalid value:Montoring slot periodicity and offset");
+ DU_LOG("\nERROR --> DU APP : Invalid value:Montoring slot periodicity and offset");
return RFAILED;
}
}
sizeof(BIT_STRING_t));
if(!searchSpace->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSymbolsWithinSlot->size = 2*sizeof(uint8_t);
searchSpace->monitoringSymbolsWithinSlot->size );
if(!searchSpace->monitoringSymbolsWithinSlot->buf)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSymbolsWithinSlot->buf[0] = duPdcchCfg.monitorSymbolsInSlot[0];
sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpace->nrofCandidates)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->nrofCandidates->aggregationLevel1 = duPdcchCfg.numCandAggLvl1;
sizeof( struct SearchSpace__searchSpaceType));
if(!searchSpace->searchSpaceType)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
DU_ALLOC(searchSpace->searchSpaceType->choice.common, sizeof(struct SearchSpace__searchSpaceType__common));
if(!searchSpace->searchSpaceType->choice.common)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
if(!searchSpace->searchSpaceType->choice.common->dci_Format0_0_AndFormat1_0)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
break;
}
default:
{
- DU_LOG("\nDU_APP: Invalid Search Space type");
+ DU_LOG("\nERROR --> DU_APP: Invalid Search Space type");
return RFAILED;
}
}
DU_ALLOC(pdcchCfg->choice.setup, sizeof(PDCCH_ConfigCommon_t));
if(!pdcchCfg->choice.setup)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
pdcchSetup = pdcchCfg->choice.setup;
DU_ALLOC(pdcchSetup->controlResourceSetZero, sizeof(ControlResourceSetZero_t));
if(!pdcchSetup->controlResourceSetZero)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->controlResourceSetZero = duPdcchCfg.ctrlRsrcSetZero;
DU_ALLOC(pdcchSetup->searchSpaceZero, sizeof(SearchSpaceZero_t));
if(!pdcchSetup->searchSpaceZero)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->searchSpaceZero = duPdcchCfg.searchSpcZero;
sizeof(struct PDCCH_ConfigCommon__commonSearchSpaceList));
if(!pdcchSetup->commonSearchSpaceList)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
elementCnt = ODU_VALUE_ONE;
DU_ALLOC(pdcchSetup->searchSpaceSIB1, sizeof(SearchSpaceId_t));
if(!pdcchSetup->searchSpaceSIB1)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->searchSpaceSIB1 = duPdcchCfg.searchSpcSib1;
DU_ALLOC(pdcchSetup->pagingSearchSpace, sizeof(SearchSpaceId_t));
if(!pdcchSetup->pagingSearchSpace)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->pagingSearchSpace = duPdcchCfg.pagingSearchSpc;
DU_ALLOC(pdcchSetup->ra_SearchSpace, sizeof(SearchSpaceId_t));
if(!pdcchSetup->ra_SearchSpace)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->ra_SearchSpace = duPdcchCfg.raSearchSpc;
}
default :
{
- DU_LOG("\nDU APP : Invalid PDCCH Config type");
+ DU_LOG("\nERROR --> DU APP : Invalid PDCCH Config type");
return RFAILED;
}
}
DU_ALLOC(pdschCfg->choice.setup, sizeof(PDSCH_ConfigCommon_t));
if(!pdschCfg->choice.setup)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
pdschSetup = pdschCfg->choice.setup;
sizeof(PDSCH_TimeDomainResourceAllocationList_t));
if(!pdschSetup->pdsch_TimeDomainAllocationList)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
elementCnt = ODU_VALUE_ONE;
pdschSetup->pdsch_TimeDomainAllocationList->list.size);
if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
sizeof(PDSCH_TimeDomainResourceAllocation_t));
if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx])
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
if(!timeDomRsrcAllocInfo->k0)
{
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*timeDomRsrcAllocInfo->k0 = duPdschCfg.k0;
}
default:
{
- DU_LOG("\nDU APP: Invalid PDSCH Configuration type");
+ DU_LOG("\nERROR --> DU APP: Invalid PDSCH Configuration type");
return RFAILED;
}
}
sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
if(!bwp->pdcch_ConfigCommon)
{
- DU_LOG("\nDU APP : DL BWP memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : DL BWP memory allocation failed");
return RFAILED;
}
ret=BuildPdcchCfgCommon(bwp->pdcch_ConfigCommon);
sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
if(!bwp->pdsch_ConfigCommon)
{
- DU_LOG("\nDU APP : DL BWP memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : DL BWP memory allocation failed");
return RFAILED;
}
ret=BuildPdschCfgCommon(bwp->pdsch_ConfigCommon);
}
default:
{
- DU_LOG("\nDU APP : Invalid nAndPagingFrameOffset configuration");
+ DU_LOG("\nERROR --> DU APP : Invalid nAndPagingFrameOffset configuration");
return RFAILED;
}
}
frequencyInfoDL->frequencyBandList.list.size);
if(!frequencyInfoDL->frequencyBandList.list.array)
{
- DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
return RFAILED;
}
sizeof(NR_MultiBandInfo_t));
if(!frequencyInfoDL->frequencyBandList.list.array[idx])
{
- DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
return RFAILED;
}
}
DU_ALLOC(multiBandInfo->freqBandIndicatorNR, sizeof(FreqBandIndicatorNR_t));
if(!multiBandInfo->freqBandIndicatorNR)
{
- DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
return RFAILED;
}
*multiBandInfo->freqBandIndicatorNR = dlCfg.freqBandInd;
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
DU_ALLOC(scsCarrierList->list.array[idx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[idx])
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
}
DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
if(!frequencyInfoUL->p_Max)
{
- DU_LOG("\nDU APP : UL Frequency Infoo memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : UL Frequency Infoo memory allocation failure");
return RFAILED;
}
*frequencyInfoUL->p_Max = ulCfg.pMax;
DU_ALLOC(rachCfg->choice.setup, sizeof(RACH_ConfigCommon_t));
if(!rachCfg->choice.setup)
{
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
setup = rachCfg->choice.setup;
DU_ALLOC(setup->totalNumberOfRA_Preambles, sizeof(long));
if(!setup->totalNumberOfRA_Preambles)
{
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
*setup->totalNumberOfRA_Preambles = duRachCfg.numRaPreamble;
sizeof(struct RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB));
if(!setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB)
{
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present = \
}
default:
{
- DU_LOG("\nDU APP: Invalid value for \
+ DU_LOG("\nERROR --> DU APP: Invalid value for \
ssb_PerRach_OccassionAndCB_PreamblesPerSSB");
return RFAILED;
}
DU_ALLOC(setup->rsrp_ThresholdSSB, sizeof(RSRP_Range_t));
if(!setup->rsrp_ThresholdSSB)
{
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
*setup->rsrp_ThresholdSSB = duRachCfg.rsrpThreshSsb;
}
default:
{
- DU_LOG("\nDU APP: Inavlid PRACH root sequence index type");
+ DU_LOG("\nERROR --> DU APP: Inavlid PRACH root sequence index type");
return RFAILED;
}
}
DU_ALLOC(setup->msg1_SubcarrierSpacing, sizeof(SubcarrierSpacing_t));
if(!setup->msg1_SubcarrierSpacing)
{
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
*setup->msg1_SubcarrierSpacing = duRachCfg.msg1Scs;
}
default:
{
- DU_LOG("\nDU APP : Invalid RACH Config type ");
+ DU_LOG("\nERROR --> DU APP : Invalid RACH Config type ");
return RFAILED;
}
}
DU_ALLOC(puschCfg->choice.setup, sizeof(PUSCH_ConfigCommon_t));
if(!puschCfg->choice.setup)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
setup = puschCfg->choice.setup;
sizeof(PUSCH_TimeDomainResourceAllocationList_t));
if(!setup->pusch_TimeDomainAllocationList)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
elementCnt = ODU_VALUE_ONE;
setup->pusch_TimeDomainAllocationList->list.size);
if(!setup->pusch_TimeDomainAllocationList->list.array)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
sizeof(PUSCH_TimeDomainResourceAllocation_t));
if(!setup->pusch_TimeDomainAllocationList->list.array[idx])
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
if(!timeDomRsrcAllocInfo->k2)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
*timeDomRsrcAllocInfo->k2 = duPuschCfg.k2;
DU_ALLOC(setup->msg3_DeltaPreamble, sizeof(long));
if(!setup->msg3_DeltaPreamble)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
*setup->msg3_DeltaPreamble = duPuschCfg.msg3DeltaPreamble;
DU_ALLOC(setup->p0_NominalWithGrant, sizeof(long));
if(!setup->p0_NominalWithGrant)
{
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
*setup->p0_NominalWithGrant = duPuschCfg.p0NominalWithGrant;
}
default:
{
- DU_LOG("\nDU APP : Invalid PUSCH configuration type ");
+ DU_LOG("\nERROR --> DU APP : Invalid PUSCH configuration type ");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->choice.setup, sizeof(PUCCH_ConfigCommon_t));
if(!pucchCfg->choice.setup)
{
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUCCH Config memory alloc failed");
return RFAILED;
}
setup = pucchCfg->choice.setup;
DU_ALLOC(setup->pucch_ResourceCommon, sizeof(long));
if(!setup->pucch_ResourceCommon)
{
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUCCH Config memory alloc failed");
return RFAILED;
}
*setup->pucch_ResourceCommon = duPucchCfg.rsrcComm;
DU_ALLOC(setup->p0_nominal, sizeof(long));
if(!setup->p0_nominal)
{
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ DU_LOG("\nERROR --> DU APP : PUCCH Config memory alloc failed");
return RFAILED;
}
*setup->p0_nominal = duPucchCfg.p0Nominal;
}
default:
{
- DU_LOG("\nDU APP : Invalid PUCCH Config type");
+ DU_LOG("\nERROR --> DU APP : Invalid PUCCH Config type");
return RFAILED;
}
}
sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
if(!bwp->rach_ConfigCommon)
{
- DU_LOG("\nDU APP : UL BWP memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
ret = BuildRachCfgCommon(bwp->rach_ConfigCommon);
sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
if(!bwp->pusch_ConfigCommon)
{
- DU_LOG("\nDU APP : UL BWP memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
ret = BuildPuschCfgCommon(bwp->pusch_ConfigCommon);
sizeof(struct BWP_UplinkCommon__pucch_ConfigCommon));
if(!bwp->pucch_ConfigCommon)
{
- DU_LOG("\nDU APP : UL BWP memory allocation failed");
+ DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
ret = BuildPucchCfgCommon(bwp->pucch_ConfigCommon);
DU_ALLOC(ssbPosInBurst->buf, ssbPosInBurst->size * sizeof(uint8_t));
if(!ssbPosInBurst->buf)
{
- DU_LOG("\nDU APP : Serving cell config common memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : Serving cell config common memory allocation failure");
return RFAILED;
}
ssbPosInBurst->buf[0] = duSrvCellCfg.ssbPosInBurst;
DU_ALLOC(srvCellCfg->uplinkConfigCommon, sizeof(UplinkConfigCommonSIB_t));
if(!srvCellCfg->uplinkConfigCommon)
{
- DU_LOG("\nDU APP : Serving cell config common memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : Serving cell config common memory allocation failure");
return RFAILED;
}
ret = BuildUlCfgCommSib(srvCellCfg->uplinkConfigCommon);
DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
if(!srvCellCfg->tdd_UL_DL_ConfigurationCommon)
{
- DU_LOG("\nDU APP : Serving cell config common memory allocation failure");
+ DU_LOG("\nERROR --> DU APP : Serving cell config common memory allocation failure");
return RFAILED;
}
ret = BuildTddUlDlCfgComm(srvCellCfg->tdd_UL_DL_ConfigurationCommon);
DU_ALLOC(sib1Msg, sizeof(SIB1_t));
if(!sib1Msg)
{
- DU_LOG("DU APP: SIB1 msg memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: SIB1 msg memory allocation failure");
break;
}
DU_ALLOC(sib1Msg->connEstFailureControl, sizeof(ConnEstFailureControl_t));
if(!sib1Msg->connEstFailureControl)
{
- DU_LOG("DU APP: sib1Msg->connEstFailureControl memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: sib1Msg->connEstFailureControl memory allocation failure");
break;
}
sib1Msg->connEstFailureControl->connEstFailCount =\
DU_ALLOC(sib1Msg->si_SchedulingInfo, sizeof(SI_SchedulingInfo_t));
if(!sib1Msg->si_SchedulingInfo)
{
- DU_LOG("DU APP: sib1Msg->si_SchedulingInfo memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: sib1Msg->si_SchedulingInfo memory allocation failure");
break;
}
elementCnt = ODU_VALUE_ONE;
DU_ALLOC(sib1Msg->servingCellConfigCommon, sizeof(ServingCellConfigCommonSIB_t));
if(!sib1Msg->servingCellConfigCommon)
{
- DU_LOG("DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
+ DU_LOG("\nERROR --> DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
break;
}
ret1 = BuildServCellCfgCommonSib(sib1Msg->servingCellConfigCommon);
printf("\nencbufSize: %d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nDU APP : Could not encode SIB1 structure (at %s)\n",\
+ DU_LOG("\nERROR --> DU APP : Could not encode SIB1 structure (at %s)\n",\
encRetVal.failed_type ?
encRetVal.failed_type->name :
"unknown");
/* TODO : Extract RbId/UeID/CellID/SduId from database
using tunnel id in egtp header */
- DU_LOG("\nDU_APP : Processing DL data");
+ DU_LOG("\nDEBUG --> DU_APP : Processing DL data");
#ifdef EGTP_TEST
Pst pst;
KwuDatReqInfo datReqInfo;
DlCcchIndInfo *dlCcchIndInfo = NULLP;
Pst pst;
- DU_LOG("\nDU APP : Building and Sending DL CCCH Ind to MAC");
+ DU_LOG("\nDEBUG --> DU APP : Building and Sending DL CCCH Ind to MAC");
DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
if(!dlCcchIndInfo)
{
- DU_LOG("\nDU APP : Memory alloc failed while building DL CCCH Ind");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building DL CCCH Ind");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(dlCcchIndInfo->dlCcchMsg, dlCcchIndInfo->dlCcchMsgLen);
if(!dlCcchIndInfo->dlCcchMsg)
{
- DU_LOG("\nDU APP : Memory alloc failed while building DL CCCH Ind");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building DL CCCH Ind");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, sizeof(DlCcchIndInfo));
return RFAILED;
}
ret = (*packMacDlCcchIndOpts[pst.selector])(&pst, dlCcchIndInfo);
if(ret != ROK)
{
- DU_LOG("\nDU_APP : Failure in sending DL CCCH to MAC");
+ DU_LOG("\nERROR --> DU_APP : Failure in sending DL CCCH to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo->dlCcchMsg,\
dlCcchIndInfo->dlCcchMsgLen);
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, \
if(!f1DlRrcMsg)
{
- DU_LOG("\nDU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
+ DU_LOG("\nERROR --> DU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
if(!dlRrcMsgInfo)
{
- DU_LOG("\nDU APP : Memory allocation failed for dlRrcMsgInfo in \
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for dlRrcMsgInfo in \
duBuildAndSendDlRrcMsgToRlc");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1DlRrcMsg->rrcMsgPdu, f1DlRrcMsg->rrcMsgSize);
return RFAILED;
/* Filling post structure and sending msg */
FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC);
- DU_LOG("\nDU_APP: Sending Dl RRC Msg to RLC \n");
+ DU_LOG("\nDEBUG --> DU_APP: Sending Dl RRC Msg to RLC \n");
ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo);
if(ret != ROK)
{
ret = duBuildAndSendDlCcchInd(&cellId, &crnti, RRC_SETUP, dlRrcMsg->rrcMsgSize, dlRrcMsg->rrcMsgPdu);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Falied to build DlCcch Ind at procDlRrcMsgTrans()");
+ DU_LOG("\nERROR --> DU APP : Failed to build DlCcch Ind at procDlRrcMsgTrans()");
}
else
{
ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], dlRrcMsg->gnbCuUeF1apId);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
+ DU_LOG("\nERROR --> DU APP : Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
duCb.ueCcchCtxt[ueIdx].cellId);
}
}
else
{
- DU_LOG("\nDU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
+ DU_LOG("\nERROR --> DU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
ret = RFAILED;
}
}
ulCcchIndInfo->ulCcchMsg));
if(ret != ROK)
{
- DU_LOG("\nDU_APP : BuildAndSendInitialRrcMsgTransfer failed");
+ DU_LOG("\nERROR --> DU_APP : BuildAndSendInitialRrcMsgTransfer failed");
}
DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
}
else
{
- DU_LOG("\n DUAPP: Memory is NULL of InitalUlBwp");
+ DU_LOG("\nERROR --> DU APP : Memory is NULL of InitalUlBwp");
}
}
}
else
{
- DU_LOG("\n DU_APP: Memory is NULL for SpCellGrp");
+ DU_LOG("\nERROR --> DU APP : Memory is NULL for SpCellGrp");
}
}
}
else
{
- DU_LOG("\nDUAPP: Memory is NULL for Physical Cell Group");
+ DU_LOG("\nERROR --> DU APP : Memory is NULL for Physical Cell Group");
}
}
}
else
{
- DU_LOG("\nDUAPP: Memory is NULL for Master Cell Group");
+ DU_LOG("\nERROR --> DU APP : Memory is NULL for Master Cell Group");
}
}
DU_ALLOC_SHRABL_BUF(lcCfg->drbQos, sizeof(DrbQosInfo));
if(!lcCfg->drbQos)
{
- DU_LOG("\nDU APP: Memory Alloc failed at drQos at fillMacLcCfgToAddMod()");
+ DU_LOG("\nERROR --> DU APP : Memory Alloc failed at drQos at fillMacLcCfgToAddMod()");
return RFAILED;
}
}
DU_ALLOC_SHRABL_BUF(lcCfg->snssai, sizeof(Snssai));
if(!lcCfg->snssai)
{
- DU_LOG("\nDU APP: Memory Alloc failed at snnsai at fillMacLcCfgToAddMod()");
+ DU_LOG("\nERROR --> DU APP : Memory Alloc failed at snnsai at fillMacLcCfgToAddMod()");
ret = RFAILED;
}
}
DU_ALLOC_SHRABL_BUF(*macAmbr, sizeof(AmbrCfg));
if(*macAmbr == NULLP)
{
- DU_LOG("\nDUAPP: Memory Alloc Failed at fillAmbr()");
+ DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillAmbr()");
return RFAILED;
}
}
if(macUeCfg)
{
/* Processing one Ue at a time to MAC */
- DU_LOG("\nDU_APP: Sending Ue Reconfig Request to MAC");
+ DU_LOG("\nDEBUG --> DU_APP: Sending Ue Reconfig Request to MAC");
ret = (*packMacUeReconfigReqOpts[pst.selector])(&pst, macUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to send Reconfig Request to MAC at sendUeReCfgReqToMac()");
+ DU_LOG("\nERROR --> DU APP : Failed to send Reconfig Request to MAC at sendUeReCfgReqToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
}
}
else
{
- DU_LOG("\n DU_APP: Received macUeCfg is NULLP at sendUeReCfgReqToMac()");
+ DU_LOG("\nERROR --> DU_APP: Received macUeCfg is NULLP at sendUeReCfgReqToMac()");
ret = RFAILED;
}
return ret;
bitPos++;
}
}
- DU_LOG("\nDU_APP: Max LC Reached in getDrbLcId()");
+ DU_LOG("\nERROR --> DU_APP: Max LC Reached in getDrbLcId()");
return RFAILED;
}
}
else
{
- DU_LOG("\n DU_APP: Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx);
+ DU_LOG("\nERROR --> DU APP : Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx);
break;
}
}/*End of Outer FOR loop */
fillDefaultAmInfo(lcCfg->u.amCfg);
else
{
- DU_LOG("\n DU_APP: Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
+ DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg);
else
{
- DU_LOG("\n DU_APP: Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
+ DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg);
else
{
- DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
+ DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg);
else
{
- DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
+ DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
break;
}
default:
- DU_LOG("\nDUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
+ DU_LOG("\nERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
return RFAILED;
}
}
else
{
- DU_LOG("\nDUAPP: Received Lc Config is NULL");
+ DU_LOG("\nERROR --> DUAPP: Received LC Config is NULL");
return RFAILED;
}
return ROK;
if(rlcUeCfg)
{
/* Processing one Ue at a time to RLC */
- DU_LOG("\nDU_APP: Sending Ue Reconfig Request to RLC UL");
+ DU_LOG("\nDEBUG --> DU_APP: Sending Ue Reconfig Request to RLC UL");
ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()");
+ DU_LOG("\nERROR --> DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
}
}
else
{
- DU_LOG("\n DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()");
+ DU_LOG("\nERROR --> DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()");
ret = RFAILED;
}
return ret;
ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]);
if(ret == RFAILED)
{
- DU_LOG("\n DU_APP: Failed to fill Rlc Mode at fillRlcUeCfg()");
+ DU_LOG("\n ERROR --> DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
return ret;
}
if(ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId)
{
GET_UE_IDX(ueCcchCtxt->crnti, ueIdx);
- DU_LOG("\nDU_APP: Filling UeCb for ueIdx [%d]", ueIdx);
+ DU_LOG("\nDEBUG --> DU_APP: Filling UeCb for ueIdx [%d]", ueIdx);
duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb = NULLP;
duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti = ueCcchCtxt->crnti;
ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
+ DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
/* Filling Rlc Ue Config */
memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg, 0, sizeof(RlcUeCfg));
ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU_APP: Failed to send UE create request to RLC");
+ DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
duCb.actvCellLst[cellIdx]->numActvUes++;
memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
ret = fillMacUeCfg(cellId, ueIdx, crnti, NULL, duMacUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU APP: Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG("\nERROR --> DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
return RFAILED;
}
/* Fill Pst */
{
memset(macUeCfg, 0, sizeof(MacUeCfg));
memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx -1].macUeCfg, sizeof(MacUeCfg));
- DU_LOG("\nDU_APP: Sending UE create request to MAC");
+ DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to MAC");
/* Processing one Ue at a time to MAC */
ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG("\nERROR --> DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
}
}
else
{
- DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG("\n ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
ret = RFAILED;
}
return ret;
freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
+ DU_LOG("\nERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
break;
}
}
ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[numLcs], &f1UeDb->duUeCfg.macLcCfg[dbIdx]);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
+ DU_LOG("\nERROR --> DU APP : Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
break;
}
macUeCfg->numLcs++;
break;
}
default:
- DU_LOG("\nDU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
+ DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
return RFAILED;
}
return ROK;
freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
+ DU_LOG("\nERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
break;
}
}
ueCb->macUeCfg.crnti = crnti;
ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
if(ret == RFAILED)
- DU_LOG("\nDU APP: Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
+ DU_LOG("\nERROR --> DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
}
else
- DU_LOG("\nDU APP: Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
+ DU_LOG("\nERROR --> DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
}
else
ret = RFAILED;
{
if(pst->event == EVENT_MAC_UE_CREATE_RSP)
{
- DU_LOG("\nDU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
+ DU_LOG("\nINFO --> DU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
macUeCfg.macUeCfgState = UE_CREATE_COMPLETE;
}
else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
{
- DU_LOG("\nDU APP : MAC UE Reconfig Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
+ DU_LOG("\nINFO --> DU APP : MAC UE Reconfig Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
macUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
}
else
{
- DU_LOG("\nDU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [UE IDX : %d]", pst->event, cfgRsp->ueIdx);
+ DU_LOG("\nERROR --> DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [UE IDX : %d]", pst->event, cfgRsp->ueIdx);
if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
{
//TODO: Send the failure case in Ue Context Setup Response
}
else
{
- DU_LOG("\nDU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
+ DU_LOG("\nERROR --> DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
ret = RFAILED;
}
return ret;
ret = fillRlcUeCfg(cellId, ueIdx, NULL, duRlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP: Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
+ DU_LOG("\nERROR --> DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
return ret;
}
memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
/* Processing one Ue at a time to RLC */
- DU_LOG("\nDU_APP: Sending UE create request to RLC UL");
+ DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to RLC UL");
ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU_APP : Failure in sending Ue Create Req to RLC");
+ DU_LOG("\nERROR --> DU_APP : Failure in sending Ue Create Req to RLC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
ret = RFAILED;
}
}
else
{
- DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
+ DU_LOG("\n ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
ret = RFAILED;
}
return ret;
{
if(pst->event == EVENT_RLC_UE_CREATE_RSP)
{
- DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
+ DU_LOG("\nINFO --> DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
}
else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
{
- DU_LOG("\nDU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
+ DU_LOG("\nINFO --> DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
}
else
{
- DU_LOG("\nDU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
+ DU_LOG("\nERROR --> DU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
pst->event, cfgRsp->ueIdx, cfgRsp->reason);
if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
{
}
else
{
- DU_LOG("\nDU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
+ DU_LOG("\nERROR --> DU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
ret = RFAILED;
}
return ret;
memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
ret = fillRlcUeCfg(cellId, ueIdx, ueCfgDb, rlcUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU APP: Failed at duBuildAndSendUeReCfgReqToRlc()");
+ DU_LOG("\nERROR --> DU APP : Failed at duBuildAndSendUeReCfgReqToRlc()");
else
ret = sendUeReCfgReqToRlc(rlcUeCfg);
}
else
{
- DU_LOG("\nDU APP: Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()");
+ DU_LOG("\nERROR --> DU APP : Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()");
ret = RFAILED;
}
return ret;
memset(macUeCfg, 0, sizeof(MacUeCfg));
ret = fillMacUeCfg(cellId, ueIdx, crnti, ueCfgDb, macUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU_APP: Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
+ DU_LOG("\nERROR --> DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
else
ret = sendUeReCfgReqToMac(macUeCfg);
}
else
{
- DU_LOG("\nDU_APP: Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()");
ret = RFAILED;
}
return ret;
{
uint8_t ret = ROK;
- DU_LOG("\nDU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
+ DU_LOG("\nDEBUG --> DU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
/* Filling RLC Ue Reconfig */
ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU_APP: Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
+ DU_LOG("\nERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
/* Filling MAC Ue Reconfig */
ret = duBuildAndSendUeReCfgReqToMac(cellId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDU_APP: Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
+ DU_LOG("\nERROR --> DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
return ret;
}
{
ret = duBuildAndSendUeContextSetupReq(dlRrcMsg->cellId, dlRrcMsg->crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nDUAPP: Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
+ DU_LOG("\nERROR --> DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
}
}
else
- DU_LOG("\nDUAPP: Failed to transmit DL RRC Msg");
+ DU_LOG("\nERROR --> DU APP : Failed to transmit DL RRC Msg");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsg, sizeof(RlcDlRrcMsgRsp));
return ret;
ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
- DU_LOG("\nDU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
+ DU_LOG("\nERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
ueCb->f1UeDb->dlRrcMsg->rrcMsgSize);
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
ret = duBuildAndSendUeContextSetupReq(cellId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nDU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
+ DU_LOG("\nERROR --> DU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
}
}
}
else
{
//TODO: To send the failure cause in UeContextSetupRsp
- DU_LOG("DU_APP: Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()");
+ DU_LOG("ERROR --> DU APP : Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()");
}
return ret;
}
Code Review / o-du / l2.git / commitdiff