# macro for output file name and makefile name
#
-PLTFRM_FLAGS=-UMSPD -DODU -DINTEL_FAPI -UODU_MEMORY_DEBUG_LOG -DDEBUG_ASN_PRINT -UDEBUG_PRINT -DERROR_PRINT -USTART_DL_UL_DATA -UNR_DRX -UCALL_FLOW_DEBUG_LOG -UODU_SLOT_IND_DEBUG_LOG -UTHREAD_AFFINITY -UMEM_SIZE_CHECK
+PLTFRM_FLAGS=-UMSPD -DODU -DINTEL_FAPI -UODU_MEMORY_DEBUG_LOG -DDEBUG_ASN_PRINT -UDEBUG_PRINT -DERROR_PRINT -USTART_DL_UL_DATA -UNR_DRX -UCALL_FLOW_DEBUG_LOG -UODU_SLOT_IND_DEBUG_LOG -UTHREAD_AFFINITY -UMEM_SIZE_CHECK -DLOG_TIMESTAMP
ifeq ($(MODE),TDD)
PLTFRM_FLAGS += -DNR_TDD
strcpy(sourceTask,"Invalid Source Entity Id");\r
}\r
}\r
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);\r
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);\r
}\r
#endif\r
\r
char newIp[INET_ADDRSTRLEN];\r
memset(newIp, 0, INET_ADDRSTRLEN);\r
\r
- DU_LOG("\nINFO --> LWR MAC: Extracting information from param resp message");\r
+ DU_LOG("INFO --> LWR MAC: Extracting information from param resp message");\r
//Upacking error code and number of tlv as per : 5G nFAPI Specification,\r
//section 3.2.2 PARAM.response, Table 3-14\r
CMCHKPK(oduUnpackUInt8, &(errorCode), mBuf);\r
if(errorCode != 0)\r
{\r
- DU_LOG("\nERROR --> LWR MAC: Param rsp errorCode is %d", errorCode);\r
+ DU_LOG("ERROR --> LWR MAC: Param rsp errorCode is %d", errorCode);\r
return RFAILED;\r
}\r
\r
CMCHKPK(oduUnpackUInt16, &(port), mBuf);\r
if (inet_ntop(AF_INET, pnfAdd, newIp, INET_ADDRSTRLEN) == NULL) \r
{\r
- DU_LOG("\nERROR --> LWR MAC: failed to convert the pnf ip");\r
+ DU_LOG("ERROR --> LWR MAC: failed to convert the pnf ip");\r
return RFAILED;\r
}\r
cmInetAddr((S8*)newIp, &vnfIp);\r
vnfDb.p7TransInfo.destIpv4Port = port;\r
vnfDb.p7TransInfo.destIpNetAddr.address = CM_INET_NTOH_UINT32(vnfDb.p7TransInfo.destIpv4Address);\r
vnfDb.p7TransInfo.destIpNetAddr.port = vnfDb.p7TransInfo.destIpv4Port;\r
- DU_LOG("\nINFO --> LWR MAC: Sending param response message body buffer to lower mac");\r
+ DU_LOG("INFO --> LWR MAC: Sending param response message body buffer to lower mac");\r
sendEventToLowerMacFsm(PARAM_RESPONSE, 0, mBuf); \r
return ROK;\r
}\r
LwrMacEnqueueWlsBlock();\r
\r
/* Start thread to receive from L1 */\r
- DU_LOG("\nINFO --> LWR MAC: Starting WLS receiver thread");\r
+ DU_LOG("INFO --> LWR MAC: Starting WLS receiver thread");\r
LwrMacRecvPhyMsg();\r
break;\r
}\r
default:\r
{\r
ODU_PUT_MSG_BUF(mBuf);\r
- DU_LOG("\nERROR --> LWR MAC: Invalid event %d received", pst->event);\r
+ DU_LOG("ERROR --> LWR MAC: Invalid event %d received", pst->event);\r
ret = RFAILED;\r
}\r
}\r
}\r
default:\r
{\r
- DU_LOG("\nERROR --> LWR_MAC: Invalid event %d received from PHY STUB", pst->event);\r
+ DU_LOG("ERROR --> LWR_MAC: Invalid event %d received from PHY STUB", pst->event);\r
}\r
}\r
break;\r
if(msgHdr.sRU_termination_type != NFAPI_P5_P7_SRU_TYPE)\r
{\r
ODU_PUT_MSG_BUF(mBuf);\r
- DU_LOG("\nERROR --> NFAPI_VNF: Incorrect SRU Termination Type:%d",\\r
+ DU_LOG("ERROR --> NFAPI_VNF: Incorrect SRU Termination Type:%d",\\r
msgHdr.sRU_termination_type);\r
return RFAILED;\r
}\r
if(convertNfapiP5TagValToMsgId(msgHdr.msg_id, &nfapiPnfEvent, &phyEvent)!=ROK)\r
{\r
ODU_PUT_MSG_BUF(mBuf);\r
- DU_LOG("\nERROR --> NFAPI_VNF: Incorrect NFAPI MsgID received:%d",\\r
+ DU_LOG("ERROR --> NFAPI_VNF: Incorrect NFAPI MsgID received:%d",\\r
msgHdr.msg_id);\r
return RFAILED;\r
}\r
if(sendParamRspToLowerMacFsm(mBuf) != ROK)\r
{\r
ODU_PUT_MSG_BUF(mBuf);\r
- DU_LOG("\nERROR --> NFAPI_VNF: Failed to process param response");\r
+ DU_LOG("ERROR --> NFAPI_VNF: Failed to process param response");\r
return RFAILED;\r
}\r
\r
retVal = sendEventToLowerMacFsm(phyEvent, msgHdr.length, mBuf);\r
if(phyEvent == START_RESPONSE && retVal == ROK)\r
{\r
- DU_LOG("\nDEBUG --> NFAPI_VNF: Opening UDP Socket");\r
+ DU_LOG("DEBUG --> NFAPI_VNF: Opening UDP Socket");\r
nfapiP7UdpOpenReq(); \r
}\r
}\r
#endif\r
default:\r
{\r
- DU_LOG("\nERROR --> LWR_MAC: Invalid event %d received from SCTP", pst->event);\r
+ DU_LOG("ERROR --> LWR_MAC: Invalid event %d received from SCTP", pst->event);\r
}\r
}\r
break;\r
default:\r
{\r
ODU_PUT_MSG_BUF(mBuf);\r
- DU_LOG("\nERROR --> LWR MAC: Message from invalid source entity %d", pst->srcEnt);\r
+ DU_LOG("ERROR --> LWR MAC: Message from invalid source entity %d", pst->srcEnt);\r
ret = RFAILED;\r
}\r
}\r
uint8_t lwr_mac_procInvalidEvt(void *msg)
{
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : INVALID_EVENT\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : INVALID_EVENT\n");
#endif
- DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("ERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Value Extraction failed" );
+ DU_LOG("ERROR --> LWR_MAC: Value Extraction failed" );
return RFAILED;
}
}
{
*mibPdu |= (((uint8_t)(sfn << 2)) & MIB_SFN_BITMASK);
*val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
- DU_LOG("\nDEBUG --> LWR_MAC: MIB PDU %x", *val);
+ DU_LOG("DEBUG --> LWR_MAC: MIB PDU %x", *val);
}
/*******************************************************************
Buffer *mBuf = NULLP;
Pst pst;
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 PARAM_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 PARAM_REQ\n");
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
#ifdef INTEL_FAPI
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : PARAM_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : PARAM_REQ\n");
#endif
/* startGuardTimer(); */
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for param req header");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for param req header");
LWR_MAC_FREE(paramReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_param_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nDEBUG --> LWR_MAC: Sending Param Request to Phy");
+ DU_LOG("DEBUG --> LWR_MAC: Sending Param Request to Phy");
LwrMacSendToL1(headerElem);
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for Param Request");
+ DU_LOG("ERROR --> LWR_MAC: Failed to allocate memory for Param Request");
return RFAILED;
}
#endif
if ((macCb.fapiMsgCompStatus.paramMsgComp >> 1) & 1)
{
ret = sendEventToLowerMacFsm(CONFIG_REQUEST, 0, (void *)NULL);
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
}
macCb.fapiMsgCompStatus.paramMsgComp = (macCb.fapiMsgCompStatus.paramMsgComp | 1);
return ret;
ClCellParam *cellParam = NULLP;
paramRsp = (fapi_param_resp_t *)msg;
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
if(paramRsp != NULLP)
{
MAC_ALLOC(cellParam, sizeof(ClCellParam));
if(cellParam != NULLP)
{
- DU_LOG("\nDEBUG --> LWR_MAC: Filling TLVS into MAC API");
+ DU_LOG("DEBUG --> LWR_MAC: Filling TLVS into MAC API");
if(paramRsp->error_code == MSG_OK)
{
for(index = 0; index < paramRsp->number_of_tlvs; index++)
encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
if(encodedVal != RFAILED && encodedVal != lwrMacCb.phyState)
{
- DU_LOG("\nERROR --> PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
+ DU_LOG("ERROR --> PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
return RFAILED;
}
break;
}
break;
default:
- //DU_LOG("\nERROR --> Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
+ //DU_LOG("ERROR --> Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
break;
}
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", paramRsp->error_code);
+ DU_LOG("ERROR --> LWR_MAC: Invalid error code %d", paramRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for cell param");
+ DU_LOG("ERROR --> LWR_MAC: Failed to allocate memory for cell param");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Param Response received from PHY is NULL");
+ DU_LOG("ERROR --> LWR_MAC: Param Response received from PHY is NULL");
return RFAILED;
}
#else
LWR_MAC_ALLOC(iqSampleElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_ext_iq_samples_req_t)));
if(!iqSampleElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for IQ sample req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for IQ sample req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(iqSampleElem, NULLP, FAPI_VENDOR_EXT_UL_IQ_SAMPLES, 1, \
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(headerElem, iqSampleElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nINFO --> LWR_MAC: Sending IQ Sample request to Phy");
+ DU_LOG("INFO --> LWR_MAC: Sending IQ Sample request to Phy");
LwrMacSendToL1(headerElem);
return ROK;
}
lwrMacCb.cellCb[lwrMacCb.numCell].cellId = macCfgParams.cellId;
lwrMacCb.cellCb[lwrMacCb.numCell].phyCellId = macCfgParams.cellCfg.phyCellId;
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 CONFIG_REQ %d\n",cellIdx);
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 CONFIG_REQ %d\n",cellIdx);
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfConfigReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfConfigReq");
return RFAILED;
}
//TODO /* fill Beamforming Tables and fill Precoding Table */
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : Sending P5 CONFIG_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : Sending P5 CONFIG_REQ\n");
FILL_PST_LWR_MAC_TO_DUAPP(pst, EVENT_PNF_DATA);
return ODU_POST_TASK(&pst, mBuf);
#ifdef NFAPI_ENABLED
if(buildAndSendConfigReqToPnf() != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to build and send config req");
+ DU_LOG("ERROR --> LWR_MAC: Failed to build and send config req");
return RFAILED;
}
#ifdef INTEL_FAPI
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n");
#endif
#ifdef NR_TDD
uint8_t slotIdx = 0;
p_fapi_api_queue_elem_t vendorMsgQElem;
p_fapi_api_queue_elem_t cfgReqQElem;
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
cellId = (uint16_t *)msg;
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgQElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
if(!cfgReqQElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for config req");
LWR_MAC_FREE(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_FREE(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
LWR_MAC_FREE(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->num_msg = 2; /* Config req msg and vendor specific msg */
msgHeader->handle = 0;
- DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy");
+ DU_LOG("DEBUG --> LWR_MAC: Sending Config Request to Phy");
LwrMacSendToL1(headerElem);
#endif
#endif
{
#ifdef NFAPI_ENABLED
uint8_t errCode = 0;
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
CMCHKPK(oduUnpackUInt8, &(errCode), msg);
if(errCode == NFAPI_MSG_OK)
{
- DU_LOG("\nDEBUG --> LWR_MAC: PHY has moved to Configured state \n");
+ DU_LOG("DEBUG --> LWR_MAC: PHY has moved to Configured state \n");
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
/* TODO :
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
return RFAILED;
}
fapi_config_resp_t *configRsp;
configRsp = (fapi_config_resp_t *)msg;
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
if(configRsp != NULL)
{
if(configRsp->error_code == MSG_OK)
{
- DU_LOG("\nDEBUG --> LWR_MAC: PHY has moved to Configured state \n");
+ DU_LOG("DEBUG --> LWR_MAC: PHY has moved to Configured state \n");
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
/* TODO :
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", configRsp->error_code);
+ DU_LOG("ERROR --> LWR_MAC: Invalid error code %d", configRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Config Response received from PHY is NULL");
+ DU_LOG("ERROR --> LWR_MAC: Config Response received from PHY is NULL");
return RFAILED;
}
#endif
Buffer *mBuf = NULLP;
Pst pst;
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 START_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : NFAPI P5 START_REQ\n");
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in StartReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in StartReq");
return RFAILED;
}
//As per 5G nFAPI Specification, section 3.2.5 START.request
#ifdef INTEL_FAPI
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : START_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : START_REQ\n");
#endif
fapi_msg_header_t *msgHeader;
fapi_start_req_t *startReq;
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in start req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for vendor msg in start req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
if(!startReqElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for start req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for start req");
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_FREE(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->handle = 0;
/* Send to PHY */
- DU_LOG("\nDEBUG --> LWR_MAC: Sending Start Request to Phy");
+ DU_LOG("DEBUG --> LWR_MAC: Sending Start Request to Phy");
LwrMacSendToL1(headerElem);
#endif
#endif
uint8_t lwr_mac_procStartRspEvt(void *msg)
{
uint8_t errCode = 0;
- DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("INFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
CMCHKPK(oduUnpackUInt8, &(errCode), msg);
{
if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
{
- DU_LOG("\nINFO --> LWR_MAC: PHY has moved to running state");
+ DU_LOG("INFO --> LWR_MAC: PHY has moved to running state");
lwrMacCb.phyState = PHY_STATE_RUNNING;
lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING;
}
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
return RFAILED;
}
return ROK;
{
#ifdef INTEL_FAPI
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : STOP_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : STOP_REQ\n");
#endif
fapi_stop_req_t *stopReq;
LWR_MAC_ALLOC(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
if(!stopReqElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for stop req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for stop req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(stopReqElem, NULLP, FAPI_STOP_REQUEST, 1, sizeof(fapi_stop_req_t));
fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, sizeof(fapi_stop_req_t));
/* Send to PHY */
- DU_LOG("\nINFO --> LWR_MAC: Sending Stop Request to Phy");
+ DU_LOG("INFO --> LWR_MAC: Sending Stop Request to Phy");
prevElem->p_next = stopReqElem;
#endif
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("ERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("ERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("ERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("ERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu");
+ DU_LOG("ERROR --> LWR_MAC: Failed filling PDCCH Pdu");
return RFAILED;
}
uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
{
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : DL_TTI_REQUEST\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : DL_TTI_REQUEST\n");
#endif
#ifdef INTEL_FAPI
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgQElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
return RFAILED;
}
}
}
DU_LOG("\033[1;31m");
- DU_LOG("\nDEBUG --> LWR_MAC: MIB sent..");
+ DU_LOG("DEBUG --> LWR_MAC: MIB sent..");
DU_LOG("\033[0m");
}
numPduEncoded++;
}
DU_LOG("\033[1;34m");
- DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent...");
+ DU_LOG("DEBUG --> LWR_MAC: SIB1 sent...");
DU_LOG("\033[0m");
}
}
numPduEncoded++;
}
DU_LOG("\033[1;34m");
- DU_LOG("\nDEBUG --> LWR_MAC: PAGE sent...");
+ DU_LOG("DEBUG --> LWR_MAC: PAGE sent...");
DU_LOG("\033[0m");
}
pduIndex++;
DU_LOG("\033[1;32m");
- DU_LOG("\nDEBUG --> LWR_MAC: RAR sent...");
+ DU_LOG("DEBUG --> LWR_MAC: RAR sent...");
DU_LOG("\033[0m");
}
}
DU_LOG("\033[1;32m");
if((macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status))
{
- DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent...");
+ DU_LOG("DEBUG --> LWR_MAC: MSG4 sent...");
MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status, sizeof(bool));
}
else
{
- DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent...");
+ DU_LOG("DEBUG --> LWR_MAC: DL MSG sent...");
}
DU_LOG("\033[0m");
}
dlTtiReq->nGroup++;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
+ DU_LOG("DEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
/* Intel L1 expects UL_TTI.request following DL_TTI.request */
else
{
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
+ DU_LOG("DEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
/* Intel L1 expects UL_TTI.request following DL_TTI.request */
fillUlTtiReq(currTimingInfo, dlTtiElem, &(vendorMsg->p7_req_vendor.ul_tti_req));
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
+ DU_LOG("ERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
memset(currDlSlot, 0, sizeof(MacDlSlot));
return RFAILED;
}
{
#ifdef INTEL_FAPI
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : TX_DATA_REQ\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : TX_DATA_REQ\n");
#endif
uint8_t nPdu = 0;
LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
if(txDataElem == NULLP)
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request");
+ DU_LOG("ERROR --> LWR_MAC: Failed to allocate memory for TX data Request");
return RFAILED;
}
}
/* Fill message header */
- DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request");
+ DU_LOG("DEBUG --> LWR_MAC: Sending TX DATA Request");
prevElem->p_next = txDataElem;
}
#endif
uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_tti_req_t* vendorUlTti)
{
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_TTI_REQUEST\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : UL_TTI_REQUEST\n");
#endif
#ifdef INTEL_FAPI
if(ulTtiReq->nPdus > 0)
{
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: UL_TTI_REQ, datatype:%d, sfn/slot:%d/%d", currUlSlot->ulSchInfo.dataType, ulTtiReq->sfn, ulTtiReq->slot);
+ DU_LOG("DEBUG --> LWR_MAC: UL_TTI_REQ, datatype:%d, sfn/slot:%d/%d", currUlSlot->ulSchInfo.dataType, ulTtiReq->sfn, ulTtiReq->slot);
#endif
/* Fill Prach Pdu */
if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PRACH)
if(currUlSlot->ulSchInfo.schPuschInfo[ueIdx].crnti != 0)
{
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: UL_TTI_REQ, PUSCH PDU ueId:%d", ueIdx);
+ DU_LOG("DEBUG --> LWR_MAC: UL_TTI_REQ, PUSCH PDU ueId:%d", ueIdx);
#endif
pduIdx++;
fillPuschPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, &currUlSlot->ulSchInfo.schPuschInfo[ueIdx]);
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request");
+ DU_LOG("DEBUG --> LWR_MAC: Sending UL TTI Request");
#endif
prevElem->p_next = ulTtiElem;
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request");
+ DU_LOG("ERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request");
memset(currUlSlot, 0, sizeof(MacUlSlot));
return RFAILED;
}
void fillUlDciPdu(fapi_dl_dci_t *ulDciPtr, DciInfo *schDciInfo)
{
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_DCI_REQUEST\n");
+ DU_LOG("Call Flow: ENTMAC -> ENTLWRMAC : UL_DCI_REQUEST\n");
#endif
if(ulDciPtr != NULLP)
{
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("ERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
MAC_FREE(currDlSlot->dlInfo.ulGrant, sizeof(DciInfo));
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending UL DCI Request");
+ DU_LOG("DEBUG --> LWR_MAC: Sending UL DCI Request");
#endif
}
prevElem->p_next = ulDciElem;
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in procSlotInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in procSlotInd");
ret = RFAILED;
}
return ret;
MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t));
if(!cellId)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory Allocation failed in procStopInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory Allocation failed in procStopInd");
return RFAILED;
}
*cellId = lwrMacCb.cellCb[0].cellId;
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
- DU_LOG("\nINFO --> LWR_MAC: PHY has moved to configured state");
+ DU_LOG("INFO --> LWR_MAC: PHY has moved to configured state");
FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC);
pst.selector = ODU_SELECTOR_LWLC;
if(!fapiRachInd->numPdus)
{
- DU_LOG("\nDEBUG --> LWR_MAC : No PDU in RACH.indication at [%d, %d]", fapiRachInd->sfn, fapiRachInd->slot);
+ DU_LOG("DEBUG --> LWR_MAC : No PDU in RACH.indication at [%d, %d]", fapiRachInd->sfn, fapiRachInd->slot);
return ROK;
}
MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd));
if(!rachInd)
{
- DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procRachInd");
+ DU_LOG("ERROR --> LWR_MAC : Memory Allocation failed in procRachInd");
return RFAILED;
}
rachInd->cellId = lwrMacCb.cellCb[0].cellId;
MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd));
if(!crcInd)
{
- DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procCrcInd");
+ DU_LOG("ERROR --> LWR_MAC : Memory Allocation failed in procCrcInd");
return RFAILED;
}
if(!fapiCrcInd->numCrcs)
{
- DU_LOG("\nDEBUG --> LWR_MAC : No CRC PDUs in CRC.indication at [%d, %d]", fapiCrcInd->sfn, fapiCrcInd->slot);
+ DU_LOG("DEBUG --> LWR_MAC : No CRC PDUs in CRC.indication at [%d, %d]", fapiCrcInd->sfn, fapiCrcInd->slot);
return ROK;
}
MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd));
if(!rxDataInd)
{
- DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procRxDataInd");
+ DU_LOG("ERROR --> LWR_MAC : Memory Allocation failed in procRxDataInd");
return RFAILED;
}
if(!fapiRxDataInd->numPdus)
{
- DU_LOG("\nDEBUG --> LWR_MAC : No PDU in RX_Data.indication at [%d, %d]", fapiRxDataInd->sfn, fapiRxDataInd->slot);
+ DU_LOG("DEBUG --> LWR_MAC : No PDU in RX_Data.indication at [%d, %d]", fapiRxDataInd->sfn, fapiRxDataInd->slot);
return ROK;
}
MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd));
if(!macUciInd)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory Allocation failed in procUciInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory Allocation failed in procUciInd");
return RFAILED;
}
- DU_LOG("\nDEBUG --> LWR_MAC: Processing UCI Indication");
+ DU_LOG("DEBUG --> LWR_MAC: Processing UCI Indication");
memset(macUciInd, 0, sizeof(UciInd));
macUciInd->cellId = lwrMacCb.cellCb[0].cellId;
macUciInd->slotInd.sfn = fapiUciInd->sfn;
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nERROR --> LWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
+ DU_LOG("ERROR --> LWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed sending UCI Ind to MAC");
+ DU_LOG("ERROR --> LWR_MAC: Failed sending UCI Ind to MAC");
}
return ret;
}
strcpy(message,"FAPI_STOP_INDICATION");
break;
}
- DU_LOG("\nCall Flow: PHY -> ENTLWRMAC : %s\n",message);
+ DU_LOG("Call Flow: PHY -> ENTLWRMAC : %s\n",message);
}
#endif
#ifdef INTEL_TIMER_MODE
case FAPI_VENDOR_EXT_UL_IQ_SAMPLES:
{
- DU_LOG("\nDEBUG --> LWR_MAC: Received FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
+ DU_LOG("DEBUG --> LWR_MAC: Received FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
//send config req
uint16_t cellId = 1;
sendEventToLowerMacFsm(CONFIG_REQUEST, 0, (void *)&cellId);
{
if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
{
- DU_LOG("\nINFO --> LWR_MAC: PHY has moved to running state");
+ DU_LOG("INFO --> LWR_MAC: PHY has moved to running state");
lwrMacCb.phyState = PHY_STATE_RUNNING;
lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING;
}
}
case FAPI_STOP_INDICATION:
{
- DU_LOG("\nINFO --> LWR_MAC: Handling Stop Indication");
+ DU_LOG("INFO --> LWR_MAC: Handling Stop Indication");
procStopInd();
break;
}
Pst pst;
Buffer *mBuf;
- DU_LOG("\nINFO --> LWR MAC : Requesting to start WLS receiver thread");
+ DU_LOG("INFO --> LWR MAC : Requesting to start WLS receiver thread");
/* Filling post */
memset(&pst, 0, sizeof(Pst));
if (ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR MAC : Memory allocation failed for LwrMacStartWlsRcvr");
+ DU_LOG("ERROR --> LWR MAC : Memory allocation failed for LwrMacStartWlsRcvr");
return;
}
strcpy(message, "INVALID_MSG");
break;
}
- DU_LOG("\nCall Flow: ENTLWRMAC -> PHY : %s\n",message);
+ DU_LOG("Call Flow: ENTLWRMAC -> PHY : %s\n",message);
currMsg = currMsg->p_next;
}
#endif
addWlsBlockToFree(currMsg, msgLen, (lwrMacCb.phySlotIndCntr-1));
if(currMsg->p_next == NULLP)
{
- DU_LOG("\nERROR --> LWR MAC : There cannot be only one block to send");
+ DU_LOG("ERROR --> LWR MAC : There cannot be only one block to send");
return RFAILED;
}
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_FIRST);
if(ret != 0)
{
- DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
+ DU_LOG("ERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = currMsg->p_next;
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_NEXT);
if(ret != 0)
{
- DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
+ DU_LOG("ERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = currMsg->p_next;
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_LAST);
if(ret != 0)
{
- DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
+ DU_LOG("ERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = NULLP;
#ifdef MEM_SIZE_CHECK
#define WLS_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\nRLC line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG("LWR_MAC line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define WLS_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packCrcInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packCrcInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)crcInd, mBuf);
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packRxDataInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packRxDataInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)rxDataInd, mBuf);
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packRachInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packRachInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)rachInd, mBuf);
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packSlotInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packSlotInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)slotInd, mBuf);
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packStopInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packStopInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
Buffer *mBuf = NULLP;
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in packUciInd");
+ DU_LOG("ERROR --> LWR_MAC: Memory allocation failed in packUciInd");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)uciInd, mBuf);
if(cellId >= MAX_NUM_CELL)
{
- DU_LOG("\nERROR --> Invalid Cell Id [%d]. rgClUtlGetCellCb failed.", cellId);
+ DU_LOG("ERROR --> Invalid Cell Id [%d]. rgClUtlGetCellCb failed.", cellId);
return NULLP;
}
{
Pst schPst;
- DU_LOG("\nINFO --> MAC : Received Scheduler gen config at MAC");
+ DU_LOG("INFO --> MAC : Received Scheduler gen config at MAC");
memset(&schPst, 0, sizeof(Pst));
FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG);
**/
uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm)
{
- DU_LOG("\nDEBUG --> MAC : Sending Scheduler config confirm to DU APP");
+ DU_LOG("DEBUG --> MAC : Sending Scheduler config confirm to DU APP");
pst->dstEnt = ENTDUAPP;
pst->dstInst = 0;
pst->srcInst = 0;
MAC_ALLOC(macCellCb, sizeof(MacCellCb));
if(macCellCb == NULLP)
{
- DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of macCellCfg\n");
+ DU_LOG("ERROR --> MAC : macCellCb is NULL at handling of macCellCfg\n");
return RFAILED;
}
memset(macCellCb, 0, sizeof(MacCellCb));
macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen);
if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu == NULLP)
{
- DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
+ DU_LOG("ERROR --> MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
return RFAILED;
}
memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, macCellCfg->cellCfg.sib1Cfg.sib1Pdu, \
* sizeof(Snssai*));
if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai == NULLP)
{
- DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
+ DU_LOG("ERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
return RFAILED;
}
MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
if(!macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
{
- DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
+ DU_LOG("ERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
return RFAILED;
}
memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx],\
MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai, schCellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices * sizeof(Snssai*));
if(!schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai)
{
- DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
+ DU_LOG("ERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
return RFAILED;
}
for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++)
MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
if(!schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
{
- DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
+ DU_LOG("ERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
return RFAILED;
}
memcpy(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
uint16_t *cellId = NULLP;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
#endif
if(schCellCfgCfm->rsp == RSP_OK)
MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
if(!deleteRsp)
{
- DU_LOG("\nERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
+ DU_LOG("ERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
return RFAILED;
}
CauseOfResult cause;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
#endif
if(schCellDelRsp)
{
if(schCellDelRsp->rsp == RSP_OK)
{
- DU_LOG("\nINFO --> MAC : SCH CELL Delete response for cellId[%d] is successful ", \
+ DU_LOG("INFO --> MAC : SCH CELL Delete response for cellId[%d] is successful ", \
schCellDelRsp->cellId);
GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
if(macCb.macCell[cellIdx])
}
if(MacSendCellDeleteRsp(cause, schCellDelRsp->cellId) != ROK)
{
- DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
+ DU_LOG("ERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
+ DU_LOG("ERROR --> MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
ret = RFAILED;
}
return ret;
uint8_t ret = ROK, cellIdx=0;
SchCellDeleteReq schCellDelete;
- DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
+ DU_LOG("INFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
if(cellDelete)
{
ret = sendCellDelReqToSch(&schCellDelete);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
cellDelete->cellId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
cellDelete->cellId);
ret = RFAILED;
}
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU");
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU");
if(MacSendCellDeleteRsp(CELLID_INVALID, cellDelete->cellId) != ROK)
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
cellDelete->cellId);
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
+ DU_LOG("ERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
ret = RFAILED;
}
return ret;
MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
if(macSliceCfgRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
return RFAILED;
}
macSliceCfgRsp->snssai = schSliceCfgRsp->snssai;
MAC_ALLOC_SHRABL_BUF(macSliceRecfgRsp, sizeof(MacSliceRecfgRsp));
if(macSliceRecfgRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp");
return RFAILED;
}
if(pcchInd)
{
- DU_LOG("\nINFO --> MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId);
+ DU_LOG("INFO --> MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId);
GET_CELL_IDX(pcchInd->cellId, cellIdx);
if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId)
{
- DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId);
+ DU_LOG("ERROR --> MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId);
}
else
{
if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0))
{
- DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Pcch pdu is null");
+ DU_LOG("ERROR --> MAC : MacProcDlPcchInd(): Received Pcch pdu is null");
}
else
{
MAC_ALLOC(schPageInd, sizeof(SchPageInd));
if(schPageInd == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory");
+ DU_LOG("ERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory");
}
else
{
MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen);
if(schPageInd->pagePdu == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory");
+ DU_LOG("ERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory");
MAC_FREE(schPageInd, sizeof(SchPageInd));
}
else
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Null pointer");
+ DU_LOG("ERROR --> MAC : MacProcDlPcchInd(): Received Null pointer");
}
return ret;
}
if(dlBroadcastReq)
{
- DU_LOG("\nINFO --> MAC : Received DL braodcast req from DU_APP for cellId[%d]", dlBroadcastReq->cellId);
+ DU_LOG("INFO --> MAC : Received DL braodcast req from DU_APP for cellId[%d]", dlBroadcastReq->cellId);
GET_CELL_IDX(dlBroadcastReq->cellId, cellIdx);
if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != dlBroadcastReq->cellId)
{
ret = RFAILED;
- DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): CellId[%d] does not exist", dlBroadcastReq->cellId);
+ DU_LOG("ERROR --> MAC : MacProcDlBroadcastReq(): CellId[%d] does not exist", dlBroadcastReq->cellId);
}
else
{
else
{
ret = RFAILED;
- DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): Received Null pointer");
+ DU_LOG("ERROR --> MAC : MacProcDlBroadcastReq(): Received Null pointer");
}
return ret;
}
Pst pst;
MacStatsRsp *macStatsRsp = NULLP;
- DU_LOG("\nINFO --> MAC : MacSendStatsRspToDuApp: Sending Statistics Response to DU APP");
+ DU_LOG("INFO --> MAC : MacSendStatsRspToDuApp: Sending Statistics Response to DU APP");
MAC_ALLOC_SHRABL_BUF(macStatsRsp, sizeof(MacStatsRsp));
if(macStatsRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchStatsRsp");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchStatsRsp");
ret = RFAILED;
}
else
FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATISTICS_RSP);
if(((*macDuStatsRspOpts[pst.selector])(&pst, macStatsRsp))!= ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to send statistics response to DU APP");
+ DU_LOG("ERROR --> MAC : Failed to send statistics response to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsRsp, sizeof(MacStatsRsp));
ret = RFAILED;
}
SchStatsReq *schStatsReq = NULLP;
MacStatsRsp *macStatsRsp = NULLP;
- DU_LOG("\nINFO --> MAC : Received Statistics Request from DU_APP");
+ DU_LOG("INFO --> MAC : Received Statistics Request from DU_APP");
if(macStatsReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsReq(): Received Null pointer");
+ DU_LOG("ERROR --> MAC : MacProcStatsReq(): Received Null pointer");
return RFAILED;
}
* towards DU APP has reached its maximum limit */
if(macCb.statistics.numPendingStatsRsp >= MAX_PENDING_STATS_RSP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsReq: Maximum number of statistics response is pending. \
+ DU_LOG("ERROR --> MAC : MacProcStatsReq: Maximum number of statistics response is pending. \
Cannot process new request.");
MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq));
MAC_ALLOC(schStatsReq, sizeof(SchStatsReq));
if(schStatsReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsReq: Failed to allocate memory");
+ DU_LOG("ERROR --> MAC : MacProcStatsReq: Failed to allocate memory");
MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq));
return RFAILED;
}
default:
{
- DU_LOG("\nERROR --> MAC : MacProcStatsReq: Invalid measurement type [%d]", \
+ DU_LOG("ERROR --> MAC : MacProcStatsReq: Invalid measurement type [%d]", \
macStatsGrp->statsList[macStatsIdx]);
measTypeInvalid = true;
}
{
/* [Step 5] If none of the groups passes all validation, mac-stats-response
* is sent to du app with all group as part of stats-group-rejected-list. */
- DU_LOG("\nERROR --> MAC : MacProcStatsReq: All statistics group found invalid");
+ DU_LOG("ERROR --> MAC : MacProcStatsReq: All statistics group found invalid");
MAC_FREE(schStatsReq, sizeof(SchStatsReq));
ret = MacSendStatsRspToDuApp(macStatsRsp);
}
MAC_ALLOC_SHRABL_BUF(macStatsDeleteRsp, sizeof(MacStatsDeleteRsp));
if(macStatsDeleteRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchStatsDeleteRsp");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchStatsDeleteRsp");
ret = RFAILED;
}
}
}
- DU_LOG("\nINFO --> MAC : MacSendStatsDeleteRspToDuApp: Sending Delete Statistics Response to DU APP");
+ DU_LOG("INFO --> MAC : MacSendStatsDeleteRspToDuApp: Sending Delete Statistics Response to DU APP");
memset(&pst, 0, sizeof(Pst));
FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATS_DELETE_RSP);
if(((*macDuStatsDeleteRspOpts[pst.selector])(&pst, macStatsDeleteRsp))!= ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to send statistics delete response to DU APP");
+ DU_LOG("ERROR --> MAC : Failed to send statistics delete response to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsDeleteRsp, sizeof(MacStatsDeleteRsp));
ret = RFAILED;
}
uint8_t ret = RFAILED;
SchStatsDeleteReq *schStatsDeleteReq = NULLP;
- DU_LOG("\nINFO --> MAC : Received Statistics delete Request from DU_APP");
+ DU_LOG("INFO --> MAC : Received Statistics delete Request from DU_APP");
if(macStatsDeleteReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsDeleteReq(): Received Null pointer");
+ DU_LOG("ERROR --> MAC : MacProcStatsDeleteReq(): Received Null pointer");
return RFAILED;
}
MAC_ALLOC(schStatsDeleteReq, sizeof(SchStatsDeleteReq));
if(schStatsDeleteReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsDeleteReq: Failed to allocate memory");
+ DU_LOG("ERROR --> MAC : MacProcStatsDeleteReq: Failed to allocate memory");
}
else
{
uint8_t ret = ROK;
MacStatsModificationRsp *macStatsModificationRsp = NULLP;
- DU_LOG("\nINFO --> MAC : MacSendStatsModificationRspToDuApp: Sending Statistics Modification Response to DU APP");
+ DU_LOG("INFO --> MAC : MacSendStatsModificationRspToDuApp: Sending Statistics Modification Response to DU APP");
MAC_ALLOC_SHRABL_BUF(macStatsModificationRsp, sizeof(MacStatsModificationRsp));
if(macStatsModificationRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchStatsModificationRsp");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchStatsModificationRsp");
ret = RFAILED;
}
else
FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATISTICS_MODIFY_RSP);
if(((*macDuStatsModificationRspOpts[pst.selector])(&pst, macStatsModificationRsp))!= ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to send statistics modification response to DU APP");
+ DU_LOG("ERROR --> MAC : Failed to send statistics modification response to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsModificationRsp, sizeof(MacStatsModificationRsp));
ret = RFAILED;
}
SchStatsModificationReq *schStatsModificationReq = NULLP;
MacStatsModificationRsp *macStatsModificationRsp = NULLP;
- DU_LOG("\nINFO --> MAC : Received Statistics Modification Request from DU_APP");
+ DU_LOG("INFO --> MAC : Received Statistics Modification Request from DU_APP");
if(macStatsModificationReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsModificationReq(): Received Null pointer");
+ DU_LOG("ERROR --> MAC : MacProcStatsModificationReq(): Received Null pointer");
return RFAILED;
}
/* [Step -1] */
if(macCb.statistics.numPendingStatsRsp >= MAX_PENDING_STATS_RSP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsModificationReq: Maximum number of statistics response is pending. \
+ DU_LOG("ERROR --> MAC : MacProcStatsModificationReq: Maximum number of statistics response is pending. \
Cannot process new request.");
MacRejectAllStatsModification(macStatsModificationReq, RESOURCE_UNAVAILABLE);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsModificationReq, sizeof(MacStatsModificationReq));
MAC_ALLOC(schStatsModificationReq, sizeof(SchStatsModificationReq));
if(schStatsModificationReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcStatsModificationReq: Failed to allocate memory");
+ DU_LOG("ERROR --> MAC : MacProcStatsModificationReq: Failed to allocate memory");
MacRejectAllStatsModification(macStatsModificationReq, RESOURCE_UNAVAILABLE);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsModificationReq, sizeof(MacStatsModificationReq));
return RFAILED;
}
default:
{
- DU_LOG("\nERROR --> MAC : MacProcStatsModificationReq: Invalid measurement type [%d]", \
+ DU_LOG("ERROR --> MAC : MacProcStatsModificationReq: Invalid measurement type [%d]", \
macStatsGrp->statsList[macStatsIdx]);
measTypeInvalid = true;
}
else
{
/* [Step 5] */
- DU_LOG("\nERROR --> MAC : MacProcStatsModificationReq: All statistics group found invalid");
+ DU_LOG("ERROR --> MAC : MacProcStatsModificationReq: All statistics group found invalid");
MAC_FREE(schStatsModificationReq, sizeof(SchStatsModificationReq));
ret = MacSendStatsModificationRspToDuApp(macStatsModificationRsp);
}
if(rxDataIndPdu == NULLP)
{
- DU_LOG("\nERROR --> MAC: Rx Data is empty");
+ DU_LOG("ERROR --> MAC: Rx Data is empty");
return RFAILED;
}
if(macCb.macCell[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> CellId :%d is not created, as CellCB is empty", cellId);
+ DU_LOG("ERROR --> CellId :%d is not created, as CellCB is empty", cellId);
return RFAILED;
}
pduLen = rxDataIndPdu->pduLength;
MAC_ALLOC_SHRABL_BUF(pdu, length);
if(!pdu)
{
- DU_LOG("\nERROR --> MAC : UL CCCH PDU memory allocation failed");
+ DU_LOG("ERROR --> MAC : UL CCCH PDU memory allocation failed");
return RFAILED;
}
rxPduIdx++;
case MAC_LCID_MIN ... MAC_LCID_MAX :
{
- DU_LOG("\nINFO --> MAC : PDU received for LC ID %d", lcId);
+ DU_LOG("INFO --> MAC : PDU received for LC ID %d", lcId);
pduLen--;
rxPduIdx++;
MAC_ALLOC_SHRABL_BUF(pdu, length);
if(!pdu)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed while demuxing Rx Data PDU");
+ DU_LOG("ERROR --> MAC : Memory allocation failed while demuxing Rx Data PDU");
return RFAILED;
}
pduLen--;
}
else
{
- DU_LOG("\nERROR --> MAC: Invalid BsrIdx:%d rcvd for lcgIdx:%d",lcgIdx,rxDataPdu[rxPduIdx]);
+ DU_LOG("ERROR --> MAC: Invalid BsrIdx:%d rcvd for lcgIdx:%d",lcgIdx,rxDataPdu[rxPduIdx]);
}
/*next byte in PDU*/
pduLen--;
default:
{
- DU_LOG("\nERROR --> MAC : Invalid LC Id %d", lcId);
+ DU_LOG("ERROR --> MAC : Invalid LC Id %d", lcId);
return RFAILED;
}
} /* End of switch */
MAC_ALLOC(tbInfo->tb, tbSize);
if(!tbInfo->tb)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for TB in updateTbInDlHqProcCb");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for TB in updateTbInDlHqProcCb");
return RFAILED;
}
memcpy(tbInfo->tb, txPdu, tbSize);
{
uint16_t cellIdx;
CrcIndInfo crcIndInfo;
- DU_LOG("\nDEBUG --> MAC : Received CRC indication");
+ DU_LOG("DEBUG --> MAC : Received CRC indication");
GET_CELL_IDX(crcInd->cellId, cellIdx);
/* Considering one pdu and one preamble */
crcIndInfo.cellId = macCb.macCell[cellIdx]->cellId;
{
uint8_t ueId = 0;
uint16_t pduIdx, cellIdx = 0;
- DU_LOG("\nDEBUG --> MAC : Received Rx Data indication");
+ DU_LOG("DEBUG --> MAC : Received Rx Data indication");
/* TODO : compare the handle received in RxDataInd with handle send in PUSCH
* PDU, which is stored in raCb */
if(macCb.macCell[cellIdx] && macCb.macCell[cellIdx]->ueCb[ueId -1].transmissionAction == STOP_TRANSMISSION)
{
- DU_LOG("\nINFO --> MAC : UL data transmission not allowed for UE %d", macCb.macCell[cellIdx]->ueCb[ueId -1].ueId);
+ DU_LOG("INFO --> MAC : UL data transmission not allowed for UE %d", macCb.macCell[cellIdx]->ueCb[ueId -1].ueId);
}
else
{
DlRlcBoInfo dlBoInfo;
memset(&macDlData , 0, sizeof(MacDlData));
- DU_LOG("\nDEBUG --> MAC: Received DL data for sfn=%d slot=%d numPdu= %d", \
+ DU_LOG("DEBUG --> MAC: Received DL data for sfn=%d slot=%d numPdu= %d", \
dlData->slotInfo.sfn, dlData->slotInfo.slot, dlData->numPdu);
GET_UE_ID(dlData->rnti, ueId);
/* Store DL data in the scheduled slot */
if(macCb.macCell[cellIdx] ==NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcRlcDlData(): macCell does not exists");
+ DU_LOG("ERROR --> MAC : MacProcRlcDlData(): macCell does not exists");
return RFAILED;
}
currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlData->slotInfo.slot];
MAC_ALLOC(txPdu, txPduLen);
if(!txPdu)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcRlcDlData");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in MacProcRlcDlData");
return RFAILED;
}
macMuxPdu(&macDlData, NULLP, txPdu, txPduLen);
MAC_ALLOC_SHRABL_BUF(ulData, sizeof(RlcUlData));
if(!ulData)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed while sending UL data to RLC");
+ DU_LOG("ERROR --> MAC : Memory allocation failed while sending UL data to RLC");
return RFAILED;
}
memset(ulData, 0, sizeof(RlcUlData));
MAC_ALLOC_SHRABL_BUF(schedRpt, sizeof(RlcSchedResultRpt));
if(!schedRpt)
{
- DU_LOG("\nERROR --> MAC: Memory allocation failure in sendSchResultRepToRlc");
+ DU_LOG("ERROR --> MAC: Memory allocation failure in sendSchResultRepToRlc");
return RFAILED;
}
- DU_LOG("\nDEBUG --> MAC: Send scheduled result report for sfn %d slot %d", slotInfo.sfn, slotInfo.slot);
+ DU_LOG("DEBUG --> MAC: Send scheduled result report for sfn %d slot %d", slotInfo.sfn, slotInfo.slot);
schedRpt->cellId = dlInfo.cellId;
schedRpt->slotInfo.sfn = slotInfo.sfn;
schedRpt->slotInfo.slot = slotInfo.slot;
FILL_PST_MAC_TO_RLC(pst, RLC_DL_INST, EVENT_SCHED_RESULT_TO_RLC);
if(MacSendSchedResultRptToRlc(&pst, schedRpt) != ROK)
{
- DU_LOG("\nERROR --> MAC: Failed to send Schedule result report to RLC");
+ DU_LOG("ERROR --> MAC: Failed to send Schedule result report to RLC");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, schedRpt, sizeof(RlcSchedResultRpt));
return RFAILED;
}
* ****************************************************************/
uint8_t MacProcCellStart(Pst *pst, CellStartInfo *cellStart)
{
- DU_LOG("\nINFO --> MAC : Handling cell start request");
+ DU_LOG("INFO --> MAC : Handling cell start request");
#ifndef NFAPI_ENABLED
gConfigInfo.gSlotCount = 0;
sendEventToLowerMacFsm(START_REQUEST, 0, cellStart);
#ifdef INTEL_FAPI
uint16_t cellIdx;
- DU_LOG("\nINFO --> MAC : Sending cell stop request to Lower Mac");
+ DU_LOG("INFO --> MAC : Sending cell stop request to Lower Mac");
GET_CELL_IDX(cellStop->cellId, cellIdx);
if(macCb.macCell[cellIdx])
{
DlRlcBoInfo dlBoInfo;
memset(&dlBoInfo, 0, sizeof(DlRlcBoInfo));
- DU_LOG("\nDEBUG --> MAC : Handling DL CCCH IND");
+ DU_LOG("DEBUG --> MAC : Handling DL CCCH IND");
GET_CELL_IDX(dlCcchIndInfo->cellId, cellIdx);
MAC_ALLOC_SHRABL_BUF(ulCcchIndInfo, sizeof(UlCcchIndInfo));
if(!ulCcchIndInfo)
{
- DU_LOG("\nERROR --> MAC: Memory failed in macProcUlCcchInd");
+ DU_LOG("ERROR --> MAC: Memory failed in macProcUlCcchInd");
return RFAILED;
}
if(MacDuAppUlCcchInd(&pst, ulCcchIndInfo) != ROK)
{
- DU_LOG("\nERROR --> MAC: Failed to send UL CCCH Ind to DU APP");
+ DU_LOG("ERROR --> MAC: Failed to send UL CCCH Ind to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo));
ret = RFAILED;
case UCI_IND_PUCCH_F0F1:
{
{
- DU_LOG("\nDEBUG --> MAC : Received HARQ UCI Indication\n");
+ DU_LOG("DEBUG --> MAC : Received HARQ UCI Indication\n");
GET_CELL_IDX(macUciInd->cellId, cellIdx);
buildAndSendHarqInd(&macUciInd->pdus[pduIdx].uci.uciPucchF0F1.harqInfo, macUciInd->pdus[pduIdx].uci.uciPucchF0F1.crnti, cellIdx, &macUciInd->slotInd);
}
if(macUciInd->pdus[pduIdx].uci.uciPucchF0F1.srInfo.srIndPres)
{
- DU_LOG("\nDEBUG --> MAC : Received SR UCI indication");
+ DU_LOG("DEBUG --> MAC : Received SR UCI indication");
crnti = macUciInd->pdus[pduIdx].uci.uciPucchF0F1.crnti;
ret = buildAndSendSrInd(macUciInd, crnti);
}
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nERROR --> MAC: Invalid Pdu Type %d at FapiMacUciInd", macUciInd->pdus[pduIdx].pduType);
+ DU_LOG("ERROR --> MAC: Invalid Pdu Type %d at FapiMacUciInd", macUciInd->pdus[pduIdx].pduType);
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nERROR --> MAC: Received Uci Ind is NULL at FapiMacUciInd()");
+ DU_LOG("ERROR --> MAC: Received Uci Ind is NULL at FapiMacUciInd()");
ret = RFAILED;
}
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macUciInd, sizeof(UciInd));
MAC_ALLOC(schSliceCfgReq->listOfSlices, schSliceCfgReq->numOfConfiguredSlice *sizeof(SchRrmPolicyOfSlice*));
if(schSliceCfgReq->listOfSlices == NULLP)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
return RFAILED;
}
cfgIdx = 0;
MAC_ALLOC(schSliceCfgReq->listOfSlices[cfgIdx], sizeof(SchRrmPolicyOfSlice));
if(schSliceCfgReq->listOfSlices[cfgIdx] == NULLP)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
return RFAILED;
}
Pst schPst;
SchSliceCfgReq *schSliceCfgReq;
- DU_LOG("\nINFO --> MAC : Received Slice Cfg request from DU APP");
+ DU_LOG("INFO --> MAC : Received Slice Cfg request from DU APP");
if(macSliceCfgReq)
{
MAC_ALLOC(schSliceCfgReq, sizeof(SchSliceCfgReq));
if(schSliceCfgReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceCfgReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in MacProcSliceCfgReq");
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nINFO --> MAC : Received MacSliceCfgReq is NULL");
+ DU_LOG("INFO --> MAC : Received MacSliceCfgReq is NULL");
}
return ret;
}
Pst schPst;
SchSliceRecfgReq *schSliceRecfgReq;
- DU_LOG("\nINFO --> MAC : Received Slice ReCfg request from DU APP");
+ DU_LOG("INFO --> MAC : Received Slice ReCfg request from DU APP");
if(macSliceRecfgReq)
{
MAC_ALLOC(schSliceRecfgReq, sizeof(SchSliceRecfgReq));
if(schSliceRecfgReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceRecfgReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in MacProcSliceRecfgReq");
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nINFO --> MAC : Received MacSliceRecfgReq is NULL");
+ DU_LOG("INFO --> MAC : Received MacSliceRecfgReq is NULL");
}
return ret;
}
MacStatsInd *macStatsInd;
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> MAC : MacProcSchStatsInd: Received Statistics Indication from SCH");
+ DU_LOG("DEBUG --> MAC : MacProcSchStatsInd: Received Statistics Indication from SCH");
#endif
if(schStatsInd == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcSchStatsInd: NULL pointer :schStatsInd");
+ DU_LOG("ERROR --> MAC : MacProcSchStatsInd: NULL pointer :schStatsInd");
return RFAILED;
}
MAC_ALLOC_SHRABL_BUF(macStatsInd, sizeof(MacStatsInd));
if(macStatsInd == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchStatsInd");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory in MacProcSchStatsInd");
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> MAC : MacProcSchStatsInd: Invalid measurement type [%d]", \
+ DU_LOG("ERROR --> MAC : MacProcSchStatsInd: Invalid measurement type [%d]", \
schStatsInd->measuredStatsList[statsIdx].type);
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsInd, sizeof(MacStatsInd));
return RFAILED;
break;
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
break;
}
default:
- DU_LOG("\nERROR --> MAC: Invalid LCID %d in mac pdu",lcid);
+ DU_LOG("ERROR --> MAC: Invalid LCID %d in mac pdu",lcid);
break;
}
}
}
default:
- DU_LOG("\nERROR --> MAC: Invalid LCID %d in mac pdu",lcid);
+ DU_LOG("ERROR --> MAC: Invalid LCID %d in mac pdu",lcid);
break;
}
}
ueIdx = getFreeBitFromUeBitMap(rachIndInfo->cellId);
if(ueIdx == -1)
{
- DU_LOG("\nERROR --> MAC : Failed to find free UE Idx in UE bit map of cell Id [%d]", rachIndInfo->cellId);
+ DU_LOG("ERROR --> MAC : Failed to find free UE Idx in UE bit map of cell Id [%d]", rachIndInfo->cellId);
return RFAILED;
}
RachIndInfo *rachIndInfo = NULLP;
MacCellCb *cellCb = NULLP;
- DU_LOG("\nINFO --> MAC : Received RACH indication");
+ DU_LOG("INFO --> MAC : Received RACH indication");
/* Considering one pdu and one preamble */
pduIdx = 0;
preambleIdx = 0;
if(!cellCb)
{
- DU_LOG("\nERROR --> MAC : Invalid Cell ID [%d] received in RACH Indication", rachInd->cellId);
+ DU_LOG("ERROR --> MAC : Invalid Cell ID [%d] received in RACH Indication", rachInd->cellId);
return RFAILED;
}
MAC_ALLOC(rachIndInfo, sizeof(RachIndInfo));
if(!rachIndInfo)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failure in fapiMacRachInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failure in fapiMacRachInd");
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd));
return RFAILED;
}
MacUeCb *ueCb = NULLP;
SchRachRsrcReq *schRachRsrcReq = NULLP;
- DU_LOG("\nINFO --> MAC : Recieved RACH Resource Request for Cell ID [%d] UE ID [%d]",\
+ DU_LOG("INFO --> MAC : Recieved RACH Resource Request for Cell ID [%d] UE ID [%d]",\
rachRsrcReq->cellId, rachRsrcReq->ueId);
/* Fetch Cell Cb */
ret = SchMessageRouter(&schPst, (void *)schRachRsrcReq);
}
else
- DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource request to SCH");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for RACH resource request to SCH");
}
else
- DU_LOG("\nERROR --> MAC : UE ID [%d] not found", rachRsrcReq->ueId);
+ DU_LOG("ERROR --> MAC : UE ID [%d] not found", rachRsrcReq->ueId);
}
else
- DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", rachRsrcReq->cellId);
+ DU_LOG("ERROR --> MAC : Cell ID [%d] not found", rachRsrcReq->cellId);
/* Free sharable buffer used to send RACH reource request from DU APP to MAC */
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachRsrcReq, sizeof(MacRachRsrcReq));
MacCellCb *cellCb = NULLP;
MacUeCb *ueCb = NULLP;
- DU_LOG("\nINFO --> MAC : Received RACH resource response from SCH : Cell ID [%d] CRNTI [%d]", \
+ DU_LOG("INFO --> MAC : Received RACH resource response from SCH : Cell ID [%d] CRNTI [%d]", \
schRachRsrcRsp->cellId, schRachRsrcRsp->crnti);
/* Fill RACH resource response to send to DU APP */
MAC_ALLOC_SHRABL_BUF(rachRsrcRsp, sizeof(MacRachRsrcRsp));
if(!rachRsrcRsp)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource response");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for RACH resource response");
MAC_FREE(schRachRsrcRsp, sizeof(SchRachRsrcRsp));
return RFAILED;
}
/* If negative response is received from SCH, send it further to DU APP */
if(schRachRsrcRsp->result == RSP_NOK)
{
- DU_LOG("\nINFO --> MAC : RACH Resource response from SCH : Result [FAILURE]");
+ DU_LOG("INFO --> MAC : RACH Resource response from SCH : Result [FAILURE]");
rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
}
else
{
- DU_LOG("\nINFO --> MAC : RACH Resource response from SCH : Result [SUCCESS]");
+ DU_LOG("INFO --> MAC : RACH Resource response from SCH : Result [SUCCESS]");
/* Fetch Cell Cb */
GET_CELL_IDX(schRachRsrcRsp->cellId, cellIdx);
ueCb = &cellCb->ueCb[rachRsrcRsp->ueId-1];
else
{
- DU_LOG("\nERROR --> MAC : CRNTI [%d] not found", schRachRsrcRsp->crnti);
+ DU_LOG("ERROR --> MAC : CRNTI [%d] not found", schRachRsrcRsp->crnti);
rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
}
}
else
{
- DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", schRachRsrcRsp->cellId);
+ DU_LOG("ERROR --> MAC : Cell ID [%d] not found", schRachRsrcRsp->cellId);
rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
}
}
MacUeCb *ueCb = NULLP;
SchRachRsrcRel *schRachRsrcRel = NULLP;
- DU_LOG("\nINFO --> MAC : Recieved RACH Resource Release for Cell ID [%d] UE ID [%d]",\
+ DU_LOG("INFO --> MAC : Recieved RACH Resource Release for Cell ID [%d] UE ID [%d]",\
rachRsrcRel->cellId, rachRsrcRel->ueId);
/* Fetch Cell Cb */
ret = SchMessageRouter(&schPst, (void *)schRachRsrcRel);
}
else
- DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource release to SCH");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for RACH resource release to SCH");
}
else
- DU_LOG("\nERROR --> MAC : UE ID [%d] not found", rachRsrcRel->ueId);
+ DU_LOG("ERROR --> MAC : UE ID [%d] not found", rachRsrcRel->ueId);
}
else
- DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", rachRsrcRel->cellId);
+ DU_LOG("ERROR --> MAC : Cell ID [%d] not found", rachRsrcRel->cellId);
/* Free sharable buffer used to send RACH reource release from DU APP to MAC */
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachRsrcRel, sizeof(MacRachRsrcRel));
uint16_t cellIdx;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UL_SCH_INFO\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_UL_SCH_INFO\n");
#endif
GET_CELL_IDX(ulSchedInfo->cellId, cellIdx);
DlHarqProcCb *hqProcCb = NULLP;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_SCH_INFO\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_DL_SCH_INFO\n");
#endif
if(dlSchedInfo != NULLP)
{
MAC_ALLOC(txPdu, txPduLen);
if(!txPdu)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcDlAlloc");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in MacProcDlAlloc");
return RFAILED;
}
memcpy(txPdu, retxTb, txPduLen);
MacDlSlot *currDlSlot = NULLP;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_PAGING_ALLOC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_DL_PAGING_ALLOC\n");
#endif
if(dlPageAlloc != NULLP)
{
MAC_ALLOC(currDlSlot->pageAllocInfo, sizeof(DlPageAlloc));
if(currDlSlot->pageAllocInfo == NULLP)
{
- DU_LOG("\nERROR --> MAC : MacProcDlPageAlloc : Memory Allocation is failed!");
+ DU_LOG("ERROR --> MAC : MacProcDlPageAlloc : Memory Allocation is failed!");
return RFAILED;
}
memcpy(currDlSlot->pageAllocInfo, dlPageAlloc, sizeof(DlPageAlloc));
}
else
{
- DU_LOG("\nERROR --> MAC : DL Paging Allocation is failed!");
+ DU_LOG("ERROR --> MAC : DL Paging Allocation is failed!");
return RFAILED;
}
return ROK;
if(macCb.macCell[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> MAC: Cell Id[%d] not found", cellId);
+ DU_LOG("ERROR --> MAC: Cell Id[%d] not found", cellId);
return;
}
}
else
{
- DU_LOG("\nERROR --> MAC: Failed allocating memory for msg4TxPdu");
+ DU_LOG("ERROR --> MAC: Failed allocating memory for msg4TxPdu");
}
/* Free memory allocated */
MAC_FREE(msg4DlData.pduInfo[msg4DlData.numPdu-1].dlPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen);
}
else
{
- DU_LOG("\nERROR --> MAC: Failed at fillMsg4Pdu()");
+ DU_LOG("ERROR --> MAC: Failed at fillMsg4Pdu()");
}
}
MAC_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId));
if(!oduCellId)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed for cell up indication");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for cell up indication");
return RFAILED;
}
oduCellId->cellId = cellId;
ret = MacDuAppCellUpInd(&pst, oduCellId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC: Failed to send cell up indication to DU APP");
+ DU_LOG("ERROR --> MAC: Failed to send cell up indication to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, oduCellId, sizeof(OduCellId));
}
MAC_ALLOC_SHRABL_BUF(slotIndInfo, sizeof(SlotTimingInfo));
if(!slotIndInfo)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed for slot indication");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for slot indication");
return RFAILED;
}
memcpy(slotIndInfo, slotInd,sizeof(SlotTimingInfo));
ret = MacDuAppSlotInd(&pst, slotIndInfo);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC: Failed to send slot up indication to DU APP");
+ DU_LOG("ERROR --> MAC: Failed to send slot up indication to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, slotIndInfo, sizeof(SlotTimingInfo));
}
volatile uint32_t startTime=0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> MAC : Slot Indication received. [%d : %d]", slotInd->sfn, slotInd->slot);
+ DU_LOG("DEBUG --> MAC : Slot Indication received. [%d : %d]", slotInd->sfn, slotInd->slot);
#endif
/*starting Task*/
ODU_START_TASK(&startTime, PID_MAC_TTI_IND);
ret = sendSlotIndMacToSch(slotInd);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : Sending of slot ind msg from MAC to SCH failed");
+ DU_LOG("ERROR --> MAC : Sending of slot ind msg from MAC to SCH failed");
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotTimingInfo));
return ret;
}
ret = macProcSlotInd(*slotInd);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : macProcSlotInd failed");
+ DU_LOG("ERROR --> MAC : macProcSlotInd failed");
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotTimingInfo));
return ret;
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC :Sending of slot ind msg from MAC to DU APP failed");
+ DU_LOG("ERROR --> MAC :Sending of slot ind msg from MAC to DU APP failed");
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotTimingInfo));
return ret;
}
MAC_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId));
if(!oduCellId)
{
- DU_LOG("\nERROR --> MAC : Stop Indication memory allocation failed");
+ DU_LOG("ERROR --> MAC : Stop Indication memory allocation failed");
return RFAILED;
}
oduCellId->cellId = cellId;
ret = MacDuAppStopInd(&pst, oduCellId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC: Failed to send stop indication to DU APP");
+ DU_LOG("ERROR --> MAC: Failed to send stop indication to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, oduCellId, sizeof(OduCellId));
}
return ROK;
MAC_ALLOC_SHRABL_BUF(ueSyncStatusInd, sizeof(MacUeSyncStatusInd));
if(!ueSyncStatusInd)
{
- DU_LOG("\nERROR --> MAC : Memory allocation for UE Sync Status Indication failed");
+ DU_LOG("ERROR --> MAC : Memory allocation for UE Sync Status Indication failed");
return RFAILED;
}
schedReqCfg->addModListCount = macCellGrp.schReqCfg.addModListCount;
if(schedReqCfg->addModListCount > MAX_NUM_SR_CFG_PER_CELL_GRP)
{
- DU_LOG("\nERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
+ DU_LOG("ERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
schedReqCfg->addModListCount, MAX_NUM_SR_CFG_PER_CELL_GRP);
return RFAILED;
}
tagCfg->addModListCount = macCellGrp.tagCfg.addModListCount;
if(tagCfg->addModListCount > MAX_NUM_TAGS)
{
- DU_LOG("\nERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
+ DU_LOG("ERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
tagCfg->addModListCount, MAX_NUM_TAGS);
return RFAILED;
}
MAC_ALLOC(schPdschCfg->maxMimoLayers, sizeof(uint8_t));
if(!schPdschCfg->maxMimoLayers)
{
- DU_LOG("\nERROR --> MAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()");
+ DU_LOG("ERROR --> MAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
if(!schPdschCfg->maxCodeBlkGrpPerTb)
{
- DU_LOG("\nERROR --> MAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()");
+ DU_LOG("ERROR --> MAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool));
if(!schPdschCfg->codeBlkGrpFlushInd)
{
- DU_LOG("\nERROR --> MAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()");
+ DU_LOG("ERROR --> MAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead));
if(!schPdschCfg->xOverhead)
{
- DU_LOG("\nERROR --> MAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()");
+ DU_LOG("ERROR --> MAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
schPuschCfg->numTimeDomRsrcAlloc = macPuschCfg.numTimeDomRsrcAlloc;
if(schPuschCfg->numTimeDomRsrcAlloc > MAX_NUM_UL_ALLOC)
{
- DU_LOG("\nERROR --> MAC : Number of Time domain resource allocation [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of Time domain resource allocation [%d] exceeds max limit [%d]",\
schPuschCfg->numTimeDomRsrcAlloc, MAX_NUM_UL_ALLOC);
return RFAILED;
}
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0, sizeof(SchPucchFormat0));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format0 in fillResrcList()");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for Format0 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0->initialCyclicShift =\
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1, sizeof(SchPucchFormat1));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format1 in fillResrcList()");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for Format1 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1->initialCyclicShift =\
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format2, sizeof(SchPucchFormat2_3));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format2 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format2 in fillResrcList()");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for Format2 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format2->numPrbs =\
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format3, sizeof(SchPucchFormat2_3));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format3 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format3 in fillResrcList()");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for Format3 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format3->numPrbs =\
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format4, sizeof(SchPucchFormat4));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format4 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format4 in fillResrcList()");
+ DU_LOG("ERROR --> MAC : Failed to allocate memory for Format4 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format4->numSymbols =\
MAC_ALLOC(schPucchCfg->format1, sizeof(SchPucchFormatCfg));
if(schPucchCfg->format1 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 1 in fillOtherPucchFormatCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Format 1 in fillOtherPucchFormatCfg()");
return RFAILED;
}
fillPucchFormatCfg(macFormatCfg, schPucchCfg->format1);
MAC_ALLOC(schPucchCfg->format2, sizeof(SchPucchFormatCfg));
if(schPucchCfg->format2 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 2 in fillOtherPucchFormatCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Format 2 in fillOtherPucchFormatCfg()");
return RFAILED;
}
fillPucchFormatCfg(macFormatCfg, schPucchCfg->format2);
MAC_ALLOC(schPucchCfg->format3, sizeof(SchPucchFormatCfg));
if(schPucchCfg->format3 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 3 in fillOtherPucchFormatCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Format 3 in fillOtherPucchFormatCfg()");
return RFAILED;
}
fillPucchFormatCfg(macFormatCfg, schPucchCfg->format3);
MAC_ALLOC(schPucchCfg->format4, sizeof(SchPucchFormatCfg));
if(schPucchCfg->format4 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 4 in fillOtherPucchFormatCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Format 4 in fillOtherPucchFormatCfg()");
return RFAILED;
}
fillPucchFormatCfg(macFormatCfg, schPucchCfg->format4);
break;
}
default:
- DU_LOG("\nERROR --> MAC : Invalid Format Cfg %d in fillInitialUlBwpPucchCfg()", pucchFormat);
+ DU_LOG("ERROR --> MAC : Invalid Format Cfg %d in fillInitialUlBwpPucchCfg()", pucchFormat);
return RFAILED;
}
return ROK;
MAC_ALLOC(schPucchCfg->resrcSet, sizeof(SchPucchResrcSetCfg));
if(schPucchCfg->resrcSet == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Resrc set List in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Resrc set List in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->resrcSet, 0, sizeof(SchPucchResrcSetCfg));
MAC_ALLOC(schPucchCfg->resrc, sizeof(SchPucchResrcCfg));
if(schPucchCfg->resrc == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Resrc List in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for Resrc List in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->resrc, 0, sizeof(SchPucchResrcCfg));
if((fillResrcList(macPucchCfg->resrc, schPucchCfg->resrc)) != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed in fillResrcList() at fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed in fillResrcList() at fillInitialUlBwpPucchCfg()");
return RFAILED;
}
}
MAC_ALLOC(schPucchCfg->schedReq, sizeof(SchPucchSchedReqCfg));
if(schPucchCfg->schedReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for PucchSchedReqCfg in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for PucchSchedReqCfg in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->schedReq, 0, sizeof(SchPucchSchedReqCfg));
MAC_ALLOC(schPucchCfg->multiCsiCfg, sizeof(SchPucchMultiCsiCfg));
if(schPucchCfg->multiCsiCfg == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for multiCsiCfg in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for multiCsiCfg in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->multiCsiCfg, 0, sizeof(SchPucchMultiCsiCfg));
MAC_ALLOC(schPucchCfg->dlDataToUlAck, sizeof(SchPucchDlDataToUlAck));
if(schPucchCfg->dlDataToUlAck == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for dlDataToUlAck in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for dlDataToUlAck in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->dlDataToUlAck, 0, sizeof(SchPucchDlDataToUlAck));
MAC_ALLOC(schPucchCfg->powerControl, sizeof(SchPucchPowerControl));
if(schPucchCfg->powerControl == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate Mem for powerControl in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to allocate Mem for powerControl in fillInitialUlBwpPucchCfg()");
return RFAILED;
}
memset(schPucchCfg->powerControl, 0, sizeof(SchPucchPowerControl));
memset(&schInitUlBwp->pucchCfg, 0, sizeof(SchPucchCfg));
if(fillInitialUlBwpPucchCfg(&macInitUlBwp.pucchCfg, &schInitUlBwp->pucchCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to fill Pucch Cfg in fillInitialUlBwpPucchCfg()");
+ DU_LOG("ERROR --> MAC : Failed to fill Pucch Cfg in fillInitialUlBwpPucchCfg()");
freeUlBwpPucchCfg(&schInitUlBwp->pucchCfg);
return RFAILED;
}
memset(&schInitUlBwp->puschCfg, 0, sizeof(SchPuschCfg));
if(fillInitalUlBwpPuschCfg(macInitUlBwp.puschCfg, &schInitUlBwp->puschCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to fill Pusch Cfg in fillInitalUlBwpPuschCfg()");
+ DU_LOG("ERROR --> MAC : Failed to fill Pusch Cfg in fillInitalUlBwpPuschCfg()");
return RFAILED;
}
}
schPdcchCfg->numCRsetToAddMod = macPdcchCfg.numCRsetToAddMod;
if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
{
- DU_LOG("\nERROR --> MAC : Number of CORESET to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of CORESET to ADD/MOD [%d] exceeds max limit [%d]",\
schPdcchCfg->numCRsetToAddMod, MAX_NUM_CRSET);
return RFAILED;
}
schPdcchCfg->numCRsetToRel = macPdcchCfg.numCRsetToRel;
if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
{
- DU_LOG("\nERROR --> MAC : Number of CORESET to release [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of CORESET to release [%d] exceeds max limit [%d]",\
schPdcchCfg->numCRsetToRel, MAX_NUM_CRSET);
return RFAILED;
}
schPdcchCfg->numSearchSpcToAddMod = macPdcchCfg.numSearchSpcToAddMod;
if(schPdcchCfg->numSearchSpcToAddMod > MAX_NUM_SEARCH_SPC)
{
- DU_LOG("\nERROR --> MAC : Number of search space to ADD/MOD [%d] exceeds max [%d]", \
+ DU_LOG("ERROR --> MAC : Number of search space to ADD/MOD [%d] exceeds max [%d]", \
schPdcchCfg->numSearchSpcToAddMod, MAX_NUM_SEARCH_SPC);
return RFAILED;
}
schPdcchCfg->numSearchSpcToRel = macPdcchCfg.numSearchSpcToRel;
if(schPdcchCfg->numSearchSpcToRel > MAX_NUM_SEARCH_SPC)
{
- DU_LOG("\nERROR --> MAC : Number of search space to release [%d] exceeds max [%d]", \
+ DU_LOG("ERROR --> MAC : Number of search space to release [%d] exceeds max [%d]", \
schPdcchCfg->numSearchSpcToRel, MAX_NUM_SEARCH_SPC);
return RFAILED;
}
schPdschCfg->numTimeDomRsrcAlloc = macPdschCfg.numTimeDomRsrcAlloc;
if(schPdschCfg->numTimeDomRsrcAlloc > MAX_NUM_DL_ALLOC)
{
- DU_LOG("\nERROR --> MAC : Number of time domain resource allocation [%d], exceeds\
+ DU_LOG("ERROR --> MAC : Number of time domain resource allocation [%d], exceeds\
max limit [%d]", schPdschCfg->numTimeDomRsrcAlloc, MAX_NUM_DL_ALLOC);
return RFAILED;
}
MAC_ALLOC(schPdschCfg->timeDomRsrcAllociList[idx].k0, sizeof(uint8_t));
if(!schPdschCfg->timeDomRsrcAllociList[idx].k0)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed for K0 in fillInitDlBwpPdschCfg()");
+ DU_LOG("ERROR --> MAC : Memory allocation failed for K0 in fillInitDlBwpPdschCfg()");
return RFAILED;
}
*(schPdschCfg->timeDomRsrcAllociList[idx].k0) = *(macPdschCfg.timeDomRsrcAllociList[idx].k0);
{
if(fillInitDlBwpPdcchCfg(macInitDlBwp.pdcchCfg, &schInitDlBwp->pdcchCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillInitDlBwpPdcchCfg() failed");
+ DU_LOG("ERROR --> MAC : fillInitDlBwpPdcchCfg() failed");
return RFAILED;
}
}
{
if(fillInitDlBwpPdschCfg(macInitDlBwp.pdschCfg,&schInitDlBwp->pdschCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillInitDlBwpPdschCfg() failed");
+ DU_LOG("ERROR --> MAC : fillInitDlBwpPdschCfg() failed");
return RFAILED;
}
}
if(fillInitialDlBwp(macSpCellCfg.servCellCfg.initDlBwp, \
&servCellCfg->initDlBwp) != ROK )
{
- DU_LOG("\nERROR --> MAC : fillInitialDlBwp() failed");
+ DU_LOG("ERROR --> MAC : fillInitialDlBwp() failed");
return RFAILED;
}
servCellCfg->numDlBwpToAdd = macSpCellCfg.servCellCfg.numDlBwpToAdd;
if(servCellCfg->numDlBwpToAdd > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of DL BWP to ADD [%d] exceeds max limit [%d]",\
servCellCfg->numDlBwpToAdd, MAX_NUM_BWP);
return RFAILED;
}
if(fillPdschServCellCfg(macSpCellCfg.servCellCfg.pdschServCellCfg, \
&servCellCfg->pdschServCellCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillPdschServCellCfg() failed");
+ DU_LOG("ERROR --> MAC : fillPdschServCellCfg() failed");
return RFAILED;
}
if(fillInitialUlBwp(macSpCellCfg.servCellCfg.initUlBwp, \
&servCellCfg->initUlBwp) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillInitialUlBwp() failed");
+ DU_LOG("ERROR --> MAC : fillInitialUlBwp() failed");
return RFAILED;
}
servCellCfg->numUlBwpToAdd = macSpCellCfg.servCellCfg.numUlBwpToAdd;
if(servCellCfg->numUlBwpToAdd > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of UL BWP to ADD [%d] exceeds max limit [%d]",\
servCellCfg->numUlBwpToAdd, MAX_NUM_BWP);
return RFAILED;
}
if(fillInitialDlBwp(macSpCellRecfg.servCellCfg.initDlBwp, \
&servCellRecfg->initDlBwp) != ROK )
{
- DU_LOG("\nERROR --> MAC : fillInitialDlBwp() failed");
+ DU_LOG("ERROR --> MAC : fillInitialDlBwp() failed");
return RFAILED;
}
servCellRecfg->numDlBwpToAddOrMod = macSpCellRecfg.servCellCfg.numDlBwpToAddOrMod;
if(servCellRecfg->numDlBwpToAddOrMod > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
servCellRecfg->numDlBwpToAddOrMod, MAX_NUM_BWP);
return RFAILED;
}
servCellRecfg->numDlBwpToRel = macSpCellRecfg.servCellCfg.numDlBwpToRel;
if(servCellRecfg->numDlBwpToRel > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of DL BWP to RELEASE [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of DL BWP to RELEASE [%d] exceeds max limit [%d]",\
servCellRecfg->numDlBwpToRel, MAX_NUM_BWP);
return RFAILED;
}
if(fillPdschServCellCfg(macSpCellRecfg.servCellCfg.pdschServCellCfg, \
&servCellRecfg->pdschServCellCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillPdschServCellCfg() failed");
+ DU_LOG("ERROR --> MAC : fillPdschServCellCfg() failed");
return RFAILED;
}
if(fillInitialUlBwp(macSpCellRecfg.servCellCfg.initUlBwp, \
&servCellRecfg->initUlBwp) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillInitialUlBwp() failed");
+ DU_LOG("ERROR --> MAC : fillInitialUlBwp() failed");
return RFAILED;
}
servCellRecfg->numUlBwpToAddOrMod = macSpCellRecfg.servCellCfg.numUlBwpToAddOrMod;
if(servCellRecfg->numUlBwpToAddOrMod > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
servCellRecfg->numUlBwpToAddOrMod, MAX_NUM_BWP);
return RFAILED;
}
servCellRecfg->numUlBwpToRel = macSpCellRecfg.servCellCfg.numUlBwpToRel;
if(servCellRecfg->numUlBwpToRel > MAX_NUM_BWP)
{
- DU_LOG("\nERROR --> MAC : Number of UL BWP to RELEASE [%d] exceeds max limit [%d]",\
+ DU_LOG("ERROR --> MAC : Number of UL BWP to RELEASE [%d] exceeds max limit [%d]",\
servCellRecfg->numUlBwpToRel, MAX_NUM_BWP);
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> Invalid Pst received %d", pst->event);
+ DU_LOG("ERROR --> Invalid Pst received %d", pst->event);
return RFAILED;
}
}
MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
if(!schLcCfg->drbQos)
{
- DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
+ DU_LOG("ERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
ret = RFAILED;
}
}
MAC_ALLOC(schLcCfg->snssai, sizeof(Snssai));
if(!schLcCfg->snssai)
{
- DU_LOG("\nERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
+ DU_LOG("ERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
ret = RFAILED;
}
}
{
if(fillLogicalChannelCfg(&schUeCfg->schLcCfg[lcIdx], &ueCfg->lcCfgList[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
+ DU_LOG("ERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
return RFAILED;
}
schUeCfg->numLcsToAdd++;
{
if(fillLogicalChannelCfg(&schUeRecfg->schLcCfgAdd[lcIdx], &ueRecfg->lcCfgAdd[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
+ DU_LOG("ERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
return RFAILED;
}
schUeRecfg->numLcsToAdd++;
{
if(fillLogicalChannelCfg(&schUeRecfg->schLcCfgMod[lcIdx], &ueRecfg->lcCfgMod[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
+ DU_LOG("ERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
return RFAILED;
}
schUeRecfg->numLcsToMod++;
memset(&schUeCfg->macCellGrpCfg, 0, sizeof(SchMacCellGrpCfg));
if(fillMacCellGroupCfg(ueCfg->macCellGrpCfg, &schUeCfg->macCellGrpCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillMacCellGroupCfg() failed");
+ DU_LOG("ERROR --> MAC : fillMacCellGroupCfg() failed");
return RFAILED;
}
}
memset(&schUeCfg->phyCellGrpCfg, 0,sizeof(SchPhyCellGrpCfg));
if(fillPhyCellGroupCfg(ueCfg->phyCellGrpCfg, &schUeCfg->phyCellGrpCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillPhyCellGroupCfg() failed");
+ DU_LOG("ERROR --> MAC : fillPhyCellGroupCfg() failed");
return RFAILED;
}
}
memset(&schUeCfg->spCellCfg, 0, sizeof(SchSpCellCfg));
if(fillSpCellCfg(ueCfg->spCellCfg, &schUeCfg->spCellCfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillSpCellCfg() failed");
+ DU_LOG("ERROR --> MAC : fillSpCellCfg() failed");
return RFAILED;
}
}
MAC_ALLOC(schUeCfg->ambrCfg, sizeof(SchAmbrCfg));
if(!schUeCfg->ambrCfg)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
return RFAILED;
}
schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr;
ret = fillSchLcCfgList(schUeCfg, ueCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeCfg()");
+ DU_LOG("ERROR --> MAC : Failed to copy LCs at fillSchUeCfg()");
return ret;
}
memset(&schUeRecfg->macCellGrpRecfg, 0, sizeof(SchMacCellGrpCfg));
if(fillMacCellGroupCfg(ueRecfg->macCellGrpRecfg, &schUeRecfg->macCellGrpRecfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillMacCellGroupRecfg() failed");
+ DU_LOG("ERROR --> MAC : fillMacCellGroupRecfg() failed");
return RFAILED;
}
}
memset(&schUeRecfg->phyCellGrpRecfg, 0,sizeof(SchPhyCellGrpCfg));
if(fillPhyCellGroupCfg(ueRecfg->phyCellGrpRecfg, &schUeRecfg->phyCellGrpRecfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillPhyCellGroupRecfg() failed");
+ DU_LOG("ERROR --> MAC : fillPhyCellGroupRecfg() failed");
return RFAILED;
}
}
memset(&schUeRecfg->spCellRecfg, 0, sizeof(SchSpCellCfg));
if(fillSpCellRecfg(ueRecfg->spCellRecfg, &schUeRecfg->spCellRecfg) != ROK)
{
- DU_LOG("\nERROR --> MAC : fillSpCellRecfg() failed");
+ DU_LOG("ERROR --> MAC : fillSpCellRecfg() failed");
return RFAILED;
}
}
MAC_ALLOC(schUeRecfg->ambrRecfg, sizeof(SchAmbrCfg));
if(!schUeRecfg->ambrRecfg)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
return RFAILED;
}
schUeRecfg->ambrRecfg->ulBr = ueRecfg->ambrRecfg->ulBr;
ret = fillSchLcRecfgList(schUeRecfg, ueRecfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeRecfg()");
+ DU_LOG("ERROR --> MAC : Failed to copy LCs at fillSchUeRecfg()");
return ret;
}
memcpy(ulInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai));
}
#endif
- DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
+ DU_LOG("INFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
ueLcCfg->lcId,ueLcIdx);
break;
}
memset(&ulInfo->lcCb[ueLcIdx], 0, sizeof(UlLcCb));
(ulInfo->numUlLc)--;
updateMacUlCb(ueLcIdx, ulInfo);
- DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel);
+ DU_LOG("INFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel);
break;
}
}
memcpy(dlInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai));
}
#endif
- DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
+ DU_LOG("INFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
ueLcCfg->lcId,ueLcIdx);
break;
}
memset(&dlInfo->lcCb[ueLcIdx], 0, sizeof(DlLcCb));
(dlInfo->numDlLc)--;
updateMacDlCb(ueLcIdx, dlInfo);
- DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel);
+ DU_LOG("INFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel);
break;
}
}
ret = fillMacLcCfgList(ueCb, ueCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at fillMacUeCb()");
+ DU_LOG("ERROR --> MAC: Failed while filing MAC LC List at fillMacUeCb()");
}
return ret;
}
ret = updateMacLcCfgList(ueCb, ueRecfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at updateMacUeCb()");
+ DU_LOG("ERROR --> MAC: Failed while filing MAC LC List at updateMacUeCb()");
}
ueCb->transmissionAction = ueRecfg->transmissionAction;
}
else
{
- DU_LOG("\nERROR --> MAC : No RA CB found for UE ID [%d]", ueCb->ueId);
+ DU_LOG("ERROR --> MAC : No RA CB found for UE ID [%d]", ueCb->ueId);
return RFAILED;
}
return ROK;
if((ueCb->ueId == ueCfg->ueId) && (ueCb->crnti == ueCfg->crnti)\
&&(ueCb->state == UE_STATE_ACTIVE))
{
- DU_LOG("\nERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti);
+ DU_LOG("ERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti);
return ROKDUP;
}
else
ret = fillMacUeCb(ueCb, ueCfg, cellIdx);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to create Ue Cb at createUeCb()");
+ DU_LOG("ERROR --> MAC : Failed to create Ue Cb at createUeCb()");
return ret;
}
else
if((ueCb->ueId == ueRecfg->ueId) && (ueCb->crnti == ueRecfg->crnti)\
&&(ueCb->state == UE_STATE_ACTIVE))
{
- DU_LOG("\nINFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueRecfg->crnti);
+ DU_LOG("INFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueRecfg->crnti);
ret = updateMacUeCb(ueCb, ueRecfg, cellIdx);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to modify MacUeCb at modifyUeCb()");
+ DU_LOG("ERROR --> MAC : Failed to modify MacUeCb at modifyUeCb()");
return ret;
}
else
/* Validate cell id */
if(macCb.macCell[cellIdx]->cellId != cellId)
{
- DU_LOG("\nERROR --> MAC : Cell Id %d not configured", cellId);
+ DU_LOG("ERROR --> MAC : Cell Id %d not configured", cellId);
return RFAILED;
}
/* Check if max number of UE configured */
if(macCb.macCell[cellIdx]->numActvUe > MAX_NUM_UE)
{
- DU_LOG("\nERROR --> MAC : Max number of UE [%d] already configured", MAX_NUM_UE);
+ DU_LOG("ERROR --> MAC : Max number of UE [%d] already configured", MAX_NUM_UE);
return RFAILED;
}
{
ret = createUeCb(cellIdx, ueCb, ueCfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
+ DU_LOG("ERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
break;
}
{
ret = modifyUeCb(cellIdx, ueCb, ueRecfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
+ DU_LOG("ERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
break;
}
MAC_ALLOC(tmpData, sizeof(MacUeCreateReq));
if(!tmpData)
{
- DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()");
+ DU_LOG("ERROR --> MAC: Memory Alloc Failed at copyToTmpData()");
return RFAILED;
}
memcpy(tmpData, ueCfg, sizeof(MacUeCreateReq));
MAC_ALLOC(tmpData, sizeof(MacUeRecfg));
if(!tmpData)
{
- DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()");
+ DU_LOG("ERROR --> MAC: Memory Alloc Failed at copyToTmpData()");
return RFAILED;
}
memcpy(tmpData, ueRecfg, sizeof(MacUeRecfg));
SchUeCfgReq schUeCfg;
memset(&schUeCfg, 0, sizeof(SchUeCfgReq));
- DU_LOG("\nINFO --> MAC : UE Create Request for CRNTI[%d]", ueCfg->crnti);
+ DU_LOG("INFO --> MAC : UE Create Request for CRNTI[%d]", ueCfg->crnti);
if(ueCfg)
{
/*Sending Cfg Req to SCH */
ret = fillSchUeCfg(&schUeCfg, ueCfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
+ DU_LOG("ERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
else
{
/* Fill event and send UE create request to SCH */
ret = sendUeReqToSch(pst, &schUeCfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH");
+ DU_LOG("ERROR --> MAC : Failed to send UE Create request to SCH");
}
}
else
{
- DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG ");
+ DU_LOG("ERROR --> MAC : Failed to store MAC UE CFG ");
}
}
else
{
- DU_LOG("\nERROR --> MAC : MAC UE Create request processing failed");
+ DU_LOG("ERROR --> MAC : MAC UE Create request processing failed");
ret = RFAILED;
}
/* FREE shared memory */
MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCreateRsp));
if(!cfgRsp)
{
- DU_LOG("\nERROR --> MAC: Memory allocation for UE config response failed");
+ DU_LOG("ERROR --> MAC: Memory allocation for UE config response failed");
return RFAILED;
}
MAC_ALLOC_SHRABL_BUF(recfgRsp, sizeof(MacUeRecfgRsp));
if(!recfgRsp)
{
- DU_LOG("\nERROR --> MAC: Memory allocation for UE Reconfig response failed");
+ DU_LOG("ERROR --> MAC: Memory allocation for UE Reconfig response failed");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC: Failed to get macCellCb in getMacUeCfg()");
+ DU_LOG("ERROR --> MAC: Failed to get macCellCb in getMacUeCfg()");
}
return ueCfg;
}
}
else
{
- DU_LOG("\nERROR --> MAC: Failed to get macCellCb in getMacUeRecfg()");
+ DU_LOG("ERROR --> MAC: Failed to get macCellCb in getMacUeRecfg()");
}
return ueRecfg;
}
switch(pst->event)
{
case EVENT_UE_CONFIG_RSP_TO_MAC:
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_CONFIG_RSP_TO_MAC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_UE_CONFIG_RSP_TO_MAC\n");
break;
case EVENT_UE_RECONFIG_RSP_TO_MAC:
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
break;
default:
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : Invalid Event\n");
break;
}
#endif
ueCfg = getMacUeCfg(cellIdx, ueId);
if(ueCfg == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
+ DU_LOG("ERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
ret = RFAILED;
}
if(schCfgRsp->rsp != RSP_NOK)
{
- DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("INFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
if(ret == ROK)
{
ret = procMacUeCfgData(pst, ueCfg, NULLP);
}
else
{
- DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("ERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
}
ret = MacSendUeCreateRsp(result, schCfgRsp);
MAC_FREE(ueCfg, sizeof(MacUeCreateReq));
switch(pst->event)
{
case EVENT_UE_RECONFIG_RSP_TO_MAC:
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
break;
default:
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : Invalid Event\n");
break;
}
#endif
ueRecfg = getMacUeRecfg(cellIdx, ueId);
if(ueRecfg == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
+ DU_LOG("ERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
ret = RFAILED;
}
if(schRecfgRsp->rsp != RSP_NOK)
{
- DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()",\
+ DU_LOG("INFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()",\
schRecfgRsp->crnti);
if(ret == ROK)
{
}
else
{
- DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()",\
+ DU_LOG("ERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()",\
schRecfgRsp->crnti);
}
ret = MacSendUeReconfigRsp(result, schRecfgRsp);
SchUeRecfgReq schUeRecfg;
memset(&schUeRecfg, 0, sizeof(SchUeRecfgReq));
- DU_LOG("\nINFO --> MAC : UE Reconfig Request for CRNTI[%d]", ueRecfg->crnti);
+ DU_LOG("INFO --> MAC : UE Reconfig Request for CRNTI[%d]", ueRecfg->crnti);
if(ueRecfg)
{
/*Sending Cfg Req to SCH */
ret = fillSchUeRecfg(&schUeRecfg, ueRecfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()");
+ DU_LOG("ERROR --> MAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()");
else
{
/* Fill event and send UE Reconfiguration request to SCH */
ret = sendUeReqToSch(pst, &schUeRecfg);
if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to send UE Reconfig Request to SCH");
+ DU_LOG("ERROR --> MAC : Failed to send UE Reconfig Request to SCH");
}
}
else
{
- DU_LOG("\nERROR --> MAC : Failed to store MAC UE Cb ");
+ DU_LOG("ERROR --> MAC : Failed to store MAC UE Cb ");
}
}
else
{
- DU_LOG("\nERROR --> MAC : MAC UE Reconfiguration request processing failed");
+ DU_LOG("ERROR --> MAC : MAC UE Reconfiguration request processing failed");
ret = RFAILED;
}
/* FREE shared memory */
MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacUeDeleteRsp));
if(!deleteRsp)
{
- DU_LOG("\nERROR --> MAC : Memory allocation for UE delete response failed");
+ DU_LOG("ERROR --> MAC : Memory allocation for UE delete response failed");
return RFAILED;
}
DlHarqEnt *dlHarqEnt;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_DELETE_RSP_TO_MAC\n");
+ DU_LOG("Call Flow: ENTSCH -> ENTMAC : EVENT_UE_DELETE_RSP_TO_MAC\n");
#endif
if(schUeDelRsp)
{
if(schUeDelRsp->rsp == RSP_OK)
{
- DU_LOG("\nINFO --> MAC : SCH UE Delete response for CRNTI[%d] is successful", schUeDelRsp->crnti);
+ DU_LOG("INFO --> MAC : SCH UE Delete response for CRNTI[%d] is successful", schUeDelRsp->crnti);
GET_CELL_IDX(schUeDelRsp->cellId, cellIdx);
if(macCb.macCell[cellIdx])
{
if(!isCrntiValid)
{
/*C-RNTI value is out of Acceptable range*/
- DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): Invalid crnti[%d] ",schUeDelRsp->crnti);
+ DU_LOG("ERROR --> MAC : MacProcSchUeDeleteRsp(): Invalid crnti[%d] ",schUeDelRsp->crnti);
status = UEID_INVALID;
}
else
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti);
+ DU_LOG("ERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti);
status = UEID_INVALID;
}
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): cellId[%d] does not exist ",schUeDelRsp->cellId);
+ DU_LOG("ERROR --> MAC : MacProcSchUeDeleteRsp(): cellId[%d] does not exist ",schUeDelRsp->cellId);
status = CELLID_INVALID;
}
}
if(MacSendUeDeleteRsp(schUeDelRsp->cellId, schUeDelRsp->crnti, status) != ROK)
{
- DU_LOG("\nERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to send UE delete response");
+ DU_LOG("ERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to send UE delete response");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to receive UE delete response by SCH");
+ DU_LOG("ERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to receive UE delete response by SCH");
ret = RFAILED;
}
return ret;
}
else
{
- DU_LOG("\nERROR --> SCH: sendUeDelReqToSch():MAC Ue Delete is NULL");
+ DU_LOG("ERROR --> SCH: sendUeDelReqToSch():MAC Ue Delete is NULL");
return RFAILED;
}
return ROK;
MacUeCb *ueCb = NULLP;
MacCellCb *cellCb = NULLP;
- DU_LOG("\nINFO --> MAC : UE Delete Request received for ueId[%d]", ueDelete->ueId);
+ DU_LOG("INFO --> MAC : UE Delete Request received for ueId[%d]", ueDelete->ueId);
if(ueDelete)
{
ret = sendUeDelReqToSch(pst, ueDelete);
if(ret != ROK)
{
- DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to send UE Delete Request to SCH");
+ DU_LOG("ERROR --> MAC : MacProcUeDeleteReq(): Failed to send UE Delete Request to SCH");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): CRNTI is not matched");
+ DU_LOG("ERROR --> MAC : MacProcUeDeleteReq(): CRNTI is not matched");
status = UEID_INVALID;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeId = %d",ueDelete->ueId);
+ DU_LOG("ERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeId = %d",ueDelete->ueId);
status = CELLID_INVALID;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): MAC UE delete request processing failed");
+ DU_LOG("ERROR --> MAC : MacProcUeDeleteReq(): MAC UE delete request processing failed");
ret = RFAILED;
}
return ret;
MAC_ALLOC_SHRABL_BUF(ResetRsp, sizeof(MacUeResetRsp));
if(!ResetRsp)
{
- DU_LOG("\nERROR --> MAC : Memory allocation for UE Reset response failed");
+ DU_LOG("ERROR --> MAC : Memory allocation for UE Reset response failed");
return RFAILED;
}
MacUeCb *ueCb = NULLP;
MacCellCb *cellCb = NULLP;
- DU_LOG("\nINFO --> MAC : UE Reset Request received for ueId[%d]", ueReset->ueId);
+ DU_LOG("INFO --> MAC : UE Reset Request received for ueId[%d]", ueReset->ueId);
if(ueReset)
{
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): UE ID [%d] not found in Cell Id [%d]", ueCb->ueId , ueReset->cellId);
+ DU_LOG("ERROR --> MAC : MacProcUeResetReq(): UE ID [%d] not found in Cell Id [%d]", ueCb->ueId , ueReset->cellId);
status = UEID_INVALID;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): Cell Id [%d] not found ",ueReset->cellId);
+ DU_LOG("ERROR --> MAC : MacProcUeResetReq(): Cell Id [%d] not found ",ueReset->cellId);
status = CELLID_INVALID;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): MAC UE reset request processing failed");
+ DU_LOG("ERROR --> MAC : MacProcUeResetReq(): MAC UE reset request processing failed");
return RFAILED;
}
return ROK;
#ifdef MEM_SIZE_CHECK
#define MAC_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\n MAC line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG(" MAC line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define MAC_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
CMCHKPK(oduUnpackUInt8, &(p5Hdr->more_segNum), mBuf);
CMCHKPK(oduUnpackUInt8, &(p5Hdr->seq_num), mBuf);
CMCHKPK(oduUnpackUInt32, &(p5Hdr->timeStamp), mBuf);
- DU_LOG("\nINFo --> NFAPI_VNF: seqLen:%d, moreSegNum:%d, seqNum:%d, timeStamp:%d",
+ DU_LOG("INFo --> NFAPI_VNF: seqLen:%d, moreSegNum:%d, seqNum:%d, timeStamp:%d",
p5Hdr->seg_len,p5Hdr->more_segNum,p5Hdr->seq_num,p5Hdr->timeStamp);
}
CMCHKPK(oduUnpackUInt32, &(p7Hdr->tot_SDU_len), mBuf);
CMCHKPK(oduUnpackUInt32, &(p7Hdr->byteOffset), mBuf);
CMCHKPK(oduUnpackUInt32, &(p7Hdr->timeStamp), mBuf);
- DU_LOG("\nINFo --> NFAPI_VNF: se1_num:%d, totSdu len:%u, byteOffset:%u, timeStamp:%u",
+ DU_LOG("INFo --> NFAPI_VNF: se1_num:%d, totSdu len:%u, byteOffset:%u, timeStamp:%u",
p7Hdr->seq_num,p7Hdr->tot_SDU_len, p7Hdr->byteOffset, p7Hdr->timeStamp);
}
CMCHKPK(oduUnpackUInt16, &(msgHdr->msg_id), mBuf);
CMCHKPK(oduUnpackUInt32, &(msgHdr->length), mBuf);
- DU_LOG("\nINFO --> NFAPI_VNF: RUType:%d, phy_id:%d, msgId:%d, len:%d",\
+ DU_LOG("INFO --> NFAPI_VNF: RUType:%d, phy_id:%d, msgId:%d, len:%d",\
msgHdr->sRU_termination_type,msgHdr->phy_id,msgHdr->msg_id,msgHdr->length );
}
}
default:
{
- DU_LOG("\n Incorrect TAG VALUE of NFAPI P5 Messages:%d",tagVal);
+ DU_LOG(" Incorrect TAG VALUE of NFAPI P5 Messages:%d",tagVal);
return RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR -> NFAPI_VNF: P7 CLOCK Act task received Incorrect event:%d",\
+ DU_LOG("ERROR -> NFAPI_VNF: P7 CLOCK Act task received Incorrect event:%d",\
pst->event);
ret = RFAILED;
break;
}
default:
{
- DU_LOG("\nERROR --> NFAPI_VNF: P7 CLOCK Act task received from wrong Entity:%d",\
+ DU_LOG("ERROR --> NFAPI_VNF: P7 CLOCK Act task received from wrong Entity:%d",\
pst->srcEnt);
ret = RFAILED;
break;
vnfDb.vnfP7Info.p7SyncInfo.frameInfo.sfn++;
vnfDb.vnfP7Info.p7SyncInfo.frameInfo.slot++;
- DU_LOG("\nINFO --> VNF_NFAPI : Starting to generate slot indications t_ref:%llu, slotDur:%f, perTTi:%u, slotsPerFrame:%d, nanoSec:%d",\
+ DU_LOG("INFO --> VNF_NFAPI : Starting to generate slot indications t_ref:%llu, slotDur:%f, perTTi:%u, slotsPerFrame:%d, nanoSec:%d",\
vnfDb.vnfP7Info.t_ref_ns, slotDur_ms, PER_TTI_TIME_USEC, NUM_SLOTS_PER_SUBFRAME, tti_req.tv_nsec);
nfapiBuildAndSendDlNodeSync();
}
/*TODO: To enable when P5 messages are all done and implemented*/
if(nfapiSendSlotIndToMac() != ROK)
{
- DU_LOG("\nERROR -> NFAPI_VNF: Memory Corruption issue while sending SLOT IND to MAC");
+ DU_LOG("ERROR -> NFAPI_VNF: Memory Corruption issue while sending SLOT IND to MAC");
break;
}
#endif
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nVNF_NFAPI --> DEBUG: SFN/Slot:%d,%d",\
+ DU_LOG("VNF_NFAPI --> DEBUG: SFN/Slot:%d,%d",\
vnfDb.vnfP7Info.p7SyncInfo.frameInfo.sfn, vnfDb.vnfP7Info.p7SyncInfo.frameInfo.slot);
#endif
clock_nanosleep(CLOCK_REALTIME, 0, &tti_req, NULL);
if(ODU_GET_MSG_BUF(DFLT_REGION, nfapiP7Pst.pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed to allocate memory");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed to allocate memory");
return RFAILED;
}
pst.intfVer = 0;
if(packSlotInd(&pst, slotInd) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF: Unable to Send Slot Ind to MAC");
+ DU_LOG("ERROR --> NFAPI_VNF: Unable to Send Slot Ind to MAC");
NFAPI_P7_CLK_FREE_SHRABL_BUF(pst.region, pst.pool, slotInd, sizeof(SlotTimingInfo));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Memory allocation failed in procSlotInd");
+ DU_LOG("ERROR --> NFAPI_VNF: Memory allocation failed in procSlotInd");
return RFAILED;
}
return ROK;
if(ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
return RFAILED;
}
* ****************************************************************/
uint8_t nfapiValidatingT1(uint32_t ulNodeSyncT1)
{
- DU_LOG("\nDEBUG --> NFAPI_VNF: t1@VNF:%u, t1_from_pnf:%u",\
+ DU_LOG("DEBUG --> NFAPI_VNF: t1@VNF:%u, t1_from_pnf:%u",\
vnfDb.vnfP7Info.p7SyncInfo.prev_t1, ulNodeSyncT1);
if(vnfDb.vnfP7Info.p7SyncInfo.prev_t1 == ulNodeSyncT1)
{
- DU_LOG("\nINFO --> NFAPI_VNF: T1 matching so this UL Node Sync can be processed");
+ DU_LOG("INFO --> NFAPI_VNF: T1 matching so this UL Node Sync can be processed");
return ROK;
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Mismatch T1");
+ DU_LOG("ERROR --> NFAPI_VNF: Mismatch T1");
return RFAILED;
}
}
vnfDb.vnfP7Info.p7SyncInfo.inSync = FALSE;
if(cmpStatus == -1)
{ /*PNF is ahead.*/
- DU_LOG("\nINFO --> NFAPI_VNF: PNF is ahead.");
+ DU_LOG("INFO --> NFAPI_VNF: PNF is ahead.");
CALC_TIME_DIFF(t3_sfnSlot, vnfDb.vnfP7Info.p7SyncInfo.frameInfo, numSlotDiff);
}
else if(cmpStatus == 1)
{
- DU_LOG("\nINFO --> NFAPI_VNF: VNF is ahead.");
+ DU_LOG("INFO --> NFAPI_VNF: VNF is ahead.");
CALC_TIME_DIFF(vnfDb.vnfP7Info.p7SyncInfo.frameInfo, t3_sfnSlot, numSlotDiff);
}
vnfDb.vnfP7Info.p7SyncInfo.delta_sfn_slot = cmpStatus * numSlotDiff;
ret = nfapiBuildAndSendDlNodeSync();
}
- DU_LOG("\nDEBUG --> NFAPI_VNF: delta:%d insyn:%d", vnfDb.vnfP7Info.p7SyncInfo.delta_sfn_slot, vnfDb.vnfP7Info.p7SyncInfo.inSync);
+ DU_LOG("DEBUG --> NFAPI_VNF: delta:%d insyn:%d", vnfDb.vnfP7Info.p7SyncInfo.delta_sfn_slot, vnfDb.vnfP7Info.p7SyncInfo.inSync);
return ret;
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: T1 Validation failed");
+ DU_LOG("ERROR --> NFAPI_VNF: T1 Validation failed");
return RFAILED;
}
return ret;
{
case TAG_NFAPI_UL_NODE_SYNC:
{
- DU_LOG("\nINFO --> NFAPI_VNF: Received UL Node Synch");
+ DU_LOG("INFO --> NFAPI_VNF: Received UL Node Synch");
nfapiP7ProcUlNodeSync(mBuf);
break;
}
default:
{
- DU_LOG("\nERROR --> NFAPI_VNF: Wrong MsgId:%d", msgHdr.msg_id);
+ DU_LOG("ERROR --> NFAPI_VNF: Wrong MsgId:%d", msgHdr.msg_id);
return RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR -> NFAPI_VNF: UDP Act task received Incorrect event:%d",\
+ DU_LOG("ERROR -> NFAPI_VNF: UDP Act task received Incorrect event:%d",\
pst->event);
ret = RFAILED;
break;
{
case EVTSTARTNFAPIP7POLL:
{
- DU_LOG("\nINFO --> VNF_NFAPI:Start Polling");
+ DU_LOG("INFO --> VNF_NFAPI:Start Polling");
nfapiP7UdpRecvMsg();
ODU_PUT_MSG_BUF(mBuf);
break;
}
default:
{
- DU_LOG("\nERROR -> NFAPI_VNF: UDP Act task received Incorrect event:%d",\
+ DU_LOG("ERROR -> NFAPI_VNF: UDP Act task received Incorrect event:%d",\
pst->event);
ret = RFAILED;
break;
}
default:
{
- DU_LOG("\nERROR --> NFAPI_VNF: UDP Act task received from wrong Entity:%d",\
+ DU_LOG("ERROR --> NFAPI_VNF: UDP Act task received from wrong Entity:%d",\
pst->srcEnt);
ret = RFAILED;
break;
}
else
{
- DU_LOG("\nINFO --> MAC : Received NfapiP7UdpCfg is NULL");
+ DU_LOG("INFO --> MAC : Received NfapiP7UdpCfg is NULL");
ret = RFAILED;
}
return ret;
ret = cmInetSocket(sockType, &(vnfDb.p7TransInfo.sockFd), CM_INET_PROTO_UDP);
if(ret != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed to open UDP socket");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed to open UDP socket");
return ret;
}
ret = cmInetBind(&(vnfDb.p7TransInfo.sockFd), &(vnfDb.p7TransInfo.srcIpNetAddr));
if(ret != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed to bind socket");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed to bind socket");
return ret;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed to allocate memory");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed to allocate memory");
return RFAILED;
}
Pst nfapiP7Pst; /* Self post */
uint8_t sockType; /* Socket type */
- DU_LOG("\nDEBUG --> NFAPI_VNF : Received NFAPI P7's UDP open Client request");
+ DU_LOG("DEBUG --> NFAPI_VNF : Received NFAPI P7's UDP open Client request");
sockType = CM_INET_DGRAM;
ret = nfapiP7UdpCliOpenPrc(sockType);
/* Opening and Binding receiver socket */
if(ret != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed while opening receiver transport server");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed while opening receiver transport server");
return ret;
}
- DU_LOG("\nDEBUG --> NFAPI_VNF : Socket [%d] is open", vnfDb.p7TransInfo.sockFd.fd);
+ DU_LOG("DEBUG --> NFAPI_VNF : Socket [%d] is open", vnfDb.p7TransInfo.sockFd.fd);
/* Start Socket polling */
memset(&nfapiP7Pst, 0, sizeof(nfapiP7Pst));
packNfapiP7UdpStartPollingReq(&nfapiP7Pst);
/*Trigger P7 Clock as well */
- DU_LOG("\nDEBUG --> NFAPI_VNF : Triggering Clock");
+ DU_LOG("DEBUG --> NFAPI_VNF : Triggering Clock");
nfapiTriggerP7Clock();
return ret;
}
ret = cmInetRecvMsg(&vnfDb.p7TransInfo.sockFd, &vnfDb.p7TransInfo.destIpNetAddr, &memInfo, &recvBuf, (int16_t *)&bufLen, CM_INET_NO_FLAG);
if(ret == ROK && recvBuf != NULLP)
{
- DU_LOG("\nDEBUG --> NFAPI_VNF : Received P7 Message\n");
+ DU_LOG("DEBUG --> NFAPI_VNF : Received P7 Message\n");
nfapiP7MsgHandler(recvBuf);
ODU_PUT_MSG_BUF(recvBuf);
info.region = NFAPI_UDP_P7_MEM_REGION;
info.pool = NFAPI_UDP_P7_POOL;
- DU_LOG("\n udp sending: add:0x%x, port:%d", vnfDb.p7TransInfo.destIpNetAddr.address, vnfDb.p7TransInfo.destIpNetAddr.port );
+ DU_LOG(" udp sending: add:0x%x, port:%d", vnfDb.p7TransInfo.destIpNetAddr.address, vnfDb.p7TransInfo.destIpNetAddr.port );
ret = cmInetSendMsg(&vnfDb.p7TransInfo.sockFd, &vnfDb.p7TransInfo.destIpNetAddr, &info, mBuf, (int16_t *)&txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Failed sending the message");
+ DU_LOG("ERROR --> NFAPI_VNF : Failed sending the message");
return RFAILED;
}
else
{
- DU_LOG("\nDEBUG --> NFAPI_VNF : Sent NFAPI P7 Message [%ld]", numDataSent+1);
+ DU_LOG("DEBUG --> NFAPI_VNF : Sent NFAPI P7 Message [%ld]", numDataSent+1);
numDataSent++;
}
{
uint32_t version = 0;
- DU_LOG("\nINFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
+ DU_LOG("INFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
CMCHKPK(oduUnpackUInt32, &(version), msg);
- DU_LOG("\nINFO --> NFAPI_VNF: PNF_READY_IND version:%d",version);
+ DU_LOG("INFO --> NFAPI_VNF: PNF_READY_IND version:%d",version);
sendEventToNfapiVnfFsm(PNF_PARAM_REQ, NULLP, NULLP, NULLP);
return ROK;
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfParamReq");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t errorCode = 1,idx=0,numtlv=0;
nFapi_pnf_param_general paramGeneral;
- DU_LOG("\nINFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
+ DU_LOG("INFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
CMCHKPK(oduUnpackUInt8, &(errorCode), msg);
if(errorCode != NFAPI_MSG_OK)
{
- DU_LOG("\nERROR --> NFAPI_VNF: Param response error code is not okay, errCode:%d", errorCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Param response error code is not okay, errCode:%d", errorCode);
return RFAILED;
}
CMCHKPK(oduUnpackUInt16, ¶mGeneral.numRfInstances, msg);
CMCHKPK(oduUnpackUInt16, ¶mGeneral.numDfeInstances, msg);
- DU_LOG("\nINFO --> NFAPI_VNF: PNF_PARAM_RESP errCode:%d, numtlv:%d",errorCode,numtlv);
+ DU_LOG("INFO --> NFAPI_VNF: PNF_PARAM_RESP errCode:%d, numtlv:%d",errorCode,numtlv);
sendEventToNfapiVnfFsm(PNF_CONFIG_REQ, NULLP, NULLP, NULLP);
return ROK;
}
{
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfConfigReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfConfigReq");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
nfapiFillMsgHdr(mBuf, NFAPI_P5_PHY_ID, TAG_NFAPI_PNF_CONFIG_REQ, 0);
CMCHKPK(oduPackPostUInt8, 0, mBuf);
- DU_LOG("\nINFO --> NFAPI_VNF: Sending config request");
+ DU_LOG("INFO --> NFAPI_VNF: Sending config request");
FILL_PST_LWR_MAC_TO_DUAPP(pst, EVENT_PNF_DATA);
return ODU_POST_TASK(&pst, mBuf);
}
uint8_t nfapi_vnf_procPnfConfigRespEvt(nFapi_p5_hdr *p5Hdr, nFapi_msg_header *msgHdr, void *msg)
{
uint8_t errCode = 0;
- DU_LOG("\nINFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
+ DU_LOG("INFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
CMCHKPK(oduUnpackUInt8, &(errCode), msg);
if(errCode == NFAPI_MSG_OK)
{
vnfDb.pnfStateAtVnf=PNF_STATE_CONFIGURED;
- DU_LOG("\nINFO --> NFAPI_VNF: PNF STATE[%d]",vnfDb.pnfStateAtVnf);
+ DU_LOG("INFO --> NFAPI_VNF: PNF STATE[%d]",vnfDb.pnfStateAtVnf);
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Config response error code is not okay, errCode:%d", errCode);
return RFAILED;
}
sendEventToNfapiVnfFsm(PNF_START_REQ, NULLP, NULLP, NULLP);
if(vnfDb.pnfStateAtVnf != PNF_STATE_RUNNING)
{
- DU_LOG("\nINFO --> NFAPI_VNF: Building the Pnf start request");
+ DU_LOG("INFO --> NFAPI_VNF: Building the Pnf start request");
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfStartReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfStartReq");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t nfapi_vnf_procPnfStartRespEvt(nFapi_p5_hdr *p5Hdr, nFapi_msg_header *msgHdr, void *msg)
{
uint8_t errCode = 0;
- DU_LOG("\nINFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
+ DU_LOG("INFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
CMCHKPK(oduUnpackUInt8, &(errCode), msg);
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Start response error code is not okay, errCode:%d", errCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Start response error code is not okay, errCode:%d", errCode);
return RFAILED;
}
return ROK;
Buffer *mBuf = NULLP;
Pst pst;
- DU_LOG("\nINFO --> NFAPI_VNF: Building the Pnf stop request");
+ DU_LOG("INFO --> NFAPI_VNF: Building the Pnf stop request");
if (ODU_GET_MSG_BUF(MAC_MEM_REGION, MAC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_VNF : Memory allocation failed in packPnfStopReq");
+ DU_LOG("ERROR --> NFAPI_VNF : Memory allocation failed in packPnfStopReq");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t nfapi_vnf_procPnfStopRespEvt(nFapi_p5_hdr *p5Hdr, nFapi_msg_header *msgHdr, void *msg)
{
uint8_t errCode = 0;
- DU_LOG("\nINFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
+ DU_LOG("INFO --> NFAPI_VNF: Received EVENT[%d] at STATE[%d]",\
vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
CMCHKPK(oduUnpackUInt8, &(errCode), msg);
if(errCode == NFAPI_MSG_OK)
{
vnfDb.pnfStateAtVnf=PNF_STATE_CONFIGURED;
- DU_LOG("\nINFO --> NFAPI_VNF: PNF STATE[%d]",vnfDb.pnfStateAtVnf);
+ DU_LOG("INFO --> NFAPI_VNF: PNF STATE[%d]",vnfDb.pnfStateAtVnf);
}
else
{
- DU_LOG("\nERROR --> NFAPI_VNF: Stop response error code is not okay, errCode:%d", errCode);
+ DU_LOG("ERROR --> NFAPI_VNF: Stop response error code is not okay, errCode:%d", errCode);
return RFAILED;
}
* ****************************************************************/
uint8_t TriggerPnfRestartProcedure()
{
- DU_LOG("\nINFO --> NFAPI_VNF: Build and send PNF Restart procedure");
+ DU_LOG("INFO --> NFAPI_VNF: Build and send PNF Restart procedure");
vnfDb.pnfToRestart = true;
sendEventToNfapiVnfFsm(PNF_STOP_REQ, NULLP, NULLP, NULLP);
* ****************************************************************/
uint8_t TriggerPnfReconfigureProcedure()
{
- DU_LOG("\nINFO --> NFAPI_VNF: Build and send PNF Recfg procedure");
+ DU_LOG("INFO --> NFAPI_VNF: Build and send PNF Recfg procedure");
vnfDb.pnfToReconfigure = true;
sendEventToNfapiVnfFsm(PNF_STOP_REQ, NULLP, NULLP, NULLP);
* ****************************************************************/
uint8_t nfapi_vnf_procInvalidEvt(nFapi_p5_hdr *p5Hdr, nFapi_msg_header *msgHdr, void *msg)
{
- DU_LOG("\nINFO --> NFAPI_VNF: Invalid Msg received EVENT[%d] at STATE[%d]",\
+ DU_LOG("INFO --> NFAPI_VNF: Invalid Msg received EVENT[%d] at STATE[%d]",\
vnfDb.pnfEvent, vnfDb.pnfStateAtVnf);
return ROK;
}
ret = nFapiEvtHdlr[vnfDb.pnfStateAtVnf][vnfDb.pnfEvent](p5Hdr, msgHdr, msg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> NFAPI_VNF: NFAPI_VNF FSM failed");
+ DU_LOG("ERROR --> NFAPI_VNF: NFAPI_VNF FSM failed");
}
}
ssGetDBufOfSize(mInfo->region,_size, &_padBuf); \
if (_padBuf == NULLP) \
{ \
- DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_CEHDR_FAIL");\
+ DU_LOG("ERROR --> MAC : RGERR_MUX_BLD_CEHDR_FAIL");\
return RFAILED;\
} \
if (mInfo->endptr == NULLP) { \
#define RG_NULL_CHECK(_inst, _ptr ) \
if((_ptr) == NULLP) \
{ \
- DU_LOG("\nERROR --> MAC : Null Pointer detected");\
+ DU_LOG("ERROR --> MAC : Null Pointer detected");\
SExit();\
}
#define RG_ARRAY_BOUND_CHECK(_inst, _array, _idxVal) \
if((_idxVal) >= (sizeof(_array)/sizeof(_array[0]))) \
{ \
- DU_LOG("\nERROR --> MAC : Array Bound Check Failed");\
+ DU_LOG("ERROR --> MAC : Array Bound Check Failed");\
SExit();\
}
#else
- DU_LOG("\nINFO --> MAC : Received CfgReq for MAC layer, Entity = %d, Instance = %d", pst->srcEnt, pst->srcInst);
+ DU_LOG("INFO --> MAC : Received CfgReq for MAC layer, Entity = %d, Instance = %d", pst->srcEnt, pst->srcInst);
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
default:
ret = LCM_PRIM_NOK;
reason = LCM_REASON_INVALID_ELMNT;
- DU_LOG("\nERROR --> MAC : Invalid Elmnt=%d",
+ DU_LOG("ERROR --> MAC : Invalid Elmnt=%d",
cfg->hdr.elmId.elmnt);
break;
}
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
RgMiLrgStsCfm(&cfmPst,&cfm);
- DU_LOG("\nERROR --> MAC : Gen Cfg not done");
+ DU_LOG("ERROR --> MAC : Gen Cfg not done");
return ROK;
}
default:
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
- DU_LOG("\nERROR --> MAC : Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
+ DU_LOG("ERROR --> MAC : Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
break;
}
RgMiLrgStsCfm(&cfmPst,&cfm);
(cfg->s.rguSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- DU_LOG("\nERROR --> MAC : unsupported Selector value for RGU");
+ DU_LOG("ERROR --> MAC : unsupported Selector value for RGU");
break;
}
upSapCb = &(rgCb[inst].rguSap[cfg->s.rguSap.spId]);
(cfg->s.crgSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- DU_LOG("\nERROR --> MAC : unsupported Selector value for CRG");
+ DU_LOG("ERROR --> MAC : unsupported Selector value for CRG");
break;
}
if(rgCb[inst].crgSap.sapSta.sapState == LRG_NOT_CFG)
(cfg->s.tfuSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- DU_LOG("\nERROR --> MAC : unsupported Selector value for TFU");
+ DU_LOG("ERROR --> MAC : unsupported Selector value for TFU");
break;
}
#endif
if ((cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_TC) &&
(cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
{
- DU_LOG("\nERROR --> MAC : unsupported Selector value for RGU");
+ DU_LOG("ERROR --> MAC : unsupported Selector value for RGU");
return (LCM_REASON_INVALID_PAR_VAL);
}
/* Update the Pst structure for LM interface */
if(cfg->s.genCfg.numRguSaps == 0)
{
- DU_LOG("\nERROR --> MAC : rgGenCfg(): Invalid numRguSap.\n");
+ DU_LOG("ERROR --> MAC : rgGenCfg(): Invalid numRguSap.\n");
return RFAILED;
}
MAC_ALLOC(rgCb[inst].rguSap, sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps);
if(rgCb[inst].rguSap == NULLP)
{
- DU_LOG("\nERROR --> MAC : rgGenCfg(): Failed to allocate mem for RGU SAP's.\n");
+ DU_LOG("ERROR --> MAC : rgGenCfg(): Failed to allocate mem for RGU SAP's.\n");
return RFAILED;
}
rgCb[inst].numRguSaps = cfg->s.genCfg.numRguSaps;
if(ODU_REG_TMR_MT(ENTMAC, macCb.macInst, macCb.tmrRes, macActvTmr) != ROK)
{
- DU_LOG("\nERROR --> MAC : Failed to register timer");
+ DU_LOG("ERROR --> MAC : Failed to register timer");
MAC_FREE(rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
}
break;
default:
- DU_LOG("\nERROR --> MAC : Invalid tmrEvnt=%d",tmrEvnt);
+ DU_LOG("ERROR --> MAC : Invalid tmrEvnt=%d",tmrEvnt);
ret = RFAILED;
break;
}
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
- DU_LOG("\nDEBUG --> MAC : SAP Not Configured");
+ DU_LOG("DEBUG --> MAC : SAP Not Configured");
ret = RgUiRguBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
- DU_LOG("\nDEBUG --> MAC : SAP Not yet bound");
+ DU_LOG("DEBUG --> MAC : SAP Not yet bound");
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_BND;
rgCb[inst].rguSap[spId].sapCfg.suId = suId;
/* Send Bind Confirm with status as SUCCESS */
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
- DU_LOG("\nDEBUG --> MAC : SAP already bound");
+ DU_LOG("DEBUG --> MAC : SAP already bound");
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP State:RgUiRguBndReq failed\n");
+ DU_LOG("ERROR --> MAC : Invalid SAP State:RgUiRguBndReq failed\n");
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP Id:RgUiRguBndReq failed\n");
+ DU_LOG("ERROR --> MAC : Invalid SAP Id:RgUiRguBndReq failed\n");
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
switch(rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is already bound*/
- DU_LOG("\nDEBUG --> MAC : SAP already bound");
+ DU_LOG("DEBUG --> MAC : SAP already bound");
/* setting SAP state to UN BOUND */
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguUbndReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP State:%d RgUiRguUbndReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP Id:RgUiRguUbndReq failed\n");
+ DU_LOG("ERROR --> MAC : Invalid SAP Id:RgUiRguUbndReq failed\n");
#endif
return RFAILED;
}
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiRguBndCfm Failed ");
+ DU_LOG("ERROR --> MAC : RgUiRguBndCfm Failed ");
return (ret);
}
return (ret);
#ifndef NO_ERRCLS
if (measReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : Input Response Buffer is NULL");
+ DU_LOG("ERROR --> MAC : Input Response Buffer is NULL");
return RFAILED;
}
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
- DU_LOG("\nERROR --> MAC : SAP is already bound");
+ DU_LOG("ERROR --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
+ DU_LOG("ERROR --> MAC : Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
#endif
return RFAILED;
}
ret = rgROML2MUlThrpMeasReq(inst,measReq);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : Processing Of Meas Request Failed");
+ DU_LOG("ERROR --> MAC : Processing Of Meas Request Failed");
}
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo));
{
S16 ret = ROK;
- DU_LOG("\nINFO --> MAC : rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd);
+ DU_LOG("INFO --> MAC : rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd);
ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId,
staInd);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiRguDStaInd Failed");
+ DU_LOG("ERROR --> MAC : RgUiRguDStaInd Failed");
return (ret);
}
return (ret);
staInd);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiRguCStaInd Failed");
+ DU_LOG("ERROR --> MAC : RgUiRguCStaInd Failed");
return (ret);
}
return (ret);
datInd);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiRguDdatInd Failed");
+ DU_LOG("ERROR --> MAC : RgUiRguDdatInd Failed");
return (ret);
}
#else
{
S16 ret = ROK;
- DU_LOG("\nDEBUG --> MAC : rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd);
+ DU_LOG("DEBUG --> MAC : rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd);
rguUlSap->sapSts.numPduTxmit++;
- DU_LOG("\nDEBUG --> MAC : rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId);
+ DU_LOG("DEBUG --> MAC : rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId);
ret = RgUiRguCDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
datInd);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiRguCDatInd Failed");
+ DU_LOG("ERROR --> MAC : RgUiRguCDatInd Failed");
return (ret);
}
return (ret);
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
- DU_LOG("\nDEBUG --> MAC : SAP Not Configured");
+ DU_LOG("DEBUG --> MAC : SAP Not Configured");
ret = RgUiCrgBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
- DU_LOG("\nERROR --> MAC : SAP Not yet bound");
+ DU_LOG("ERROR --> MAC : SAP Not yet bound");
rgCb[inst].crgSap.sapSta.sapState = LRG_BND;
rgCb[inst].crgSap.sapCfg.suId = suId;
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
- DU_LOG("\nDEBUG --> MAC : SAP is already bound");
+ DU_LOG("DEBUG --> MAC : SAP is already bound");
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgBndReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP State:%d RgUiCrgBndReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgBndReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP Id:%d RgUiCrgBndReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
{
case LRG_BND: /* SAP is already bound*/
/* setting SAP state to UN BOUND */
- DU_LOG("\nDEBUG --> MAC : SAP is already bound");
+ DU_LOG("DEBUG --> MAC : SAP is already bound");
rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgUbndReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP State:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgUbndReq failed",
+ DU_LOG("ERROR --> MAC : Invalid SAP Id:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
return RFAILED;
if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiCrgBndCfm Failed ");
+ DU_LOG("ERROR --> MAC : RgUiCrgBndCfm Failed ");
return RFAILED;
}
ret = RgUiCrgCfgCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, transId, status);
if (ret != ROK)
{
- DU_LOG("\nERROR --> MAC : RgUiCrgCfgCfm Failed ");
+ DU_LOG("ERROR --> MAC : RgUiCrgCfgCfm Failed ");
return (ret);
}
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
- DU_LOG("\nERROR --> MAC : Unable to Allocate Buffer");
+ DU_LOG("ERROR --> MAC : Unable to Allocate Buffer");
return RFAILED;
}
if (data != NULLP)
{
- DU_LOG("\nERROR --> MAC : rgFreeSBuf failed.\n");
+ DU_LOG("ERROR --> MAC : rgFreeSBuf failed.\n");
return;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed");
return;
}
#endif /* ERRCLASS & ERRCLS_RES */
nackSnInfo->sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- DU_LOG("\nDEBUG --> RLC_DL : soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
retx->amHdr.so, retx->soEnd,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (datCfm == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
if(mAckSn > mTxNext)
{
- DU_LOG("\nERROR --> RLC_DL : Invalid ACK SN = %d received. Current Vta =%d"
+ DU_LOG("ERROR --> RLC_DL : Invalid ACK SN = %d received. Current Vta =%d"
"UEID:%d CELLID:%d",
pStaPdu->ackSn,
RLC_AMDL.txNextAck,
nackSnInfo.nackRange = pStaPdu->nackInfo[idx].nackRange;
nackSnInfo.sn = pStaPdu->nackInfo[idx].sn;
- DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
nackSnInfo.sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
if ((mNackSn > mAckSn) || (mNackSn >= mTxNext))
{
/* Erroneous NACK_SN, we should raise an error towards L3 */
- DU_LOG("\nERROR --> RLC_DL : Status Pdu is not correct UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Status Pdu is not correct UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
{
rlcStatusAckCnt++;
/* For All ACKs */
- DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
{
if(datCfm->numSduIds > 1024)
{
- DU_LOG("\nDEBUG --> RLC_DL : Sending [%u] SDU Cfms to PDCP & [%u] lost for"
+ DU_LOG("DEBUG --> RLC_DL : Sending [%u] SDU Cfms to PDCP & [%u] lost for"
"UEID:%d CELLID:%d",
datCfm->numSduIds,
datCfm->numSduIds-1024,
#if (ERRCLASS & ERRCLS_ADD_RES)
if (sdu == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
+ DU_LOG("ERROR --> RLC_DL : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
* queue */
if (RLC_AMDL.nxtTx == NULLP)
{
- DU_LOG("\nDEBUG --> RLC_DL : rlcAmmQSdu: Received SDU will be transmitted next \
+ DU_LOG("DEBUG --> RLC_DL : rlcAmmQSdu: Received SDU will be transmitted next \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
RLC_AMDL.nxtTx = sdu;
}
}
else
{
- DU_LOG("\nERROR --> RLC_DL : rlcAmmProcessSdus: Miscomputation of control Bo. \
+ DU_LOG("ERROR --> RLC_DL : rlcAmmProcessSdus: Miscomputation of control Bo. \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
}
RLC_AMDL.cntrlBo = 0;
{
uint8_t pollBit;
- DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: Send retx buf without segmentation "
+ DU_LOG("INFO --> RLC_DL : rlcResegRetxPdus: Send retx buf without segmentation "
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
if (retx->yetToConst)
/* Segment this pdu / portion of pdu. Insert this segment into */
/* retxLst and update offset */
- DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
+ DU_LOG("INFO --> RLC_DL : rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* Eliminate fixed header size if the pdu is segmented for the */
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tNode == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
amDl->retxBo -= retx->segSz;
}
#ifndef ALIGN_64BIT
- DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %ld"
+ DU_LOG("INFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %ld"
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#else
- DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %d "
+ DU_LOG("INFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %d "
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#endif
#if (ERRCLASS & ERRCLS_ADD_RES)
if (discSduInfo == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
/* store the info for sending it to PDCP */
if(discSduInfo->numSduIds > 500)
{
- DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: This is a big error, we shouldn't be here"
+ DU_LOG("ERROR --> RLC_DL : rlcAssembleSdus: This is a big error, we shouldn't be here"
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
break;
}
/** Check for window stall when you are creating a new PDU */
if (RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
- DU_LOG("\nINFO --> RLC_DL : Window stalled \n");
+ DU_LOG("INFO --> RLC_DL : Window stalled \n");
gRlcStats.amRlcStats.numRlcAmCellWinStall++;
break;
}
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
}
- DU_LOG("\nDEBUG --> RLC_DL : rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
amDl->bo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask;
- DU_LOG("\nINFO --> RLC_DL : rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
+ DU_LOG("INFO --> RLC_DL : rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
amDl->pollSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* kw005.201: Fix for poll retransmission timer.
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*datCfm == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
return;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (staInd == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
return;
if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : UeId [%d]: UeCb not found RBID;%d",
+ DU_LOG("ERROR --> RLC_DL : UeId [%d]: UeCb not found RBID;%d",
rlcId.ueId,
rlcId.rbId);
return;
if (txBuf != NULLP)
{
- DU_LOG("\nDEBUG --> RLC_DL : rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
+ DU_LOG("DEBUG --> RLC_DL : rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
"with sn = %d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if ((txBuf != NULLP))
{
- DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* set ACK SN */
{
- DU_LOG("\nINFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"\
+ DU_LOG("INFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"\
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0xF00)>> 8;
/* set ACK SN */
{
- DU_LOG("\nINFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"
+ DU_LOG("INFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId,rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0x3C000) >> 14;
else
{
/* ERROR Log */
- DU_LOG("\nERROR --> RLC_DL : rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
+ DU_LOG("ERROR --> RLC_DL : rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
UEID:%d CELLID:%d", rbCb->m.amDl.snLen, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
if( ROK != rlcDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
- DU_LOG("\nERROR --> RLC_DL : RLC UECb Not found...\n");
+ DU_LOG("ERROR --> RLC_DL : RLC UECb Not found...\n");
return RFAILED;
}
if(ROK != SExamMsg((Data *)(&fByte),
rlcSdu, 0))
{
- DU_LOG("\nERROR --> RLC_DL : Failure in Rlc Hdr SExamMsg\n");
+ DU_LOG("ERROR --> RLC_DL : Failure in Rlc Hdr SExamMsg\n");
return RFAILED;
}
/* For missing PDUs */
if ((NULLP == recBuf) && nackCnt < RLC_MAX_NACK_CNT )
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing PDU's SN = %d UEID:%d \
+ DU_LOG("ERROR --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing PDU's SN = %d UEID:%d \
CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
pStatusPdu,
&prevNackSn);
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing byte segment's"
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing byte segment's"
" SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d \
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d \
UEID:%d CELLID:%d", seqSo, seg->amHdr.so - 1, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
pStatusPdu,
&prevNackSn);
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing (last) byte "
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Missing (last) byte "
"segment's SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d\
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d\
UEID:%d CELLID:%d", seqSo, RLC_ALL_BYTES_MISSING, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
pStatusPdu->ackSn = sn;
}
- DU_LOG("\nINFO --> RLC_UL : rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
+ DU_LOG("INFO --> RLC_UL : rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d", pStatusPdu->ackSn, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
&rbCb->rlcId,
pStatusPdu) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Failed to Send Sta Pdu UEID:%d \
+ DU_LOG("ERROR --> RLC_UL : rlcAmmUlAssembleCntrlInfo: Failed to Send Sta Pdu UEID:%d \
CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
sapCb->pst.pool,
amUl = &RLC_AMUL;
numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU);
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmProcessPdus: numPdu[%d],numPduToProcess[%d] UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmProcessPdus: numPdu[%d],numPduToProcess[%d] UEID:%d CELLID:%d",
numPdu, numPduToProcess, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
while (numPdu < numPduToProcess)
if (! pdu)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmProcessPdus: Null Pdu UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : rlcAmmProcessPdus: Null Pdu UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
gCb->genSts.errorPdusRecv++;
break;
a single pointer */
if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : rlcAmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
gCb->genSts.errorPdusRecv++;
}
if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so))
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmProcessPdus: Dropping PDU because SO can't be zero\
+ DU_LOG("ERROR --> RLC_UL : rlcAmmProcessPdus: Dropping PDU because SO can't be zero\
for last segment sn:%u UEID:%d CELLID:%d", amHdr.sn, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
{
ODU_GET_MSG_LEN(pdu, &pduSz);
snssaiTputNode->dataVol += (uint64_t)pduSz;
- DU_LOG("\nINFO --> RLC_UL: SNSSAI AMM_UL List PduLen:%d, lcId:%d, total :%ld",\
+ DU_LOG("INFO --> RLC_UL: SNSSAI AMM_UL List PduLen:%d, lcId:%d, total :%ld",\
pduSz, rbCb->lch.lChId, snssaiTputNode->dataVol);
}
}
{
amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask));
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
amUl->rxNextHighestRcvd, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
}
{
if ((NULLP == recBuf) || (!recBuf->allRcvd))
{
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxHighestStatus:%d "
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxHighestStatus:%d "
"UEID:%d CELLID:%d",
tSn,
rbCb->rlcId.ueId,
{
rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REASSEMBLE_TMR);
tmrRunning = FALSE;
- DU_LOG("\nINFO --> RLC_UL: rlcAmmProcessPdus: Stopped ReAssembly Timer rxNextStatusTigger = %d"
+ DU_LOG("INFO --> RLC_UL: rlcAmmProcessPdus: Stopped ReAssembly Timer rxNextStatusTigger = %d"
"rxNextReassembly = %d", amUl->rxNextStatusTrig, amUl->rxNext);
}
}
rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REASSEMBLE_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxNextStatusTrig = %d"
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmProcessPdus: Updated rxNextStatusTrig = %d"
"UEID:%d CELLID:%d", amUl->rxNextStatusTrig, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
/* check if LI is zero */
if (! hdrInfo.val)
{
- DU_LOG("\nERROR --> RLC_UL : Received LI as 0");
+ DU_LOG("ERROR --> RLC_UL : Received LI as 0");
return RFAILED;
}
/*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/
if(e && (amHdr->numLi >= RLC_MAX_UL_LI))
{
- DU_LOG("\nERROR --> RLC_UL : LI Count [%u] exceeds Max LI Count[%u]",
+ DU_LOG("ERROR --> RLC_UL : LI Count [%u] exceeds Max LI Count[%u]",
amHdr->numLi, RLC_MAX_UL_LI);
return RFAILED;
}
if ( totalSz >= pduSz )
{
- DU_LOG("\nERROR --> RLC_UL : SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
+ DU_LOG("ERROR --> RLC_UL : SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
amHdr->sn, totalSz, pduSz);
return RFAILED;
}
/* D/C has been shifted in the calling function */
if (hdrInfo.hdr & 0xE0)
{
- DU_LOG("\nINFO --> RLC_UL : rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \
+ DU_LOG("INFO --> RLC_UL : rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \
CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
hdrInfo.len = RLC_E1_LEN;
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (uint8_t)hdrInfo.val;
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* Extract the Reserved Bits after ACK SN field */
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val;
- DU_LOG("\nDEBUG --> RLC_UL : rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
+ DU_LOG("DEBUG --> RLC_UL : rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
"UEID:%d CELLID:%d", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tseg == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
return FALSE;
if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
{
gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
- DU_LOG("\nERROR --> RLC_UL : rlcAmmUlPlacePduInRecBuf: SN %d outside the window"
+ DU_LOG("ERROR --> RLC_UL : rlcAmmUlPlacePduInRecBuf: SN %d outside the window"
"UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
gCb->genSts.unexpPdusRecv++;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcAmmUlPlacePduInRecBuf: Memory allocation failed \
+ DU_LOG("ERROR --> RLC_UL : rlcAmmUlPlacePduInRecBuf: Memory allocation failed \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
return FALSE;
* The "=" in the 2nd condition is removed */
if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
{
- DU_LOG("\nINFO --> RLC_UL : rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
+ DU_LOG("INFO --> RLC_UL : rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
amUl->staTrg = TRUE;
*/
static S16 rlcCfgFillDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb,RlcDlUeCb *ueCb,RlcEntCfgInfo *entCfg)
{
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgFillRbCb(ueId(%d),cellId(%d) rbType(%d))",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgFillRbCb(ueId(%d),cellId(%d) rbType(%d))",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId,
entCfg->rbType);
}
default:
{
- DU_LOG("\nERROR --> RLC_DL : Invalid RB Mode ueId(%d),cellId(%d)",
+ DU_LOG("ERROR --> RLC_DL : Invalid RB Mode ueId(%d),cellId(%d)",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
return RFAILED;
RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
if(rbCb->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcCfgFillDlRbCb(): Failed to allocate memory");
+ DU_LOG("ERROR --> RLC_DL : rlcCfgFillDlRbCb(): Failed to allocate memory");
return RFAILED;
}
memcpy(rbCb->snssai, entCfg->snssai, sizeof(Snssai));
/*Create the entry of this SNSSAI if not exist in Snssai Tput list*/
if(rlcHandleSnssaiTputlist(gCb, rbCb->snssai, CREATE, DIR_DL) == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcCfgFillDlRbCb(): SNSSAI insertion in Tput list failed");
+ DU_LOG("ERROR --> RLC_DL : rlcCfgFillDlRbCb(): SNSSAI insertion in Tput list failed");
}
}
rbCb->mode = entCfg->entMode;
if (rbCb->mode != entCfg->entMode)
{
- DU_LOG("\nERROR --> RLC_DL : RB Mode Mismatch : exp [%d] rcv [%d] UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : RB Mode Mismatch : exp [%d] rcv [%d] UEID:%d CELLID:%d",
rbCb->mode,
entCfg->entMode,
rbCb->rlcId.ueId,
RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
if(rbCb->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcCfgFillDlRbCb(): Failed to allocate memory");
+ DU_LOG("ERROR --> RLC_DL : rlcCfgFillDlRbCb(): Failed to allocate memory");
return RFAILED;
}
}
RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
uint8_t reason; /* Rb Identifier */
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
cellId,
ueId,
entCfg->cfgType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Add DLRb,CellId is 0 for UEID:%d",
+ DU_LOG("ERROR --> RLC_DL : Add DLRb,CellId is 0 for UEID:%d",
ueId);
return RFAILED;
}
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Invalid RbId ,Max is [%d] CELLID:%d UEID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid RbId ,Max is [%d] CELLID:%d UEID:%d",
RLC_MAX_RB_PER_CELL,
cellId,
ueId);
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_PRSNT);
- DU_LOG("\nERROR --> RLC_DL : RbId [%d] already exists UEID:%d",
+ DU_LOG("ERROR --> RLC_DL : RbId [%d] already exists UEID:%d",
entCfg->rbId,
ueId);
return RFAILED;
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_CREAT_FAIL);
- DU_LOG("\nERROR --> RLC_DL : cellCb Creation failed RBID:%d UEID:%d",
+ DU_LOG("ERROR --> RLC_DL : cellCb Creation failed RBID:%d UEID:%d",
entCfg->rbId,
ueId);
return RFAILED;
/* Validate LChId */
if(entCfg->lCh[0].lChId <= 0)
{
- DU_LOG("\nERROR --> RLC_DL : Invalid LcId CELLID:%d UEID:%d RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid LcId CELLID:%d UEID:%d RBID:%d",
cellId,
ueId,
entCfg->rbId);
RLC_ALLOC(gCb,rlcRbCb, sizeof (RlcDlRbCb));
if (!rlcRbCb)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed for rbId:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed for rbId:%d CELLID:%d",
entCfg->rbId,
ueId);
/* Fill entCfm structure */
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Invalid RbId for RbType[%d] UEID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid RbId for RbType[%d] UEID:%d",
entCfg->rbType,
ueId);
return RFAILED;
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_PRSNT);
- DU_LOG("\nERROR --> RLC_DL : CellId[%u]:rbId [%d] already exists",
+ DU_LOG("ERROR --> RLC_DL : CellId[%u]:rbId [%d] already exists",
cellId,
entCfg->rbId);
return RFAILED;
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_UE_CREAT_FAIL);
- DU_LOG("\nERROR --> RLC_DL : UeId [%u]:ueCb Creation Failed RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : UeId [%u]:ueCb Creation Failed RBID:%d",
ueId,
entCfg->rbId);
return RFAILED;
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_CREAT_FAIL);
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed RBID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed RBID:%d CELLID:%d",
entCfg->rbId,
cellId);
return RFAILED;
/* Delete RB CB created */
RLC_FREE(gCb,rlcRbCb, sizeof(RlcDlRbCb));
- DU_LOG("\nERROR --> RLC_DL : Filling of RbCb failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Filling of RbCb failed UEID:%d CELLID:%d",
ueId,
cellId);
return RFAILED;
RlcDlUeCb *ueCb; /* Ue Control Block */
uint8_t ret;
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
cellId, entCfg->cfgType,entCfg->rbId);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Invalid RbId , Max is [%d] UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid RbId , Max is [%d] UEID:%d CELLID:%d",
RLC_MAX_RB_PER_CELL,
ueId,
cellId);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellCb not found ueId:%d RBID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : CellCb not found ueId:%d RBID:%d CELLID:%d",
ueId,
entCfg->rbId,
cellId);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CELLID:%d RBID:%d not found",
+ DU_LOG("ERROR --> RLC_DL : CELLID:%d RBID:%d not found",
cellId,
entCfg->rbId);
return RFAILED;
CKW_CFG_CFM_NOK,
ret);
- DU_LOG("\nERROR --> RLC_DL : CELLID:%u RBID:%d updation failed",
+ DU_LOG("ERROR --> RLC_DL : CELLID:%u RBID:%d updation failed",
cellId,
entCfg->rbId);
memcpy(rbCb, &tRbCb, sizeof(RlcDlRbCb));
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CELLID:%d Invalid RBID:%d for RbType[%d]",
+ DU_LOG("ERROR --> RLC_DL : CELLID:%d Invalid RBID:%d for RbType[%d]",
cellId,
entCfg->rbId,
entCfg->rbType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : UEID:%d UeCb not found RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : UEID:%d UeCb not found RBID:%d",
ueId,
entCfg->rbId);
return (ret);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CELLID:%d RBID:%d not found",
+ DU_LOG("ERROR --> RLC_DL : CELLID:%d RBID:%d not found",
cellId,
entCfg->rbId);
return (ret);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
ret);
- DU_LOG("\nERROR --> RLC_DL : CELLID:%d RBID:%d updation failed",
+ DU_LOG("ERROR --> RLC_DL : CELLID:%d RBID:%d updation failed",
cellId,
entCfg->rbId);
memcpy(rbCb, &tRbCb, sizeof(RlcDlRbCb));
RlcDlCellCb *cellCb; /* UE Control Block */
RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgDelRb(RBID(%d), cellId(%d), cfgType(%d))",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgDelRb(RBID(%d), cellId(%d), cfgType(%d))",
entCfg->rbId,
cellId,
entCfg->cfgType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Invalid RbId, Max is [%d] UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid RbId, Max is [%d] UEID:%d CELLID:%d",
RLC_MAX_RB_PER_CELL,
ueId,
cellId);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellCb not found UEID:%d RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : CellCb not found UEID:%d RBID:%d",
ueId,
entCfg->rbId);
return (ret);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
return (ret);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : Invalid RbId for RbType[%d] UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Invalid RbId for RbType[%d] UEID:%d CELLID:%d",
entCfg->rbType,
ueId,
cellId);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : UeId [%d]: UeCb not found RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : UeId [%d]: UeCb not found RBID:%d",
ueId,
entCfg->rbId);
return (ret);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
return (ret);
RlcDlRbCb *rbCb; /* RB Control Block */
CmLteRlcId rlcId; /* RLC Identifier */
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgReEstDlRb(ueId(%d), cellId(%d), cfgType(%d))",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgReEstDlRb(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
cellId,
entCfg->cfgType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, rlcId.rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
return RFAILED;
S16 ret; /* Return Value */
RlcDlUeCb *ueCb; /* UE Control Block */
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgDelUe(ueId(%d), cellId(%d), cfgType(%d))",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgDelUe(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
cellId,
entCfg->cfgType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : ueId(%d), cellId(%d)",
+ DU_LOG("ERROR --> RLC_DL : ueId(%d), cellId(%d)",
ueId,
cellId);
return RFAILED;
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : UEID:%d UeCb not found RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : UEID:%d UeCb not found RBID:%d",
ueId,
entCfg->rbId);
return RFAILED;
RlcDlCellCb *cellCb; /* UE Control Block */
uint8_t rbId; /* RB Identifier */
- DU_LOG("\nDEBUG --> RLC_DL : rlcCfgDelCell( cellId(%d), cfgType(%d)",
+ DU_LOG("DEBUG --> RLC_DL : rlcCfgDelCell( cellId(%d), cfgType(%d)",
cellId,
entCfg->cfgType);
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : cellId is 0 (%d) ",
+ DU_LOG("ERROR --> RLC_DL : cellId is 0 (%d) ",
cellId);
return RFAILED;
}
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
- DU_LOG("\nERROR --> RLC_DL : CellCb not found for RBID:%d",
+ DU_LOG("ERROR --> RLC_DL : CellCb not found for RBID:%d",
entCfg->rbId);
return RFAILED;
}
{
status->reason = CKW_CFG_REAS_SAME_UEID;
status->status = CKW_CFG_CFM_NOK;
- DU_LOG("\nERROR --> RLC_DL : Old UeId[%d] same as new UeId[%d]",
+ DU_LOG("ERROR --> RLC_DL : Old UeId[%d] same as new UeId[%d]",
ueInfo->ueId,
newUeInfo->ueId);
return RFAILED;
if(ROK == rlcDbmFetchDlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : NewUeId[%d]:ueCb already exists",
+ DU_LOG("ERROR --> RLC_DL : NewUeId[%d]:ueCb already exists",
newUeInfo->ueId);
status->reason = CKW_CFG_REAS_UE_EXISTS;
status->status = CKW_CFG_CFM_NOK;
if(ROK != rlcDbmFetchDlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, &ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : UeId [%d]: UeCb not found",
+ DU_LOG("ERROR --> RLC_DL : UeId [%d]: UeCb not found",
ueInfo->ueId);
status->reason = CKW_CFG_REAS_UE_UNKWN;
status->status = CKW_CFG_CFM_NOK;
#endif
if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : UeId[%u] HashList Deletion Failed",
+ DU_LOG("ERROR --> RLC_DL : UeId[%u] HashList Deletion Failed",
ueInfo->ueId);
status->reason = CKW_CFG_REAS_UE_CREAT_FAIL;
status->status = CKW_CFG_CFM_NOK;
(uint16_t) sizeof(CmLteRnti)))
{
- DU_LOG("\nERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
+ DU_LOG("ERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
newUeInfo->ueId);
status->reason = CKW_CFG_REAS_UE_CREAT_FAIL;
status->status = CKW_CFG_CFM_NOK;
static S16 rlcCfgFillUlRbCb(RlcCb *gCb,RlcUlRbCb *rbCb,RlcUlUeCb *ueCb,RlcEntCfgInfo *entCfg)
{
- DU_LOG("\nDEBUG --> RLC_UL : rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
+ DU_LOG("DEBUG --> RLC_UL : rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
rbCb->rlcId.cellId,
entCfg->rbId,
entCfg->rbType);
}
default:
{
- DU_LOG("\nERROR --> RLC_UL : INVALID RB Mode cellId(%d), rbId(%d)",
+ DU_LOG("ERROR --> RLC_UL : INVALID RB Mode cellId(%d), rbId(%d)",
rbCb->rlcId.cellId,
entCfg->rbId);
return RFAILED;
RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
if(rbCb->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcCfgFillUlRbCb(): Failed to allocate memory for snssai ");
+ DU_LOG("ERROR --> RLC_UL : rlcCfgFillUlRbCb(): Failed to allocate memory for snssai ");
return RFAILED;
}
}
/*Create the entry of this SNSSAI if not exist in Snssai Tput list*/
if(rlcHandleSnssaiTputlist(gCb, rbCb->snssai, CREATE, DIR_UL) == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcCfgFillUlRbCb(): SNSSAI insertion in Tput list failed");
+ DU_LOG("ERROR --> RLC_UL : rlcCfgFillUlRbCb(): SNSSAI insertion in Tput list failed");
}
}
rbCb->mode = entCfg->entMode;
RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
if(rbCb->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : rlcCfgUpdateUlRb(): Failed to allocate memory for snssai ");
+ DU_LOG("ERROR --> RLC_UL : rlcCfgUpdateUlRb(): Failed to allocate memory for snssai ");
return RFAILED;
}
}
(cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_6BIT_SN_LEN) &&
(cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_12BIT_SN_LEN))
{
- DU_LOG("\nERROR --> RLC_UL : UM Mode RB[%d],Invalid SN Len[%d]",
+ DU_LOG("ERROR --> RLC_UL : UM Mode RB[%d],Invalid SN Len[%d]",
cfgToValidate->rbId,
cfgToValidate->m.umInfo.ul.snLen);
status->reason = CKW_CFG_REAS_INVALID_SNLEN;
)
{
- DU_LOG("\nDEBUG --> RLC_UL : cellId(%d), cfgType(%d)",
+ DU_LOG("DEBUG --> RLC_UL : cellId(%d), cfgType(%d)",
cfgTmpData->cellId,
cfgToValidate->cfgType);
RLC_ALLOC(gCb,cfgTmpData->cellCb, sizeof(RlcUlCellCb));
if(!cfgTmpData->cellCb)
{
- DU_LOG("\nERROR --> RLC_UL : Memory allocation failure CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : Memory allocation failure CELLID:%d",
cfgTmpData->cellId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
return RFAILED;
RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
if(!cfgTmpData->ueCb)
{
- DU_LOG("\nERROR --> RLC_UL : Memory allocation failure CELLID:%d",
+ DU_LOG("ERROR --> RLC_UL : Memory allocation failure CELLID:%d",
cfgTmpData->cellId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
return RFAILED;
rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
if(!cfgTmpData->cellCb)
{
- DU_LOG("\nERROR --> RLC_UL : CellCb not found UEID:%d",
+ DU_LOG("ERROR --> RLC_UL : CellCb not found UEID:%d",
cfgTmpData->ueId);
/*how can a modify request come for a cell which does not exist*/
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
- DU_LOG("\nERROR --> RLC_UL : UeId [%d]: UeCb not found",
+ DU_LOG("ERROR --> RLC_UL : UeId [%d]: UeCb not found",
cfgTmpData->ueId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
return RFAILED;
)
{
- DU_LOG("\nDEBUG --> RLC_UL : cellId(%d), cfgType(%d)",
+ DU_LOG("DEBUG --> RLC_UL : cellId(%d), cfgType(%d)",
cfgTmpData->cellId,cfgToValidate->cfgType);
/* Check for ueId is present or not */
if ( cfgTmpData->ueId == 0 )
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
- DU_LOG("\nERROR --> RLC_UL : UeId is 0 for CELLID;%d",
+ DU_LOG("ERROR --> RLC_UL : UeId is 0 for CELLID;%d",
cfgTmpData->cellId);
return RFAILED;
}
/* Fetch Ue Cb */
if(ROK != rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
{
- DU_LOG("\nERROR --> RLC_UL : UeId [%d]: UeCb not found",
+ DU_LOG("ERROR --> RLC_UL : UeId [%d]: UeCb not found",
cfgTmpData->ueId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
return RFAILED;
)
{
- DU_LOG("\nDEBUG --> RLC_UL : cfgType(%d)",
+ DU_LOG("DEBUG --> RLC_UL : cfgType(%d)",
cfgToValidate->cfgType);
cfgTmpData->cellCb = NULLP;
if ( cellId == 0 )
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
- DU_LOG("\nERROR --> RLC_UL : CellId is 0");
+ DU_LOG("ERROR --> RLC_UL : CellId is 0");
return RFAILED;
}
if (!cfgTmpData->cellCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
- DU_LOG("\nERROR --> RLC_UL : CellCb not found");
+ DU_LOG("ERROR --> RLC_UL : CellCb not found");
return RFAILED;
}
return ROK;
{
CmLteRlcId rlcId; /* RLC Identifier */
- DU_LOG("\nDEBUG --> RLC_UL : cellId(%d) RBID:%d",
+ DU_LOG("DEBUG --> RLC_UL : cellId(%d) RBID:%d",
cellId,
cfgToValidate->rbId);
rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
if (cfgEntData->rbCb == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : CellId [%u]: rbId [%d] not found",
+ DU_LOG("ERROR --> RLC_UL : CellId [%u]: rbId [%d] not found",
cellId,
cfgToValidate->rbId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
{
- DU_LOG("\nERROR --> RLC_UL : NewUeId[%d]:ueCb already exists",
+ DU_LOG("ERROR --> RLC_UL : NewUeId[%d]:ueCb already exists",
newUeInfo->ueId);
CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
CFM_STATUS.status = CKW_CFG_CFM_NOK;
if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
&cfgTmpData->ueCb))
{
- DU_LOG("\nERROR --> RLC_UL : UeId [%d]: UeCb not found",
+ DU_LOG("ERROR --> RLC_UL : UeId [%d]: UeCb not found",
ueInfo->ueId);
CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
CFM_STATUS.status = CKW_CFG_CFM_NOK;
(uint16_t) sizeof(CmLteRnti)))
{
- DU_LOG("\nERROR --> RLC_UL : UeId[%u] HashList Insertion Failed",
+ DU_LOG("ERROR --> RLC_UL : UeId[%u] HashList Insertion Failed",
newUeInfo->ueId);
}
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
- DU_LOG("\nERROR --> RLC_DL : UeLstCp Initialization Failed");
+ DU_LOG("ERROR --> RLC_DL : UeLstCp Initialization Failed");
return RFAILED;
}
RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- DU_LOG("\nERROR --> RLC_DL : CellLstCp Initialization Failed");
+ DU_LOG("ERROR --> RLC_DL : CellLstCp Initialization Failed");
return RFAILED;
}
{
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- DU_LOG("\nERROR --> RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
+ DU_LOG("ERROR --> RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
return RFAILED;
}
cmHashListDeinit(&rlcCb.rlcL2Cb.qciHlCp);
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- DU_LOG("\nERROR --> RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
+ DU_LOG("ERROR --> RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
return RFAILED;
}
#endif /* LTE_L2_MEAS */
if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId, Max is [%d] \
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId, Max is [%d] \
UEID:%d CELLID:%d", RLC_MAX_RB_PER_CELL, rlcId->ueId, rlcId->cellId);
return;
}
rlcDbmFetchDlCellCb(gCb,rlcId->cellId, &cellCb);
if(!cellCb)
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : CellCb[%d] not found UEID:%d \
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : CellCb[%d] not found UEID:%d \
RBID:%d", rlcId->cellId, rlcId->ueId, rlcId->rbId);
return;
}
RlcDlUeCb *ueCb;
if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId[%d] for RbType[%d] \
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId[%d] for RbType[%d] \
RBID:%d CELLID:%d", rlcId->rbId, rlcId->rbType, rlcId->ueId, rlcId->cellId);
return;
}
if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : UeId [%d]: UeCb not found RBID:%d",\
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbByRbId : UeId [%d]: UeCb not found RBID:%d",\
rlcId->ueId, rlcId->rbId);
return;
}
rlcDbmFetchDlCellCb(gCb, cellId, &cellCb);
if(!cellCb)
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbFromLchId: CellCb[%d] not found UEID:%d", \
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbFromLchId: CellCb[%d] not found UEID:%d", \
cellId, ueId);
return;
}
if (rlcDbmFetchDlUeCb(gCb, ueId, cellId, &ueCb) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : rlcDbmFetchDlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
+ DU_LOG("ERROR --> RLC_DL : rlcDbmFetchDlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
return;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*ueCb == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed cellID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed cellID:%d",
cellId);
return RFAILED;
}
(uint8_t *)&(tUeCb->ueId),
(uint16_t) sizeof(CmLteRnti)))
{
- DU_LOG("\nERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
+ DU_LOG("ERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
ueId);
return RFAILED;
}
/* Delete ueCb entry from ueLstCp */
if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
{
- DU_LOG("\nERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
+ DU_LOG("ERROR --> RLC_DL : UeId[%u] HashList Insertion Failed",
ueCb->ueId);
}
memset(&gCb->rlcThpt.ueTputInfo.thptPerUe[ueCb->ueId -1], 0, sizeof(RlcThptPerUe));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*cellCb == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed");
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
(uint8_t *)&(tCellCb->cellId),
(uint16_t) sizeof(CmLteCellId)))
{
- DU_LOG("\nERROR --> RLC_DL : HashList Insertion Failed");
+ DU_LOG("ERROR --> RLC_DL : HashList Insertion Failed");
return RFAILED;
}
RLC_DEF_SEQ_NUM,
(PTR*) cellCb))
{
- DU_LOG("\nERROR --> RLC_DL : CellCb [%d] not found", cellId);
+ DU_LOG("ERROR --> RLC_DL : CellCb [%d] not found", cellId);
return RFAILED;
}
/* Delete cellCb entry in hash list cellLstCp */
if(ROK != cmHashListDelete(&(gCb->u.dlCb->cellLstCp), (PTR) cellCb))
{
- DU_LOG("\nERROR --> RLC_DL : HashList Deletion Failed");
+ DU_LOG("ERROR --> RLC_DL : HashList Deletion Failed");
}
/* Deallocate cellCb */
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
- DU_LOG("\nERROR --> RLC_UL : UeLstCp Initialization Failed");
+ DU_LOG("ERROR --> RLC_UL : UeLstCp Initialization Failed");
return RFAILED;
}
RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
- DU_LOG("\nERROR --> RLC_UL : CellLstCp Initialization Failed");
+ DU_LOG("ERROR --> RLC_UL : CellLstCp Initialization Failed");
return RFAILED;
}
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
cmHashListDeinit(&gCb->u.ulCb->cellLstCp);
- DU_LOG("\nERROR --> RLC_UL : transIdLstCp Initialization Failed");
+ DU_LOG("ERROR --> RLC_UL : transIdLstCp Initialization Failed");
return RFAILED;
}
if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
{
- DU_LOG("\nERROR --> RLC_UL : Invalid RbId, cellId:%d UEID:%d Max is [%d]",
+ DU_LOG("ERROR --> RLC_UL : Invalid RbId, cellId:%d UEID:%d Max is [%d]",
rlcId->cellId, rlcId->ueId, RLC_MAX_RB_PER_CELL);
return;
}
rlcDbmFetchUlCellCb(gCb,rlcId->cellId, &cellCb);
if(!cellCb)
{
- DU_LOG("\nERROR --> RLC_UL : CellCb not found RBID:%d UEID:%d",
+ DU_LOG("ERROR --> RLC_UL : CellCb not found RBID:%d UEID:%d",
rlcId->rbId,
rlcId->ueId);
return;
if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
- DU_LOG("\nERROR --> RLC_UL : Invalid RbId for RbType[%d] CELLID:%d UEID:%d",
+ DU_LOG("ERROR --> RLC_UL : Invalid RbId for RbType[%d] CELLID:%d UEID:%d",
rlcId->rbType,
rlcId->cellId,
rlcId->ueId);
if (rlcDbmFetchUlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : UeId [%d]: UeCb not found RBID:%d",
+ DU_LOG("ERROR --> RLC_UL : UeId [%d]: UeCb not found RBID:%d",
rlcId->ueId,
rlcId->rbId);
return;
rlcDbmFetchUlCellCb(gCb,cellId, &cellCb);
if(!cellCb)
{
- DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: CellCb[%d] not found UEID:%d",\
+ DU_LOG("ERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: CellCb[%d] not found UEID:%d",\
cellId, ueId);
return;
}
if (rlcDbmFetchUlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
+ DU_LOG("ERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
return;
}
(uint8_t *)&(ueCb->ueId),
(uint16_t) sizeof(CmLteRnti)))
{
- DU_LOG("\nERROR --> RLC_UL : UeId[%u] HashList Insertion Failed",
+ DU_LOG("ERROR --> RLC_UL : UeId[%u] HashList Insertion Failed",
ueId);
return RFAILED;
}
)
{
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> RLC_UL : (transId(%ld)", cfg->transId);
+ DU_LOG("DEBUG --> RLC_UL : (transId(%ld)", cfg->transId);
#else
- DU_LOG("\nDEBUG --> RLC_UL : (transId(%d))", cfg->transId);
+ DU_LOG("DEBUG --> RLC_UL : (transId(%d))", cfg->transId);
#endif
return (cmHashListInsert(&(gCb->u.ulCb->transIdLstCp),
sizeof (transId),
RLC_DEF_SEQ_NUM,(PTR *) cfg))
{
- DU_LOG("\nERROR --> RLC_UL : TransId [%d] not found",transId);
+ DU_LOG("ERROR --> RLC_UL : TransId [%d] not found",transId);
return RFAILED;
}
return ROK;
if(cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (cfg)) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : HashList Deletion failed");
+ DU_LOG("ERROR --> RLC_UL : HashList Deletion failed");
return RFAILED;
}
/* Delete ueCb entry from ueLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) ueCb))
{
- DU_LOG("\nERROR --> RLC_UL : HashList Deletion Failed cellId(%d)",
+ DU_LOG("ERROR --> RLC_UL : HashList Deletion Failed cellId(%d)",
ueCb->cellId);
}
/* kw005.201 ccpu00117318, updating the statistics */
(uint8_t *)&(tCellCb->cellId),
(uint16_t) sizeof(CmLteCellId)))
{
- DU_LOG("\nERROR --> RLC_UL : HashList Insertion Failed");
+ DU_LOG("ERROR --> RLC_UL : HashList Insertion Failed");
return RFAILED;
}
(uint8_t *)&(cellId),sizeof(CmLteCellId),
RLC_DEF_SEQ_NUM, (PTR*) cellCb))
{
- DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlCellCb : CellCb[%d] not found", cellId);
+ DU_LOG("ERROR --> RLC_UL : rlcDbmFetchUlCellCb : CellCb[%d] not found", cellId);
}
return;
/* Delete cellCb entry in hash list cellLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->cellLstCp), (PTR) cellCb))
{
- DU_LOG("\nERROR --> RLC_UL : HashList Deletion Failed");
+ DU_LOG("ERROR --> RLC_UL : HashList Deletion Failed");
}
/* Deallocate cellCb */
RLC_FREE(gCb, cellCb, sizeof(RlcUlCellCb));
strcpy(sourceTask,"Invalid Source Entity Id");
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Event[%d] from SM",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Event[%d] from SM",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Event[%d] from RLC UL",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Event[%d] from RLC UL",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Event[%d] from RRC",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Event[%d] from RRC",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Event[%d] from PDCP",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Event[%d] from PDCP",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Event[%d] from MAC",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Event[%d] from MAC",
pst->event);
}
ret = RFAILED;
if (pst->dstInst < MAX_RLC_INSTANCES)
{
/*RlcCb *tRlcCb = RLC_GET_RLCCB(pst->dstInst);*/
- DU_LOG("\nERROR --> RLC_DL : Received Invalid Source Entity[%d]",
+ DU_LOG("ERROR --> RLC_DL : Received Invalid Source Entity[%d]",
pst->event);
}
ODU_PUT_MSG_BUF(mBuf);
}
default:
{
- DU_LOG("\nERROR --> RLC : cmPkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
+ DU_LOG("ERROR --> RLC : cmPkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
exit(1);
}
#endif
}
default:
{
- DU_LOG("\nERROR --> RLC : cmUnpkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
+ DU_LOG("ERROR --> RLC : cmUnpkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
exit(1);
}
/* Update the State */
udxSap->state = RLC_SAP_BND;
- DU_LOG("\nINFO --> RLC_DL : UDX SAP state [%d]", udxSap->state);
+ DU_LOG("INFO --> RLC_DL : UDX SAP state [%d]", udxSap->state);
break;
}
/* SAP is already bound */
RLC_SEND_SAPID_ALARM(tRlcCb, spId,
LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_PAR_VAL);
- DU_LOG("\nERROR --> RLC_DL : UDX SAP already Bound");
+ DU_LOG("ERROR --> RLC_DL : UDX SAP already Bound");
rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
}
break;
RLC_SEND_SAPID_ALARM(tRlcCb,spId,
LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- DU_LOG("\nERROR --> RLC_DL : Invalid UDX SAP State in Bind Req");
+ DU_LOG("ERROR --> RLC_DL : Invalid UDX SAP State in Bind Req");
rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
break;
}
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC_DL : Unbind Req for spId[%d], reason[%d]",
+ DU_LOG("DEBUG --> RLC_DL : Unbind Req for spId[%d], reason[%d]",
spId, reason);
UNUSED(reason);
/* disable upper sap (CKW) */
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cfgCfm == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Memory Allocation Failed.");
+ DU_LOG("ERROR --> RLC_DL : Memory Allocation Failed.");
/* kw002.201 Freeing from proper region */
/* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
return RFAILED;
if (rlcCfgAddDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : Addition Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : Addition Failed due to[%d]",
entCfgCfm->status.reason);
}
}
if (rlcCfgReCfgDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : ReCfg Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : ReCfg Failed due to[%d]",
entCfgCfm->status.reason);
}
}
if (rlcCfgDelDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : Deletion Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : Deletion Failed due to[%d]",
entCfgCfm->status.reason);
}
}
if (rlcCfgReEstDlRb(tRlcCb,cfg->ueId, cfg->cellId,
sndReEst,entCfg, entCfgCfm) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : Reest Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : Reest Failed due to[%d]",
entCfgCfm->status.reason);
}
}
if (rlcCfgDelDlUe(tRlcCb,cfg->ueId, cfg->cellId,
entCfg, entCfgCfm) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : deletion Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : deletion Failed due to[%d]",
entCfgCfm->status.reason);
}
else
{
- DU_LOG("\nDEBUG --> RLC_DL: UE information is deleted for UEId[%d] and CellId[%d]",\
+ DU_LOG("DEBUG --> RLC_DL: UE information is deleted for UEId[%d] and CellId[%d]",\
cfg->ueId, cfg->cellId);
}
break;
if (rlcCfgDelDlCell(tRlcCb,cfg->cellId,entCfg,entCfgCfm)
!= ROK )
{
- DU_LOG("\nERROR --> RLC_DL : deletion Failed due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : deletion Failed due to[%d]",
entCfgCfm->status.reason);
}
break;
{
RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,\
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
- DU_LOG("\nERROR --> RLC_DL : Invalid CfgType");
+ DU_LOG("ERROR --> RLC_DL : Invalid CfgType");
}
}
}
if (rlcCfgDlUeIdChng(tRlcCb, ueInfo, newUeInfo, &status) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : Failure due to[%d]",
+ DU_LOG("ERROR --> RLC_DL : Failure due to[%d]",
status.reason);
}
rlcDlUdxUeIdChgCfm(&(tRlcCb->u.dlCb->udxDlSap[spId].pst),
rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb); /* Fetch DBM RbCb */
if (!rbCb)
{
- DU_LOG("\nERROR --> RLC_DL : CellId [%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (!rbCb)
{
- DU_LOG("\nERROR --> RLC_DL : CellId [%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
if (tRlcCb->init.cfgDone != TRUE)
{
- DU_LOG("\nERROR --> RLC_UL : General configuration not done");
+ DU_LOG("ERROR --> RLC_UL : General configuration not done");
RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
if (suId < 0)
{
- DU_LOG("\nERROR --> RLC_UL : Invalid suId");
+ DU_LOG("ERROR --> RLC_UL : Invalid suId");
RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
{
- DU_LOG("\nERROR --> RLC_UL : Invalid suId");
+ DU_LOG("ERROR --> RLC_UL : Invalid suId");
RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
RLC_FREE_SHRABL_BUF(pst->region,
if(ROK != rlcDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : Invalid transId");
+ DU_LOG("ERROR --> RLC_UL : Invalid transId");
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cfgCfm == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : Memory Allocation failed.");
+ DU_LOG("ERROR --> RLC_UL : Memory Allocation failed.");
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
{
- DU_LOG("\nERROR --> RLC_UL : Invalid suId");
+ DU_LOG("ERROR --> RLC_UL : Invalid suId");
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(ROK != rlcDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : Invalid transId");
+ DU_LOG("ERROR --> RLC_UL : Invalid transId");
return (RFAILED);
}
rlcDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (rbCb == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : CellId [%u]:RbId[%d] not found",
+ DU_LOG("ERROR --> RLC_UL : CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
return RFAILED;
}
{
RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_DIR);
- DU_LOG("\nDEBUG --> RLC_UL : RBID[%d] direction[%d] is invalid",
+ DU_LOG("DEBUG --> RLC_UL : RBID[%d] direction[%d] is invalid",
entCfg->rbId,entCfg->dir);
}
break;
RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
- DU_LOG("\nERROR --> RLC_UL : Invalid configuration type");
+ DU_LOG("ERROR --> RLC_UL : Invalid configuration type");
}
}
}
if(cfg->maxUe > RLC_MAX_UE)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC : Invalid maxUe : Max [%lu] Received [%lu]",
+ DU_LOG("ERROR --> RLC : Invalid maxUe : Max [%lu] Received [%lu]",
RLC_MAX_UE,
cfg->maxUe);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(cfg->maxKwuSaps > RLC_MAX_KWUSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC : Invalid maxKwuSaps : Max [%lu] Received [%lu]",
+ DU_LOG("ERROR --> RLC : Invalid maxKwuSaps : Max [%lu] Received [%lu]",
RLC_MAX_KWUSAPS,
cfg->maxKwuSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(cfg->maxUdxSaps > RLC_MAX_UDXSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC : Invalid maxUduSaps : Max [%lu] Received [%lu]",
+ DU_LOG("ERROR --> RLC : Invalid maxUduSaps : Max [%lu] Received [%lu]",
RLC_MAX_UDXSAPS,
cfg->maxUdxSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_ALLOC(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
if (gCb->u.dlCb == NULLP)
{
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
if(gCb->u.dlCb->rlcKwuDlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
{
RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- DU_LOG("\nERROR --> RLC_DL : RLC DL Initialization failed");
+ DU_LOG("ERROR --> RLC_DL : RLC DL Initialization failed");
return (LCM_REASON_MEM_NOAVAIL);
}
RLC_ALLOC(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
if (gCb->u.ulCb == NULLP)
{
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
{
RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- DU_LOG("\nERROR --> RLC_DL : RLC DL Initialization failed");
+ DU_LOG("ERROR --> RLC_DL : RLC DL Initialization failed");
}
/* Register the timer */
else
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC : Received Invalid RLC Mode");
+ DU_LOG("ERROR --> RLC : Received Invalid RLC Mode");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
return (LCM_REASON_INVALID_PAR_VAL);
/* Starting timer to print throughput */
if((rlcChkTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_UE_THROUGHPUT_TMR)) == FALSE)
{
- DU_LOG("\nINFO --> RLC_DL : Starting UE Throughput timer");
+ DU_LOG("INFO --> RLC_DL : Starting UE Throughput timer");
rlcStartTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_UE_THROUGHPUT_TMR);
}
}
/* Starting timer to print throughput */
if((rlcChkTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_SNSSAI_THROUGHPUT_TMR)) == FALSE)
{
- DU_LOG("\nINFO --> RLC_DL : Starting SNSSAI Throughput timer");
+ DU_LOG("INFO --> RLC_DL : Starting SNSSAI Throughput timer");
rlcStartTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_SNSSAI_THROUGHPUT_TMR);
}
break;
default:
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC : Received Invalid Message Type");
+ DU_LOG("ERROR --> RLC : Received Invalid Message Type");
if(!gCb)
{
fflush(stdout);
return (RFAILED);
}
- DU_LOG("\nDEBUG --> RLC : RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> RLC : RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
switch(cfg->hdr.elmId.elmnt)
{
rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
return (RFAILED);
}
- DU_LOG("\nDEBUG --> RLC : RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> RLC : RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
/* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
* In all error cases appropriate reason is returned
return (RFAILED);
}
- DU_LOG("\nDEBUG --> RLC : Status request for elmId(%d))", sta->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> RLC : Status request for elmId(%d))", sta->hdr.elmId.elmnt);
reason = LCM_REASON_NOT_APPL;
return (RFAILED);
}
- DU_LOG("\nDEBUG --> RLC : RlcMiLkwStsReq(elmId(%d),action(%d))",
+ DU_LOG("DEBUG --> RLC : RlcMiLkwStsReq(elmId(%d),action(%d))",
action,
sts->hdr.elmId.elmnt);
#if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */
if(measEvt == NULLP)
{
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return RFAILED;
}
#endif
/* Check for reconfiguration */
if (rlcKwuSapCb->state != RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : RLC Mode [%d] : Invalid rlckwuSap State [%d]",
+ DU_LOG("ERROR --> RLC : RLC Mode [%d] : Invalid rlckwuSap State [%d]",
gCb->genCfg.rlcMode, rlcKwuSapCb->state);
/* reconfiguration not allowed */
return (LCM_REASON_RECONFIG_FAIL);
/* Check for reconfiguration */
if(ckwSap->state != RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : Invalid rlckwuSap State [%d]",ckwSap->state);
+ DU_LOG("ERROR --> RLC : Invalid rlckwuSap State [%d]",ckwSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Check for reconfiguration */
if(udxDlSap->state != RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : Invalid udxDlSap State [%d]",udxDlSap->state);
+ DU_LOG("ERROR --> RLC : Invalid udxDlSap State [%d]",udxDlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Check for reconfiguration */
if(udxUlSap->state != RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : Invalid udxUlSap State [%d]", udxUlSap->state);
+ DU_LOG("ERROR --> RLC : Invalid udxUlSap State [%d]", udxUlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Check for reconfiguration */
if(rguSap->state != RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : RLC Mode [%d]: Invalid rguSap State [%d]",
+ DU_LOG("ERROR --> RLC : RLC Mode [%d]: Invalid rguSap State [%d]",
gCb->genCfg.rlcMode, rguSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
/* validate SAP */
if(UDX_SAP.state == RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : udxUlSap not configured yet");
+ DU_LOG("ERROR --> RLC : udxUlSap not configured yet");
return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* validate SAP */
if(rguSap->state == RLC_SAP_NOT_CFG)
{
- DU_LOG("\nERROR --> RLC : RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
+ DU_LOG("ERROR --> RLC : RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
MsgLen tempCnt;
Pst pst;
- DU_LOG("\nDEBUG --> RLC : rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
+ DU_LOG("DEBUG --> RLC : rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
event,
gCb->trcLen);
!= ROK)
{
/* rg005.201 removed SPutSBuf on error */
- DU_LOG("\nERROR --> RLC : SCpyMsgMsg Failed");
+ DU_LOG("ERROR --> RLC : SCpyMsgMsg Failed");
return RFAILED;
}
/* Send Trace Indication to Layer manager */
/* Get the length of the recvd message buffer */
if (SFndLenMsg(mBuf, &bufLen) != ROK)
{
- DU_LOG("\nERROR --> RLC : SFndLenMsg Failed");
+ DU_LOG("ERROR --> RLC : SFndLenMsg Failed");
return RFAILED;
}
/* Check if the recvd buffer size is less than request trace len */
if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
!= ROK)
{
- DU_LOG("\nERROR --> RLC : SCpyMsgMsg Failed");
+ DU_LOG("ERROR --> RLC : SCpyMsgMsg Failed");
return RFAILED;
}
{
(Void) SPutSMem(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb));
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Copy trcLen nos of bytes from the recvd message */
if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
{
- DU_LOG("\nERROR --> RLC : SCpyMsgFix Failed");
+ DU_LOG("ERROR --> RLC : SCpyMsgFix Failed");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory Allocation failed");
+ DU_LOG("ERROR --> RLC : Memory Allocation failed");
return RFAILED;
}
/* Copy the tempBuf data to dst mBuf */
if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
{
- DU_LOG("\nERROR --> RLC : SCpyMsgFix Failed");
+ DU_LOG("ERROR --> RLC : SCpyMsgFix Failed");
return RFAILED;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC UL : RlcLiRguBndCfm(suId(%d), status(%d)", suId, status);
+ DU_LOG("DEBUG --> RLC UL : RlcLiRguBndCfm(suId(%d), status(%d)", suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (tRlcCb->init.cfgDone != TRUE)
{
- DU_LOG("\nERROR --> RLC UL : General configuration not done");
+ DU_LOG("ERROR --> RLC UL : General configuration not done");
RLC_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- DU_LOG("\nERROR --> RLC UL : Invalid suId");
+ DU_LOG("ERROR --> RLC UL : Invalid suId");
RLC_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
rguSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
&(tRlcCb->u.dlCb->rguDlSap[suId]) : &(tRlcCb->u.ulCb->rguUlSap[suId]);
- DU_LOG("\nDEBUG --> RLC UL : RlcLiRguBndCfm: For RGU SAP state=%d", rguSap->state);
+ DU_LOG("DEBUG --> RLC UL : RlcLiRguBndCfm: For RGU SAP state=%d", rguSap->state);
switch (rguSap->state)
{
#if (ERRCLASS & ERRCLS_DEBUG)
if(RLC_MAX_LCH_PER_CELL <= datInd->lcId)
{
- DU_LOG("\nERROR --> RLC UL : rlcProcCommLcUlData : Invalid LcId [%d], Max is [%d]",\
+ DU_LOG("ERROR --> RLC UL : rlcProcCommLcUlData : Invalid LcId [%d], Max is [%d]",\
datInd->lcId, RLC_MAX_LCH_PER_CELL);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
return RFAILED;
rlcDbmFetchUlRbCbFromLchId(tRlcCb, datInd->rnti, datInd->cellId, datInd->lcId, &rbCb);
if (!rbCb)
{
- DU_LOG("\nERROR --> RLC UL : rlcProcCommLcUlData : LcId [%d] not found",
+ DU_LOG("ERROR --> RLC UL : rlcProcCommLcUlData : LcId [%d] not found",
datInd->lcId);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
return RFAILED;
#if (ERRCLASS & ERRCLS_DEBUG)
if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- DU_LOG("\nDEBUG --> RLC UL : rlcProcDedLcUlData : suId(%d))recieved in DL Inst", suId);
+ DU_LOG("DEBUG --> RLC UL : rlcProcDedLcUlData : suId(%d))recieved in DL Inst", suId);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguDDatIndInfo));
return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid RGU suId %d\n", suId);
+ DU_LOG("ERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid RGU suId %d\n", suId);
return RFAILED;
}
if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
- DU_LOG("\nDEBUG --> RLC UL : rlcProcCommLcSchedRpt: Received in RLC UL CELLID:%d",
+ DU_LOG("DEBUG --> RLC UL : rlcProcCommLcSchedRpt: Received in RLC UL CELLID:%d",
staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
return RFAILED;
#if (ERRCLASS & ERRCLS_DEBUG)
if(RLC_MAX_LCH_PER_CELL < staInd->lcId)
{
- DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid LcId, Max is [%d] CELLID:%d",
+ DU_LOG("ERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid LcId, Max is [%d] CELLID:%d",
RLC_MAX_LCH_PER_CELL, staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
return RFAILED;
rlcDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb);
if(!rbCb)
{
- DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: LcId [%d] not found CELLID:%d",
+ DU_LOG("ERROR --> RLC UL : rlcProcCommLcSchedRpt: LcId [%d] not found CELLID:%d",
staInd->lcId, staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
return RFAILED;
#if (ERRCLASS & ERRCLS_INT_PAR)
if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
- DU_LOG("\nDEBUG --> RLC UL : rlcProcDedLcSchedRpt: Received in RLC UL ");
+ DU_LOG("DEBUG --> RLC UL : rlcProcDedLcSchedRpt: Received in RLC UL ");
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguDStaIndInfo));
return RFAILED;
}
if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
{
- DU_LOG("\nERROR --> RLC UL : rlcProcDedLcSchedRpt: Invalid RGU suId %d\n", suId);
+ DU_LOG("ERROR --> RLC UL : rlcProcDedLcSchedRpt: Invalid RGU suId %d\n", suId);
return (RFAILED);
}
#endif
RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCreateRsp));
if(!ueRsp)
{
- DU_LOG("\nERROR --> RLC: Memory allocation failed for ueRsp at SendRlcUeCreateRspToDu()");
+ DU_LOG("ERROR --> RLC: Memory allocation failed for ueRsp at SendRlcUeCreateRspToDu()");
ret = RFAILED;
}
else
ret = (*rlcUeCreateRspOpts[pst->selector])(pst, ueRsp);
if(ret)
{
- DU_LOG("\nERROR --> RLC: Failed at SendRlcUeCreateRspToDu()");
+ DU_LOG("ERROR --> RLC: Failed at SendRlcUeCreateRspToDu()");
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCreateRsp));
}
}
else
{
- DU_LOG("\nERROR --> RLC: Failed at fillRlcUeCreateRsp() for event %d", pst->event);
+ DU_LOG("ERROR --> RLC: Failed at fillRlcUeCreateRsp() for event %d", pst->event);
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCreateRsp));
}
}
RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeReconfigRsp));
if(!ueRsp)
{
- DU_LOG("\nERROR --> RLC: Memory allocation failed for ueRsp at SendRlcUeReconfigRspToDu()");
+ DU_LOG("ERROR --> RLC: Memory allocation failed for ueRsp at SendRlcUeReconfigRspToDu()");
ret = RFAILED;
}
else
ret = (*rlcUeReconfigRspOpts[pst->selector])(pst, ueRsp);
if(ret)
{
- DU_LOG("\nERROR --> RLC: Failed at SendRlcUeReconfigRspToDu()");
+ DU_LOG("ERROR --> RLC: Failed at SendRlcUeReconfigRspToDu()");
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeReconfigRsp));
}
}
else
{
- DU_LOG("\nERROR --> RLC: Failed at fillRlcUeCreateRsp() for event %d", pst->event);
+ DU_LOG("ERROR --> RLC: Failed at fillRlcUeCreateRsp() for event %d", pst->event);
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeReconfigRsp));
}
}
RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, maxRetransInfo, sizeof(RlcMaxRetransInfo));
if(!maxRetransInfo)
{
- DU_LOG("\nERROR --> RLC: sendRlcMaxRetransIndToDu(): Memory allocation failed ");
+ DU_LOG("ERROR --> RLC: sendRlcMaxRetransIndToDu(): Memory allocation failed ");
return RFAILED;
}
else
if(rlcSendMaxRetransIndToDu(&pst, maxRetransInfo) == ROK)
{
- DU_LOG("\nDEBUG --> RLC: UE [ %d] max retransmission information sent successfully",ueId);
+ DU_LOG("DEBUG --> RLC: UE [ %d] max retransmission information sent successfully",ueId);
}
else
{
- DU_LOG("\nERROR --> RLC: SendRlcMaxRetransIndToDu(): fail to send UeId's[%d] maximum retransmission information", ueId);
+ DU_LOG("ERROR --> RLC: SendRlcMaxRetransIndToDu(): fail to send UeId's[%d] maximum retransmission information", ueId);
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, maxRetransInfo, sizeof(RlcMaxRetransInfo));
return RFAILED;
}
*direction = RLC_CFG_DIR_DL;
break;
default :
- DU_LOG("\nERROR --> RLC: Rlc Mode invalid %d", rlcMode);
+ DU_LOG("ERROR --> RLC: Rlc Mode invalid %d", rlcMode);
break;
}
}
RLC_ALLOC(gCb, rlcUeCfg->snssai, sizeof(Snssai));
if(rlcUeCfg->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC : fillLcCfg(): Failed to allocate memory for snssai");
+ DU_LOG("ERROR --> RLC : fillLcCfg(): Failed to allocate memory for snssai");
return RFAILED;
}
memcpy(rlcUeCfg->snssai, duRlcUeCfg->snssai, sizeof(Snssai));
{
if(fillLcCfg(gCb, &rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfgAdd[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
+ DU_LOG("ERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
return RFAILED;
}
rlcUeCfg->entCfg[lcIdx].cfgType = CONFIG_ADD;
{
if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgAdd[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
+ DU_LOG("ERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
return RFAILED;
}
rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_ADD;
{
if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgMod[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
+ DU_LOG("ERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
return RFAILED;
}
rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_MOD;
{
if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgRel[lcIdx]) != ROK)
{
- DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
+ DU_LOG("ERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration");
return RFAILED;
}
rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_DEL;
RLC_ALLOC(gCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
- DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()");
+ DU_LOG("ERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()");
ret = RFAILED;
}
else
ret = fillRlcCfg(gCb, rlcUeCfg, ueCfg);
if(ret != ROK)
{
- DU_LOG("\nERROR --> RLC: Failed to fill configuration at RlcProcUeCreateReq()");
+ DU_LOG("ERROR --> RLC: Failed to fill configuration at RlcProcUeCreateReq()");
FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_CREATE_RSP);
fillRlcCfgFailureRsp(&cfgRsp, ueCfg);
SendRlcUeCreateRspToDu(&rspPst, &cfgRsp);
{
ret = RlcProcCfgReq(pst, rlcUeCfg);
if(ret != ROK)
- DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
+ DU_LOG("ERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
}
}
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCreate));
Pst pst;
RrcDeliveryReport *rrcDelivery;
- DU_LOG("\nINFO --> RLC : Filling RRC Delivery Report");
+ DU_LOG("INFO --> RLC : Filling RRC Delivery Report");
RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, rrcDelivery, sizeof(RrcDeliveryReport));
if(rrcDelivery)
}
else
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed");
+ DU_LOG("ERROR --> RLC : Memory allocation failed");
}
return ROK;
RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
if(!datReqInfo)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
+ DU_LOG("ERROR --> RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
return RFAILED;
/* Copy fixed buffer to message */
if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */
/* Initializing dedicated logical channel Database */
- DU_LOG("\nDEBUG --> RLC: Received UL Data request from MAC");
+ DU_LOG("DEBUG --> RLC: Received UL Data request from MAC");
for(idx = 0; idx < MAX_NUM_LC; idx++)
{
dLchData[idx].lcId = idx;
sizeof(RguDDatIndInfo));
if(!dLchUlDat)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
ret = RFAILED;
break;
}
if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \
&dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++)
{
ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]);
uint8_t nmbDLch = 0; /* Number of dedicated logical channles */
RguDStaIndInfo *dLchSchInfo; /* Dedicated logical channel scheduling result */
- DU_LOG("\nDEBUG --> RLC : Received scheduling report from MAC");
+ DU_LOG("DEBUG --> RLC : Received scheduling report from MAC");
for(idx=0; idx < schRep->numLc; idx++)
{
/* Fill status info structure if at least one channel's scheduling report is received */
sizeof(RguDStaIndInfo));
if(!dLchSchInfo)
{
- DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
+ DU_LOG("ERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
ret = RFAILED;
break;
}
RlcCfgCfmInfo cfgRsp;
Pst rspPst;
- DU_LOG("\nDEBUG --> RLC: UE reconfig request received. CellID[%d] UEID[%d]",ueRecfg->cellId, ueRecfg->ueId);
+ DU_LOG("DEBUG --> RLC: UE reconfig request received. CellID[%d] UEID[%d]",ueRecfg->cellId, ueRecfg->ueId);
rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
- DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeReconfigReq()");
+ DU_LOG("ERROR --> RLC: Failed to allocate memory at RlcProcUeReconfigReq()");
ret = RFAILED;
}
else
ret = updateRlcCfg(rlcUeCb, rlcUeCfg, ueRecfg);
if(ret != ROK)
{
- DU_LOG("\nERROR --> RLC: Failed to fill configuration at RlcProcUeReconfigReq()");
+ DU_LOG("ERROR --> RLC: Failed to fill configuration at RlcProcUeReconfigReq()");
FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_RSP);
fillRlcRecfgFailureRsp(&cfgRsp, ueRecfg);
SendRlcUeReconfigRspToDu(&rspPst, &cfgRsp);
{
ret = RlcProcCfgReq(pst, rlcUeCfg);
if(ret != ROK)
- DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
+ DU_LOG("ERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
}
}
if(dlDataMsgInfo->dlMsg == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : Received DL message is NULLP in RlcProcDlUserDataTransfer()");
+ DU_LOG("ERROR --> RLC_DL : Received DL message is NULLP in RlcProcDlUserDataTransfer()");
return RFAILED;
}
RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
if(!datReqInfo)
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed for DatReq in RlcProcDlUserDataTransfer()");
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed for DatReq in RlcProcDlUserDataTransfer()");
ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
return RFAILED;
RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
if(!ueDeleteRsp)
{
- DU_LOG("\nERROR --> RLC: sendRlcUeDeleteRspToDu(): Memory allocation failed ");
+ DU_LOG("ERROR --> RLC: sendRlcUeDeleteRspToDu(): Memory allocation failed ");
return RFAILED;
}
else
if(rlcSendUeDeleteRspToDu(&pst, ueDeleteRsp) == ROK)
{
- DU_LOG("\nDEBUG --> RLC: UE Delete response send successfully");
+ DU_LOG("DEBUG --> RLC: UE Delete response send successfully");
}
else
{
- DU_LOG("\nERROR --> RLC: SendRlcUeDeleteRspToDu():Failed to send UE Delete response to DU");
+ DU_LOG("ERROR --> RLC: SendRlcUeDeleteRspToDu():Failed to send UE Delete response to DU");
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
return RFAILED;
}
RlcUlUeCb *ueCb = NULLP;
CauseOfResult status =SUCCESSFUL;
- DU_LOG("\nDEBUG --> RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId);
+ DU_LOG("DEBUG --> RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId);
if(ueDelete != NULLP)
{
ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, status);
if(ret != ROK)
{
- DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU");
+ DU_LOG("ERROR --> RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU");
}
}
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(RlcUeDelete));
}
else
{
- DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq(): Recieved NULL pointer UE Delete ");
+ DU_LOG("ERROR --> RLC: RlcProcUeDeleteReq(): Recieved NULL pointer UE Delete ");
ret = RFAILED;
}
return ret;
if(!sliceStats)
{
- DU_LOG("\nERROR --> RLC: sendSlicePmToDu(): Memory allocation failed ");
+ DU_LOG("ERROR --> RLC: sendSlicePmToDu(): Memory allocation failed ");
return RFAILED;
}
else
{
if(rlcSendSlicePmToDu(&pst, sliceStats) == ROK)
{
- DU_LOG("\nDEBUG --> RLC: Slice PM send successfully");
+ DU_LOG("DEBUG --> RLC: Slice PM send successfully");
}
else
{
- DU_LOG("\nERROR --> RLC: sendSlicePmToDu():Failed to send Slice PM to DU");
+ DU_LOG("ERROR --> RLC: sendSlicePmToDu():Failed to send Slice PM to DU");
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, sliceStats, sizeof(SlicePmList));
return RFAILED;
}
if(snssaiCnt == 0)
{
- DU_LOG("\nERROR --> RLC: No SNSSAI to send the SLice PM");
+ DU_LOG("ERROR --> RLC: No SNSSAI to send the SLice PM");
return RFAILED;
}
RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList));
if(sliceStats == NULLP)
{
- DU_LOG("\nERROR --> RLC: Memory Allocation Failed");
+ DU_LOG("ERROR --> RLC: Memory Allocation Failed");
return RFAILED;
}
RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats->sliceRecord, snssaiCnt * (sizeof(SlicePm)));
if(sliceStats->sliceRecord == NULLP)
{
- DU_LOG("\nERROR --> RLC: Memory Allocation Failed");
+ DU_LOG("ERROR --> RLC: Memory Allocation Failed");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList));
return RFAILED;
}
node = arrTputPerSnssai[dir]->first;
if(node == NULLP)
{
- DU_LOG("\nERROR --> RLC: No SNSSAI in list");
+ DU_LOG("ERROR --> RLC: No SNSSAI in list");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList));
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats->sliceRecord, (snssaiCnt * (sizeof(SlicePm))));
return RFAILED;
RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp));
if(!ueReestablishRsp)
{
- DU_LOG("\nERROR --> RLC: sendRlcUeReestablishRspToDu(): Memory allocation failed ");
+ DU_LOG("ERROR --> RLC: sendRlcUeReestablishRspToDu(): Memory allocation failed ");
return RFAILED;
}
else
if(rlcSendUeReestablishRspToDu(&pst, ueReestablishRsp) == ROK)
{
- DU_LOG("\nDEBUG --> RLC: UE Reestablishment response send successfully");
+ DU_LOG("DEBUG --> RLC: UE Reestablishment response send successfully");
}
else
{
- DU_LOG("\nERROR --> RLC: SendRlcUeReestablishRspToDu():Failed to send UE Reestablishment response to DU");
+ DU_LOG("ERROR --> RLC: SendRlcUeReestablishRspToDu():Failed to send UE Reestablishment response to DU");
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp));
return RFAILED;
}
else
{
status = CELLID_INVALID;
- DU_LOG("\nERROR --> SCH : RlcProcUeReestablishReq(): cell Id[%d] not found", ueReestablishReq->cellId);
+ DU_LOG("ERROR --> SCH : RlcProcUeReestablishReq(): cell Id[%d] not found", ueReestablishReq->cellId);
}
}
else
{
status = UEID_INVALID;
- DU_LOG("\nERROR --> SCH : RlcProcUeReestablishReq(): ue Id[%d] not found", ueReestablishReq->cellId);
+ DU_LOG("ERROR --> SCH : RlcProcUeReestablishReq(): ue Id[%d] not found", ueReestablishReq->cellId);
}
if(status != SUCCESSFUL)
{
if(sendRlcUeReestablishRspToDu(ueReestablishReq->cellId, ueReestablishReq->ueId, status) != ROK)
{
- DU_LOG("\nERROR --> RLC: RlcProcUeReestablishReq():Failed to send UE Reestablishment response to DU");
+ DU_LOG("ERROR --> RLC: RlcProcUeReestablishReq():Failed to send UE Reestablishment response to DU");
}
}
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueReestablishReq, sizeof(RlcUeDelete));
}
else
{
- DU_LOG("\nERROR --> RLC: RlcProcUeReestablishReq(): Recieved NULL pointer UE Reestablishment ");
+ DU_LOG("ERROR --> RLC: RlcProcUeReestablishReq(): Recieved NULL pointer UE Reestablishment ");
}
return ret;
}
}
else
{
- DU_LOG("\nERROR --> RLC UL : Received NULL buffer");
+ DU_LOG("ERROR --> RLC UL : Received NULL buffer");
}
rguDatInd->msg=NULLP;
SRngIncrRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
}
else
{
- DU_LOG("\nERROR --> RLC_DL : RLC DL STA RSP RBUF is FULL!!! ");
+ DU_LOG("ERROR --> RLC_DL : RLC DL STA RSP RBUF is FULL!!! ");
SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktDrop++;
ret1 = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> RLC_DL : RLC DL DAT REQ RBUF is FULL!!! \n");
+ DU_LOG("ERROR --> RLC_DL : RLC DL DAT REQ RBUF is FULL!!! \n");
SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktDrop++;
ret1 = RFAILED;
}
CmLteRlcId rlcId
)
{
- DU_LOG("\nINFO --> RLC : In RlcUiKwuReEstCmpInd");
+ DU_LOG("INFO --> RLC : In RlcUiKwuReEstCmpInd");
/* jump to specific primitive depending on configured selector */
(*kwUiKwuReEstCmpIndMt[pst->selector])(pst, suId, rlcId);
}
else
{
- DU_LOG("\nERROR --> RLC : mBuf is NULL");
+ DU_LOG("ERROR --> RLC : mBuf is NULL");
if(datReq->mBuf)
cmUnpkKwuDatReq(rlcProcDlData, &datReq->pst, datReq->mBuf);
RLC_ALLOC(gCb, l2CellStats[cnt], (Size)sizeof (TSL2CellStatsCb));
if(l2CellStats[cnt] == NULL)
{
- DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure\n");
+ DU_LOG("ERROR --> RLC : STATS Unexpected MEM Alloc Failure\n");
}
}
memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
RLC_ALLOC(gCb, statsCb, (Size)sizeof (TSL2UeStatsCb));
if(NULL == statsCb)
{
- DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
+ DU_LOG("ERROR --> RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
}
}
memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
tmp = freeL2UeStatsLst.first;
if (tmp == NULLP)
{
- DU_LOG("\nERROR --> RLC : STATS Unexpected Mem BLK unavailable for UE %d\n", rnti);
+ DU_LOG("ERROR --> RLC : STATS Unexpected Mem BLK unavailable for UE %d\n", rnti);
}
cmLListDelFrm(&freeL2UeStatsLst, tmp);
statsCb = (TSL2UeStatsCb *)(tmp->node);
{
if (cellId != 1)
{
- DU_LOG("\nERROR --> RLC : STATS Unexpected CellID = %d\n", (int)cellId);
+ DU_LOG("ERROR --> RLC : STATS Unexpected CellID = %d\n", (int)cellId);
}
return (l2CellStats[cellId-1]);
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
(sdu->mode.tm.slot != ((slot+TFU_DELTA)%10)))
{
node = node->next;
- DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: Releasing SDU of RNTI = %d for RNTI = %d \
+ DU_LOG("INFO --> RLC_DL : rlcTmmSendToMac: Releasing SDU of RNTI = %d for RNTI = %d \
UEID:%d CELLID:%d", sdu->mode.tm.rnti, staInd->rnti, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: sfn %d slot %d UEID:%d CELLID:%d",
+ DU_LOG("INFO --> RLC_DL : rlcTmmSendToMac: sfn %d slot %d UEID:%d CELLID:%d",
sfn, slot, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
ODU_PUT_MSG_BUF(sdu->mBuf);
{
timeDiff = curTime - sdu->arrTime;
}
- DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received \
+ DU_LOG("DEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received \
for Rnti %d Sdu Rnti %d UEID:%d CELLID:%d", staInd->rnti,
sdu->mode.tm.rnti, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received : \
+ DU_LOG("DEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received : \
timeDiff %d SduQCnt %d UEID:%d CELLID:%d", timeDiff, rbCb->m.tm.sduQ.count,
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
if (timeDiff > 40)
{
/* Memory leak needs to be fixed */
node = node->next;
- DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: timeDiff greater than 40, so deleting\
+ DU_LOG("ERROR --> RLC_DL : rlcTmmSendToMac: timeDiff greater than 40, so deleting\
the Sdu %u UEID:%d CELLID:%d", sdu->mode.tm.rnti, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
{
/* Memory leak needs to be fixed */
node = node->next;
- DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: Searching for Rnti %d Skipping \
+ DU_LOG("DEBUG --> RLC_DL : rlcTmmSendToMac: TMM: Searching for Rnti %d Skipping \
Sdu for Rnti %d UEID:%d CELLID:%d", staInd->rnti, sdu->mode.tm.rnti,
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: timeDiff %d sdu->arrTime %d UEID:%d CELLID:%d",
+ DU_LOG("INFO --> RLC_DL : rlcTmmSendToMac: timeDiff %d sdu->arrTime %d UEID:%d CELLID:%d",
timeDiff, sdu->arrTime, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: curTime %d SduQCnt %d and continuing"
+ DU_LOG("INFO --> RLC_DL : rlcTmmSendToMac: curTime %d SduQCnt %d and continuing"
" UEID:%d CELLID:%d", curTime, rbCb->m.tm.sduQ.count, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
continue;
}
else
{
- DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu found %u UEID:%d CELLID:%d",
+ DU_LOG("DEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu found %u UEID:%d CELLID:%d",
sdu->mode.tm.rnti, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
break;
}
}
if ( node == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: SDU not found TM Queue is empty UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcTmmSendToMac: SDU not found TM Queue is empty UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( dlData == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: Memory Allocation failed UEID:%d CELLID:%d",
+ DU_LOG("ERROR --> RLC_DL : rlcTmmSendToMac: Memory Allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
dlData->pduInfo[0].pduBuf, pduLen);
if (dlData->pduInfo[0].pduBuf == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
+ DU_LOG("ERROR --> RLC_DL : Memory allocation failed");
return;
}
ODU_COPY_MSG_TO_FIX_BUF(sdu->mBuf, 0, pduLen, \
boStatus, sizeof(RlcBoStatus));
if ( boStatus == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",\
+ DU_LOG("ERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
SAddPstMsgMult(rrcConReq,6,pdu);
- DU_LOG("\nINFO --> RLC_UL : Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
+ DU_LOG("INFO --> RLC_UL : Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
rlcSendUlDataToDu(&ulPst1, datIndInfo, pdu);
}
else if(2 == rrcMsgType)
SAddPstMsgMult(rrcConSetupComplete,34,pdu);
- DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Connection Setup Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("INFO --> RLC_UL : Profiling Framework: Sending RRC Connection Setup Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
#else
SAddPstMsgMult(rrcUeCapabilityInfo,sizeof(rrcUeCapabilityInfo),pdu);
#endif
- DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC UE Capability Info to RRC for UE :%d\n",crnti);
+ DU_LOG("INFO --> RLC_UL : Profiling Framework: Sending RRC UE Capability Info to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
SAddPstMsgMult(rrcSecurityModeComplete,2,pdu);
- DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Security Mode Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("INFO --> RLC_UL : Profiling Framework: Sending RRC Security Mode Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
SAddPstMsgMult(rrcReconfigComplete,2,pdu);
- DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Reconfig Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("INFO --> RLC_UL : Profiling Framework: Sending RRC Reconfig Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#ifdef EG_GEN_LOAD_5GTF
}
else
{
- DU_LOG("\nERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for UL RRC Msg");
+ DU_LOG("ERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for UL RRC Msg");
}
}
else
{
- DU_LOG("\nERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for ulRrcMsgInfo");
+ DU_LOG("ERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for ulRrcMsgInfo");
}
return;
RlcUlRbCb *rbCb
)
{
- DU_LOG("\nINFO --> RLC_UL : do nothing for TMM for ReEstablish");
+ DU_LOG("INFO --> RLC_UL : do nothing for TMM for ReEstablish");
return;
}
}
default:
{
- DU_LOG("\nERROR --> RLC : rlcStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> RLC : rlcStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
}
default:
{
- DU_LOG("\nERROR --> RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
+ DU_LOG("ERROR --> RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
break;
}
}
}
default:
{
- DU_LOG("\nERROR --> RLC : rlcChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> RLC : rlcChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
}
/* If cell is up, print throughout for each UE attached to the cell */
- DU_LOG("\n===================== DL Throughput Per UE==============================");
- DU_LOG("\nNumber of UEs : %d", rlcThptCb->ueTputInfo.numActvUe);
+ DU_LOG("===================== DL Throughput Per UE==============================");
+ DU_LOG("Number of UEs : %d", rlcThptCb->ueTputInfo.numActvUe);
if(rlcThptCb->ueTputInfo.numActvUe)
{
for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
*/
tpt = (double)(rlcThptCb->ueTputInfo.thptPerUe[ueIdx].dataVol * 8)/(double)gConfigInfo.gUeThrptTimeIntervl;
- DU_LOG("\nUE Id : %d DL Tpt : %.2Lf", rlcThptCb->ueTputInfo.thptPerUe[ueIdx].ueId, tpt);
+ DU_LOG("UE Id : %d DL Tpt : %.2Lf", rlcThptCb->ueTputInfo.thptPerUe[ueIdx].ueId, tpt);
rlcThptCb->ueTputInfo.thptPerUe[ueIdx].dataVol = 0;
}
}
}
- DU_LOG("\n==================================================================");
+ DU_LOG("==================================================================");
/* Restart timer */
rlcStartTmr(RLC_GET_RLCCB(rlcThptCb->inst), (PTR)rlcThptCb, EVENT_RLC_UE_THROUGHPUT_TMR);
RLC_ALLOC(gRlcCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
- DU_LOG("\nERROR --> RLC: rlcUeDeleteTmrExpiry(): Failed to allocate memory");
+ DU_LOG("ERROR --> RLC: rlcUeDeleteTmrExpiry(): Failed to allocate memory");
return RFAILED;
}
memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
fillRlcUeDelInfo(ueCb, rlcUeCfg);
if(RlcProcCfgReq(&ueCb->ueDeleteInfo.pst, rlcUeCfg) != ROK)
{
- DU_LOG("\nERROR --> RLC: rlcUeDeleteTmrExpiry(): Failed to delete UE");
+ DU_LOG("ERROR --> RLC: rlcUeDeleteTmrExpiry(): Failed to delete UE");
if(sendRlcUeDeleteRspToDu(rlcUeCfg->cellId, rlcUeCfg->ueId, UEID_INVALID) != ROK)
{
DU_LOG("ERROR --> RLC: rlcUeDeleteTmrExpiry(): Failed to send UE delete response ");
strcpy(sourceTask,"Invalid Source Entity Id");
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from SM",
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Event[%d] from SM",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from RLC UL",
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Event[%d] from RLC UL",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from RRC",
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Event[%d] from RRC",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from PDCP",
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Event[%d] from PDCP",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from MAC",
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Event[%d] from MAC",
pst->event);
}
ret = RFAILED;
}
default:
{
- DU_LOG("\nERROR --> RLC_UL : Invalid Event[%d] from CL to PDCPUL\n",
+ DU_LOG("ERROR --> RLC_UL : Invalid Event[%d] from CL to PDCPUL\n",
pst->event);
ODU_PUT_MSG_BUF(mBuf);
break;
{
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- DU_LOG("\nERROR --> RLC_UL : Received Invalid Source Entity[%d]",pst->event);
+ DU_LOG("ERROR --> RLC_UL : Received Invalid Source Entity[%d]",pst->event);
}
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
- DU_LOG("\nERROR --> RLC DL : Memory allocation failed in rlcUmmQSdu for UEID:%d CELLID:%d",\
+ DU_LOG("ERROR --> RLC DL : Memory allocation failed in rlcUmmQSdu for UEID:%d CELLID:%d",\
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(mBuf);
RLC_ALLOC(gCb,recBuf, sizeof(RlcUmRecBuf));
if (recBuf == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : Failed to allocate memory to recv buf for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()",
+ DU_LOG("ERROR --> RLC_UL : Failed to allocate memory to recv buf for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
if (expSo > umHdr->so)
{
- DU_LOG("\nDEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()");
+ DU_LOG("DEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()");
/* This is a duplicate segment */
ODU_PUT_MSG_BUF(pdu);
return FALSE;
if ((seg) && (seg->umHdr.so <= soEnd))
{
- DU_LOG("\nDEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()");
+ DU_LOG("DEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()");
/* This is a duplicate segment */
ODU_PUT_MSG_BUF(pdu);
return FALSE;
RLC_ALLOC_WC(gCb, tseg, sizeof(RlcUmSeg));
if (tseg == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL : Failed to allocate memory to segment for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()",
+ DU_LOG("ERROR --> RLC_UL : Failed to allocate memory to segment for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
return FALSE;
{
/* Release the existing SDU as we have PDUs or */
/* segments that are out of sequence */
- DU_LOG("\nDEBUG --> RLC_UL : Received Segments are out of sequence in rlcUmmProcSeg()");
+ DU_LOG("DEBUG --> RLC_UL : Received Segments are out of sequence in rlcUmmProcSeg()");
ODU_PUT_MSG_BUF(RLC_UMUL.assembleSdu);
return RFAILED;
}
/* get the pdu header */
if (rlcUmmExtractHdr(gCb, rbCb, pdu, &umHdr))
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",\
+ DU_LOG("ERROR --> RLC_UL: rlcUmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
count++;
{
ODU_GET_MSG_LEN(pdu, &pduSz);
snssaiTputNode->dataVol += (uint64_t)pduSz;
- DU_LOG("\nINFO --> RLC_UL: UMM_UL SNSSAI List PduLen:%d, lcId:%d, total :%ld",\
+ DU_LOG("INFO --> RLC_UL: UMM_UL SNSSAI List PduLen:%d, lcId:%d, total :%ld",\
pduSz, rbCb->lch.lChId, snssaiTputNode->dataVol);
}
}
if (seqNum < ur)
{
/* PDU needs to be discarded */
- DU_LOG("\nINFO --> RLC_UL: rlcUmmProcessPdus: Received an unexpected pdu with sn %d \
+ DU_LOG("INFO --> RLC_UL: rlcUmmProcessPdus: Received an unexpected pdu with sn %d \
UEID:%d CELLID:%d", curSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, umHdr.sn);
if (recBuf == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmProcessPdus: recBuf is NULLP UEID:%d CELLID:%d", \
+ DU_LOG("ERROR --> RLC_UL: rlcUmmProcessPdus: recBuf is NULLP UEID:%d CELLID:%d", \
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(pdu);
count++;
if(recBuf != NULLP && recBuf->allSegRcvd)
{
rlcUmmReAssembleSdus(gCb, rbCb, recBuf);
- DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: Assembled the Sdus for sn = %d UEID:%d CELLID:%d",\
+ DU_LOG("DEBUG --> RLC_UL: rlcUmmProcessPdus: Assembled the Sdus for sn = %d UEID:%d CELLID:%d",\
umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* if curSn is same as the RX_NEXT_Reassembly */
/* If curSn is outside re-assembly window */
else if (!rlcUmmCheckSnInReassemblyWindow(curSn,&RLC_UMUL))
{
- DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: curent sn is outSide the re-Assembly window. \
+ DU_LOG("DEBUG --> RLC_UL: rlcUmmProcessPdus: curent sn is outSide the re-Assembly window. \
sn = %d UEID:%d CELLID:%d", umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* update RX_NEXT_Highest */
{
rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
tmrRunning = FALSE;
- DU_LOG("\nINFO --> RLC_UL: rlcUmmProcessPdus: Stopped ReAssembly Timer rxTimerTigger = %d \
+ DU_LOG("INFO --> RLC_UL: rlcUmmProcessPdus: Stopped ReAssembly Timer rxTimerTigger = %d \
rxNextReassembly = %d rxNextHighest = %d ", tRxTimerTigger, tRxNextReassembly, tRxNextHighest);
}
}
if ((tRxNextHighest > tRxNextReassemblyNxt) || ((tRxNextHighest == tRxNextReassemblyNxt)
&& (recBuf && (!recBuf->noMissingSeg))))
{
- DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: Start ReAssembly Timer tRxNextReassemblyNxt = %d \
+ DU_LOG("DEBUG --> RLC_UL: rlcUmmProcessPdus: Start ReAssembly Timer tRxNextReassemblyNxt = %d \
tRxNextHighest %d", tRxNextReassemblyNxt, tRxNextHighest);
rlcStartTmr(gCb, (PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
*vrUx = *vrUh;
}
else
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmProcessPdus:Failed to assemble the PDU for SN = %d UEID:%d CELLID:%d",\
+ DU_LOG("ERROR --> RLC_UL: rlcUmmProcessPdus:Failed to assemble the PDU for SN = %d UEID:%d CELLID:%d",\
umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
}
ret = ODU_REM_PRE_MSG(dst,pdu);
if (ret != ROK)
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SI\
+ DU_LOG("ERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SI\
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return RFAILED;
}
ret = ODU_REM_PRE_MSG(dst,pdu);
if (ret != ROK)
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SN\
+ DU_LOG("ERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SN\
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return RFAILED;
}
ret = ODU_REM_PRE_MSG_MULT(dst,2,pdu);
if (ret != ROK)
{
- DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed for 16 bits SO \
+ DU_LOG("ERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed for 16 bits SO \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return RFAILED;
}
RlcSn tRxNextReassembly;
RlcUmRecBuf *recBuf;
- DU_LOG("\nINFO --> RLC_UL: rlcUmmReAsmblTmrExp: UM Re-assembly timer expired");
+ DU_LOG("INFO --> RLC_UL: rlcUmmReAsmblTmrExp: UM Re-assembly timer expired");
/* set VR(UR) to SN >= VR(UX) that has not been reassembled */
rlcUmmFindRxNextReassembly(gCb, &RLC_UMUL, RLC_UMUL.vrUx);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC_UL : spId(%d), suId(%d)", spId, suId);
+ DU_LOG("DEBUG --> RLC_UL : spId(%d), suId(%d)", spId, suId);
ckwSap = &(tRlcCb->u.ulCb->ckwSap);
/* Take action based on the current state of the SAP */
switch(ckwSap->state)
/* Update the State */
ckwSap->state = RLC_SAP_BND;
- DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwBndReq: state (%d)", ckwSap->state);
+ DU_LOG("DEBUG --> RLC_UL : RlcUiCkwBndReq: state (%d)", ckwSap->state);
break;
}
case RLC_SAP_BND:
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
- DU_LOG("\nERROR --> RLC_UL : CKW SAP already Bound");
+ DU_LOG("ERROR --> RLC_UL : CKW SAP already Bound");
RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
return (RFAILED);
}
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC_UL : Invalid CKW SAP State in Bind Req");
+ DU_LOG("ERROR --> RLC_UL : Invalid CKW SAP State in Bind Req");
RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC_UL : spId(%d), reason(%d)",
+ DU_LOG("DEBUG --> RLC_UL : spId(%d), reason(%d)",
spId,
reason);
tRlcCb->u.ulCb->rlcUlUdxEventType = pst->event;
if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
{
- DU_LOG("\nERROR --> RLC_UL : Addition to UL transId Lst Failed");
+ DU_LOG("ERROR --> RLC_UL : Addition to UL transId Lst Failed");
for(cfgIdx=0; cfgIdx<cfg->numEnt; cfgIdx++)
{
RLC_PST_FREE(pst->region, pst->pool, cfg->entCfg[cfgIdx].snssai, sizeof(Snssai));
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
+ DU_LOG("DEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
spId,
transId);
#else
- DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
+ DU_LOG("DEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
spId, transId);
#endif
if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : Addition to UL transId Lst Failed");
+ DU_LOG("ERROR --> RLC_UL : Addition to UL transId Lst Failed");
ret = RFAILED;
break;
}
if(ROK != rlcCfgValidateUeIdChng(tRlcCb,ueInfo,newUeInfo,cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : Validation Failure for UeId change");
+ DU_LOG("ERROR --> RLC_UL : Validation Failure for UeId change");
}
rlcUlUdxUeIdChgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : CELLID [%u]:Validation Failure for UL RB [%d]",
+ DU_LOG("ERROR --> RLC_UL : CELLID [%u]:Validation Failure for UL RB [%d]",
cfg->cellId,cfg->entCfg[idx].rbId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/*Validation is getting failed so no need to do configuration at DL.
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx]))
{
- DU_LOG("\nERROR --> RLC_UL : CellID [%u]:Validation Failure for Reest UL RB [%d]",
+ DU_LOG("ERROR --> RLC_UL : CellID [%u]:Validation Failure for Reest UL RB [%d]",
cfg->cellId,cfg->entCfg[idx].rbId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : UL UEID [%d]:Validation Failure",
+ DU_LOG("ERROR --> RLC_UL : UL UEID [%d]:Validation Failure",
cfgTmpData->ueId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- DU_LOG("\nERROR --> RLC_UL : Del UL Cell Validation Failure");
+ DU_LOG("ERROR --> RLC_UL : Del UL Cell Validation Failure");
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
cfg->entCfg[idx].dir = RLC_DIR_UL;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC_UL : RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
+ DU_LOG("DEBUG --> RLC_UL : RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
/* Validation of input parameters */
#if (ERRCLASS & ERRCLS_INT_PAR)
if(!((spId < (S16) tRlcCb->genCfg.maxKwuSaps) && (spId >=0)))
{
- DU_LOG("\nERROR --> RLC_UL : Invalid spId");
+ DU_LOG("ERROR --> RLC_UL : Invalid spId");
RLC_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
return RFAILED;
}
/* Update the State */
rlckwuSap->state = RLC_SAP_BND;
- DU_LOG("\nDEBUG --> RLC_UL : RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
+ DU_LOG("DEBUG --> RLC_UL : RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
break;
}
case RLC_SAP_BND:
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
- DU_LOG("\nERROR --> RLC_UL : RLC Mode [%d] : KWU SAP already Bound",
+ DU_LOG("ERROR --> RLC_UL : RLC Mode [%d] : KWU SAP already Bound",
tRlcCb->genCfg.rlcMode);
RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
return (RFAILED);
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- DU_LOG("\nERROR --> RLC_UL : RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
+ DU_LOG("ERROR --> RLC_UL : RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
tRlcCb->genCfg.rlcMode);
RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- DU_LOG("\nDEBUG --> RLC_UL : spId(%d), reason(%d)",
+ DU_LOG("DEBUG --> RLC_UL : spId(%d), reason(%d)",
spId,
reason);
RlcDlRbCb *rbCb; /* RB Control Block */
RlcCb *tRlcCb;
- DU_LOG("\nDEBUG --> RLC_DL : Received DL Data");
+ DU_LOG("DEBUG --> RLC_DL : Received DL Data");
#if (ERRCLASS & ERRCLS_INT_PAR)
if(pst->dstInst >= MAX_RLC_INSTANCES)
rlcDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
if(!rbCb)
{
- DU_LOG("\nERROR --> RLC_DL : CellId[%u]:DL RbId [%d] not found",
+ DU_LOG("ERROR --> RLC_DL : CellId[%u]:DL RbId [%d] not found",
datReq->rlcId.cellId,datReq->rlcId.rbId);
ODU_PUT_MSG_BUF(mBuf);
}
default:
{
- DU_LOG("\nERROR --> RLC_DL : Invalid RB Mode");
+ DU_LOG("ERROR --> RLC_DL : Invalid RB Mode");
break;
}
}
{
if(snssaiList == NULLP)
{
- DU_LOG("\nERROR --> RLC: SNSSAI DL list doesnt exist!");
+ DU_LOG("ERROR --> RLC: SNSSAI DL list doesnt exist!");
return NULLP;
}
}
{
if(snssaiList == NULLP)
{
- DU_LOG("\nERROR --> RLC: SNSSAI UL list doesnt exist!");
+ DU_LOG("ERROR --> RLC: SNSSAI UL list doesnt exist!");
return NULLP;
}
}
}
else
{
- DU_LOG("\nERROR --> RLC : Direction:%d is invalid", dir);
+ DU_LOG("ERROR --> RLC : Direction:%d is invalid", dir);
return NULLP;
}
snssaiNode = (RlcTptPerSnssai *)node->node;
if(memcmp(snssaiNode->snssai, snssai, sizeof(Snssai)) == 0)
{
- DU_LOG("\nDEBUG --> RLC : SNSSAI found in LL");
+ DU_LOG("DEBUG --> RLC : SNSSAI found in LL");
found = TRUE;
break;
}
RLC_ALLOC(gCb, snssaiNode->snssai, sizeof(Snssai));
if(snssaiNode->snssai == NULLP)
{
- DU_LOG("\nERROR --> RLC : Allocation of SNSSAI node failed");
+ DU_LOG("ERROR --> RLC : Allocation of SNSSAI node failed");
return NULLP;
}
memcpy(snssaiNode->snssai,snssai,sizeof(Snssai));
}
else
{
- DU_LOG("\nERROR --> RLC : Allocation of SNSSAI node failed");
+ DU_LOG("ERROR --> RLC : Allocation of SNSSAI node failed");
return NULLP;
}
}
else
{
- DU_LOG("\nERROR --> RLC : Allocation of SNSSAI node failed");
+ DU_LOG("ERROR --> RLC : Allocation of SNSSAI node failed");
return NULLP;
}
- DU_LOG("\nDEBUG --> RLC : SNSSAI node added successfully");
+ DU_LOG("DEBUG --> RLC : SNSSAI node added successfully");
return (snssaiNode);
}
node = cmLListDelFrm(snssaiList, node);
RLC_FREE(gCb, node, sizeof(CmLList));
RLC_FREE(gCb, snssaiNode, sizeof(RlcTptPerSnssai));
- DU_LOG("\nDEBUG --> RLC : SNSSAI node found and deletion performed");
+ DU_LOG("DEBUG --> RLC : SNSSAI node found and deletion performed");
if(snssaiList->count == 0)
{
RLC_FREE(gCb, snssaiList, sizeof(CmLListCp));
- DU_LOG("\nINFO --> RLC : This SNSSAI was last in the list thus freeing the list also");
+ DU_LOG("INFO --> RLC : This SNSSAI was last in the list thus freeing the list also");
}
}
else
{
- DU_LOG("\nERROR --> RLC : SNSSAI node not found in List thus no deletion performed");
+ DU_LOG("ERROR --> RLC : SNSSAI node not found in List thus no deletion performed");
}
return NULLP;
}
}
default:
{
- DU_LOG("\nERROR -> RLC: Incorrect ActionType:%d",action);
+ DU_LOG("ERROR -> RLC: Incorrect ActionType:%d",action);
break;
}
}
}
else
{
- DU_LOG("\nERROR --> RLC: Invalid direction:%d",dir);
+ DU_LOG("ERROR --> RLC: Invalid direction:%d",dir);
return RFAILED;
}
if(snssaiList == NULLP)
{
- DU_LOG("\nERROR --> RLC: SnssaiList not exist");
+ DU_LOG("ERROR --> RLC: SnssaiList not exist");
return RFAILED;
}
node = snssaiList->first;
if(snssaiList->count == 0)
{
RLC_FREE(gCb, snssaiList, sizeof(CmLListCp));
- DU_LOG("\nDEBUG --> RLC : This SNSSAI was last in the list thus freeing the list also");
+ DU_LOG("DEBUG --> RLC : This SNSSAI was last in the list thus freeing the list also");
}
return ROK;
}
node = snssaiList->first;
if(node == NULLP)
{
- DU_LOG("\n No SNSSAI in list");
+ DU_LOG(" No SNSSAI in list");
return(snssaiCnt);
}
/*Traversing the LC LinkList*/
if(dir == DIR_DL)
{
- DU_LOG("\nDEBUG --> RLC_DL: SNSSAI(sst:%d,sd [%d,%d, %d]), DL Tpt : %.5lf", snssaiNode->snssai->sst,\
+ DU_LOG("DEBUG --> RLC_DL: SNSSAI(sst:%d,sd [%d,%d, %d]), DL Tpt : %.5lf", snssaiNode->snssai->sst,\
snssaiNode->snssai->sd[0], snssaiNode->snssai->sd[1],snssaiNode->snssai->sd[2] , snssaiNode->tpt);
}
if(dir == DIR_UL)
{
- DU_LOG("\nDEBUG --> RLC_UL: SNSSAI(sst:%d,sd [%d,%d, %d]), UL Tpt : %.5lf", snssaiNode->snssai->sst,\
+ DU_LOG("DEBUG --> RLC_UL: SNSSAI(sst:%d,sd [%d,%d, %d]), UL Tpt : %.5lf", snssaiNode->snssai->sst,\
snssaiNode->snssai->sd[0], snssaiNode->snssai->sd[1],snssaiNode->snssai->sd[2] , snssaiNode->tpt);
}
#ifdef MEM_SIZE_CHECK
#define RLC_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\nRLC line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG("RLC line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define RLC_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
+ DU_LOG("INFO --> RLC_DL : RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
dlInst->genSts.pdusSent,
dlInst->genSts.pdusRetx,
dlInst->genSts.protTimeOut,
dlInst->genSts.numSduDisc);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)",
+ DU_LOG("INFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)",
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMDL: "
"StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMDL: "
"DRB:%lu MaxRetx:%lu RetransPdus:%lu",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMUL: "
" PdusDiscarded:%lu ReAsmblTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReAsmblTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
RlcCb* ulInst = rlcCb[0];
DU_LOG ("\n ================================ RLC STATS ===========================\n");
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%d), PdusRext = (%d), TimeOut = (%d), SduDiscarded = (%d)",
+ DU_LOG("INFO --> RLC_DL : RLC Stats: PDUs Sent = (%d), PdusRext = (%d), TimeOut = (%d), SduDiscarded = (%d)",
dlInst->genSts.pdusSent,
dlInst->genSts.pdusRetx,
dlInst->genSts.protTimeOut,
dlInst->genSts.numSduDisc);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%d), unexpPdus = (%d), errorPdus = (%d)",
+ DU_LOG("INFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%d), unexpPdus = (%d), errorPdus = (%d)",
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMDL: "
"StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMDL: "
"DRB:%u MaxRetx:%u RetransPdus:%u",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: "
+ DU_LOG("INFO --> RLC_DL : RLC Stats: AMUL: "
" PdusDiscarded:%u ReAsmblTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReAsmblTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
dlData, sizeof(RlcDlData));
if(dlData == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dl data");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dl data");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
datReqInfo, sizeof(RguDDatReqInfo));
return RFAILED;
if (dlData->pduInfo[dlData->numPdu].pduBuf == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed");
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, dlData->pduInfo[pduIdx].pduBuf,\
boStatus, sizeof(RlcBoStatus));
if(boStatus == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for boStatus");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for boStatus");
ret = RFAILED;
break;
}
/* Send Status Response to MAC layer */
if(RlcSendBoStatusToMac(&pst, boStatus) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send BO status");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send BO status");
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, boStatus, sizeof(RlcBoStatus));
ret = RFAILED;
break;
}
- DU_LOG("\nDEBUG --> RLC_DL : rlcSendDedLcDlData: BO Status sent successfully for LCID:%d,BO:%d",\
+ DU_LOG("DEBUG --> RLC_DL : rlcSendDedLcDlData: BO Status sent successfully for LCID:%d,BO:%d",\
boStatus->lcId, boStatus->bo);
}
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, dlData, sizeof(RlcDlData));
RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
if(dlRrcMsgRsp == NULLP)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
FILL_PST_RLC_TO_MAC(pst, RLC_DL_INST, EVENT_DL_DATA_TO_MAC);
if(RlcSendDlDataToMac(&pst, dlData) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send Dl RRC Msg To Mac");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send Dl RRC Msg To Mac");
dlRrcMsgRsp->state = TRANSMISSION_FAILED;
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
{
if(rlcSendDlRrcMsgRspToDu(&pst, dlRrcMsgRsp) != ROK)
{
- DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send Dl RRC Msg Rsp To Du");
+ DU_LOG("ERROR --> RLC_DL : rlcSendDedLcDlData: Failed to send Dl RRC Msg Rsp To Du");
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RguDDatReqInfo));
return RFAILED;
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( datReqInfo == NULLP )
{
- DU_LOG("\nERROR --> RLC_DL : rlcUtlSendToMac: Memory allocation failed");
+ DU_LOG("ERROR --> RLC_DL : rlcUtlSendToMac: Memory allocation failed");
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if(ROK != rlcDbmFetchDlUeCb(gCb, ueId, staIndInfo->cellId, &ueCb))
{
/* Fetch UeCb failed */
- DU_LOG("\nERROR --> RLC_DL : rlcUtlSendToMac: UeId[%u]:ueCb not found",
+ DU_LOG("ERROR --> RLC_DL : rlcUtlSendToMac: UeId[%u]:ueCb not found",
staInd->rnti);
/* If ueCb is not found for current rnti then continue to look for next rnti*/
continue;
if(snssaiTputNode != NULLP)
{
snssaiTputNode->dataVol += staIndTb->lchStaInd[count].totBufSize;
- DU_LOG("\nINFO --> RLC_DL: SNSSAI List Grant:%d, lcId:%d, total :%ld",\
+ DU_LOG("INFO --> RLC_DL: SNSSAI List Grant:%d, lcId:%d, total :%ld",\
staIndTb->lchStaInd[count].totBufSize, staIndTb->lchStaInd[count].lcId,\
snssaiTputNode->dataVol);
}
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ DU_LOG("DEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- DU_LOG("\nDEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
+ DU_LOG("DEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
{
if(dlRbCb->mode == RLC_MODE_UM)
{
- DU_LOG("\nDEBUG --> RLC_DL : UM Downlink UEID:%d CELLID:%d Q size = %d",
+ DU_LOG("DEBUG --> RLC_DL : UM Downlink UEID:%d CELLID:%d Q size = %d",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.umDl.sduQ.count);
numTxPdus++;
}
}
- DU_LOG("\nDEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d Sizes SDU Q = %d TX Q = %d ",
+ DU_LOG("DEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d Sizes SDU Q = %d TX Q = %d ",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.amDl.sduQ.count,
(int)numTxPdus);
- DU_LOG("\nDEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d RETX Q= %d",
+ DU_LOG("DEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d RETX Q= %d",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.amDl.retxLst.count);
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
- //DU_LOG("\nINFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
+ //DU_LOG("INFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
RLC_FREE(gCb, txBuf, sizeof(RlcTx));
return;
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
- //DU_LOG("\nINFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
+ //DU_LOG("INFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
return;
} /* rlcUtlRemovTxBuf */
if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
{
/* Fetch UeCb failed */
- DU_LOG("\nERROR --> RLC_UL : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
+ DU_LOG("ERROR --> RLC_UL : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
datIndInfo->rnti);
/* free the buffers inside the datIndInfo */
uint32_t i,j;
datIndInfo = &datIndInfoTmp;
if (datIndInfo == NULLP)
{
- DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
+ DU_LOG("ERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(sdu);
return RFAILED;
}
else
{
- DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
+ DU_LOG("ERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
+ DU_LOG("ERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
return RFAILED;
}
}
ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulUserDatInfo->userData, (MsgLen *)©Len);
ulUserDatInfo->msgLen = msgLen;
- DU_LOG("\nDEBUG --> RLC_UL -> DUAPP : UL DATA [DRB ID:%d]", ulUserDatInfo->rbId);
+ DU_LOG("DEBUG --> RLC_UL -> DUAPP : UL DATA [DRB ID:%d]", ulUserDatInfo->rbId);
/* Sending UL RRC Message transfeer to DU APP */
memset(&pst, 0, sizeof(Pst));
}
else
{
- DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for user data");
+ DU_LOG("ERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for user data");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulUserDatInfo");
+ DU_LOG("ERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulUserDatInfo");
return RFAILED;
}
}
}
}
- DU_LOG("\nDEBUG --> RLC_UL: UM UL UEID:%d CELLID:%d Reception Buffer size = %d Total segs = %d",
+ DU_LOG("DEBUG --> RLC_UL: UM UL UEID:%d CELLID:%d Reception Buffer size = %d Total segs = %d",
ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
else if(ulRbCb->mode == RLC_MODE_AM)
}
}
- DU_LOG("\nDEBUG --> RLC_UL: AM UL UEID:%d CELLID:%d Reception Buf size = %d total segs = %d",
+ DU_LOG("DEBUG --> RLC_UL: AM UL UEID:%d CELLID:%d Reception Buf size = %d total segs = %d",
ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
}
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> RLC_UL : Log for ul ip throughput:"
+ DU_LOG("DEBUG --> RLC_UL : Log for ul ip throughput:"
"RB_MeasOn:%d ttiCnt :%ld UEID:%d CELLID:%d",
rbCb->rbL2Cb.measOn,ttiCnt,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#else
- DU_LOG("\nDEBUG --> RLC_UL : Log for ul ip throughput:"
+ DU_LOG("DEBUG --> RLC_UL : Log for ul ip throughput:"
"RB_MeasOn:%d ttiCnt :%d UEID:%d CELLID:%d",
rbCb->rbL2Cb.measOn,ttiCnt,
rbCb->rlcId.ueId,
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ DU_LOG("DEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- DU_LOG("\nDEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
+ DU_LOG("DEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
uint16_t ret = LCM_REASON_NOT_APPL;
Inst inst = (dInst - SCH_INST_START);
- DU_LOG("\nDEBUG --> SCH : Entered SchInstCfg()");
+ DU_LOG("DEBUG --> SCH : Entered SchInstCfg()");
/* Check if Instance Configuration is done already */
if (schCb[inst].schInit.cfgDone == TRUE)
{
/* Timer Registration request to system services */
if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, (int)schCb[inst].schTimersInfo.tmrRes, schActvTmr) != ROK)
{
- DU_LOG("\nERROR --> SCH : SchInstCfg(): Failed to register timer.");
+ DU_LOG("ERROR --> SCH : SchInstCfg(): Failed to register timer.");
return (LCM_REASON_MEM_NOAVAIL);
}
/* Set Config done in TskInit */
schCb[inst].schInit.cfgDone = TRUE;
- DU_LOG("\nINFO --> SCH : Scheduler gen config done");
+ DU_LOG("INFO --> SCH : Scheduler gen config done");
schAllApisInit(inst);
return ret;
if(pst->dstInst < SCH_INST_START)
{
- DU_LOG("\nERROR --> SCH : Invalid inst ID");
- DU_LOG("\nERROR --> SCH : SchProcGenCfgReq(): "
+ DU_LOG("ERROR --> SCH : Invalid inst ID");
+ DU_LOG("ERROR --> SCH : SchProcGenCfgReq(): "
"pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START);
return ROK;
}
- DU_LOG("\nINFO --> SCH : Received scheduler gen config");
+ DU_LOG("INFO --> SCH : Received scheduler gen config");
/* Fill the post structure for sending the confirmation */
memset(&cfmPst, 0 , sizeof(Pst));
SchFillCfmPst(pst, &cfmPst, cfg);
default:
ret = LCM_PRIM_NOK;
reason = LCM_REASON_INVALID_ELMNT;
- DU_LOG("\nERROR --> SCH : Invalid Elmnt=%d", cfg->hdr.elmId.elmnt);
+ DU_LOG("ERROR --> SCH : Invalid Elmnt=%d", cfg->hdr.elmId.elmnt);
break;
}
}
default:
{
- DU_LOG("\nERROR --> SCH : Invalid DlUlTxPeriodicity:%d", tddPeriod);
+ DU_LOG("ERROR --> SCH : Invalid DlUlTxPeriodicity:%d", tddPeriod);
}
}
break;
}
default:
- DU_LOG("\nERROR --> SCH : Invalid slot Config in schInitTddSlotCfg");
+ DU_LOG("ERROR --> SCH : Invalid slot Config in schInitTddSlotCfg");
}
continue;
}
}
break;
default:
- DU_LOG("\nERROR --> SCH : SCS %d is currently not supported", scs);
+ DU_LOG("ERROR --> SCH : SCS %d is currently not supported", scs);
}
memset(cellCb->ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM));
memcpy(cellCb->ssbStartSymbArr, ssbStartSymbArr, SCH_MAX_SSB_BEAM);
SCH_ALLOC(cell, sizeof(SchCellCb));
if(!cell)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schInitCellCb");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schInitCellCb");
return RFAILED;
}
}
break;
default:
- DU_LOG("\nERROR --> SCH : Numerology %d not supported", cell->numerology);
+ DU_LOG("ERROR --> SCH : Numerology %d not supported", cell->numerology);
}
#ifdef NR_TDD
schInitTddSlotCfg(cell, schCellCfg);
SCH_ALLOC(cell->schDlSlotInfo, cell->numSlots * sizeof(SchDlSlotInfo*));
if(!cell->schDlSlotInfo)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schInitCellCb for schDlSlotInfo");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schInitCellCb for schDlSlotInfo");
return RFAILED;
}
SCH_ALLOC(cell->schUlSlotInfo, cell->numSlots * sizeof(SchUlSlotInfo*));
if(!cell->schUlSlotInfo)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schInitCellCb for schUlSlotInfo");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schInitCellCb for schUlSlotInfo");
return RFAILED;
}
SCH_ALLOC(schDlSlotInfo, sizeof(SchDlSlotInfo));
if(!schDlSlotInfo)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schInitCellCb");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schInitCellCb");
return RFAILED;
}
SCH_ALLOC(schUlSlotInfo, sizeof(SchUlSlotInfo));
if(!schUlSlotInfo)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schInitCellCb");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schInitCellCb");
return RFAILED;
}
#endif
schCb[inst].cells[inst] = cell;
- DU_LOG("\nINFO --> SCH : Cell init completed for cellId:%d", cell->cellId);
+ DU_LOG("INFO --> SCH : Cell init completed for cellId:%d", cell->cellId);
return ROK;
}
}
break;
default:
- DU_LOG("\nERROR --> SCH : Bandwidth %d not supported", bandwidth);
+ DU_LOG("ERROR --> SCH : Bandwidth %d not supported", bandwidth);
}
bwp->freqAlloc.startPrb = 0;
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCH : Failed to fill sib1 configuration");
+ DU_LOG("ERROR --> SCH : Failed to fill sib1 configuration");
return RFAILED;
}
memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg));
SchCellDeleteRsp delRsp;
- DU_LOG("\nINFO --> SCH : Filling Cell Delete response");
+ DU_LOG("INFO --> SCH : Filling Cell Delete response");
memset(&delRsp, 0, sizeof(SchCellDeleteRsp));
delRsp.cellId = ueDelete->cellId;
delRsp.rsp = result;
ret = MacMessageRouter(&rspPst, (void *)&delRsp);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response");
+ DU_LOG("ERROR --> SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response");
return ret;
}
return ret;
if(!cellDelete)
{
- DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): Ue Delete request failed");
+ DU_LOG("ERROR --> SCH : SchProcCellDeleteReq(): Ue Delete request failed");
}
else
{
GET_CELL_IDX(cellDelete->cellId, cellIdx);
if(schCb[inst].cells[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId);
+ DU_LOG("ERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId);
result = RSP_NOK;
}
else
result = RSP_OK;
ret = ROK;
SCH_FREE(schCb[inst].cells[cellIdx], sizeof(SchCellCb));
- DU_LOG("\nINFO --> SCH : Sending Cell Delete response to MAC");
+ DU_LOG("INFO --> SCH : Sending Cell Delete response to MAC");
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId);
+ DU_LOG("ERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId);
result = RSP_NOK;
}
}
if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK)
{
- DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): failed to send Cell Delete response");
+ DU_LOG("ERROR --> SCH : SchProcCellDeleteReq(): failed to send Cell Delete response");
ret = RFAILED;
}
}
SchCellCb *cell = NULLP;
Inst inst = pst->dstInst-SCH_INST_START;
- DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume);
+ DU_LOG("DEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume);
cell = schCb[inst].cells[inst];
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcDlRlcBoInfo(): Cell does not exists");
+ DU_LOG("ERROR --> SCH : SchProcDlRlcBoInfo(): Cell does not exists");
return RFAILED;
}
SchUeCb *ueCb = NULLP;
uint8_t lcgIdx = 0;
- DU_LOG("\nDEBUG --> SCH : Received BSR");
+ DU_LOG("DEBUG --> SCH : Received BSR");
if(bsrInd == NULLP)
{
- DU_LOG("\nERROR --> SCH : BSR Ind is empty");
+ DU_LOG("ERROR --> SCH : BSR Ind is empty");
return RFAILED;
}
cellCb = schCb[schInst].cells[schInst];
if(cellCb == NULLP)
{
- DU_LOG("\nERROR --> SCH : CellCb is empty");
+ DU_LOG("ERROR --> SCH : CellCb is empty");
return RFAILED;
}
ueCb = schGetUeCb(cellCb, bsrInd->crnti);
if(ueCb == NULLP)
{
- DU_LOG("\nERROR --> SCH : UeCB is empty");
+ DU_LOG("ERROR --> SCH : UeCB is empty");
return RFAILED;
}
if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION)
{
- DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
+ DU_LOG("INFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
return ROK;
}
SchUeCb *ueCb;
SchCellCb *cellCb = schCb[inst].cells[inst];
- DU_LOG("\nDEBUG --> SCH : Received SR");
+ DU_LOG("DEBUG --> SCH : Received SR");
ueCb = schGetUeCb(cellCb, uciInd->crnti);
if(ueCb->state == SCH_UE_STATE_INACTIVE)
{
- DU_LOG("\nERROR --> SCH : Crnti %d is inactive", uciInd->crnti);
+ DU_LOG("ERROR --> SCH : Crnti %d is inactive", uciInd->crnti);
return ROK;
}
if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION)
{
- DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
+ DU_LOG("INFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
return ROK;
}
if(uciInd->numSrBits)
SchUeCb *ueCb;
SchCellCb *cellCb = schCb[inst].cells[inst];
- DU_LOG("\nDEBUG --> SCH : Received HARQ");
+ DU_LOG("DEBUG --> SCH : Received HARQ");
ueCb = schGetUeCb(cellCb, dlHarqInd->crnti);
if(ueCb->state == SCH_UE_STATE_INACTIVE)
{
- DU_LOG("\nERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti);
+ DU_LOG("ERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti);
return ROK;
}
freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
if(!freePrbNode)
{
- DU_LOG("\nERROR --> SCH: Requested DL PRB unavailable");
+ DU_LOG("ERROR --> SCH: Requested DL PRB unavailable");
return RFAILED;
}
}
{
if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
{
- DU_LOG("\nERROR --> SCH: fillPrbBitmap() failed for symbol [%d] in DL", symbol);
+ DU_LOG("ERROR --> SCH: fillPrbBitmap() failed for symbol [%d] in DL", symbol);
return RFAILED;
}
}
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : allocatePrbUl(): Received cellCb is null");
+ DU_LOG("ERROR --> SCH : allocatePrbUl(): Received cellCb is null");
return RFAILED;
}
freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
if(!freePrbNode)
{
- DU_LOG("\nERROR --> SCH: Requested UL PRB unavailable");
+ DU_LOG("ERROR --> SCH: Requested UL PRB unavailable");
return RFAILED;
}
}
{
if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
{
- DU_LOG("\nERROR --> SCH: fillPrbBitmap() failed for symbol [%d] in UL", symbol);
+ DU_LOG("ERROR --> SCH: fillPrbBitmap() failed for symbol [%d] in UL", symbol);
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> SCH: Invalid Direction!");
+ DU_LOG("ERROR --> SCH: Invalid Direction!");
return (maxFreePRB);
}
}
else
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in addOrModifySliceCfgInSchDb");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in addOrModifySliceCfgInSchDb");
return RFAILED;
}
return ROK;
}
else
{
- DU_LOG("\nERROR --> SCH : Failed to store slice configuration in SchDb");
+ DU_LOG("ERROR --> SCH : Failed to store slice configuration in SchDb");
schSliceCfgRsp.cause = RESOURCE_UNAVAILABLE;
ret = RFAILED;
}
uint8_t ret = ROK;
Inst inst = pst->dstInst - SCH_INST_START;
- DU_LOG("\nINFO --> SCH : Received Slice Cfg request from MAC");
+ DU_LOG("INFO --> SCH : Received Slice Cfg request from MAC");
if(schSliceCfgReq)
{
if(schSliceCfgReq->listOfSlices)
/* filling the slice configuration response of each slice */
if(fillSliceCfgRsp(inst, &schCb[inst].sliceCfg, schCb[inst].cells[0], schSliceCfgReq) != ROK)
{
- DU_LOG("\nERROR --> SCH : Failed to fill the slice cfg rsp");
+ DU_LOG("ERROR --> SCH : Failed to fill the slice cfg rsp");
ret = RFAILED;
}
freeSchSliceCfgReq(schSliceCfgReq);
}
else
{
- DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL");
+ DU_LOG("ERROR --> SCH : Received SchSliceCfgReq is NULL");
ret = RFAILED;
}
return ret;
uint8_t ret = ROK;
Inst inst = pst->dstInst - SCH_INST_START;
- DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC");
+ DU_LOG("INFO --> SCH : Received Slice ReCfg request from MAC");
if(schSliceRecfgReq)
{
if(schSliceRecfgReq->listOfSlices)
/* filling the slice configuration response of each slice */
if(fillSliceRecfgRsp(inst, &schCb[inst].sliceCfg, schSliceRecfgReq) != ROK)
{
- DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response");
+ DU_LOG("ERROR --> SCH : Failed to fill sch slice cfg response");
ret = RFAILED;
}
freeSchSliceCfgReq(schSliceRecfgReq);
}
else
{
- DU_LOG("\nERROR --> SCH : Received SchSliceRecfgReq is NULL");
+ DU_LOG("ERROR --> SCH : Received SchSliceRecfgReq is NULL");
}
return ret;
SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
if(!currentNodeInfo)
{
- DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Memory allocation failed");
+ DU_LOG("ERROR --> SCH : schAddPagingIndtoList() : Memory allocation failed");
return RFAILED;
}
}
else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot))
{
- DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot);
+ DU_LOG("ERROR --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot);
return RFAILED;
}
else
{
cmLListAdd2Tail(storedPageList, currentNodeInfo);
}
- DU_LOG("\nDEBUG --> SCH : Paging information is stored successfully for PF:%d, Slot:%d",\
+ DU_LOG("DEBUG --> SCH : Paging information is stored successfully for PF:%d, Slot:%d",\
recvdNode->pageTxTime.sfn, recvdNode->pageTxTime.slot);
return ROK;
}
if(pageInd)
{
- DU_LOG("\nDEBUG --> SCH : Received paging indication from MAC for cellId[%d]",\
+ DU_LOG("DEBUG --> SCH : Received paging indication from MAC for cellId[%d]",\
pageInd->cellId);
/* Fetch Cell CB */
{
if(pageInd->i_s > cellCb->cellCfg.dlCfgCommon.schPcchCfg.numPO)
{
- DU_LOG("\nERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion");
+ DU_LOG("ERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion");
}
else
{
SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen);
if(!pageInfo->pagePdu)
{
- DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory");
+ DU_LOG("ERROR --> SCH : SchProcPagingInd(): Failed to allocate memory");
}
else
{
ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to store paging record");
+ DU_LOG("ERROR --> SCH : SchProcPagingInd(): Failed to store paging record");
}
}
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory");
+ DU_LOG("ERROR --> SCH : SchProcPagingInd(): Failed to allocate memory");
}
}
}
else
{
- DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", pageInd->cellId);
+ DU_LOG("ERROR --> SCH : Cell ID [%d] not found", pageInd->cellId);
}
SCH_FREE(pageInd->pagePdu, pageInd->pduLen);
SCH_FREE(pageInd, sizeof(SchPageInd));
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Received null pointer");
+ DU_LOG("ERROR --> SCH : SchProcPagingInd(): Received null pointer");
}
return ret;
}
if(!dlCqiInd)
{
- DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): CQI Ind is empty");
+ DU_LOG("ERROR --> SCH : SchProcDlCqiInd(): CQI Ind is empty");
ret = RFAILED;
}
else
cell = schCb[inst].cells[cellIdx];
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): cell Id[%d] not found", dlCqiInd->cellId);
+ DU_LOG("ERROR --> SCH : SchProcDlCqiInd(): cell Id[%d] not found", dlCqiInd->cellId);
ret = RFAILED;
}
else
ueCb = &cell->ueCb[ueId-1];
if(ueCb->crnti != dlCqiInd->crnti)
{
- DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): UeCb for received crnti[%d] not found", dlCqiInd->crnti);
+ DU_LOG("ERROR --> SCH : SchProcDlCqiInd(): UeCb for received crnti[%d] not found", dlCqiInd->crnti);
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): Received cell Id[%d] from MAC is not matching with CellID[%d] in SCH Cb",\
+ DU_LOG("ERROR --> SCH : SchProcDlCqiInd(): Received cell Id[%d] from MAC is not matching with CellID[%d] in SCH Cb",\
dlCqiInd->cellId, cell->cellId);
ret = RFAILED;
}
if(!ulCqiInd)
{
- DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): CQI Ind is empty");
+ DU_LOG("ERROR --> SCH : SchProcUlCqiInd(): CQI Ind is empty");
ret = RFAILED;
}
else
cell = schCb[inst].cells[cellIdx];
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): cell Id[%d] not found", ulCqiInd->cellId);
+ DU_LOG("ERROR --> SCH : SchProcUlCqiInd(): cell Id[%d] not found", ulCqiInd->cellId);
ret = RFAILED;
}
else
ueCb = &cell->ueCb[ueId-1];
if(ueCb->crnti != ulCqiInd->crnti)
{
- DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): UeCb for received crnti[%d] not found",ulCqiInd->crnti);
+ DU_LOG("ERROR --> SCH : SchProcUlCqiInd(): UeCb for received crnti[%d] not found",ulCqiInd->crnti);
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): Received cell Id[%d] from MAC is not matching with CellId[%d] in SCH Cb",\
+ DU_LOG("ERROR --> SCH : SchProcUlCqiInd(): Received cell Id[%d] from MAC is not matching with CellId[%d] in SCH Cb",\
ulCqiInd->cellId, cell->cellId);
ret = RFAILED;
}
if(!schPhrInd)
{
- DU_LOG("\nERROR --> SCH : SchProcPhrInd(): PHR is empty");
+ DU_LOG("ERROR --> SCH : SchProcPhrInd(): PHR is empty");
ret = RFAILED;
}
else
cell = schCb[inst].cells[cellIdx];
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : schProcPhrInd(): cell Id[%d] is not found", schPhrInd->cellId);
+ DU_LOG("ERROR --> SCH : schProcPhrInd(): cell Id[%d] is not found", schPhrInd->cellId);
ret = RFAILED;
}
else
ueCb = &cell->ueCb[ueId-1];
if(ueCb->crnti != schPhrInd->crnti)
{
- DU_LOG("\nERROR --> SCH : SchProcPhrInd(): UeCb for received crnti[%d] not found",schPhrInd->crnti);
+ DU_LOG("ERROR --> SCH : SchProcPhrInd(): UeCb for received crnti[%d] not found",schPhrInd->crnti);
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcPhrInd(): Mismatch between Received cell Id[%d] from MAC and CellID[%d] in SCH CB ",\
+ DU_LOG("ERROR --> SCH : SchProcPhrInd(): Mismatch between Received cell Id[%d] from MAC and CellID[%d] in SCH CB ",\
schPhrInd->cellId, cell->cellId);
ret = RFAILED;
}
uint8_t ret = ROK;
SchStatsRsp *schStatsRsp;
- DU_LOG("\nINFO --> SCH : Filling statistics response");
+ DU_LOG("INFO --> SCH : Filling statistics response");
SCH_ALLOC(schStatsRsp, sizeof(SchStatsRsp));
if(schStatsRsp == NULLP)
{
- DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsRspToMac()");
+ DU_LOG("ERROR --> SCH : Failed to allocate memory in SchSendStatsRspToMac()");
return RFAILED;
}
ret = MacMessageRouter(&rspPst, (void *)schStatsRsp);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH : SchSendStatsRspToMac(): Failed to send Statistics Response");
+ DU_LOG("ERROR --> SCH : SchSendStatsRspToMac(): Failed to send Statistics Response");
return ret;
}
return ret;
cmLListAdd2Tail(kpiList, node);
return ROK;
}
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
return RFAILED;
}
SCH_ALLOC(grpInfoDb, sizeof(SchStatsGrp));
if(grpInfoDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
cause = RESOURCE_UNAVAILABLE;
ret = RFAILED;
}
SCH_ALLOC(grpInfoDb->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage));
if(!grpInfoDb->kpiStats.dlTotalPrbUsage)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
measTypeInvalid = true;
cause = RESOURCE_UNAVAILABLE;
break;
SCH_ALLOC(grpInfoDb->kpiStats.ulTotalPrbUsage, sizeof(TotalPrbUsage));
if(!grpInfoDb->kpiStats.ulTotalPrbUsage)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__);
measTypeInvalid = true;
cause = RESOURCE_UNAVAILABLE;
break;
default:
{
- DU_LOG("\nERROR --> SCH : SchProcStatsReq: Invalid measurement type [%d]", \
+ DU_LOG("ERROR --> SCH : SchProcStatsReq: Invalid measurement type [%d]", \
grpInfo->statsList[reqMeasIdx]);
measTypeInvalid = true;
cause = PARAM_INVALID;
/* Step 2.2 */
if(schAddToKpiActiveList(&schCb[inst].statistics.activeKpiList.dlTotPrbUseList, (PTR)grpInfoDb->kpiStats.dlTotalPrbUsage)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__);
cause = RESOURCE_UNAVAILABLE;
ret =RFAILED;
break;
/* Step 2.2 */
if(schAddToKpiActiveList(&schCb[inst].statistics.activeKpiList.ulTotPrbUseList, (PTR)grpInfoDb->kpiStats.ulTotalPrbUsage) != ROK)
{
- DU_LOG("\nERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__);
cause = RESOURCE_UNAVAILABLE;
ret =RFAILED;
break;
else
{
/* Step 2.5.2 */
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
cause = RESOURCE_UNAVAILABLE;
ret = RFAILED;
break;
SchStatsRsp schStatsRsp;
Inst inst = pst->dstInst - SCH_INST_START;
- DU_LOG("\nINFO --> SCH : Received Statistics Request from MAC");
+ DU_LOG("INFO --> SCH : Received Statistics Request from MAC");
if(statsReq == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Received Null pointer");
+ DU_LOG("ERROR --> SCH : SchProcStatsReq(): Received Null pointer");
return RFAILED;
}
/*Step -1*/
if(schCb[inst].statistics.statsGrpList.count >= MAX_NUM_STATS_GRP)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsReq: Maximum number of statistics configured. \
+ DU_LOG("ERROR --> SCH : SchProcStatsReq: Maximum number of statistics configured. \
Cannot process new request.");
SchRejectAllStats(statsReq, RESOURCE_UNAVAILABLE);
SCH_FREE(statsReq, sizeof(SchStatsReq));
/*Step -4 */
if(schAddToStatsGrpList(inst, &schStatsRsp, statsReq->subscriptionId, grpInfo) != ROK)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list");
+ DU_LOG("ERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list");
if((schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected-1].groupId == grpInfo->groupId &&\
(schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected-1].cause == RESOURCE_UNAVAILABLE)))
{
uint8_t ret = ROK;
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> SCH : Filling statistics indication");
+ DU_LOG("DEBUG --> SCH : Filling statistics indication");
#endif
/* Filling post structure */
ret = MacMessageRouter(&pst, (void *)statsInd);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH : SchSendStatsIndToMac(): Failed to send Statistics Indication");
+ DU_LOG("ERROR --> SCH : SchSendStatsIndToMac(): Failed to send Statistics Indication");
}
return ret;
}
SchStatsDeleteRsp *schStatsDeleteRsp;
Inst inst = pst->dstInst - SCH_INST_START;
- DU_LOG("\nINFO --> SCH : Received Statistics Delete Request from MAC");
+ DU_LOG("INFO --> SCH : Received Statistics Delete Request from MAC");
if(statsDeleteReq == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsDeleteReq(): Received Null pointer");
+ DU_LOG("ERROR --> SCH : SchProcStatsDeleteReq(): Received Null pointer");
return RFAILED;
}
SCH_ALLOC(schStatsDeleteRsp, sizeof(SchStatsDeleteRsp));
if(schStatsDeleteRsp == NULLP)
{
- DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchProcStatsDeleteReq()");
+ DU_LOG("ERROR --> SCH : Failed to allocate memory in SchProcStatsDeleteReq()");
return RFAILED;
}
schStatsDeleteRsp->subscriptionId=statsDeleteReq->subscriptionId;
ret = MacMessageRouter(&rspPst, (void *)schStatsDeleteRsp);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsDeleteReq(): Failed to send Statistics Response");
+ DU_LOG("ERROR --> SCH : SchProcStatsDeleteReq(): Failed to send Statistics Response");
}
SCH_FREE(statsDeleteReq, sizeof(SchStatsDeleteReq));
uint8_t ret = ROK;
SchStatsModificationRsp *schStatsModificationRsp=NULLP;
- DU_LOG("\nINFO --> SCH : Filling statistics modification response");
+ DU_LOG("INFO --> SCH : Filling statistics modification response");
SCH_ALLOC(schStatsModificationRsp, sizeof(SchStatsModificationRsp));
if(schStatsModificationRsp == NULLP)
{
- DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsModificationRspToMac()");
+ DU_LOG("ERROR --> SCH : Failed to allocate memory in SchSendStatsModificationRspToMac()");
return RFAILED;
}
ret = MacMessageRouter(&rspPst, (void *)schStatsModificationRsp);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH : SchSendStatsModificationRspToMac(): Failed to send Statistics Modification Response");
+ DU_LOG("ERROR --> SCH : SchSendStatsModificationRspToMac(): Failed to send Statistics Modification Response");
return ret;
}
return ret;
inst=pst->dstInst - SCH_INST_START;
- DU_LOG("\nINFO --> SCH : Received Statistics modification request from MAC");
+ DU_LOG("INFO --> SCH : Received Statistics modification request from MAC");
if(statsModificationReq == NULLP)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsModificationReq(): Received Null pointer");
+ DU_LOG("ERROR --> SCH : SchProcStatsModificationReq(): Received Null pointer");
return RFAILED;
}
memset(&statsModificationRsp, 0, sizeof(SchStatsRsp));
/* [Step - 4.1.2] */
if(schAddToStatsGrpList(inst, &statsModificationRsp, subscriptionId, &statsGrpToModify) != ROK)
{
- DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list");
+ DU_LOG("ERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list");
if(statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected-1].groupId == statsGrpToModify.groupId)
{
/* [Step - 4.1.3] */
if(cell == NULL)
{
- DU_LOG("\nERROR --> SCH: schBroadcastSsbAlloc() : Cell is NULL");
+ DU_LOG("ERROR --> SCH: schBroadcastSsbAlloc() : Cell is NULL");
return RFAILED;
}
if(dlBrdcstAlloc == NULL)
{
- DU_LOG("\nERROR --> SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
+ DU_LOG("ERROR --> SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
return RFAILED;
}
if((allocatePrbDl(cell, slotTime, ssbStartSymb, SCH_SSB_NUM_SYMB, &ssbInfo.fdAlloc.startPrb, ssbInfo.fdAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH: PRB allocation failed for SSB in SFN:SLOT [%d : %d]", slotTime.sfn, slotTime.slot);
+ DU_LOG("ERROR --> SCH: PRB allocation failed for SSB in SFN:SLOT [%d : %d]", slotTime.sfn, slotTime.slot);
return RFAILED;
}
if(cell == NULL)
{
- DU_LOG("\nERROR --> SCH: schBroadcastSsbAlloc() : Cell is NULL");
+ DU_LOG("ERROR --> SCH: schBroadcastSsbAlloc() : Cell is NULL");
return RFAILED;
}
if(dlBrdcstAlloc == NULL)
{
- DU_LOG("\nERROR --> SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
+ DU_LOG("ERROR --> SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
return RFAILED;
}
/* Allocate PRB */
if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol, &freqAlloc.startPrb, freqAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH: PRB allocation failed for SIB1 in SFN:Slot [%d : %d]", slotTime.sfn, slotTime.slot);
+ DU_LOG("ERROR --> SCH: PRB allocation failed for SIB1 in SFN:Slot [%d : %d]", slotTime.sfn, slotTime.slot);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in %s", __func__);
+ DU_LOG("ERROR --> SCH : Memory allocation failed in %s", __func__);
return RFAILED;
}
return ROK;
}/* To Add support for more Pucch Format */
default:
- DU_LOG("\nERROR --> SCH : Invalid PUCCH format[%d] in fillUlSchedPucchFormatCfg()", pucchFormat);
+ DU_LOG("ERROR --> SCH : Invalid PUCCH format[%d] in fillUlSchedPucchFormatCfg()", pucchFormat);
ret = RFAILED;
return ret;
}
if(ret == RFAILED)
{
memset(schPucchInfo, 0, sizeof(SchPucchInfo));
- DU_LOG("\nERROR --> SCH : Filling PUCCH dedicated cfg failed at fillPucchResourceInfo()");
+ DU_LOG("ERROR --> SCH : Filling PUCCH dedicated cfg failed at fillPucchResourceInfo()");
return ret;
}
}
}
else
{
- DU_LOG("\nERROR --> SCH: Invalid value of r_pucch:%d (greater than 15) ", r_pucch);
+ DU_LOG("ERROR --> SCH: Invalid value of r_pucch:%d (greater than 15) ", r_pucch);
memset(schPucchInfo, 0, sizeof(SchPucchInfo));
return ret;
}
ret = sendUlSchInfoToMac(&ulSchedInfo, schInst);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCH : Sending UL Sch info from SCH to MAC failed");
+ DU_LOG("ERROR --> SCH : Sending UL Sch info from SCH to MAC failed");
}
}
if(cell == NULL)
{
- DU_LOG("\nERROR --> SCH: schDlRsrcAllocMsg4() : Cell is NULL");
+ DU_LOG("ERROR --> SCH: schDlRsrcAllocMsg4() : Cell is NULL");
return RFAILED;
}
if(dlMsgAlloc == NULL)
{
- DU_LOG("\nERROR --> SCH: schDlRsrcAllocMsg4() : dlMsgAlloc is NULL");
+ DU_LOG("ERROR --> SCH: schDlRsrcAllocMsg4() : dlMsgAlloc is NULL");
return RFAILED;
}
if(!msg4Alloc->dlMsgPdcchCfg)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in %s",__func__);
+ DU_LOG("ERROR --> SCH : Memory allocation failed in %s",__func__);
return RFAILED;
}
pdcch = msg4Alloc->dlMsgPdcchCfg;
if((allocatePrbDl(cell, msg4Time, startSymbol, numSymbol,\
&pdsch->pdschFreqAlloc.startPrb, pdsch->pdschFreqAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH : Resource allocation failed for MSG4");
+ DU_LOG("ERROR --> SCH : Resource allocation failed for MSG4");
SCH_FREE(msg4Alloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
return RFAILED;
}
SCH_ALLOC(dlMsgAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
if(!dlMsgAlloc->dlMsgPdcchCfg)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schDlRsrcAllocDlMsg");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schDlRsrcAllocDlMsg");
return RFAILED;
}
pdcch = dlMsgAlloc->dlMsgPdcchCfg;
pdcch->coresetCfg.startSymbolIndex = pdcchStartSymbol;
else
{
- DU_LOG("\nERROR --> SCH : Invalid SymbolIndex in schDlRsrcAllocDlMsg");
+ DU_LOG("ERROR --> SCH : Invalid SymbolIndex in schDlRsrcAllocDlMsg");
return RFAILED;
}
pdcch->coresetCfg.durationSymbols = coreset1.duration;
}
else
{
- DU_LOG("\nERROR --> SCH : CORESETSize is zero in schDlRsrcAllocDlMsg");
+ DU_LOG("ERROR --> SCH : CORESETSize is zero in schDlRsrcAllocDlMsg");
return RFAILED;
}
pdcch->coresetCfg.precoderGranularity = coreset1.precoderGranularity;
if(pdcch->numDlDci >= MAX_NUM_PDCCH)
{
- DU_LOG("\nERROR --> SCH: MAX number of PDCCH allocted for this slot.");
+ DU_LOG("ERROR --> SCH: MAX number of PDCCH allocted for this slot.");
return RFAILED;
}
pdcch->dci[pdcch->numDlDci].rnti = ueCb.crnti;
if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
&pdsch->pdschFreqAlloc.startPrb, pdsch->pdschFreqAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH : allocatePrbDl() failed for DL MSG");
+ DU_LOG("ERROR --> SCH : allocatePrbDl() failed for DL MSG");
SCH_FREE(dlMsgAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
return RFAILED;
}
if(lcLL == NULLP)
{
- DU_LOG("\nERROR --> SCH: LcList not present");
+ DU_LOG("ERROR --> SCH: LcList not present");
return;
}
node = lcLL->first;
* process of LCID which was fully allocated. Check is just for safety purpose*/
if(lcNode->reqBO == 0 && lcNode->allocBO == 0)
{
- DU_LOG("\nERROR --> SCH: LCID:%d has no requirement, clearing this node",\
+ DU_LOG("ERROR --> SCH: LCID:%d has no requirement, clearing this node",\
lcNode->lcId);
deleteNodeFromLList(lcLL, node);
SCH_FREE(lcNode, sizeof(LcInfo));
/*[Exit1]: All LCs are allocated(allocBO = 0 for fully unallocated LC)*/
if(lcNode->allocBO != 0)
{
- DU_LOG("\nDEBUG --> SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB);
+ DU_LOG("DEBUG --> SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB);
return;
}
/*Loop Exit: All resources exhausted*/
if(remReservedPRB == 0 && *sharedPRB == 0)
{
- DU_LOG("\nDEBUG --> SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId);
+ DU_LOG("DEBUG --> SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId);
return;
}
}
/*Loop Exit: All resources exhausted*/
if(*sharedPRB == 0)
{
- DU_LOG("\nDEBUG --> SCH: Default resources exhausted for LC:%d",lcNode->lcId);
+ DU_LOG("DEBUG --> SCH: Default resources exhausted for LC:%d",lcNode->lcId);
return;
}
}
/*[Step4]*/
if((isTxPayloadLenAdded != NULLP) && (*isTxPayloadLenAdded == FALSE))
{
- DU_LOG("\nDEBUG --> SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\
+ DU_LOG("DEBUG --> SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\
lcNode->lcId);
*isTxPayloadLenAdded = TRUE;
lcNode->allocBO = calculateEstimateTBSize((lcNode->reqBO + TX_PAYLOAD_HDR_LEN),\
}
else if((srRcvd != NULLP) && (*srRcvd == TRUE))
{
- DU_LOG("\nDEBUG --> SCH: LC:%d is the First node to be allocated which includes UL_GRANT_SIZE",\
+ DU_LOG("DEBUG --> SCH: LC:%d is the First node to be allocated which includes UL_GRANT_SIZE",\
lcNode->lcId);
*srRcvd = FALSE;
lcNode->reqBO += UL_GRANT_SIZE;
{
if(*sharedPRB <= (estPrb - remReservedPRB))
{
- DU_LOG("\nDEBUG --> SCH: SharedPRB is less");
+ DU_LOG("DEBUG --> SCH: SharedPRB is less");
*sharedPRB = 0;
}
else
if(lcLL == NULLP)
{
- DU_LOG("\nERROR --> SCH: LcList not present");
+ DU_LOG("ERROR --> SCH: LcList not present");
return;
}
lcNode = (LcInfo *)node->node;
if(lcNode != NULLP)
{
- DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
+ DU_LOG("INFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
lcNode->lcId, lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB);
if(dlMsgAlloc != NULLP)
{
/*Calculate the Total Payload/BO size allocated*/
*accumalatedBOSize += dlMsgAlloc->transportBlock[0].lcSchInfo[dlMsgAlloc->transportBlock[0].numLc].schBytes;
- DU_LOG("\nINFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\
+ DU_LOG("INFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\
lcNode->lcId,lcNode->reqBO, dlMsgAlloc->transportBlock[0].numLc, *accumalatedBOSize);
dlMsgAlloc->transportBlock[0].numLc++;
else if(bsrInfo != NULLP)
{
*accumalatedBOSize += lcNode->allocBO;
- DU_LOG("\nINFO --> SCH: UL : LCID:%d,reqBO:%d, TotalBO Size:%d",\
+ DU_LOG("INFO --> SCH: UL : LCID:%d,reqBO:%d, TotalBO Size:%d",\
lcNode->lcId,lcNode->reqBO, *accumalatedBOSize);
}
}
if(cell == NULL)
{
- DU_LOG("\nERROR --> SCH: schProcessMsg4Req() : Cell is NULL");
+ DU_LOG("ERROR --> SCH: schProcessMsg4Req() : Cell is NULL");
return RFAILED;
}
{
if (RFAILED == schDlGetAvlHqProcess(cell, &cell->ueCb[ueId - 1], msg4HqProc))
{
- DU_LOG("\nERROR --> SCH: schProcessMsg4Req() : No process");
+ DU_LOG("ERROR --> SCH: schProcessMsg4Req() : No process");
return RFAILED;
}
}
if(findValidK0K1Value(cell, currTime, ueId, false, &pdschStartSymbol, &pdschNumSymbols, &pdcchTime, &pdschTime,\
&pucchTime, isRetxMsg4, *msg4HqProc, NULLP) != true )
{
- DU_LOG("\nERROR --> SCH: schProcessMsg4Req() : k0 k1 not found");
+ DU_LOG("ERROR --> SCH: schProcessMsg4Req() : k0 k1 not found");
return RFAILED;
}
SCH_ALLOC(dciSlotAlloc, sizeof(DlMsgSchInfo));
if(dciSlotAlloc == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciSlotAlloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciSlotAlloc");
return RFAILED;
}
cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = dciSlotAlloc;
/* Fill PDCCH and PDSCH scheduling information for Msg4 */
if((schDlRsrcAllocMsg4(cell, pdschTime, ueId, dciSlotAlloc, pdschStartSymbol, pdschNumSymbols, isRetxMsg4, *msg4HqProc)) != ROK)
{
- DU_LOG("\nERROR --> SCH: Scheduling of Msg4 failed in slot [%d]", pdschTime.slot);
+ DU_LOG("ERROR --> SCH: Scheduling of Msg4 failed in slot [%d]", pdschTime.slot);
if(!dciSlotAlloc->dlMsgPdschCfg)
{
SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
SCH_ALLOC(dciSlotAlloc->dlMsgPdschCfg, sizeof(PdschCfg));
if(!dciSlotAlloc->dlMsgPdschCfg)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciSlotAlloc->dlMsgPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciSlotAlloc->dlMsgPdschCfg");
SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
SCH_ALLOC(msg4SlotAlloc, sizeof(DlMsgSchInfo));
if(msg4SlotAlloc == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for msg4SlotAlloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for msg4SlotAlloc");
SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
if(!dciSlotAlloc->dlMsgPdschCfg)
{
}
SCH_FREE(msg4SlotAlloc, sizeof(DlMsgSchInfo));
cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for msg4SlotAlloc->dlMsgPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for msg4SlotAlloc->dlMsgPdschCfg");
return RFAILED;
}
}
if(lcLL == NULLP)
{
- DU_LOG("\nERROR --> SCH: LcList not present");
+ DU_LOG("ERROR --> SCH: LcList not present");
return;
}
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH: schProcessSrOrBsrReq() : Cell is NULL");
+ DU_LOG("ERROR --> SCH: schProcessSrOrBsrReq() : Cell is NULL");
return false;
}
if(ueCb == NULLP)
{
- DU_LOG("\nERROR --> SCH: schProcessSrOrBsrReq() : UE is NULL");
+ DU_LOG("ERROR --> SCH: schProcessSrOrBsrReq() : UE is NULL");
return false;
}
if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
&pageDlSch->freqAlloc.startPrb, pageDlSch->freqAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH : allocatePrbDl() failed for DL MSG");
+ DU_LOG("ERROR --> SCH : allocatePrbDl() failed for DL MSG");
return RFAILED;
}
return ROK;
SCH_ALLOC(dciInfo, sizeof(DciInfo));
if(!dciInfo)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciInfo alloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciInfo alloc");
return RFAILED;
}
cell->schDlSlotInfo[msg3Time.slot]->ulGrant = dciInfo;
pdcchCfg = &ue->ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg;
if(pdcchCfg == NULLP)
{
- DU_LOG("\nERROR --> SCH: PDCCH Cfg is not received thus skip filling of Coreset & SS info");
+ DU_LOG("ERROR --> SCH: PDCCH Cfg is not received thus skip filling of Coreset & SS info");
return RFAILED;
}
for(cRSetIdx = 0; cRSetIdx < pdcchCfg->numCRsetToAddMod; cRSetIdx++ )
}
else
{
- DU_LOG("\nERROR --> SCH : CORESETSize is zero in fillCoresetAndSsConfg");
+ DU_LOG("ERROR --> SCH : CORESETSize is zero in fillCoresetAndSsConfg");
continue;
}
/*[Step 2]:*/
if(!mSlotPeriodicityVal)
{
- DU_LOG("\nERROR --> SCH: Slot Periodicity is ZERO thus cant proceed with this SearchSpace");
+ DU_LOG("ERROR --> SCH: Slot Periodicity is ZERO thus cant proceed with this SearchSpace");
return false;
}
/*The Monitoring slot begins from offset thus skip the slots which are less
* SlotPeriodicity*/
if(((slotNum - searchSpace->mSlotPeriodicityAndOffset.mSlotOffset) % mSlotPeriodicityVal) == 0)
{
- DU_LOG("\nINFO --> SCH: SFN:%d/Slot:%d, is a Valid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
+ DU_LOG("INFO --> SCH: SFN:%d/Slot:%d, is a Valid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
isSlotValid = true;
}
else
{
- DU_LOG("\nINFO --> SCH: SFN:%d/Slot:%d, is InValid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
+ DU_LOG("INFO --> SCH: SFN:%d/Slot:%d, is InValid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
}
}
return (isSlotValid);
startPrb = extractStartPrbForRBG(pdcchInfo->cRSetRef->freqDomainRsrc, rbgIndex);
if(startPrb == MAX_NUM_RB)
{
- DU_LOG("\nERROR --> SCH: No RBG is allocated for PDCCH in this Coreset");
+ DU_LOG("ERROR --> SCH: No RBG is allocated for PDCCH in this Coreset");
return false;
}
/*[Step 2]: Adjust StartPrb based on CCEIndex and duration*/
/*numPrb will also get adjusted with duration*/
numPrb = (NUM_PRBS_PER_RBG * aggLvl) / pdcchInfo->cRSetRef->duration;
- DU_LOG("\nDEBUG --> SCH: RBG found for cceIndex:%d, AggLvl:%d and SymbolDuration%d with StartPrb:%d, numPrb:%d",\
+ DU_LOG("DEBUG --> SCH: RBG found for cceIndex:%d, AggLvl:%d and SymbolDuration%d with StartPrb:%d, numPrb:%d",\
cceIndex, aggLvl, pdcchInfo->cRSetRef->duration, startPrb, numPrb);
ret = allocatePrbDl(cellCb, slotTime, startSymbol,\
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> SCH: PRBs can't be allocated as they are unavailable");
+ DU_LOG("ERROR --> SCH: PRBs can't be allocated as they are unavailable");
return false;
}
return true;
pdcchInfo = &ueCb->pdcchInfo[cRSetIdx];
if(pdcchInfo->cRSetRef == NULLP)
{
- DU_LOG("\nINFO --> SCH: Coreset is not availabe at Index:%d",cRSetIdx);
+ DU_LOG("INFO --> SCH: Coreset is not availabe at Index:%d",cRSetIdx);
continue;
}
/*[Step 1]:*/
if(false == schPdcchSlotValidation(pdcchTime, pdcchInfo->ssRef, ueCb->cellCb->numSlots))
{
- DU_LOG("\nINFO --> SCH: This slot is not valid for PDCCH in this CORESET:%d.",pdcchInfo->cRSetRef->cRSetId);
+ DU_LOG("INFO --> SCH: This slot is not valid for PDCCH in this CORESET:%d.",pdcchInfo->cRSetRef->cRSetId);
break;
}
/*[Step 2]:*/
numCandidates = extractNumOfCandForAggLvl(pdcchInfo->ssRef, nextLowerAggLvl);
if(!numCandidates)
{
- DU_LOG("\nINFO --> SCH: Num Of Candidates configured for this AggLvel:%d is ZERO",baseAggLvl);
+ DU_LOG("INFO --> SCH: Num Of Candidates configured for this AggLvel:%d is ZERO",baseAggLvl);
}
/*[Step 5]:*/
cceIndex = baseAggLvl * (a % b);
if(schCheckPdcchAvail(ueCb->cellCb, pdcchTime, cceIndex, pdcchInfo,nextLowerAggLvl) == true)
{
- DU_LOG("\nINFO --> SCH: PDCCH allocation is successful at cceIndex:%d",cceIndex);
+ DU_LOG("INFO --> SCH: PDCCH allocation is successful at cceIndex:%d",cceIndex);
pdcchAllocInfo->cRSetId = pdcchInfo->cRSetRef->cRSetId;
pdcchAllocInfo->aggLvl = nextLowerAggLvl;
pdcchAllocInfo->cceIndex = cceIndex;
}
if (cell->ueCb[ueId-1].hqUlmap[crcInd->timingInfo.slot]->hqList.first == 0)
{
- DU_LOG("\nERROR --> SCH: NULL harq stored in ul hq map at slot %d ue id %d\n",\
+ DU_LOG("ERROR --> SCH: NULL harq stored in ul hq map at slot %d ue id %d\n",\
crcInd->timingInfo.slot, ueId);
crcCnt++;
continue;
SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
if(!currentNodeInfo)
{
- DU_LOG("\nERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
+ DU_LOG("ERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
return RFAILED;
}
cmLListAdd2Tail(drxTimerList, currentNodeInfo);
(*drxNodeInfo) = currentNodeInfo;
- DU_LOG("\nINFO --> SCH : Drx node added into the list");
+ DU_LOG("INFO --> SCH : Drx node added into the list");
return ROK;
}
SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
if(!currentNodeInfo)
{
- DU_LOG("\nERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
+ DU_LOG("ERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
return RFAILED;
}
cmLListAdd2Tail(drxTimerList, currentNodeInfo);
(*drxNodeInfo) = currentNodeInfo;
- DU_LOG("\nINFO --> SCH : Drx node added into the list");
+ DU_LOG("INFO --> SCH : Drx node added into the list");
return ROK;
}
SCH_ALLOC(fcfsCellCb, sizeof(SchFcfsCellCb));
if(!fcfsCellCb)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schFcfsCellCfgReq");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schFcfsCellCfgReq");
return RFAILED;
}
cmLListInit(&fcfsCellCb->ueToBeScheduled);
SCH_ALLOC(ueFcfsCb, sizeof(SchFcfsHqCb));
if(!ueFcfsCb)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in SchFcfsAddUeConfigReq");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in SchFcfsAddUeConfigReq");
return RFAILED;
}
SCH_ALLOC(fcfsHqP, sizeof(SchFcfsHqProcCb));
if(!fcfsHqP)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schFcfsInitDlHqProcCb");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schFcfsInitDlHqProcCb");
return RFAILED;
}
SCH_ALLOC(fcfsHqP, sizeof(SchFcfsHqProcCb));
if(!fcfsHqP)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schFcfsInitUlHqProcCb");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schFcfsInitUlHqProcCb");
return RFAILED;
}
cmLListInit(&fcfsHqP->lcCb.dedLcList);
SCH_ALLOC(ueId, sizeof(uint8_t));
if(!ueId)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failure in schFcfsAddUeToSchedule");
+ DU_LOG("ERROR --> SCH : Memory allocation failure in schFcfsAddUeToSchedule");
return RFAILED;
}
*ueId = ueIdToAdd;
if(addNodeToLList(&fcfsCellCb->ueToBeScheduled, ueId, NULLP) != ROK)
{
- DU_LOG("\nERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
+ DU_LOG("ERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
return RFAILED;
}
return ROK;
/*[Step2]: Update the reqPRB and Payloadsize for this LC in the appropriate List*/
if(updateLcListReqPRB(lcLL, lcId, ueCb->bsrInfo[lcgIdx].dataVol) != ROK)
{
- DU_LOG("\nERROR --> SCH: LcgId:%d updation failed",lcId);
+ DU_LOG("ERROR --> SCH: LcgId:%d updation failed",lcId);
return RFAILED;
}
}
if((fcfsHqP->lcCb.dedLcList.count == 0) || ((maxFreePRB < rsvdDedicatedPRB)))
{
fcfsHqP->lcCb.sharedNumPrb = maxFreePRB;
- DU_LOG("\nDEBUG --> SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\
+ DU_LOG("DEBUG --> SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\
fcfsHqP->lcCb.sharedNumPrb);
/*PRB Alloc for Default LCs*/
{
if(maxFreePRB == 0)
{
- DU_LOG("\nERROR --> SCH : NO FREE PRB!!");
+ DU_LOG("ERROR --> SCH : NO FREE PRB!!");
}
else
{
/*Schedule the LC for next slot*/
- DU_LOG("\nDEBUG --> SCH : No LC has been scheduled");
+ DU_LOG("DEBUG --> SCH : No LC has been scheduled");
}
return RFAILED;
}
SCH_ALLOC(dciInfo, sizeof(DciInfo));
if(!dciInfo)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciInfo alloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciInfo alloc");
if(isRetx != TRUE)
{
if(fcfsHqProcCb->lcCb.dedLcList.count != 0)
if(updateLcListReqPRB(lcLL, ueCb->dlInfo.dlLcCtxt[lcIdx].lcId,\
(ueCb->dlInfo.dlLcCtxt[lcIdx].bo + MAC_HDR_SIZE)) != ROK)
{
- DU_LOG("\nERROR --> SCH : Updation in LC List Failed");
+ DU_LOG("ERROR --> SCH : Updation in LC List Failed");
/* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
if(!dciSlotAlloc->dlMsgPdschCfg)
{
if ((fcfsHqProcCb->lcCb.defLcList.count == 0) && (fcfsHqProcCb->lcCb.dedLcList.count == 0))
{
- DU_LOG("\nDEBUG --> SCH : No pending BO for any LC id\n");
+ DU_LOG("DEBUG --> SCH : No pending BO for any LC id\n");
UNSET_ONE_BIT((*hqP)->hqEnt->ue->ueId, (*hqP)->hqEnt->cell->boIndBitMap);
/* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
if((fcfsHqProcCb->lcCb.dedLcList.count == NULLP) || ((maxFreePRB < rsvdDedicatedPRB)))
{
fcfsHqProcCb->lcCb.sharedNumPrb = maxFreePRB;
- DU_LOG("\nDEBUG --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\
+ DU_LOG("DEBUG --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\
fcfsHqProcCb->lcCb.sharedNumPrb);
/*PRB Alloc for Default LCs*/
{
if(maxFreePRB == 0)
{
- DU_LOG("\nERROR --> SCH : NO FREE PRB!!");
+ DU_LOG("ERROR --> SCH : NO FREE PRB!!");
}
else
{
/*Schedule the LC for next slot*/
- DU_LOG("\nDEBUG --> SCH : No LC has been scheduled");
+ DU_LOG("DEBUG --> SCH : No LC has been scheduled");
}
/* Not Freeing dlMsgAlloc as ZERO BO REPORT to be sent to RLC so that
* Allocation can be done in next slot*/
}
if(!isUlGrantPending && !isDlMsgPending && !isRarPending && !isMsg4Pending)
{
- DU_LOG("\nERROR --> SCH: In SchFcfsScheduleSlot, UE:%d is wrongly queued\
+ DU_LOG("ERROR --> SCH: In SchFcfsScheduleSlot, UE:%d is wrongly queued\
in Pending UE List without any actions, Removing the UE from the list",ueId);
schFcfsRemoveUeFrmScheduleLst(cell, pendingUeNode);
}
if(cell->schDlSlotInfo[slotInd->slot]->prbAlloc.numPrbAlloc >= MAX_NUM_RB)
{
- DU_LOG("\nINFO --> SCH: No PRB available to proceed with next UE");
+ DU_LOG("INFO --> SCH: No PRB available to proceed with next UE");
return;
}
pendingUeNode = fcfsCell->ueToBeScheduled.first;
{
if(hqP->hqEnt->free.count == 0)
{
- DU_LOG("\n ERROR schUlHqDeleteFromInUseList no proc in in free\n");
+ DU_LOG(" ERROR schUlHqDeleteFromInUseList no proc in in free\n");
}
cmLListDelFrm(&(hqP->hqEnt->free), &hqP->ulHqEntLnk);
}
{
if(hqP->hqEnt->inUse.count == 0)
{
- DU_LOG("\n ERROR schUlHqDeleteFromInUseList no proc in in use\n");
+ DU_LOG(" ERROR schUlHqDeleteFromInUseList no proc in in use\n");
}
cmLListDelFrm(&(hqP->hqEnt->inUse), &hqP->ulHqEntLnk);
}
strcpy(message,"Invalid Event");
break;
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
}
default:
{
- DU_LOG("\nERROR --> SCH : SchMessageRouter(): Invalid event [%d] received", pst->event);
+ DU_LOG("ERROR --> SCH : SchMessageRouter(): Invalid event [%d] received", pst->event);
return RFAILED;
}
}
if(UL_SLOT != schGetSlotSymbFrmt(prachOccasionTimingInfo.slot % cell->numSlotsInPeriodicity,\
cell->slotFrmtBitMap))
{
- DU_LOG("\nERROR --> SCH : PrachCfgIdx %d doesn't support UL slot", prachCfgIdx);
+ DU_LOG("ERROR --> SCH : PrachCfgIdx %d doesn't support UL slot", prachCfgIdx);
return FALSE;
}
#endif
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : schPrachResAlloc(): Received cellCb is null");
+ DU_LOG("ERROR --> SCH : schPrachResAlloc(): Received cellCb is null");
return;
}
ulSchedInfo->prachSchInfo.prachFormat = prachFormat;
ulSchedInfo->prachSchInfo.numRa = numRa;
ulSchedInfo->prachSchInfo.prachStartSymb = prachStartSymbol;
- DU_LOG("\nINFO --> SCH : RACH occassion set for slot %d", prachOccasionTimingInfo.slot);
+ DU_LOG("INFO --> SCH : RACH occassion set for slot %d", prachOccasionTimingInfo.slot);
}
/**
SchUeCb *ueCb = NULLP;
SchRachRsrcRsp *rachRsrcRsp = NULLP;
- DU_LOG("\nINFO --> SCH : Received RACH resource request for Cell ID [%d] CRNTI [%d]", \
+ DU_LOG("INFO --> SCH : Received RACH resource request for Cell ID [%d] CRNTI [%d]", \
schRachRsrcReq->cellId, schRachRsrcReq->crnti);
/* Fill RACH resource response to MAC */
SCH_ALLOC(rachRsrcRsp, sizeof(SchRachRsrcRsp));
if(!rachRsrcRsp)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed for RACH resource response");
+ DU_LOG("ERROR --> SCH : Memory allocation failed for RACH resource response");
return RFAILED;
}
rachRsrcRsp->cellId = schRachRsrcReq->cellId;
ueCb = schGetUeCb(cellCb, schRachRsrcReq->crnti);
if(ueCb->crnti != schRachRsrcReq->crnti)
{
- DU_LOG("\nERROR --> SCH : CRNTI [%d] not found" ,schRachRsrcReq->crnti);
+ DU_LOG("ERROR --> SCH : CRNTI [%d] not found" ,schRachRsrcReq->crnti);
rachRsrcRsp->result = RSP_NOK;
}
}
else
{
- DU_LOG("\nERROR --> SCH : Cell ID [%d] not found" ,schRachRsrcReq->cellId);
+ DU_LOG("ERROR --> SCH : Cell ID [%d] not found" ,schRachRsrcReq->cellId);
rachRsrcRsp->result = RSP_NOK;
}
}
else
{
- DU_LOG("\nINFO : SCH : No dedicated preameble availble to assign to ssbIdx[%d]", schRachRsrcReq->ssbIdx[ssbIdx]);
+ DU_LOG("INFO : SCH : No dedicated preameble availble to assign to ssbIdx[%d]", schRachRsrcReq->ssbIdx[ssbIdx]);
/* Breaking out of for loop since no dedicated preambles are available
* for remaining ssbIdx too */
break;
cell = schCb[schInst].cells[schInst];
if(cell == NULL)
{
- DU_LOG("\n\nERROR --> SCH : Failed to find cell in schAllocMsg3Pusch");
+ DU_LOG("ERROR --> SCH : Failed to find cell in schAllocMsg3Pusch");
return NULLP;
}
SCH_ALLOC(schUlSlotInfo->schPuschInfo[ueId - 1], sizeof(SchPuschInfo));
if(!schUlSlotInfo->schPuschInfo[ueId - 1])
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in schAllocMsg3Pusch");
+ DU_LOG("ERROR --> SCH : Memory allocation failed in schAllocMsg3Pusch");
return NULLP;
}
cell->schUlSlotInfo[msg3SlotTime.slot]->puschPres = true;
SCH_ALLOC(dciSlotAlloc, sizeof(RarAlloc));
if(dciSlotAlloc == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciSlotAlloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciSlotAlloc");
return false;
}
cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = dciSlotAlloc;
/* Fill PDCCH and PDSCH scheduling information for RAR */
if((schFillRar(cell, rarTime, ueId, dciSlotAlloc, k0Index)) != ROK)
{
- DU_LOG("\nERROR --> SCH: Scheduling of RAR failed in slot [%d]", rarSlot);
+ DU_LOG("ERROR --> SCH: Scheduling of RAR failed in slot [%d]", rarSlot);
if(!dciSlotAlloc->rarPdschCfg)
{
SCH_FREE(dciSlotAlloc, sizeof(RarAlloc));
{
SCH_FREE(dciSlotAlloc, sizeof(RarAlloc));
cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = NULLP;
- DU_LOG("\nERROR --> SCH : Resource allocation for PUCCH failed for CFRA!");
+ DU_LOG("ERROR --> SCH : Resource allocation for PUCCH failed for CFRA!");
return false;
}
SCH_FREE(dciSlotAlloc->rarPdcchCfg, sizeof(PdcchCfg));
SCH_FREE(dciSlotAlloc, sizeof(RarAlloc));
cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = NULLP;
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciSlotAlloc->rarPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciSlotAlloc->rarPdschCfg");
return false;
}
SCH_ALLOC(rarSlotAlloc, sizeof(RarAlloc));
if(rarSlotAlloc == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for rarSlotAlloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for rarSlotAlloc");
SCH_FREE(dciSlotAlloc->rarPdcchCfg, sizeof(PdcchCfg));
if(!dciSlotAlloc->rarPdschCfg)
{
}
else
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for rarSlotAlloc->rarPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for rarSlotAlloc->rarPdschCfg");
SCH_FREE(dciSlotAlloc->rarPdcchCfg, sizeof(PdcchCfg));
if(!dciSlotAlloc->rarPdschCfg)
{
Inst schInst = pst->dstInst-SCH_INST_START;
SchCellCb *cell = schCb[schInst].cells[schInst];
- DU_LOG("\nINFO --> SCH : Received Rach indication");
+ DU_LOG("INFO --> SCH : Received Rach indication");
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH: Failed to find cell in SchProcRachInd");
+ DU_LOG("ERROR --> SCH: Failed to find cell in SchProcRachInd");
return RFAILED;
}
GET_UE_ID(rachInd->crnti, ueId);
if(ueId <= 0)
{
- DU_LOG("\nERROR --> SCH: Invalid CRNTI [%d]", rachInd->crnti);
+ DU_LOG("ERROR --> SCH: Invalid CRNTI [%d]", rachInd->crnti);
return RFAILED;
}
SCH_ALLOC(raReq, sizeof(SchRaReq));
if(!raReq)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failure in SchProcRachInd");
+ DU_LOG("ERROR --> SCH : Memory allocation failure in SchProcRachInd");
SCH_FREE(rachInd, sizeof(RachIndInfo));
return RFAILED;
}
SCH_ALLOC(rarAlloc->rarPdcchCfg, sizeof(PdcchCfg));
if(rarAlloc->rarPdcchCfg == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failed in %s",__func__);
+ DU_LOG("ERROR --> SCH : Memory allocation failed in %s",__func__);
return RFAILED;
}
PdcchCfg *pdcch = rarAlloc->rarPdcchCfg;
if((allocatePrbDl(cell, rarTime, startSymbol, numSymbol,\
&pdsch->pdschFreqAlloc.startPrb, pdsch->pdschFreqAlloc.numPrb)) != ROK)
{
- DU_LOG("\nERROR --> SCH : allocatePrbDl() failed for RAR");
+ DU_LOG("ERROR --> SCH : allocatePrbDl() failed for RAR");
SCH_FREE(rarAlloc->rarPdcchCfg, sizeof(PdcchCfg));
return RFAILED;
}
SchCellCb *cellCb = NULLP;
SchUeCb *ueCb = NULLP;
- DU_LOG("\nINFO --> SCH : Received RACH resource release for Cell ID [%d] CRNTI [%d]", \
+ DU_LOG("INFO --> SCH : Received RACH resource release for Cell ID [%d] CRNTI [%d]", \
schRachRsrcRel->cellId, schRachRsrcRel->crnti);
/* Fetch Cell CB */
ueCb = schGetUeCb(cellCb, schRachRsrcRel->crnti);
if(ueCb->crnti != schRachRsrcRel->crnti)
{
- DU_LOG("\nERROR --> SCH : CRNTI [%d] not found", schRachRsrcRel->crnti);
+ DU_LOG("ERROR --> SCH : CRNTI [%d] not found", schRachRsrcRel->crnti);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", schRachRsrcRel->cellId);
+ DU_LOG("ERROR --> SCH : Cell ID [%d] not found", schRachRsrcRel->cellId);
ret = RFAILED;
}
*/
void schMsg4Complete(SchUeCb *ueCb)
{
- DU_LOG("\nINFO --> SCH: State change for ueId[%2d] to SCH_RA_STATE_MSG4_DONE\n",ueCb->ueId);
+ DU_LOG("INFO --> SCH: State change for ueId[%2d] to SCH_RA_STATE_MSG4_DONE\n",ueCb->ueId);
ueCb->cellCb->raCb[ueCb->ueId-1].raState = SCH_RA_STATE_MSG4_DONE;
ueCb->msg4HqProc = ueCb->retxMsg4HqProc = NULLP;
}
SCH_ALLOC(schSpcCellCb, sizeof(SchSliceBasedCellCb));
if(!schSpcCellCb)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schSliceBasedCellCfgReq");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schSliceBasedCellCfgReq");
return RFAILED;
}
cmLListInit(&schSpcCellCb->ueToBeScheduled);
SCH_ALLOC(ueSliceBasedCb, sizeof(SchSliceBasedHqCb));
if(!ueSliceBasedCb)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in SchSliceBasedAddUeConfigReq");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in SchSliceBasedAddUeConfigReq");
return RFAILED;
}
SCH_ALLOC(schSpcHqP, sizeof(SchSliceBasedHqProcCb));
if(!schSpcHqP)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schSliceBasedInitDlHqProcCb");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schSliceBasedInitDlHqProcCb");
return RFAILED;
}
SCH_ALLOC(schSpcHqP, sizeof(SchSliceBasedHqProcCb));
if(!schSpcHqP)
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schSliceBasedInitUlHqProcCb");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schSliceBasedInitUlHqProcCb");
return RFAILED;
}
cmLListInit(&schSpcHqP->lcCb.dedLcList);
SCH_ALLOC(ueId, sizeof(uint8_t));
if(!ueId)
{
- DU_LOG("\nERROR --> SCH : Memory allocation failure in schSliceBasedAddUeToSchedule");
+ DU_LOG("ERROR --> SCH : Memory allocation failure in schSliceBasedAddUeToSchedule");
return RFAILED;
}
*ueId = ueIdToAdd;
if(addNodeToLList(&schSpcCellCb->ueToBeScheduled, ueId, NULLP) != ROK)
{
- DU_LOG("\nERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
+ DU_LOG("ERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
return RFAILED;
}
return ROK;
/*[Step2]: Update the reqPRB and Payloadsize for this LC in the appropriate List*/
if(updateLcListReqPRB(lcLL, lcId, ueCb->bsrInfo[lcgIdx].dataVol) != ROK)
{
- DU_LOG("\nERROR --> SCH: LcgId:%d updation failed",lcId);
+ DU_LOG("ERROR --> SCH: LcgId:%d updation failed",lcId);
return RFAILED;
}
}
if((schSpcHqP->lcCb.dedLcList.count == 0) || ((maxFreePRB < rsvdDedicatedPRB)))
{
schSpcHqP->lcCb.sharedNumPrb = maxFreePRB;
- DU_LOG("\nDEBUG --> SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\
+ DU_LOG("DEBUG --> SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\
schSpcHqP->lcCb.sharedNumPrb);
/*PRB Alloc for Default LCs*/
{
if(maxFreePRB == 0)
{
- DU_LOG("\nERROR --> SCH : NO FREE PRB!!");
+ DU_LOG("ERROR --> SCH : NO FREE PRB!!");
}
else
{
/*Schedule the LC for next slot*/
- DU_LOG("\nDEBUG --> SCH : No LC has been scheduled");
+ DU_LOG("DEBUG --> SCH : No LC has been scheduled");
}
return RFAILED;
}
SCH_ALLOC(dciInfo, sizeof(DciInfo));
if(!dciInfo)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciInfo alloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciInfo alloc");
if(isRetx != TRUE)
{
if(schSpcHqProcCb->lcCb.dedLcList.count != 0)
if(updateLcListReqPRB(lcLL, ueCb->dlInfo.dlLcCtxt[lcIdx].lcId,\
(ueCb->dlInfo.dlLcCtxt[lcIdx].bo + MAC_HDR_SIZE)) != ROK)
{
- DU_LOG("\nERROR --> SCH : Updation in LC List Failed");
+ DU_LOG("ERROR --> SCH : Updation in LC List Failed");
/* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
if(!dciSlotAlloc->dlMsgPdschCfg)
{
if ((schSpcHqProcCb->lcCb.defLcList.count == 0) && (schSpcHqProcCb->lcCb.dedLcList.count == 0))
{
- DU_LOG("\nDEBUG --> SCH : No pending BO for any LC id\n");
+ DU_LOG("DEBUG --> SCH : No pending BO for any LC id\n");
UNSET_ONE_BIT((*hqP)->hqEnt->ue->ueId, (*hqP)->hqEnt->cell->boIndBitMap);
/* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
if((schSpcHqProcCb->lcCb.dedLcList.count == NULLP) || ((maxFreePRB < rsvdDedicatedPRB)))
{
schSpcHqProcCb->lcCb.sharedNumPrb = maxFreePRB;
- DU_LOG("\nDEBUG --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\
+ DU_LOG("DEBUG --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\
schSpcHqProcCb->lcCb.sharedNumPrb);
/*PRB Alloc for Default LCs*/
{
if(maxFreePRB == 0)
{
- DU_LOG("\nERROR --> SCH : NO FREE PRB!!");
+ DU_LOG("ERROR --> SCH : NO FREE PRB!!");
}
else
{
/*Schedule the LC for next slot*/
- DU_LOG("\nDEBUG --> SCH : No LC has been scheduled");
+ DU_LOG("DEBUG --> SCH : No LC has been scheduled");
}
/* Not Freeing dlMsgAlloc as ZERO BO REPORT to be sent to RLC so that
* Allocation can be done in next slot*/
SCH_ALLOC(dciSlotAlloc, sizeof(DlMsgSchInfo));
if(!dciSlotAlloc)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for ded DL msg alloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for ded DL msg alloc");
return false;
}
cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId -1] = dciSlotAlloc;
if((schDlRsrcAllocDlMsg(cell, pdschTime, crnti, accumalatedSize, dciSlotAlloc, startPrb,\
pdschStartSymbol, pdschNumSymbols, isRetx, *hqP, pdcchAllocInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCH : Scheduling of DL dedicated message failed");
+ DU_LOG("ERROR --> SCH : Scheduling of DL dedicated message failed");
/* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
if(!dciSlotAlloc->dlMsgPdschCfg)
SCH_ALLOC(dciSlotAlloc->dlMsgPdschCfg, sizeof(PdschCfg));
if(!dciSlotAlloc->dlMsgPdschCfg)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciSlotAlloc->dlMsgPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dciSlotAlloc->dlMsgPdschCfg");
SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
SCH_ALLOC(dlMsgAlloc, sizeof(DlMsgSchInfo));
if(dlMsgAlloc == NULLP)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dlMsgAlloc");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dlMsgAlloc");
SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
if(dciSlotAlloc->dlMsgPdschCfg == NULLP)
{
}
SCH_FREE(dlMsgAlloc, sizeof(DlMsgSchInfo));
cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
- DU_LOG("\nERROR --> SCH : Memory Allocation failed for dlMsgAlloc->dlMsgPdschCfg");
+ DU_LOG("ERROR --> SCH : Memory Allocation failed for dlMsgAlloc->dlMsgPdschCfg");
return false;
}
}
k0K1InfoTbl = &ueCb->k0K1InfoTbl;
if(schDlCandidateSelection(ueCb, *pdcchTime, pdcchAllocInfo) == false)
{
- DU_LOG("\nDEBUG --> SCH: DL candidate Selection failed bcz PDCCH is unavailable for this slot");
+ DU_LOG("DEBUG --> SCH: DL candidate Selection failed bcz PDCCH is unavailable for this slot");
return false;
}
}
}
else
{
- DU_LOG("\nERROR --> SCH: Unable to get any free block for Paging at SFN:%d, SLOT:%d",\
+ DU_LOG("ERROR --> SCH: Unable to get any free block for Paging at SFN:%d, SLOT:%d",\
pdschTime.sfn, pdschTime.slot);
break;
}
/*Fill PDSCH*/
if(schFillPagePdschCfg(cell, &dlPageAlloc.pageDlSch, pdschTime, tbSize, pageInfo->mcs, startPrb) != ROK)
{
- DU_LOG("\nERROR --> SCH: Issue in PDSCH Allocation for Paging at SFN:%d, SLOT:%d",\
+ DU_LOG("ERROR --> SCH: Issue in PDSCH Allocation for Paging at SFN:%d, SLOT:%d",\
pdschTime.sfn, pdschTime.slot);
break;
}
if(dlPageAlloc.pageDlSch.dlPagePdu == NULLP)
{
- DU_LOG("\nERROR --> SCH: Memory Allocation Failed during Page Resource allocation");
+ DU_LOG("ERROR --> SCH: Memory Allocation Failed during Page Resource allocation");
break;
}
memcpy(dlPageAlloc.pageDlSch.dlPagePdu, pageInfo->pagePdu, dlPageAlloc.pageDlSch.dlPagePduLen);
/* Send msg to MAC */
if(sendDlPageAllocToMac(&dlPageAlloc, schInst) != ROK)
{
- DU_LOG("\nERROR --> SCH : Sending DL Paging allocation from SCH to MAC failed");
+ DU_LOG("ERROR --> SCH : Sending DL Paging allocation from SCH to MAC failed");
SCH_FREE(dlPageAlloc.pageDlSch.dlPagePdu, sizeof(dlPageAlloc.pageDlSch.dlPagePduLen));
break;
}
cell = schCb[schInst].cells[schInst];
if(cell == NULLP)
{
- DU_LOG("\nERROR --> SCH : Cell Does not exist");
+ DU_LOG("ERROR --> SCH : Cell Does not exist");
return RFAILED;
}
memset(&dlSchedInfo, 0, sizeof(DlSchedInfo));
{
if(schBroadcastSsbAlloc(cell, dlSchedInfo.schSlotValue.broadcastTime, dlBrdcstAlloc) != ROK)
{
- DU_LOG("\nERROR --> SCH : schBroadcastSsbAlloc failed");
+ DU_LOG("ERROR --> SCH : schBroadcastSsbAlloc failed");
dlBrdcstAlloc->ssbTransmissionMode = NO_TRANSMISSION;
}
else
{
if(schBroadcastSib1Alloc(cell, dlSchedInfo.schSlotValue.broadcastTime, dlBrdcstAlloc) != ROK)
{
- DU_LOG("\nERROR --> SCH : schBroadcastSib1Alloc failed");
+ DU_LOG("ERROR --> SCH : schBroadcastSib1Alloc failed");
dlBrdcstAlloc->sib1TransmissionMode = NO_TRANSMISSION;
}
else
ret = sendDlAllocToMac(&dlSchedInfo, schInst);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCH : Sending DL Broadcast allocation from SCH to MAC failed");
+ DU_LOG("ERROR --> SCH : Sending DL Broadcast allocation from SCH to MAC failed");
return (ret);
}
{
if(((SchStatsGrp *)cb)->periodTimer.tmrEvnt == EVENT_STATISTICS_TMR)
{
- DU_LOG("\nDEBUG --> SCH : schChkTmr: Timer Evnt [%d] already running", tmrEvnt);
+ DU_LOG("DEBUG --> SCH : schChkTmr: Timer Evnt [%d] already running", tmrEvnt);
return TRUE;
}
break;
}
default:
{
- DU_LOG("\nERROR --> SCH : schChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> SCH : schChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
return FALSE;
arg.wait = 0;
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> SCH : Starting Timer Event [%d] with Wait Time [%d] ms", \
+ DU_LOG("DEBUG --> SCH : Starting Timer Event [%d] with Wait Time [%d] ms", \
tmrEvnt, timerValue);
#endif
default:
{
- DU_LOG("\nERROR --> SCH : schStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> SCH : schStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
arg.timers = NULLP;
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> SCH : Stopping Timer Event [%d]", tmrType);
+ DU_LOG("DEBUG --> SCH : Stopping Timer Event [%d]", tmrType);
#endif
switch (tmrType)
default:
{
- DU_LOG("\nERROR --> SCH : schStopTmr: Invalid tmr Evnt[%d]", tmrType);
+ DU_LOG("ERROR --> SCH : schStopTmr: Invalid tmr Evnt[%d]", tmrType);
break;
}
}
{
if(schCalcAndSendGrpStats(cb) != ROK)
{
- DU_LOG("\nERROR --> SCH : SchProcStatisticsGrpTmrExp: Fails to send group statistics");
+ DU_LOG("ERROR --> SCH : SchProcStatisticsGrpTmrExp: Fails to send group statistics");
}
schStartTmr(&schCb[cb->schInst], (PTR)(cb), EVENT_STATISTICS_TMR, cb->periodicity);
return ROK;
uint8_t schTmrExpiry(PTR cb, uint8_t tmrEvnt)
{
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> SCH : Timer Expired. Event [%d]", tmrEvnt);
+ DU_LOG("DEBUG --> SCH : Timer Expired. Event [%d]", tmrEvnt);
#endif
switch (tmrEvnt)
case EVENT_STATISTICS_TMR:
{
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> SCH : Statistics Timer Expired for Subscription Id [%ld] GroupId [%d]", \
+ DU_LOG("DEBUG --> SCH : Statistics Timer Expired for Subscription Id [%ld] GroupId [%d]", \
((SchStatsGrp*)cb)->subscriptionId, ((SchStatsGrp*)cb)->groupId);
#endif
SchProcStatisticsGrpTmrExp((SchStatsGrp*)cb);
default:
{
- DU_LOG("\nERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
break;
}
}
memset(&rspPst, 0, sizeof(Pst));
FILL_PST_SCH_TO_MAC(rspPst, inst);
rspPst.event = EVENT_UE_CONFIG_RSP_TO_MAC;
- DU_LOG("\nINFO --> SCH : Sending UE Config response to MAC");
+ DU_LOG("INFO --> SCH : Sending UE Config response to MAC");
MacMessageRouter(&rspPst, (void *)cfgRsp);
}
memset(&rspPst, 0, sizeof(Pst));
FILL_PST_SCH_TO_MAC(rspPst, inst);
rspPst.event = EVENT_UE_RECONFIG_RSP_TO_MAC;
- DU_LOG("\nINFO --> SCH : Sending UE Reconfig response to MAC");
+ DU_LOG("INFO --> SCH : Sending UE Reconfig response to MAC");
MacMessageRouter(&rspPst, (void *)reCfgRsp);
}
*rsvdDedicatedPRB = \
(uint16_t)(((rrmPolicyOfSlices->rrmPolicyRatioInfo.dedicatedRatio)*(MAX_NUM_RB))/100);
*isDedicated = TRUE;
- DU_LOG("\nINFO --> SCH : Updated RRM policy, reservedPOOL:%d",*rsvdDedicatedPRB);
+ DU_LOG("INFO --> SCH : Updated RRM policy, reservedPOOL:%d",*rsvdDedicatedPRB);
break;
}
sliceCfg = sliceCfg->next;
/*case: This LcCtxt is either a Default LC or this LC is part of someother RRM_MemberList*/
if(*isDedicated != TRUE)
{
- DU_LOG("\nINFO --> SCH : This SNSSAI is not a part of this RRMPolicy");
+ DU_LOG("INFO --> SCH : This SNSSAI is not a part of this RRMPolicy");
}
return ROK;
}
if(retUL == RFAILED || retDL == RFAILED)/*FATAL error*/
{
- DU_LOG("\nERROR --> SCH : Failure in updateDedLcInfo");
+ DU_LOG("ERROR --> SCH : Failure in updateDedLcInfo");
return RFAILED;
}
SCH_FREE(ueCfg->schLcCfg[lcIdx].drbQos, sizeof(SchDrbQosInfo));
if(retUL == RFAILED || retDL == RFAILED)/*FATAL error*/
{
- DU_LOG("\nERROR --> SCH : Failure in updateDedLcInfo");
+ DU_LOG("ERROR --> SCH : Failure in updateDedLcInfo");
return RFAILED;
}
SCH_FREE(ueRecfg->schLcCfgAdd[lcIdx].drbQos, sizeof(SchDrbQosInfo));
}
if(retUL == RFAILED)
{
- DU_LOG("\nERROR --> SCH : Failed in updating Ded Lc info");
+ DU_LOG("ERROR --> SCH : Failed in updating Ded Lc info");
return RFAILED;
}
}/*End of UL LC Ctxt*/
}
if(retDL == RFAILED)
{
- DU_LOG("\nERROR --> SCH : Failed in updating Ded Lc info");
+ DU_LOG("ERROR --> SCH : Failed in updating Ded Lc info");
return RFAILED;
}
}/*End of DL LC ctxt*/
}
if((idx == MAX_NUM_CELL) || (cellCb == NULLP))
{
- DU_LOG("\nERROR --> SCH : Ue create request failed. Invalid cell id %d", cellId);
+ DU_LOG("ERROR --> SCH : Ue create request failed. Invalid cell id %d", cellId);
return NULLP;
}
/* Check if max number of UE configured */
if(cellCb->numActvUe > MAX_NUM_UE)
{
- DU_LOG("\nERROR --> SCH : Max number of UE [%d] already configured", MAX_NUM_UE);
+ DU_LOG("ERROR --> SCH : Max number of UE [%d] already configured", MAX_NUM_UE);
return NULLP;
}
return cellCb;
if(!ueCfg)
{
- DU_LOG("\nERROR --> SCH : Adding UE Config Request failed at SchAddUeConfigReq()");
+ DU_LOG("ERROR --> SCH : Adding UE Config Request failed at SchAddUeConfigReq()");
return RFAILED;
}
- DU_LOG("\nDEBUG --> SCH : Adding UE Config Request for CRNTI[%d]", ueCfg->crnti);
+ DU_LOG("DEBUG --> SCH : Adding UE Config Request for CRNTI[%d]", ueCfg->crnti);
cellCb = getSchCellCb(pst->event, inst, ueCfg->cellId);
if(cellCb == NULLP)
if((ueCb->crnti == ueCfg->crnti) && (ueCb->state == SCH_UE_STATE_ACTIVE))
{
- DU_LOG("\nDEBUG --> SCH : CRNTI %d already configured ", ueCfg->crnti);
+ DU_LOG("DEBUG --> SCH : CRNTI %d already configured ", ueCfg->crnti);
SchSendUeCfgRspToMac(ueCfg, inst, RSP_OK, &cfgRsp);
return ROK;
}
if ( (ueCb->hqDlmap == NULLP) || (ueCb->hqUlmap == NULLP) )
{
- DU_LOG("\nINFO --> SCH : Memory Allocation Failed");
+ DU_LOG("INFO --> SCH : Memory Allocation Failed");
return RFAILED;
}
for (idx = 0; idx<ueCb->cellCb->numSlots; idx++)
if ( (ueCb->hqDlmap[idx] == NULLP) || (ueCb->hqUlmap[idx] == NULLP) )
{
- DU_LOG("\nINFO --> SCH : Memory Allocation Failed");
+ DU_LOG("INFO --> SCH : Memory Allocation Failed");
return RFAILED;
}
cmLListInit(&ueCb->hqDlmap[idx]->hqList);
if(fillUeCoresetAndSsInfo(ueCb) == RFAILED)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation Failed");
+ DU_LOG("ERROR --> SCH : Memory Allocation Failed");
return RFAILED;
}
if(ret == ROK)
if(ueCb == NULLP)
{
- DU_LOG("\nERROR --> SCH: UE CB is empty");
+ DU_LOG("ERROR --> SCH: UE CB is empty");
return RFAILED;
}
cellCb = ueCb->cellCb;
if(cellCb == NULLP)
{
- DU_LOG("\nERROR --> SCH: CELL CB is empty");
+ DU_LOG("ERROR --> SCH: CELL CB is empty");
return RFAILED;
}
SCH_ALLOC(schUlSlotInfo->schPuschInfo[ueCb->ueId - 1], sizeof(SchPuschInfo));
if(!schUlSlotInfo->schPuschInfo[ueCb->ueId - 1])
{
- DU_LOG("\nERROR --> SCH: Memory allocation failed in schAllocMsg3Pusch");
+ DU_LOG("ERROR --> SCH: Memory allocation failed in schAllocMsg3Pusch");
return RFAILED;
}
cellCb->schUlSlotInfo[puschTime.slot]->puschPres = true;
if(!ueRecfg)
{
- DU_LOG("\nERROR --> SCH : Modifying Ue Config request failed at SchModUeConfigReq()");
+ DU_LOG("ERROR --> SCH : Modifying Ue Config request failed at SchModUeConfigReq()");
return RFAILED;
}
- DU_LOG("\nDEBUG --> SCH : Modifying Ue Config Request for CRNTI[%d]", ueRecfg->crnti);
+ DU_LOG("DEBUG --> SCH : Modifying Ue Config Request for CRNTI[%d]", ueRecfg->crnti);
cellCb = getSchCellCb(pst->event, inst, ueRecfg->cellId);
if(cellCb == NULLP)
if(!ueCb)
{
- DU_LOG("\nERROR --> SCH : SchUeCb not found at SchModUeConfigReq() ");
+ DU_LOG("ERROR --> SCH : SchUeCb not found at SchModUeConfigReq() ");
SchSendUeRecfgRspToMac(ueRecfg, inst, RSP_NOK, &recfgRsp);
return RFAILED;
}
ret = fillSchUeCbFrmRecfgReq(inst, ueCb, ueRecfg);
if(fillUeCoresetAndSsInfo(ueCb) == RFAILED)
{
- DU_LOG("\nERROR --> SCH : Memory Allocation Failed");
+ DU_LOG("ERROR --> SCH : Memory Allocation Failed");
return RFAILED;
}
if(ret == ROK)
if(!ueDelete)
{
- DU_LOG("\nERROR --> SCH : SchProcUeDeleteReq(): Ue Delete request failed");
+ DU_LOG("ERROR --> SCH : SchProcUeDeleteReq(): Ue Delete request failed");
ret = RFAILED;
}
- DU_LOG("\nDEBUG --> SCH : Ue Delete request received for crnti[%d]", ueDelete->crnti);
+ DU_LOG("DEBUG --> SCH : Ue Delete request received for crnti[%d]", ueDelete->crnti);
cellCb = schCb[inst].cells[idx];
if(cellCb->cellId != ueDelete->cellId)
{
- DU_LOG("\nERROR --> SCH : SchProcUeDeleteReq(): cell Id is not available");
+ DU_LOG("ERROR --> SCH : SchProcUeDeleteReq(): cell Id is not available");
cause = CELLID_INVALID;
}
else
}
else
{
- DU_LOG("\nERROR --> SCH : SchProcUeDeleteReq(): SchUeCb not found");
+ DU_LOG("ERROR --> SCH : SchProcUeDeleteReq(): SchUeCb not found");
cause = UEID_INVALID;
}
}
node = hqDlMap->hqList.first;
if(node == NULLP)
{
- DU_LOG("\nERROR : SCH --> DL HARQ list is empty thus no need to process the dl harq feedback!");
+ DU_LOG("ERROR : SCH --> DL HARQ list is empty thus no need to process the dl harq feedback!");
return;
}
if (ueCb->cellCb->raCb[ueCb->ueId-1].raState != SCH_RA_STATE_MSG4_PENDING)
/* Check if requested number of blocks can be allocated from the current block */
if(freeBlock->numFreePrb < numPrb)
{
- DU_LOG("\nINFO --> SCH: In isPrbAvailable, numFreePrb:%d is less than reqPrb:%d", freeBlock->numFreePrb, numPrb);
+ DU_LOG("INFO --> SCH: In isPrbAvailable, numFreePrb:%d is less than reqPrb:%d", freeBlock->numFreePrb, numPrb);
node = node->next;
continue;
}
if(lcLL == NULLP)
{
- DU_LOG("\nERROR --> SCH: LcList doesnt exist");
+ DU_LOG("ERROR --> SCH: LcList doesnt exist");
return NULLP;
}
node = lcLL->first;
}
else
{
- DU_LOG("\nERROR --> SCH : Allocation of List failed,lcId:%d",lcId);
+ DU_LOG("ERROR --> SCH : Allocation of List failed,lcId:%d",lcId);
return NULLP;
}
if(addNodeToLList(lcLL, lcNode, NULLP) == RFAILED)
{
- DU_LOG("\nERROR --> SCH : failed to Add Node,lcId:%d",lcId);
+ DU_LOG("ERROR --> SCH : failed to Add Node,lcId:%d",lcId);
SCH_FREE(lcNode, sizeof(LcInfo));
return NULLP;
}
{
if(!found || lcNode == NULLP)
{
- DU_LOG("\nERROR --> SCH: LCID%d not found; thus Deletion unsuccessful",lcId);
+ DU_LOG("ERROR --> SCH: LCID%d not found; thus Deletion unsuccessful",lcId);
}
else
{
if(deleteNodeFromLList(lcLL, node) == ROK)
SCH_FREE(lcNode, sizeof(LcInfo));
- DU_LOG("\nDEBUG --> SCH: LCID%d Deleted successfully",lcId);
+ DU_LOG("DEBUG --> SCH: LCID%d Deleted successfully",lcId);
}
return NULLP;
}
}
default:
{
- DU_LOG("\nERROR --> SCH: Action type wrong: %d",action);
+ DU_LOG("ERROR --> SCH: Action type wrong: %d",action);
break;
}
}
if(lcNode == NULLP)
{
- DU_LOG("\nERROR --> SCH : LC is neither present nor able to create in List lcId:%d",lcId);
+ DU_LOG("ERROR --> SCH : LC is neither present nor able to create in List lcId:%d",lcId);
return RFAILED;
}
if(lcLL == NULLP)
{
- DU_LOG("\nERROR --> SCH: LcList doesnt exist");
+ DU_LOG("ERROR --> SCH: LcList doesnt exist");
return;
}
node = lcLL->first;
pageInfo = (SchPageInfo*)node->node;
if(pageInfo == NULLP)
{
- DU_LOG("\nERROR --> SCH: PageInfo empty");
+ DU_LOG("ERROR --> SCH: PageInfo empty");
}
else if(pageInfo->pageTxTime.sfn == slotInfo.sfn &&
(pageInfo->pageTxTime.slot == slotInfo.slot))
if(lcLL == NULLP)
{
- DU_LOG("\nINFO --> SCH: LcList doesnt exist");
+ DU_LOG("INFO --> SCH: LcList doesnt exist");
return;
}
node = lcLL->first;
lcNode = (LcInfo *)node->node;
if(lcNode)
{
- DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
+ DU_LOG("INFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
lcNode->lcId,lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB);
}
}
default:
{
- DU_LOG("\nERROR --> SCH: Issue in calculating value of Y");
+ DU_LOG("ERROR --> SCH: Issue in calculating value of Y");
return(0);
}
}
SCH_ALLOC(pdcchInfo->y, (sizeof(uint32_t) * ueCb->cellCb->numSlots));
if(pdcchInfo->y == NULLP)
{
- DU_LOG("\nERROR --> SCH: Memory Allocation of Y failed");
+ DU_LOG("ERROR --> SCH: Memory Allocation of Y failed");
return RFAILED;
}
}
#ifdef MEM_SIZE_CHECK
#define SCH_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\n SCH line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG(" SCH line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define SCH_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
" sockFd->fd(%ld)\n", tempErrorNo, port, sockFd->fd);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET010, 0, prntBuf);
#else
- DU_LOG("\nCmInetSctpConnectx() Failed : error(%d), port(0x%1x),\
+ DU_LOG("CmInetSctpConnectx() Failed : error(%d), port(0x%1x),\
sockFd->fd(%d)\n", tempErrorNo, port, sockFd->fd);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
" sockFd->fd(%ld)\n", INET_ERR_CODE, sockFd->fd);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET014, 0, prntBuf);
#else
- DU_LOG("\ncmInetSctpRecvMsg() Failed : error(%d), sockFd->fd(%d)", \
+ DU_LOG("cmInetSctpRecvMsg() Failed : error(%d), sockFd->fd(%d)", \
INET_ERR_CODE, sockFd->fd);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
#ifndef LTE_ENB_PAL
if( evntSize > maxBlkSize)
{
- DU_LOG("\nERROR --> Not Allocating memory for Event\n");
+ DU_LOG("ERROR --> Not Allocating memory for Event\n");
#ifdef ALIGN_64BIT
- DU_LOG("\nERROR --> eventSize [%d] greater than maxBlkSize [%d]\n",
+ DU_LOG("ERROR --> eventSize [%d] greater than maxBlkSize [%d]\n",
evntSize, maxBlkSize);
#else
- DU_LOG("\nERROR --> eventSize [%ld] greater than maxBlkSize [%ld]\n",
+ DU_LOG("ERROR --> eventSize [%ld] greater than maxBlkSize [%ld]\n",
evntSize, maxBlkSize);
#endif
return RFAILED;
if(((uint64_t)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0)
{
- DU_LOG("\nINFO --> address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo);
+ DU_LOG("INFO --> address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo);
}
leakInfo = (((T2kMeamLeakInfo*)(regMemLeakInfo.gMemLeakInfo[region])) + index1);
leakInfo->prevRemLineNo = 0;
leakInfo->prevRemFileName = '\0';
- //DU_LOG("\nINFO --> InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d \
+ //DU_LOG("INFO --> InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d \
from File=%s, line=%d \n",address,index1,fileName,lineNo);
if(smallTick++ == 4096)
{
}
else
{
- DU_LOG("\nERROR --> Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo);
- DU_LOG("\nINFO --> Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d",
+ DU_LOG("ERROR --> Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo);
+ DU_LOG("INFO --> Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d",
leakInfo->address, leakInfo->fileName,
leakInfo->lineNo, leakInfo->size,
leakInfo->age);
if(index1 >= T2K_MEM_LEAK_INFO_TABLE_SIZE)
{
- DU_LOG("\nERROR --> index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n",
+ DU_LOG("ERROR --> index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n",
index1,
address,
file,
}
else
{
- DU_LOG("\nERROR --> Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region);
+ DU_LOG("ERROR --> Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region);
- DU_LOG("\nINFO --> Last Del file %s line %d\n",leakInfo->lastDelFileName,
+ DU_LOG("INFO --> Last Del file %s line %d\n",leakInfo->lastDelFileName,
leakInfo->lastDelLineNum);
if(leakInfo->prevRemFileName != NULLP)
{
- DU_LOG("\nINFO --> Previous File:%s, Previous Line:%d\n",
+ DU_LOG("INFO --> Previous File:%s, Previous Line:%d\n",
leakInfo->prevRemFileName, leakInfo->prevRemLineNo);
}
}
if(fp == NULL)
{
- DU_LOG("\nERROR --> Could not open file for dumping mem leak info\n");
+ DU_LOG("ERROR --> Could not open file for dumping mem leak info\n");
return;
}
for(reg=0; reg <regMemLeakInfo.numActvRegions; reg++)
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* Initialize the hast list to maintain the SSI memory information for Broadcom */
offset = (uint16_t)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
- DU_LOG("\nINFO --> offset is %d region %d\n", offset, region);
+ DU_LOG("INFO --> offset is %d region %d\n", offset, region);
if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE,
CM_HASH_KEYTYPE_UINT32_MOD, region, 0) != ROK)
{
/* Initialize the elements with 0xAB */
memset(*ptr, 0xAB, *size);
#endif
-// DU_LOG("\nINFO --> Pointer allocated %8p size %d\n", *ptr, *size);
+// DU_LOG("INFO --> Pointer allocated %8p size %d\n", *ptr, *size);
/* Store this pointer in hash list */
if ((bkt->nextBlk) && *ptr)
#elif SS_LIGHT_MEM_LEAK_STS
if (g_overused[bktIdx] == 0 && OVERUSED(bkt))
{
g_overused[bktIdx] = 1;
- /*DU_LOG("\nINFO --> cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */
+ /*DU_LOG("INFO --> cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */
}
}
#endif
size(%d) %8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
#endif
- DU_LOG("\nERROR --> Passed size (%d) does not match with allocated \
+ DU_LOG("ERROR --> Passed size (%d) does not match with allocated \
size(%d) %8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
abort();
}
/* Validate the tail part to see if there is any over run */
-// DU_LOG("\nINFO --> Pointer free request %8p, size %d\n", ptr, size);
+// DU_LOG("INFO --> Pointer free request %8p, size %d\n", ptr, size);
#endif
/* validate the block to be freed for trampling */
return (RTRAMPLINGNOK);
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- DU_LOG("\nERROR --> Memory signature is invalid\n");
+ DU_LOG("ERROR --> Memory signature is invalid\n");
abort();
#endif
}
(Void) SUnlock(&(bkt->bktLock));
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
+ DU_LOG("ERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size);
abort();
#endif
sprintf(dbgPrntBuf, "Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
#endif
- DU_LOG("\nERROR --> Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
+ DU_LOG("ERROR --> Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
abort();
}
}
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- DU_LOG("\nERROR --> Memory signature is invalid\n");
+ DU_LOG("ERROR --> Memory signature is invalid\n");
abort();
#endif
}
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
+ DU_LOG("ERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size);
abort();
#endif
{
if (FALSE == gmemLkCb.isStarted)
{
- DU_LOG("\nINFO --> leak capturing started\n");
+ DU_LOG("INFO --> leak capturing started\n");
gmemLkCb.isStarted = TRUE;
}
else
{
gmemLkCb.isStarted = FALSE;
- DU_LOG("\nINFO --> leak capturing stopped\n");
+ DU_LOG("INFO --> leak capturing stopped\n");
cmPrintLeakLog();
}
return;
static uint32_t leakCount =0;
- DU_LOG("\nINFO --> START OF LEAK LOG ");
+ DU_LOG("INFO --> START OF LEAK LOG ");
SLock(&gmemLkCb.memLock);
- DU_LOG("\nINFO --> Lock Acquired");
+ DU_LOG("INFO --> Lock Acquired");
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
{
if(gmemLkCb.allocInfo[indx].used == TRUE)
//if(leakCount % 10 == 0)
// sleep(1);
}
- DU_LOG("\nINFO --> END OF LEAK LOG ");
+ DU_LOG("INFO --> END OF LEAK LOG ");
SUnlock(&gmemLkCb.memLock);
- DU_LOG("\nINFO --> Lock Released");
+ DU_LOG("INFO --> Lock Released");
leakCount =0;
return;
}
/* If hash list is full then print the error tna continue */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
- DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
+ DU_LOG("ERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
return RFAILED;
} /* End of if */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
- DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
+ DU_LOG("ERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
return RFAILED;
} /* End of if */
} /* End of if (numEnt) */
else
{
- DU_LOG("\nERROR --> Unable to find the entry in hash list\n");
+ DU_LOG("ERROR --> Unable to find the entry in hash list\n");
return RFAILED;
}/* End of else (numEnt) */
}/* end of for (numBin = 0) */
- DU_LOG("\nERROR --> Unable to find the entry in the hash list\n");
+ DU_LOG("ERROR --> Unable to find the entry in the hash list\n");
return RFAILED;
} /* end of cmHstGrmFindEntry */
/* error check on parameters */
if(regCb == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
return RFAILED;
}
if(ptr == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
return RFAILED;
}
if(size == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory size pointer null");
return RFAILED;
}
if(!(*size))
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block size is 0");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory block size is 0");
return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
/* Some fatal error in the map table initialization. */
return RFAILED;
}
#endif
if (idx > 512)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): idx value is greater than 512");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): idx value is greater than 512");
return RFAILED;
}
/* Dequeue the memory block and return it to the user */
if(dynMemElem == NULLP)
{
#ifndef ALIGN_64BIT
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
#else
printf("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
#endif
*ptr = dynMemElem->nextBktPtr;
if (*ptr == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): nextBktPtr is null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): nextBktPtr is null");
return RFAILED;
}
dynMemElem->nextBktPtr = *((CmMmEntry **)(*ptr));
/* If the size is not matching, return failure to caller */
#ifndef ALIGN_64BIT
- DU_LOG("\nERROR --> CM : cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
+ DU_LOG("ERROR --> CM : cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
#else
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
#endif
return RFAILED;
if ( (*ptr) == NULLP)
{
- DU_LOG("\nERROR --> CM : cmDynAlloc(): Data ptr is null");
+ DU_LOG("ERROR --> CM : cmDynAlloc(): Data ptr is null");
return RFAILED;
}
/* avail_size -= *size; */
/* error check on parameters */
if(regCb == NULL)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
return RFAILED;
}
if(ptr == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
return RFAILED;
}
if(size == NULLP)
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory size pointer null");
return RFAILED;
}
if(!(*size))
{
- DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block size is 0");
+ DU_LOG("ERROR --> CM: cmDynAlloc(): Received memory block size is 0");
return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- DU_LOG("\nERROR --> CM : cmAlloc(): memType[%d] is invalid",memType);
+ DU_LOG("ERROR --> CM : cmAlloc(): memType[%d] is invalid",memType);
return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- DU_LOG("\nERROR --> CM : cmAlloc(): bktIdx is invalid");
+ DU_LOG("ERROR --> CM : cmAlloc(): bktIdx is invalid");
return RFAILED;
}
#endif
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
- DU_LOG("\nERROR --> CM : cmAlloc(): Sanity check returns failure");
+ DU_LOG("ERROR --> CM : cmAlloc(): Sanity check returns failure");
/* return RFAILED */
return RFAILED;
}
}
/* No memory available */
- DU_LOG("\nERROR --> CM : cmAlloc(): No memory available in heap");
+ DU_LOG("ERROR --> CM : cmAlloc(): No memory available in heap");
return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#endif
if ( (*ptr) == NULLP)
{
- DU_LOG("\nERROR --> CM : cmAlloc(): ptr is null");
+ DU_LOG("ERROR --> CM : cmAlloc(): ptr is null");
return RFAILED;
}
avail_size -= *size;
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- DU_LOG("\nERROR --> CM : cmDynFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr);
+ DU_LOG("ERROR --> CM : cmDynFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr);
return RFAILED;
}
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- DU_LOG("\nERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region);
+ DU_LOG("ERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region);
return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- DU_LOG("\nERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region);
+ DU_LOG("ERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
- DU_LOG("\nERROR --> CM : cmDynFree(): bktIdx is not valid");
+ DU_LOG("ERROR --> CM : cmDynFree(): bktIdx is not valid");
/* Some fatal error in the map table initialization. */
return RFAILED;
}
/* Check if the bucket index, if its not valid, return failure */
if(dynMemElem == NULLP)
{
- DU_LOG("\nERROR --> CM : cmDynFree(): dynMemElem is null");
+ DU_LOG("ERROR --> CM : cmDynFree(): dynMemElem is null");
return RFAILED;
}
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- DU_LOG("\nERROR --> CM : cmFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr);
+ DU_LOG("ERROR --> CM : cmFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr);
return RFAILED;
}
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- DU_LOG("\nERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region);
+ DU_LOG("ERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region);
return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- DU_LOG("\nERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region);
+ DU_LOG("ERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region);
return RFAILED;
}
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- DU_LOG("\nERROR --> CM : cmFree(): Invalid bktIdx");
+ DU_LOG("ERROR --> CM : cmFree(): Invalid bktIdx");
return RFAILED;
}
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure");
+ DU_LOG("ERROR --> CM : cmFree(): Sanity check returns failure");
return (RTRAMPLINGNOK);
}
}
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- DU_LOG("\nERROR --> CM : cmFree(): Memory block is already freed");
+ DU_LOG("ERROR --> CM : cmFree(): Memory block is already freed");
return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure");
+ DU_LOG("ERROR --> CM : cmFree(): Sanity check returns failure");
return (RTRAMPLINGNOK);
}
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- DU_LOG("\nERROR --> RLC : MBuf Allocation failed\n");
+ DU_LOG("ERROR --> RLC : MBuf Allocation failed\n");
}
return (mBuf);
}
#ifdef MEM_SIZE_CHECK
#define CM_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\nRLC line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG("CM line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define CM_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
#endif
if(param->unLicnsdCfgPres)
{
- DU_LOG("\nDEBUG --> pverma param->unLicnsdCfgPres cm/ctf -->%d\n",param->unLicnsdCfgPres);
+ DU_LOG("DEBUG --> pverma param->unLicnsdCfgPres cm/ctf -->%d\n",param->unLicnsdCfgPres);
CMCHKPK(cmPkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
CMCHKPK(oduPackUInt8, param->unLicnsdCfgPres, mBuf);
if(param->unLicnsdCfgPres)
{
- DU_LOG("\nDEBUG --> pverma param->unLicnsdCfgPres 2 -->%d \n",param->unLicnsdCfgPres);
+ DU_LOG("DEBUG --> pverma param->unLicnsdCfgPres 2 -->%d \n",param->unLicnsdCfgPres);
CMCHKUNPK(cmUnpkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
#ifdef EMTC_ENABLE
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
- DU_LOG("\nDEBUG --> param->pilotSigPwr = %d\nparam->priSigPwr = %d\n param->secSigPwr = %d\n",param->pilotSigPwr,param->priSigPwr,param->secSigPwr);
+ DU_LOG("DEBUG --> param->pilotSigPwr = %d\nparam->priSigPwr = %d\n param->secSigPwr = %d\n",param->pilotSigPwr,param->priSigPwr,param->secSigPwr);
#ifdef ENABLE_API_LOG
CMCHKUNPK(oduUnpackUInt8, ¶m->enableAPILog, mBuf);
#endif /* ENABLE_API_LOG */
/* pack the address of the structure */
CMCHKPK(oduPackPointer,(PTR)macCellCfg, mBuf);
- DU_LOG("\nDEBUG --> DU-APP : MAC CELL config sent");
+ DU_LOG("DEBUG --> DU-APP : MAC CELL config sent");
return ODU_POST_TASK(pst,mBuf);
}
return ROK;
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for cell start req pack");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for cell start req pack");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for cell stop req pack");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for cell stop req pack");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for packMacCellUpInd");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for packMacCellUpInd");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for stop Ind pack");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for stop Ind pack");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacUlCcchInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packMacUlCcchInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for UL CCCH Ind ");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for UL CCCH Ind ");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> MAC : Only LWLC supported for UL CCCH Ind ");
+ DU_LOG("ERROR --> MAC : Only LWLC supported for UL CCCH Ind ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacDlCcchInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packMacDlCcchInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeCreateReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeCreateReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeCreateReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeCreateReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Create Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for UE Create Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeCreateRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeCreateRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeCreateRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeCreateRsp");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeReconfigReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeReconfigReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeReconfigReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeReconfigReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Create Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for UE Create Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeRecfgRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeRecfgRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeRecfgRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeRecfgRsp");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacRachRsrcReq,");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacRachRsrcReq,");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacRachRsrcReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacRachRsrcReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for RACH resource Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for RACH resource Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacRachRsrcRel");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacRachRsrcRel");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacRachRsrcRel");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacRachRsrcRel");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for RACH Resource Release ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for RACH Resource Release ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacRachRsrcRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacRachRsrcRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacRachRsrcRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacRachRsrcRsp");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for RACH resource Response ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for RACH resource Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeDeleteReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeDeleteReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeDeleteReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeDeleteReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Delete Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for UE Delete Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeDeleteRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeDeleteRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeDeleteRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeDeleteRsp");
return RFAILED;
}
{
/* Nothing to do for other
* selectors */
- DU_LOG("\nERROR --> DU APP : unpackMacCellDeleteReq(): Only LWLC supported for CELL Delete Request ");
+ DU_LOG("ERROR --> DU APP : unpackMacCellDeleteReq(): Only LWLC supported for CELL Delete Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : packDuMacCellDeleteReq(): Memory allocation failed ");
+ DU_LOG("ERROR --> MAC : packDuMacCellDeleteReq(): Memory allocation failed ");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)cellDelete, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: packDuMacCellDeleteReq(): Only LWLC supported ");
+ DU_LOG("ERROR --> MAC: packDuMacCellDeleteReq(): Only LWLC supported ");
}
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : packDuMacCellDeleteRsp(): Memory allocation failed ");
+ DU_LOG("ERROR --> MAC : packDuMacCellDeleteRsp(): Memory allocation failed ");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)cellDeleteRsp, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: packDuMacCellDeleteRsp(): Only LWLC supported ");
+ DU_LOG("ERROR --> MAC: packDuMacCellDeleteRsp(): Only LWLC supported ");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : unpackDuMacCellDeleteRsp(): Only LWLC supported ");
+ DU_LOG("ERROR --> DU APP : unpackDuMacCellDeleteRsp(): Only LWLC supported ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in packDuMacSliceCfgReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in packDuMacSliceCfgReq");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)sliceCfgReq, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported in packDuMacSliceCfgReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported in packDuMacSliceCfgReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Slice Cfg Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Slice Cfg Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceCfgRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacSliceCfgRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceCfgRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacSliceCfgRsp");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in packDuMacSliceRecfgReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed in packDuMacSliceRecfgReq");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)sliceRecfgReq, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported in packDuMacSliceRecfgReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported in packDuMacSliceRecfgReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Slice ReCfg Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Slice ReCfg Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceRecfgRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacSliceRecfgRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceRecfgRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacSliceRecfgRsp");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacSlotInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packMacSlotInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packMacSlotInd");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packMacSlotInd");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : packDuMacDlPcchInd(): Memory allocation failed ");
+ DU_LOG("ERROR --> MAC : packDuMacDlPcchInd(): Memory allocation failed ");
return RFAILED;
}
CMCHKPK(oduPackPointer,(PTR)pcchInd, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: packDuMacDlPcchInd(): Only LWLC supported ");
+ DU_LOG("ERROR --> MAC: packDuMacDlPcchInd(): Only LWLC supported ");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : unpackMacDlPcchInd(): Only LWLC supported");
+ DU_LOG("ERROR --> DU APP : unpackMacDlPcchInd(): Only LWLC supported");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeResetReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeResetReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeResetReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeResetReq");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Reset Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for UE Reset Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeResetRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeResetRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeResetRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeResetRsp");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeSyncStatusInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacUeSyncStatusInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeSyncStatusInd");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacUeSyncStatusInd");
return RFAILED;
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacDlBroadcastReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacDlBroadcastReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacDlBroadcastReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacDlBroadcastReq");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Dl Broadcast Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Dl Broadcast Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsReq");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsRsp");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Response ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsInd");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsInd");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsInd");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Indication ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Indication ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsDeleteReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsDeleteReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsDeleteReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsDeleteReq");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Delete Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Delete Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsDeleteRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsDeleteRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsDeleteRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsDeleteRsp");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Delete Response ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Delete Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsModificationReq");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsModificationReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsModificationReq");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsModificationReq");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Modification Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Modification Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacStatsModificationRsp");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuMacStatsModificationRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacStatsModificationRsp");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuMacStatsModificationRsp");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for Statistics Modification Response ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for Statistics Modification Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuNfapiP7UdpCfg");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packDuNfapiP7UdpCfg");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuNfapiP7UdpCfg");
+ DU_LOG("ERROR --> MAC: Only LWLC supported for packDuNfapiP7UdpCfg");
return RFAILED;
}
return ODU_POST_TASK(pst,mBuf);
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> DU APP : Only LWLC supported for UDP P7 Config Request ");
+ DU_LOG("ERROR --> DU APP : Only LWLC supported for UDP P7 Config Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuMaxRetransInd");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuMaxRetransInd");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuMaxRetransInd");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuMaxRetransInd");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for Max Retransmission Reached Info ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for Max Retransmission Reached Info ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeCreateReq");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packDuRlcUeCreateReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeCreateReq");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packDuRlcUeCreateReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Create Request ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Create Request ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeCreateRsp");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuUeCreateRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeCreateRsp");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuUeCreateRsp");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Cfg Response ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Cfg Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeReconfigRsp");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuUeReconfigRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeReconfigRsp");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuUeReconfigRsp");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Re-Cfg Response ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Re-Cfg Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcUlRrcMsgToDu");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcUlRrcMsgToDu");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcUlRrcMsgToDu");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcUlRrcMsgToDu");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UL RRC Message transfer ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UL RRC Message transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgToRlc");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgToRlc");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packDlRrcMsgToRlc");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packDlRrcMsgToRlc");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UL RRC Message transfer ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UL RRC Message transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRrcDeliveryReportToDu");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRrcDeliveryReportToDu");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRrcDeliveryReportToDu");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRrcDeliveryReportToDu");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for RRC delivery Message transfer ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for RRC delivery Message transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeReconfigReq");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packDuRlcUeReconfigReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeReconfigReq");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packDuRlcUeReconfigReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Create Request ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Create Request ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgRspToDu");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgRspToDu");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDlRrcMsgRspToDu");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDlRrcMsgRspToDu");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for DL RRC Message transfer ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for DL RRC Message transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC UL: Memory allocation failed at packRlcUlUserDataToDu");
+ DU_LOG("ERROR --> RLC UL: Memory allocation failed at packRlcUlUserDataToDu");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC UL: Only LWLC supported for packRlcUlUserDataToDu");
+ DU_LOG("ERROR --> RLC UL: Only LWLC supported for packRlcUlUserDataToDu");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC UL: Only LWLC supported for UL User data transfer ");
+ DU_LOG("ERROR --> RLC UL: Only LWLC supported for UL User data transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
}
else
{
- DU_LOG("\nERROR --> RLC DL: Only LWLC supported for packRlcUlUserDataToDu");
+ DU_LOG("ERROR --> RLC DL: Only LWLC supported for packRlcUlUserDataToDu");
}
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC DL: Only LWLC supported for UL User data transfer ");
+ DU_LOG("ERROR --> RLC DL: Only LWLC supported for UL User data transfer ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeDeleteReq");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packDuRlcUeDeleteReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeDeleteReq");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packDuRlcUeDeleteReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Delete Request ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Delete Request ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeDeleteRsp");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuUeDeleteRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeDeleteRsp");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuUeDeleteRsp");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Del Response ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Del Response ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuSlicePm");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuSlicePm");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuSlicePm");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuSlicePm");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for Slice Metrics ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for Slice Metrics ");
ODU_PUT_MSG_BUF(mBuf);
}
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeReestablishReq");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packDuRlcUeReestablishReq");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeReestablishReq");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packDuRlcUeReestablishReq");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Reestablishment Req ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Reestablishment Req ");
ODU_PUT_MSG_BUF(mBuf);
}
return RFAILED;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeReestablishRsp");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDuUeReestablishRsp");
return RFAILED;
}
/* pack the address of the structure */
}
else
{
- DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeReestablishRsp");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for packRlcDuUeReestablishRsp");
return RFAILED;
}
else
{
/* Nothing to do for other selectors */
- DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Reestablishment Response ");
+ DU_LOG("ERROR --> RLC: Only LWLC supported for UE Reestablishment Response ");
ODU_PUT_MSG_BUF(mBuf);
}
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+ *******************************************************************************/
+
+#include <stdio.h>
+#include <time.h>
+#include <sys/time.h>
+
+char* getFormattedTime(void)
+{
+ struct timeval tp;
+ gettimeofday(&tp, 0);
+
+ time_t rawtime;
+ struct tm* timeinfo;
+
+ rawtime = tp.tv_sec;
+ timeinfo = localtime(&rawtime);
+
+
+ static char _retval[30];
+ snprintf(_retval, sizeof(_retval), "[%02d:%02d:%02d:%05d]", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, tp.tv_usec/1000);
+
+ return _retval;
+}
#include<syslog.h>
+char* getFormattedTime(void);
+
/*MACROS*/
+#ifndef LOG_TIMESTAMP
#define DU_LOG(...) ({\
printf(__VA_ARGS__);\
syslog(LOG_DEBUG,__VA_ARGS__);\
})
+#else
+#define __LOG__(format,...) ({\
+ printf(" %s " format "\n", getFormattedTime(), ## __VA_ARGS__);\
+ })
+
+#define DU_LOG(format,...) __LOG__(format, ## __VA_ARGS__)
+#endif
+
#endif
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
if(egtpCfg.localIp.ipV4Pres)
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to allocate memory");
+ DU_LOG("ERROR --> EGTP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to allocate memory");
+ DU_LOG("ERROR --> EGTP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to allocate memory");
+ DU_LOG("ERROR --> EGTP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to allocate memory");
+ DU_LOG("ERROR --> SCTP : Failed to allocate memory");
return RFAILED;
}
if (ODU_POST_TASK(pst, mBuf) != ROK)
{
- DU_LOG("\nERROR --> SCTP : ODU_POST_TASK failed while sending SCTP notification");
+ DU_LOG("ERROR --> SCTP : ODU_POST_TASK failed while sending SCTP notification");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC: Memory allocation failed at packBOStatus");
+ DU_LOG("ERROR --> RLC: Memory allocation failed at packBOStatus");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packSchResultRep");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packSchResultRep");
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDlData");
+ DU_LOG("ERROR --> RLC : Memory allocation failed at packRlcDlData");
return RFAILED;
}
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packRlcUlData");
+ DU_LOG("ERROR --> MAC : Memory allocation failed at packRlcUlData");
return RFAILED;
}
if(id->buf == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Buffer allocation is empty");
+ DU_LOG("ERROR --> DU_APP : Buffer allocation is empty");
return RFAILED;
}
memset(id->buf, 0, byteSize);
if(bitString->buf == NULL || bitString->size <= 0)
{
- DU_LOG("\nERROR --> DU_APP : Bit string is empty");
+ DU_LOG("ERROR --> DU_APP : Bit string is empty");
return RFAILED;
}
if(sctpSend(F1_INTERFACE, duId, mBuf) != ROK)
{
- DU_LOG("\nERROR --> F1AP : SCTP Send failed");
+ DU_LOG("ERROR --> F1AP : SCTP Send failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("ERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory");
return RFAILED;
}
Cells_to_be_Activated_List_t *cellToActivate;
RRC_Version_t *rrcVer = NULL;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Setup Response\n");
+ DU_LOG("INFO --> F1AP : Building F1 Setup Response\n");
/* Allocate the memory for F1SetupRequest_t */
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
return RFAILED;
}
f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
elementCnt * sizeof(F1SetupResponseIEs_t *));
if(f1SetupRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResponseIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1ResponseIEs failed");
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1SetupResponse\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for F1SetupResponse\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Setup Response failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Setup Response failed");
return RFAILED;
}
GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
asn_enc_rval_t enRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> F1AP : Building GNB-DU Config Update Ack\n");
+ DU_LOG("INFO --> F1AP : Building GNB-DU Config Update Ack\n");
/* Allocate the memory for F1SetupRequest_t */
CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
return RFAILED;
}
CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
return RFAILED;
/* Checking encode results */
if(enRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
+ DU_LOG("ERROR --> F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update Ack failed");
+ DU_LOG("ERROR --> F1AP : Sending GNB-DU Config Update Ack failed");
return RFAILED;
}
Reset_t *f1ResetMsg = NULLP;
F1AP_PDU_t *f1apMsg = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Reset request \n");
+ DU_LOG("INFO --> F1AP : Building F1 Reset request \n");
do
{
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
if(f1ResetMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
break;
}
for(idx=0; idx<elementCnt; idx++)
CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
break;
}
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
for(idx=0; idx< encBufSize; idx++)
{
- DU_LOG("%x",encBuf[idx]);
+ printf("%x",encBuf[idx]);
}
}
/* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset request failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Reset request failed");
break;
}
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
return RFAILED;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
for(int i = 0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
rrcContainer->size = encBufSize;
CU_ALLOC(rrcContainer->buf, rrcContainer->size);
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
+ DU_LOG("F1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
ret = RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
+ DU_LOG("ERROR --> F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: Mem alloc failed at fillCnAssoc()");
+ DU_LOG("ERROR --> F1AP: Mem alloc failed at fillCnAssoc()");
ret = RFAILED;
}
}
ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
+ DU_LOG("ERROR --> F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
}
}
else
{
- DU_LOG("\nERROR --> F1AP : memory Alloc failed at fillRrcReconfigIE()");
+ DU_LOG("ERROR --> F1AP : memory Alloc failed at fillRrcReconfigIE()");
CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
}
}
CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
{
- DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
+ DU_LOG("DEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, updateAllRbCfg);
if(ret == ROK)
{
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
for(int i = 0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
rrcContainer->size = encBufSize;
CU_ALLOC(rrcContainer->buf, rrcContainer->size);
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
+ DU_LOG("ERROR --> F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
ret = RFAILED;
}
return ret;
{
ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
if(ret == RFAILED)
- DU_LOG("\nERROR --> F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
+ DU_LOG("ERROR --> F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
}
else if(rrcMsgType == RRC_SETUP_COMPLETE)
{
- DU_LOG("\nINFO --> F1AP : Sending NAS Authentication Request");
+ DU_LOG("INFO --> F1AP : Sending NAS Authentication Request");
char authReqBuf[51] = {0x00, ueCb->pdcpSn++, 0x2a, 0x85, 0x4f, 0xc0, 0x0a, 0xc0, 0x40, 0x40, 0x00, 0x04, 0x2f, 0x58, 0x39, 0x12,\
0x37, 0x15, 0x74, 0x16, 0x4c, 0x8d, 0xd3, 0x95, 0xa6, 0x9e, 0x94, 0x03, 0x24, 0x02, 0x00, 0x6f,\
0x0b, 0x39, 0x5e, 0xbc, 0xb0, 0x00, 0x1a, 0xb1, 0xc1, 0x3f, 0x84, 0x4f, 0x77, 0xe3, 0x20, 0x00,\
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure for RRC Container buffer");
ret = RFAILED;
}
}
else if(rrcMsgType == NAS_AUTHENTICATION_RSP)
{
- DU_LOG("\nINFO --> F1AP : Sending NAS Security mode command");
+ DU_LOG("INFO --> F1AP : Sending NAS Security mode command");
char secModeBuf[30]={0x00, ueCb->pdcpSn++, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
bufLen =30;
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure for RRC Container buffer");
ret = RFAILED;
}
}
else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
{
- DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
+ DU_LOG("INFO --> F1AP : Sending RRC Security mode command");
char secModeBuf[9]={0x00, ueCb->pdcpSn++, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
bufLen =9;
rrcContainer->size = bufLen;
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure for RRC Container buffer");
ret = RFAILED;
}
}
else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
{
/*Hardcoded RRC Container from reference logs*/
- DU_LOG("\nINFO --> F1AP : Sending Registration accept");
+ DU_LOG("INFO --> F1AP : Sending Registration accept");
char buf[14] ={0x00, ueCb->pdcpSn++, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
bufLen =14;
rrcContainer->size = bufLen;
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure for RRC Container buffer");
ret = RFAILED;
}
}
{
uint16_t tmpBufIdx = 0, bufIdx = 0;
RRCContainer_t rrcContainerTmp;
- DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
+ DU_LOG("INFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
ret = fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, false);
rrcContainer->size = rrcContainerTmp.size + 2;
CU_ALLOC(rrcContainer->buf, rrcContainer->size);
}
}
if(ret == RFAILED)
- DU_LOG("\nERROR --> F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
+ DU_LOG("ERROR --> F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
}
return ret;
DLRRCMessageTransfer_t *dlRRCMsg = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> F1AP : Building DL RRC Message Transfer Message\n");
+ DU_LOG("INFO --> F1AP : Building DL RRC Message Transfer Message\n");
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
return RFAILED;
}
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
if(dlRRCMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending DL RRC Message Transfer Failed");
+ DU_LOG("ERROR --> F1AP : Sending DL RRC Message Transfer Failed");
return RFAILED;
}
freeDlRrcMessageTransfer(f1apMsg);
if(ueCb == NULLP)
{
- DU_LOG("\nERROR --> F1AP: extractCellGroupConfig(): UE Cb is NULL");
+ DU_LOG("ERROR --> F1AP: extractCellGroupConfig(): UE Cb is NULL");
return RFAILED;
}
if(cellGrpCfg == NULLP)
{
- DU_LOG("\nERROR --> F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
+ DU_LOG("ERROR --> F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
return RFAILED;
}
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> F1AP : ASN decode failed in extractDuToCuRrcCont");
+ DU_LOG("ERROR --> F1AP : ASN decode failed in extractDuToCuRrcCont");
return RFAILED;
}
printf("\n");
if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract cell group config");
+ DU_LOG("ERROR --> F1AP : Failed to extract cell group config");
return RFAILED;
}
CuUeCb *ueCb;
InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
- DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg");
+ DU_LOG("INFO --> F1AP : filling the required values in DB in procInitULRRCMsg");
SEARCH_DU_DB(duIdx, duId, duDb);
initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
(initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
{
- DU_LOG("\nINFO --> Received Du to Cu RRC Container ");
+ DU_LOG("INFO --> Received Du to Cu RRC Container ");
ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
}
if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract DU to CU RRC Container ");
+ DU_LOG("ERROR --> F1AP : Failed to extract DU to CU RRC Container ");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> Failed to receive Du to Cu RRC Container ");
+ DU_LOG("ERROR --> Failed to receive Du to Cu RRC Container ");
ret = RFAILED;
}
break;
}
default:
- DU_LOG("\nERROR --> Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
+ DU_LOG("ERROR --> Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
break;
}
if(ret == RFAILED)
CU_ALLOC(srbSet->list.array,srbSet->list.size);
if(srbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
+ DU_LOG("ERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
return RFAILED;
}
CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
if(srbSet->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
+ DU_LOG("ERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
return RFAILED;
}
}
/*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
if(pduSessionID <= INVALID_PDU_SESSION_ID)
{
- DU_LOG("\nINFO --> F1AP : Invalid PDU_SESSION_ID");
+ DU_LOG("INFO --> F1AP : Invalid PDU_SESSION_ID");
return ROK;
}
if(qosIeExt->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
return RFAILED;
}
CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
if(qosIeExt->list.array[qosCntIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
return RFAILED;
}
/*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for QosIE_extension failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for QosIE_extension failed");
return RFAILED;
}
}
CU_ALLOC(flowMap->list.array,flowMap->list.size);
if(flowMap->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for array in BuildFlowsMap()");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for array in BuildFlowsMap()");
return RFAILED;
}
for(idx=0; idx<flowCnt; idx++)
CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
if(flowMap->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
return RFAILED;
}
actionType, INVALID_PDU_SESSION_ID, hoInProgress);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to Build QOS Info in BuildFlowsMap()");
+ DU_LOG("ERROR --> F1AP : Failed to Build QOS Info in BuildFlowsMap()");
return RFAILED;
}
CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
if(ulInfo->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for array in BuildULTnlInfo()");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for array in BuildULTnlInfo()");
return RFAILED;
}
for(idx=0; idx<ulCnt; idx++)
CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
if(ulInfo->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
return RFAILED;
}
}
CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
return RFAILED;
}
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size = 4*sizeof(uint8_t);
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
return RFAILED;
}
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
return RFAILED;
}
CU_ALLOC(drbSet->list.array,drbSet->list.size);
if(drbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDRBSetup");
return RFAILED;
}
CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
if(drbSet->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
return RFAILED;
}
CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
return RFAILED;
}
drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, ueCb->hoInfo.HOType);
if(BuildQOSInforet != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build QOS Info in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to build QOS Info in BuildDRBSetup");
return RFAILED;
}
choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], ueCb->hoInfo.HOType);
if(BuildSNSSAIret != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
return RFAILED;
}
value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, ueCb->hoInfo.HOType);
if(BuildFlowsMapret != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build Flow Map Info in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to build Flow Map Info in BuildDRBSetup");
return RFAILED;
}
ueCb->hoInfo.HOType);
if(BuildULTnlInforet != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build tunnel Info in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to build tunnel Info in BuildDRBSetup");
return RFAILED;
}
CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
if(!drbToBeSetupExt)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
return RFAILED;
}
CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
if(!drbToBeSetupExt->list.array)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
return RFAILED;
}
CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
if(!drbToBeSetupExt->list.array[extIeIdx])
{
- DU_LOG("\nERROR --> F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
+ DU_LOG("ERROR --> F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
return RFAILED;
}
}
ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
break;
default:
- DU_LOG("\nERROR --> F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
+ DU_LOG("ERROR --> F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
break;
}
}
CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
if(!controlRSetList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
if(!controlRSetList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
controlRSet->frequencyDomainResources.size);
if(!controlRSet->frequencyDomainResources.buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
if(!controlRset->tci_StatesPDCCH_ToAddList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
controlRset->tci_StatesPDCCH_ToAddList->list.size)
if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
if(!controlRset->tci_PresentInDCI)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
/* TODO */
CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
if(!controlRSet->pdcch_DMRS_ScramblingID)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
*(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
if(!searchSpcList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
if(!searchSpcList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
}
CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
if(!searchSpc->controlResourceSetId)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
searchSpc->monitoringSlotPeriodicityAndOffset->present = \
CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
if(!searchSpc->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
searchSpc->monitoringSymbolsWithinSlot->size);
if(!searchSpc->monitoringSymbolsWithinSlot->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpc->nrofCandidates)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
if(!searchSpc->searchSpaceType)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
if(!searchSpc->searchSpaceType->choice.ue_Specific)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
sizeof(struct PDCCH_Config__searchSpacesToAddModList));
if(!pdcchCfg->searchSpacesToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
if(!dmrsDlCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
sizeof(struct PDSCH_TimeDomainResourceAllocation));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
}
CU_ALLOC(timeDomAlloc->k0, sizeof(long));
if(!timeDomAlloc->k0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k0) = 0;
CU_ALLOC(timeDomAlloc->k0, sizeof(long));
if(!timeDomAlloc->k0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k0) = 1;
sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
if(!prbBndlType->choice.staticBundling)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
if(!pdschCfg->tci_StatesToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
*(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
if(!dlBwp->pdcch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
if(!dlBwp->pdcch_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
if(!dlBwp->pdsch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
if(!dlBwp->pdsch_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
if(!dmrsUlCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
sizeof(long));
if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
sizeof(PUSCH_TimeDomainResourceAllocation_t));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
}
CU_ALLOC(timeDomAlloc->k2, sizeof(long));
if(!timeDomAlloc->k2)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k2) = PUSCH_K2_CFG1;
CU_ALLOC(timeDomAlloc->k2, sizeof(long));
if(!timeDomAlloc->k2)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k2) = PUSCH_K2_CFG2;
CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
if(!puschCfg->dataScramblingIdentityPUSCH)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
if(!puschCfg->pusch_TimeDomainAllocationList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
if(!puschCfg->transformPrecoder)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
*(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
if(pucchCfg->dl_DataToUL_ACK == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
CU_ALLOC(resourceList->list.array, resourceList->list.size);
if(!resourceList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
if(!resourceList->list.array[rsrcIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
}
sizeof(struct SRS_Resource__transmissionComb__n2));
if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
if(!rsrcSetList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
if(!rsrcSetList->list.array[rSetIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
if(!rsrcIdList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
if(!rsrcIdList->list.array[rsrcIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
return RFAILED;
}
CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
if(!ulBwp->pucch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
if(!ulBwp->pucch_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
if(!ulBwp->pusch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
if(!ulBwp->pusch_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
if(!ulBwp->srs_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
if(!ulBwp->srs_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
if(!puschCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
if(!puschCfg->choice.setup->ext1)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
*(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
if(!puschCfg->choice.setup->ext1->processingType2Enabled)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
*(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
if(!ulCfg->initialUplinkBWP)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
if(!ulCfg->firstActiveUplinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
if(!pdschCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
*(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
if(!srvCellCfg->initialDownlinkBWP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildInitialDlBWP failed");
+ DU_LOG("ERROR --> F1AP : BuildInitialDlBWP failed");
return RFAILED;
}
srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->firstActiveDownlinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
*(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->defaultDownlinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
*(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
if(!srvCellCfg->uplinkConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildUlCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildUlCfg failed");
return RFAILED;
}
srvCellCfg->supplementaryUplink = NULLP;
CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
if(!srvCellCfg->pdsch_ServingCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPdschSrvCellCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildPdschSrvCellCfg failed");
return RFAILED;
}
CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
if(!srvCellCfg->csi_MeasConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
+ DU_LOG("F1AP : BuildCsiMeasCfg failed");
return RFAILED;
}
#endif
CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
if(!spCellCfg->servCellIndex)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
*(spCellCfg->servCellIndex) = SERV_CELL_IDX;
CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
*(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
if(!spCellCfg->spCellConfigDedicated)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSpCellCfgDed failed");
+ DU_LOG("ERROR --> F1AP : BuildSpCellCfgDed failed");
return RFAILED;
}
return ROK;
CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
if(!phyCellGrpCfg->p_NR_FR1)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
return RFAILED;
}
*(phyCellGrpCfg->p_NR_FR1) = P_NR_FR1;
CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
if(!tagConfig->tag_ToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
CU_ALLOC(tagList->list.array, tagList->list.size);
if(!tagList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
if(!tagList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
}
CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
if(!phrConfig->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
return RFAILED;
}
sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
if(!schedulingRequestConfig->schedulingRequestToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
CU_ALLOC(schReqList->list.array, schReqList->list.size);
if(!schReqList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
if(!schReqList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
}
CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
if(!schReqList->list.array[idx]->sr_ProhibitTimer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
*(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
if(!macCellGrpCfg->schedulingRequestConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSchedulingReqConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildSchedulingReqConfig failed");
return RFAILED;
}
CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
if(!macCellGrpCfg->bsr_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildBsrConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildBsrConfig failed");
return RFAILED;
}
CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
if(!macCellGrpCfg->tag_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildTagConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildTagConfig failed");
return RFAILED;
}
CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
if(!macCellGrpCfg->phr_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPhrConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildPhrConfig failed");
return RFAILED;
}
CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
if(!rlcConfig->choice.am)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
if(!rlcConfig->choice.um_Bi_Directional)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
return RFAILED;
}
*(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
if(!macLcConfig->ul_SpecificParameters)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
*(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
*(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
if(!rlcBearerList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in CellGrpConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in CellGrpConfig");
return RFAILED;
}
rlcBearerList->list.count = elementCnt;
CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
if(!rlcBearerList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
if(!rlcBearerList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
}
CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
if(!rlcBearerList->list.array[idx]->servedRadioBearer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildRlcConfig failed");
return RFAILED;
}
CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildMacLCConfig failed");
return RFAILED;
}
idx++;
CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
if(!rlcBearerList->list.array[idx]->servedRadioBearer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildRlcConfig failed");
return RFAILED;
}
CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildMacLCConfig failed");
return RFAILED;
}
idx++;
if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP : fillCellGrpCfg failed");
+ DU_LOG("ERROR --> F1AP : fillCellGrpCfg failed");
break;
}
CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
if(!cellGrpCfg.mac_CellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in fillCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in fillCellGrpCfg");
break;
}
if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildMacCellGrpCfg failed");
break;
}
CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
if(!cellGrpCfg.physicalCellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
break;
}
if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildPhyCellGrpCfg failed");
break;
}
CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
if(!cellGrpCfg.spCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
break;
}
if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildSpCellCfg failed");
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(cellGrp->buf, cellGrp->size);
if(!cellGrp->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
break;
}
memcpy(cellGrp->buf, encBuf, cellGrp->size);
CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
if(!featureSets->featureSetsDownlinkPerCC)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
if(!featureSets->featureSetsDownlinkPerCC->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
}
CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
*(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
if(!featureSets->featureSetsUplinkPerCC)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
if(!featureSets->featureSetsUplinkPerCC->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
}
CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillFeatureSets");
return RFAILED;
}
*(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
ret = RFAILED;
break;
}
CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
if(!ueNrCap.featureSets)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
ret = RFAILED;
break;
}
if(fillFeatureSets(ueNrCap.featureSets) != ROK)
{
- DU_LOG("\nERROR --> fillDLFeatureSets() failed ");
+ DU_LOG("ERROR --> fillDLFeatureSets() failed ");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
if(!ueCapRatContBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
break;
}
memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
if(!ueCapablityList->list.array)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
+ DU_LOG("ERROR --> Memory allocation failed in fillUeCapRatContList");
ret = RFAILED;
break;
}
CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
if(ueCapablityList->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
+ DU_LOG("ERROR --> Memory allocation failed in fillUeCapRatContList");
ret = RFAILED;
break;
}
ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill UE capability RAT Conatiner");
+ DU_LOG("ERROR --> F1AP : Failed to fill UE capability RAT Conatiner");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
if(!ueCapablityListBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
break;
}
memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
if(!measTimingConfigBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed fillMeasTimingConfigBuf");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed fillMeasTimingConfigBuf");
break;
}
memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
if(!srbToAddList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
return RFAILED;
}
CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
if(!srbToAddList->list.array[srbIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
return RFAILED;
}
CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
return RFAILED;
}
*(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
return RFAILED;
}
CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
return RFAILED;
}
*(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
if(!drbToAddList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
return RFAILED;
}
CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
if(!drbToAddList->list.array[drbIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
return RFAILED;
}
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
return RFAILED;
}
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
return RFAILED;
}
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
return RFAILED;
}
*(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
return RFAILED;
}
*(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
return RFAILED;
}
*(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
return RFAILED;
}
*(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
if(!radioBearerConfig->srb_ToAddModList)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
return RFAILED;
}
if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP: failed to fill SRB to AddMod List");
+ DU_LOG("ERROR --> F1AP: failed to fill SRB to AddMod List");
return RFAILED;
}
CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
if(!radioBearerConfig->drb_ToAddModList)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
return RFAILED;
}
if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP: failed to fill DRB to AddMod List ");
+ DU_LOG("ERROR --> F1AP: failed to fill DRB to AddMod List ");
return RFAILED;
}
CU_ALLOC(measObjList->list.array, measObjList->list.size);
if(!measObjList->list.array)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for measurement object list's array");
return RFAILED;
}
CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
if(!measObjList->list.array[objIdx])
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array element");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for measurement object list's array element");
return RFAILED;
}
}
CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for mesurement object NR");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for mesurement object NR");
return RFAILED;
}
CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
if(!measObject->ssbFrequency)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
if(!measObject->ssbSubcarrierSpacing)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
if(!measObject->smtc1)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
return RFAILED;
}
measObject->smtc1->duration = SSB_MTC__duration_sf1;
CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
if(!measObject->absThreshSS_BlocksConsolidation)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
return RFAILED;
}
CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
if(!measObject->nrofSS_BlocksToAverage)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->nrofSS_BlocksToAverage) = 2;
CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
if(!measObject->offsetMO.rsrpOffsetSSB)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
if(!measObject->offsetMO.rsrqOffsetSSB)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
if(!measObject->offsetMO.sinrOffsetSSB)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
return RFAILED;
}
*(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
if(!reportCfgList->list.array)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
return RFAILED;
}
CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
if(!reportCfgList->list.array[reportCfgIdx])
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
return RFAILED;
}
}
CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
if(!reportCfg->reportConfig.choice.reportConfigNR)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
return RFAILED;
}
reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
if(!reportCfgNr->reportType.choice.eventTriggered)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
return RFAILED;
}
eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
if(!eventTriggCfg->eventId.choice.eventA3)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
return RFAILED;
}
CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
if(!eventTriggCfg->reportQuantityRS_Indexes)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
return RFAILED;
}
eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
if(!eventTriggCfg->maxNrofRS_IndexesToReport)
{
- DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
+ DU_LOG("ERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
return RFAILED;
}
*(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
if(!measConfig->measObjectToAddModList)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
return RFAILED;
}
if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failure in fillMeasObjToAddModList");
+ DU_LOG("ERROR --> F1AP: Failure in fillMeasObjToAddModList");
return RFAILED;
}
CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
if(!measConfig->reportConfigToAddModList)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for report config list in fillMeasConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for report config list in fillMeasConfig");
return RFAILED;
}
if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failure in fillReportCfgToAddModList");
+ DU_LOG("ERROR --> F1AP: Failure in fillReportCfgToAddModList");
return RFAILED;
}
CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
if(!measConfig->measIdToAddModList)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for measuerment id list in fillMeasConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for measuerment id list in fillMeasConfig");
return RFAILED;
}
if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failure in fillMeasIdToAddModList");
+ DU_LOG("ERROR --> F1AP: Failure in fillMeasIdToAddModList");
return RFAILED;
}
CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
if(!measConfig->s_MeasureConfig)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for s measuerment config in fillMeasConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for s measuerment config in fillMeasConfig");
return RFAILED;
}
if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failure in fillSMeasConfig");
+ DU_LOG("ERROR --> F1AP: Failure in fillSMeasConfig");
return RFAILED;
}
CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
if(!measConfig->quantityConfig)
{
- DU_LOG("\nERROR --> F1AP: Memory allocation failed for quantity config in fillMeasConfig");
+ DU_LOG("ERROR --> F1AP: Memory allocation failed for quantity config in fillMeasConfig");
return RFAILED;
}
if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failure in fillQuantityConfig");
+ DU_LOG("ERROR --> F1AP: Failure in fillQuantityConfig");
return RFAILED;
}
CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
if(!rrcRecfg->masterCellGroup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
return RFAILED;
}
CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
if(!rrcRecfg->masterCellGroup->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
return RFAILED;
}
memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
* received from DU */
if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
+ DU_LOG("ERROR --> F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
return RFAILED;
}
#endif
CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
{
- DU_LOG("\nERROR --> F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
return RFAILED;
}
CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
{
- DU_LOG("\nERROR --> F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
return RFAILED;
}
if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill radio bearer config in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Failed to fill radio bearer config in fillRrcReconfig");
return RFAILED;
}
CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
{
- DU_LOG("\nERROR --> F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
return RFAILED;
}
if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill measurement config in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Failed to fill measurement config in fillRrcReconfig");
return RFAILED;
}
CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
{
- DU_LOG("\nERROR --> F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
return RFAILED;
}
if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill non critical extension in fillRrcReconfig");
+ DU_LOG("ERROR --> F1AP : Failed to fill non critical extension in fillRrcReconfig");
return RFAILED;
}
return ROK;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
if(!rrcReconfigBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigBuf");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillRrcReconfigBuf");
break;
}
memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
if(!hoPrepInfoBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
break;
}
memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
if(!rrcMsg->uE_CapabilityRAT_ContainerList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE capability RAT container list failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE capability RAT container list failed");
return RFAILED;
}
ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
if(!rrcMsg->measConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for measurement configuration failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for measurement configuration failed");
return RFAILED;
}
ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
if(rrcMsg->iE_Extensions->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
ret = RFAILED;
}
CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for array elements failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for array elements failed");
ret = RFAILED;
}
}
CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
if(!drxCycle->shortDRXCycleLength)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for shortDRXCycleLength");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for shortDRXCycleLength");
return RFAILED;
}
*(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
if(!drxCycle->shortDRXCycleTimer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for shortDRXCycleTimer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for shortDRXCycleTimer");
return RFAILED;
}
*(drxCycle->shortDRXCycleTimer) = 4;
}
break;
default:
- DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
+ DU_LOG("ERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
rrcMsg->iE_Extensions->list.array[idx]->id);
break;
}
while(true)
{
- DU_LOG("\nINFO --> F1AP : Building UE Context Setup Request\n");
+ DU_LOG("INFO --> F1AP : Building UE Context Setup Request\n");
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
if(ueSetReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE Context SetupRequest failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE Context SetupRequest failed");
break;
}
ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build drx cycle");
+ DU_LOG("ERROR --> F1AP : Failed to build drx cycle");
break;
}
#endif
ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
break;
}
memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending UE Context Setup Request Failed");
+ DU_LOG("ERROR --> F1AP : Sending UE Context Setup Request Failed");
break;
}
ret = ROK;
teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
}
else
- DU_LOG("\nERROR --> EGTP: No TeId received");
+ DU_LOG("ERROR --> EGTP: No TeId received");
return(teId);
}
}
if(teId > MAX_TEID || teId < MIN_TEID)
{
- DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId);
+ DU_LOG("ERROR --> EGTP : TEID(%x) OUT Of Range",teId);
}
memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
tnlEvt.action = EGTP_TNL_MGMT_ADD;
ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId);
+ DU_LOG("ERROR --> EGTP : Tunnel management request failed for teId %x", teId);
}
return ROK;
}
{
if(addDrbTunnels(duId, teId)== ROK)
{
- DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
+ DU_LOG("DEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
/* As per Spec 38.473, in UE COntext Response, Tunnel information
* are sent to CU for setting up of Tunnels in DL direction.
}
case ProtocolIE_ID_id_DUtoCURRCInformation:
{
- DU_LOG("\nINFO --> Received Du to Cu RRC Information ");
+ DU_LOG("INFO --> Received Du to Cu RRC Information ");
duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
DUtoCURRCInformation.cellGroupConfig;
if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
DUtoCURRCInformation.cellGroupConfig)) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failed to extract Du to Cu RRC Information ");
+ DU_LOG("ERROR --> F1AP: Failed to extract Du to Cu RRC Information ");
return RFAILED;
}
break;
ueCb->f1apMsgDb.dlRrcMsgCount++;
rrcMsgType = setDlRRCMsgType(ueCb);
- DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC reconfiguration");
+ DU_LOG("INFO --> F1AP: Sending DL RRC MSG for RRC reconfiguration");
if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
{
- DU_LOG("\nINFO --> F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
+ DU_LOG("INFO --> F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
return RFAILED;
}
}
if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
{
- DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
+ DU_LOG("ERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
return RFAILED;
}
break;
CU_ALLOC(rrcContainer, rrcContLen);
if(!rrcContainer)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocated memory in procUlRrcMsg");
+ DU_LOG("ERROR --> F1AP : Failed to allocated memory in procUlRrcMsg");
return RFAILED;
}
memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
if(ret != ROK)
{
- DU_LOG("\nINFO --> F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
+ DU_LOG("INFO --> F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
}
break;
}
}
default:
- DU_LOG("\nERROR --> F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
+ DU_LOG("ERROR --> F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
break;
}
}
rrcMsgType = setDlRRCMsgType(ueCb);
if(rrcMsgType == REGISTRATION_COMPLETE)
{
- DU_LOG("\nINFO --> F1AP: Sending Ue Context Setup Request");
+ DU_LOG("INFO --> F1AP: Sending Ue Context Setup Request");
ret = BuildAndSendUeContextSetupReq(duId, ueCb);
}
else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
{
- DU_LOG("\nINFO --> F1AP: Sending UE Context Modification Request");
+ DU_LOG("INFO --> F1AP: Sending UE Context Modification Request");
BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
}
else
F1AP_PDU_t *f1apMsg = NULL;
ResetAcknowledge_t *f1ResetAck = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Reset Acknowledgment \n");
+ DU_LOG("INFO --> F1AP : Building F1 Reset Acknowledgment \n");
do{
/* Allocate the memory for F1ResetRequest_t */
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
if(f1ResetAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for F1ResetAck \n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for F1ResetAck \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset Response failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Reset Response failed");
break;
}
teIdStringToInt(buf, &teId);
if(teId > MAX_TEID || teId < MIN_TEID)
{
- DU_LOG("\nERROR --> EGTP : TEID(%d) OUT Of Range", teId);
+ DU_LOG("ERROR --> EGTP : TEID(%d) OUT Of Range", teId);
return RFAILED;
}
memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
tnlEvt.remTeid = teId;
if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to delete tunnel Id %d", teId);
+ DU_LOG("ERROR --> EGTP : Failed to delete tunnel Id %d", teId);
}
return ROK;
}
CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
if(ulInfo->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
return RFAILED;
}
for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
if(ulInfo->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
return RFAILED;
}
}
sizeof(GTPTunnel_t));
if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
return RFAILED;
}
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
transportLayerAddress.buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
return RFAILED;
}
if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
== NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
return RFAILED;
}
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
if(drbItem->qoSInformation.choice.eUTRANQoS)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
return RFAILED;
}
drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
if(drbItem->qoSInformation.choice.choice_extension == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
return RFAILED;
}
ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildQOSInfo failed");
+ DU_LOG("ERROR --> F1AP : BuildQOSInfo failed");
return RFAILED;
}
choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSNSSAI failed");
+ DU_LOG("ERROR --> F1AP : BuildSNSSAI failed");
return RFAILED;
}
ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildFlowsMap failed");
+ DU_LOG("ERROR --> F1AP : BuildFlowsMap failed");
return RFAILED;
}
}
&drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildUlTnlInfoforSetupMod failed");
+ DU_LOG("ERROR --> F1AP : BuildUlTnlInfoforSetupMod failed");
return RFAILED;
}
if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
{
- DU_LOG("\nERROR --> F1AP : FillDrbItemToSetupMod failed");
+ DU_LOG("ERROR --> F1AP : FillDrbItemToSetupMod failed");
return RFAILED;
}
return ROK;
CU_ALLOC(drbSet->list.array, drbSet->list.size);
if(drbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList");
return RFAILED;
}
CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
if(drbSet->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
return RFAILED;
}
ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : FillDrbItemList failed");
+ DU_LOG("ERROR --> F1AP : FillDrbItemList failed");
}
}
CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
if(drbItem->qoSInformation->choice.eUTRANQoS)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in FillDrbToBeModItem");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in FillDrbToBeModItem");
return RFAILED;
}
drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
if(drbItem->qoSInformation->choice.choice_extension == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in FillDrbItemToSetupMod");
return RFAILED;
}
ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildQOSInfo failed");
+ DU_LOG("ERROR --> F1AP : BuildQOSInfo failed");
return RFAILED;
}
choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSNSSAI failed");
+ DU_LOG("ERROR --> F1AP : BuildSNSSAI failed");
return RFAILED;
}
ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildFlowsMap failed");
+ DU_LOG("ERROR --> F1AP : BuildFlowsMap failed");
return RFAILED;
}
}
ProtocolIE_ID_id_DRBs_ToBeModified_Item);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildUlTnlInfoforSetupMod failed");
+ DU_LOG("ERROR --> F1AP : BuildUlTnlInfoforSetupMod failed");
return RFAILED;
}
return ROK;
drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : FillDrbToBeModItem failed");
+ DU_LOG("ERROR --> F1AP : FillDrbToBeModItem failed");
return RFAILED;
}
CU_ALLOC(drbSet->list.array, drbSet->list.size);
if(drbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
return RFAILED;
}
for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
if(drbSet->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupList");
return RFAILED;
}
ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : FillDrbToBeModItemList failed");
+ DU_LOG("ERROR --> F1AP : FillDrbToBeModItemList failed");
}
}
CU_ALLOC(drbSet->list.array, drbSet->list.size);
if(drbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
return RFAILED;
}
for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
if(drbSet->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
return RFAILED;
}
ret = FillDrbToBeRelItemList(duId, ueCb, arrIdx, (DRBs_ToBeReleased_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : FillDrbToBeRelItemList failed");
+ DU_LOG("ERROR --> F1AP : FillDrbToBeRelItemList failed");
}
}
UEContextModificationRequest_t *ueContextModifyReq = NULLP;
RRCContainer_t rrcContainerTmp, *rrcContainer = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building Ue context modification request\n");
+ DU_LOG("INFO --> F1AP : Building Ue context modification request\n");
while(1)
{
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
break;
}
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
if(ueContextModifyReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
break;
}
CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
break;
}
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
break;
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be deleted list");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be deleted list");
break;
}
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
#if 0
/* This for loop was going into an infinite loop even though encBufSize
* has a small value. Hence commented this
*/
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
- DU_LOG("%x",encBuf[ieIdx]);
+ printf("%x",encBuf[ieIdx]);
}
#endif
}
/* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending Ue context modification request failed");
+ DU_LOG("ERROR --> F1AP : Sending Ue context modification request failed");
break;
}
UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building Ue context release command\n");
+ DU_LOG("INFO --> F1AP : Building Ue context release command\n");
while(true)
{
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
break;
}
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
break;
}
CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
memAllocFailed = true;
break;
}
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
break;
}
memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode Release Command structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode Release Command structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Ue Context Release Command\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for Ue Context Release Command\n");
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
- DU_LOG("%x",encBuf[ieIdx]);
+ printf("%x",encBuf[ieIdx]);
}
}
/* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending Ue context Release Command failed");
+ DU_LOG("ERROR --> F1AP : Sending Ue context Release Command failed");
break;
}
if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
+ DU_LOG("ERROR --> F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
return RFAILED;
}
return ROK;
if(cellToBeDelete == false)
{
- DU_LOG("\nINFO --> F1AP : Sending F1 reset request");
+ DU_LOG("INFO --> F1AP : Sending F1 reset request");
if(BuildAndSendF1ResetReq() != ROK)
{
DU_LOG("ERROR --> F1AP : Failed to build and send F1 reset request");
CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
if(cuCb.snssaiList[sliceListIdx] == NULLP)
{
- DU_LOG("\nERROR --> CU_STUB: buildSliceList(): Memory allocation failed");
+ DU_LOG("ERROR --> CU_STUB: buildSliceList(): Memory allocation failed");
return RFAILED;
}
if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
{
if(addDrbTunnels(duId, teId)== ROK)
{
- DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
+ DU_LOG("DEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
}
else
if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
extensionValue.choice.SliceSupportList) != ROK)
{
- DU_LOG("\nERROR --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
+ DU_LOG("ERROR --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
return RFAILED;
}
}
}
case ProtocolIE_ID_id_DRBs_Modified_List:
{
- DU_LOG("\nINFO --> Received DRBs Modified List");
+ DU_LOG("INFO --> Received DRBs Modified List");
break;
}
case ProtocolIE_ID_id_SRBs_SetupMod_List:
}
case ProtocolIE_ID_id_DUtoCURRCInformation:
{
- DU_LOG("\nINFO --> Received Du to Cu RRC Information ");
+ DU_LOG("INFO --> Received Du to Cu RRC Information ");
if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
DUtoCURRCInformation.cellGroupConfig)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract Du to Cu RRC Information");
+ DU_LOG("ERROR --> F1AP : Failed to extract Du to Cu RRC Information");
return RFAILED;
}
break;
{
if((BuildAndSendUeContextSetupReq(tgtDuId, ueCb)) != ROK)
{
- DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextSetupReq");
+ DU_LOG("ERROR -> F1AP : Failed at BuildAndSendUeContextSetupReq");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
+ DU_LOG("ERROR --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
}
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(!duDb)
{
- DU_LOG("\nERROR --> F1AP : No entry found for DU ID [%d]", duId);
+ DU_LOG("ERROR --> F1AP : No entry found for DU ID [%d]", duId);
return;
}
CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
if(pagingCelllist->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
return RFAILED;
}
CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
if(pagingCelllist->list.array[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
return RFAILED;
}
}
DuDb *duDb;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building PAGING Message command\n");
+ DU_LOG("INFO --> F1AP : Building PAGING Message command\n");
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): DuDb is empty");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): DuDb is empty");
return ret;
}
if(duDb->numCells == 0)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): No CELL is UP!");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): No CELL is UP!");
return ret;
}
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
break;
}
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
if(paging->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg():Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg():Memory allocation failed");
break;
}
CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
if(paging->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
memAllocFailed = true;
break;
}
paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
break;
}
sizeof(struct CNUEPagingIdentity));
if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
break;
}
paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
break;
}
paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
+ DU_LOG("ERROR --> F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
break;
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode Release Command structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode Release Command structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Paging\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for Paging\n");
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
- DU_LOG("%x",encBuf[ieIdx]);
+ printf("%x",encBuf[ieIdx]);
}
}
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending Ue context Release Command failed");
+ DU_LOG("ERROR --> F1AP : Sending Ue context Release Command failed");
break;
}
CU_ALLOC(*recvBuf, (Size)(*recvBufLen));
if(*recvBuf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed");
return RFAILED;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, *recvBufLen, (Data *)*recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed while copying %d", copyCnt);
+ DU_LOG("ERROR --> F1AP : Failed while copying %d", copyCnt);
return RFAILED;
}
- DU_LOG("\nDEBUG --> F1AP : Received flat buffer to be decoded : \n");
+ DU_LOG("DEBUG --> F1AP : Received flat buffer to be decoded : \n");
for(i=0; i< *recvBufLen; i++)
{
- DU_LOG("%x ",(*recvBuf)[i]);
+ printf("%x ",(*recvBuf)[i]);
}
/* Decoding flat buffer into F1AP messsage */
rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, *recvBuf, *recvBufLen, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> F1AP : ASN decode failed");
+ DU_LOG("ERROR --> F1AP : ASN decode failed");
return RFAILED;
}
/* Printing the decoded F1AP PDU */
- DU_LOG("\n");
+ DU_LOG("");
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
return ROK;
}
F1AP_PDU_t *f1apMsg = NULLP;
F1AP_PDU_t f1apasnmsg ;
- DU_LOG("\nINFO --> F1AP : Received F1AP message buffer");
+ DU_LOG("INFO --> F1AP : Received F1AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
f1apMsg = &f1apasnmsg;
memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
if(F1APDecodeMsg(f1apMsg, mBuf, &recvBuf, &recvBufLen) != ROK)
{
- DU_LOG("\nERROR --> F1AP : F1AP PDU decode failed");
+ DU_LOG("ERROR --> F1AP : F1AP PDU decode failed");
return;
}
{
case InitiatingMessage__value_PR_Reset:
{
- DU_LOG("\nINFO --> F1AP : F1 reset request received ");
+ DU_LOG("INFO --> F1AP : F1 reset request received ");
BuildAndSendF1ResetAck();
break;
}
case InitiatingMessage__value_PR_F1SetupRequest:
{
- DU_LOG("\nINFO --> F1AP : F1 setup request received");
+ DU_LOG("INFO --> F1AP : F1 setup request received");
procF1SetupReq(duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
{
- DU_LOG("\nINFO --> F1AP : GNB-DU config update received");
+ DU_LOG("INFO --> F1AP : GNB-DU config update received");
procGnbDuUpdate(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
{
- DU_LOG("\nINFO --> F1AP : Received InitialULRRCMessageTransfer");
+ DU_LOG("INFO --> F1AP : Received InitialULRRCMessageTransfer");
procInitULRRCMsg(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_ULRRCMessageTransfer:
{
- DU_LOG("\nINFO --> F1AP : Received ULRRCMessageTransfer");
+ DU_LOG("INFO --> F1AP : Received ULRRCMessageTransfer");
procUlRrcMsg(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_RRCDeliveryReport:
{
- DU_LOG("\nINFO --> F1AP : Received RRC delivery report");
+ DU_LOG("INFO --> F1AP : Received RRC delivery report");
break;
}
case InitiatingMessage__value_PR_UEContextReleaseRequest:
{
- DU_LOG("\nINFO --> F1AP : Received UE Context Release Request");
+ DU_LOG("INFO --> F1AP : Received UE Context Release Request");
procUeContextReleaseReq(*duId, f1apMsg);
break;
}
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of intiating message [%d]",\
+ DU_LOG("ERROR --> F1AP : Invalid type of intiating message [%d]",\
f1apMsg->choice.initiatingMessage->value.present);
return;
}
{
case SuccessfulOutcome__value_PR_ResetAcknowledge:
{
- DU_LOG("\nINFO --> F1Reset Acknowledgement is received successfully ");
+ DU_LOG("INFO --> F1Reset Acknowledgement is received successfully ");
break;
}
case SuccessfulOutcome__value_PR_UEContextSetupResponse:
{
- DU_LOG("\nINFO --> F1AP : UE ContextSetupResponse received");
+ DU_LOG("INFO --> F1AP : UE ContextSetupResponse received");
procUeContextSetupResponse(*duId, f1apMsg, recvBuf, recvBufLen);
break;
}
case SuccessfulOutcome__value_PR_UEContextModificationResponse:
{
- DU_LOG("\nINFO --> F1AP : UE Context Modification Response received");
+ DU_LOG("INFO --> F1AP : UE Context Modification Response received");
procUeContextModificationResponse(*duId, f1apMsg, recvBuf, recvBufLen);
break;
}
case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
{
- DU_LOG("\nINFO --> F1AP : UE Context release complete received");
+ DU_LOG("INFO --> F1AP : UE Context release complete received");
procUeContextReleaseComplete(*duId, f1apMsg);
break;
}
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of successful outcome message [%d]",\
+ DU_LOG("ERROR --> F1AP : Invalid type of successful outcome message [%d]",\
f1apMsg->choice.successfulOutcome->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
+ DU_LOG("ERROR --> F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
return;
}
}/* End of switch(f1apMsg->present) */
pthread_attr_t attr;
init_log();
- DU_LOG("\nINFO --> CU_STUB : Starting CU_STUB\n");
+ DU_LOG("INFO --> CU_STUB : Starting CU_STUB\n");
/* Start thread to receive console input */
pthread_attr_init(&attr);
retVal = pthread_create(&conThrdId, &attr, cuConsoleHandler, NULLP);
if(retVal != 0)
{
- DU_LOG("\nERROR --> CU_STUB : Thread creation failed. Cause %d", retVal);
+ DU_LOG("ERROR --> CU_STUB : Thread creation failed. Cause %d", retVal);
}
pthread_attr_destroy(&attr);
uint8_t numDu, *numRemoteCu;
uint32_t ipv4_du, ipv4_cu, ipv4_remote_cu;
- DU_LOG("\nDEBUG --> CU_STUB : Reading CU configurations");
+ DU_LOG("DEBUG --> CU_STUB : Reading CU configurations");
cuCb.cuCfgParams.cuId = CU_ID;
strcpy(cuCb.cuCfgParams.cuName, CU_NAME);
#ifdef O1_ENABLE
if( getStartupConfigForStub(&g_cfg) != ROK )
{
- DU_LOG("\nError --> CU_STUB : Could not fetch startup "\
+ DU_LOG("Error --> CU_STUB : Could not fetch startup "\
"configurations from Netconf interface\n");
exit(1);
}
DuDb *duDb = NULLP;
CuUeCb *ueCb = NULLP;
- DU_LOG("\nINFO --> CU_STUB: Inter-DU Handover Started for ueId [%d] from DU ID [%d] to DU ID [%d]", \
+ DU_LOG("INFO --> CU_STUB: Inter-DU Handover Started for ueId [%d] from DU ID [%d] to DU ID [%d]", \
duUeF1apId, sourceDuId, targetDuId);
SEARCH_DU_DB(duIdx, sourceDuId, duDb);
}
else
{
- DU_LOG("\nINFO --> CU_STUB: DU UE F1AP ID [%d] not found", duUeF1apId);
+ DU_LOG("INFO --> CU_STUB: DU UE F1AP ID [%d] not found", duUeF1apId);
}
}
uint8_t duIdx, ueIdx;
CuUeCb *ueCb = NULLP;
- DU_LOG("\nINFO --> CU_STUB: Inter-CU Handover Started for ueId [%d] to CU ID [%d]", \
+ DU_LOG("INFO --> CU_STUB: Inter-CU Handover Started for ueId [%d] to CU ID [%d]", \
cuUeF1apId, targetCuId);
for(duIdx = 0; duIdx < cuCb.numDu; duIdx++)
}
else
{
- DU_LOG("\nINFO --> CU_STUB: CU UE F1AP ID [%d] not found", cuUeF1apId);
+ DU_LOG("INFO --> CU_STUB: CU UE F1AP ID [%d] not found", cuUeF1apId);
}
}
if(teidCb)
{
cnt =0;
- DU_LOG("\nDEBUG --> EGTP: Sending DL User Data(duId %d, teId:%d)\n", duId, teId);
+ DU_LOG("DEBUG --> EGTP: Sending DL User Data(duId %d, teId:%d)\n", duId, teId);
while(cnt < NUM_DL_PACKETS)
{
ret = cuEgtpDatReq(duId, teId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP: Issue with teid=%d\n",teId);
+ DU_LOG("ERROR --> EGTP: Issue with teid=%d\n",teId);
break;
}
/* TODO : sleep(1) will be removed later once we will be able to
}
else
{
- DU_LOG("\nDEBUG --> EGTP: TunnelId Not Found for (duId %d, teId:%d)\n", duId, teId);
+ DU_LOG("DEBUG --> EGTP: TunnelId Not Found for (duId %d, teId:%d)\n", duId, teId);
}
}
}
/* Change #if 0 to #if 1 to take input from user */
#if 0
- DU_LOG("\n EGTP --> : Enter TEID id(1..10) where DL Data to be sent\n");
+ DU_LOG(" EGTP --> : Enter TEID id(1..10) where DL Data to be sent\n");
scanf("%d",&teId);
if(teId > MAX_TEID || teId < MIN_TEID)
{
- DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId);
+ DU_LOG("ERROR --> EGTP : TEID(%x) OUT Of Range",teId);
printf("\n");
continue;
}
/* Start Pumping data from CU to DU */
- DU_LOG("\nDEBUG --> EGTP: Sending DL User Data(teId:%d)\n",teId);
+ DU_LOG("DEBUG --> EGTP: Sending DL User Data(teId:%d)\n",teId);
cnt =0;
while(cnt < NUM_DL_PACKETS)
ret = cuEgtpDatReq(teId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP: Issue with teid=%d\n",teId);
+ DU_LOG("ERROR --> EGTP: Issue with teid=%d\n",teId);
break;
}
cnt++;
HandoverType hoType;
uint32_t srcNodeId, tgtNodeId, targetCellId, ueId;
- DU_LOG("\n\nChoose the type of handover to initiate : \nEnter 1 for Inter-CU Handover over Xn interface\nEnter 2 for Inter-DU Handover\n");
+ DU_LOG("Choose the type of handover to initiate : \nEnter 1 for Inter-CU Handover over Xn interface\nEnter 2 for Inter-DU Handover\n");
scanf("%d", &hoType);
if(hoType == Xn_Based_Inter_CU_HO)
{
- DU_LOG("\nEnter Target CU ID for Inter-CU Handover : ");
+ DU_LOG("Enter Target CU ID for Inter-CU Handover : ");
scanf("%d", &tgtNodeId);
- DU_LOG("\nEnter Target Physical Cell ID for Inter-CU Handover : ");
+ DU_LOG("Enter Target Physical Cell ID for Inter-CU Handover : ");
scanf("%d", &targetCellId);
- DU_LOG("\nEnter CU UE F1AP ID to be handed over : ");
+ DU_LOG("Enter CU UE F1AP ID to be handed over : ");
scanf("%d", &ueId);
initiateInterCuHandover(tgtNodeId, targetCellId, ueId);
}
else if(hoType == Inter_DU_HO)
{
- DU_LOG("\nEnter Source DU ID for Inter-DU Handover : ");
+ DU_LOG("Enter Source DU ID for Inter-DU Handover : ");
scanf("%d", &srcNodeId);
- DU_LOG("\nEnter Target DU ID for Inter-DU Handover : ");
+ DU_LOG("Enter Target DU ID for Inter-DU Handover : ");
scanf("%d", &tgtNodeId);
- DU_LOG("\nEnter DU UE F1AP ID to be handed over : ");
+ DU_LOG("Enter DU UE F1AP ID to be handed over : ");
scanf("%d", &ueId);
initiateInterDuHandover(srcNodeId, tgtNodeId, ueId);
uint64_t sTmsi = 0;
uint8_t duId = 0;
- DU_LOG("\nEnter DU ID on which this UE to be pagged");
+ DU_LOG("Enter DU ID on which this UE to be pagged");
scanf("%d", &duId);
- DU_LOG("\nEnter 5g-S-TMSI");
+ DU_LOG("Enter 5g-S-TMSI");
scanf("%lu", &sTmsi);
if(BuildAndSendPagingMsg(sTmsi, duId) != ROK)
{
- DU_LOG("\nERROR --> EGTP: Failed to build and send paging message for 5gsTmsi[%lu]\n", sTmsi);
+ DU_LOG("ERROR --> EGTP: Failed to build and send paging message for 5gsTmsi[%lu]\n", sTmsi);
}
continue;
}
DuDb *duDb = NULLP;
CuUeCb *ueCb = NULLP;
- DU_LOG("\nEnter DU ID whose UE has to be modified");
+ DU_LOG("Enter DU ID whose UE has to be modified");
scanf("%d", &duId);
- DU_LOG("\nEnter UE ID to be modified");
+ DU_LOG("Enter UE ID to be modified");
scanf("%d", &ueId);
- DU_LOG("\nINFO --> CU_STUB: UE Context Mod for ueId [%d] at DU ID [%d]", \
+ DU_LOG("INFO --> CU_STUB: UE Context Mod for ueId [%d] at DU ID [%d]", \
ueId, duId);
SEARCH_DU_DB(duIdx, duId, duDb);
uint8_t duIdx = 0;
DuDb *duDb = NULLP;
- DU_LOG("\nEnter DU ID on which UE has to be released");
+ DU_LOG("Enter DU ID on which UE has to be released");
scanf("%d", &duId);
- DU_LOG("\nEnter UE ID to be released");
+ DU_LOG("Enter UE ID to be released");
scanf("%d", &duUeF1apId);
SEARCH_DU_DB(duIdx, duId, duDb);
***************************************************************************/
S16 egtpActvInit()
{
- DU_LOG("\n\nDEBUG --> EGTP : Initializing");
+ DU_LOG("DEBUG --> EGTP : Initializing");
memset (&egtpCb, 0, sizeof(EgtpGlobalCb));
//Initializing with INVALID value
ret = cuEgtpCfgReq();
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Configuration failed");
+ DU_LOG("ERROR --> EGTP : Configuration failed");
return (ret);
}
ret = cuEgtpSrvOpenReq();
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Transport server open request failed");
+ DU_LOG("ERROR --> EGTP : Transport server open request failed");
return (ret);
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
+ DU_LOG("ERROR --> EGTP : TeId hash list initialization failed");
return RFAILED;
}
else
{
- DU_LOG("\nINFO --> EGTP : Configuration successful");
+ DU_LOG("INFO --> EGTP : Configuration successful");
}
}
egtpCb.numDu = egtpCb.egtpCfg.numDu;
uint8_t ret, destIdx;
- DU_LOG("\nINFO --> EGTP : Received open server request");
+ DU_LOG("INFO --> EGTP : Received open server request");
sockType = CM_INET_DGRAM;
if((ret = (cmInetSocket(sockType, &(egtpCb.sockFd), protType))) != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
+ DU_LOG("ERROR --> EGTP : Failed to open UDP socket");
return RFAILED;
}
ret = cmInetBind(&(egtpCb.sockFd), &(egtpCb.localAddr));
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to bind socket");
+ DU_LOG("ERROR --> EGTP : Failed to bind socket");
return RFAILED;
}
- DU_LOG("\nINFO --> EGTP : Socket[%d] is open", egtpCb.sockFd.fd);
+ DU_LOG("INFO --> EGTP : Socket[%d] is open", egtpCb.sockFd.fd);
return ROK;
} /* cuEgtpSrvOpenReq */
{
S8 ret;
- DU_LOG("\nINFO --> EGTP : Received tunnel management request");
+ DU_LOG("INFO --> EGTP : Received tunnel management request");
switch(tnlEvt.action)
{
case EGTP_TNL_MGMT_ADD:
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid tunnel management action[%d]", tnlEvt.action);
+ DU_LOG("ERROR --> EGTP : Invalid tunnel management action[%d]", tnlEvt.action);
ret = RFAILED;
}
}
EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
- DU_LOG("\nINFO --> EGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("INFO --> EGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
CU_ALLOC(teidCb, (Size)sizeof(EgtpTeIdCb));
if(teidCb == NULLP)
{
- DU_LOG("\nERROR --> EGTP : Memory allocation failed");
+ DU_LOG("ERROR --> EGTP : Memory allocation failed");
return RFAILED;
}
ret = cmHashListInsert(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to insert in hash list");
+ DU_LOG("ERROR --> EGTP : Failed to insert in hash list");
CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
return RFAILED;
}
S16 ret;
EgtpTeIdCb *teidCb = NULLP;
- DU_LOG("\nDEBUG --> CU_STUB : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("DEBUG --> CU_STUB : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nDEBUG --> CU_STUBTunnel id not found");
+ DU_LOG("DEBUG --> CU_STUBTunnel id not found");
return RFAILED;
}
{
EgtpTeIdCb *teidCb = NULLP;
- DU_LOG("\nDEBUG --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("DEBUG --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
+ DU_LOG("ERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
return RFAILED;
}
ODU_REM_PRE_MSG(&extHdrType, mBuf);
}
- DU_LOG("\nDEBUG --> EGTP : Message Buffer after decoding header [TEID:%d]",egtpMsg.msgHdr.teId);
+ DU_LOG("DEBUG --> EGTP : Message Buffer after decoding header [TEID:%d]",egtpMsg.msgHdr.teId);
ODU_PRINT_MSG(mBuf, 0, 0);
SPutMsg(mBuf);
if(egtpCb.gCntPdu[teId] == 0xFF) //DRB not created
{
- DU_LOG("\nERROR --> EGTP : DRB not created");
+ DU_LOG("ERROR --> EGTP : DRB not created");
return RFAILED ;
}
/* Build Application message that is supposed to come from app to egtp */
ret = BuildAppMsg(duId, &egtpMsg);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to build App Msg");
+ DU_LOG("ERROR --> EGTP : Failed to build App Msg");
return RFAILED;
}
ret = BuildEgtpMsg(duId, &egtpMsg);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg");
+ DU_LOG("ERROR --> EGTP : Failed to build EGTP Msg");
return RFAILED;
}
cuEgtpSendMsg(duId, egtpMsg.msg);
{
if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
{
- DU_LOG("\nERROR --> EGTP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("ERROR --> EGTP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> EGTP : Failed to allocate memory");
+ DU_LOG("ERROR --> EGTP : Failed to allocate memory");
return RFAILED;
}
cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
+ DU_LOG("ERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
return (LCM_REASON_INVALID_PAR_VAL);
}
ret = cmInetSendMsg(&(egtpCb.sockFd), &egtpCb.dstCb[duId-1].dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> EGTP : Message send failure");
+ DU_LOG("ERROR --> EGTP : Message send failure");
return RFAILED;
}
- DU_LOG("\nDEBUG --> EGTP : Message Sent");
+ DU_LOG("DEBUG --> EGTP : Message Sent");
return ROK;
}
***************************************************************************/
uint8_t sctpActvInit()
{
- DU_LOG("\n\nDEBUG --> SCTP : Initializing");
+ DU_LOG("DEBUG --> SCTP : Initializing");
memset(&sctpCb, 0, sizeof(SctpGlobalCb));
sctpCb.sctpCfg = cuCb.cuCfgParams.sctpParams;
return ROK;
{
if((ret = cmInetSocket(socket_type, &sctpCb.xnLstnSockFd, IPPROTO_SCTP) != ROK))
{
- DU_LOG("\nERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.f1LstnSockFd.fd);
+ DU_LOG("ERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.f1LstnSockFd.fd);
}
else if((ret = cmInetSctpBindx(&sctpCb.xnLstnSockFd, &sctpCb.localAddrLst, sctpCb.sctpCfg.xnSctpInfo.port)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Binding failed at CU");
+ DU_LOG("ERROR --> SCTP: Binding failed at CU");
}
else if(ret = cmInetListen(&sctpCb.xnLstnSockFd, 1) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Listening on socket failed");
+ DU_LOG("ERROR --> SCTP : Listening on socket failed");
cmInetClose(&sctpCb.xnLstnSockFd);
return RFAILED;
}
{
if((ret = sctpAccept(&sctpCb.xnLstnSockFd, &sctpCb.assocCb[assocIdx])) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at CU");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at CU");
}
}
}
{
if((ret = cmInetSocket(socket_type, &sctpCb.assocCb[assocIdx].sockFd, IPPROTO_SCTP)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed while opening a socket in ODU");
+ DU_LOG("ERROR --> SCTP : Failed while opening a socket in ODU");
}
else if((ret = cmInetSctpBindx(&sctpCb.assocCb[assocIdx].sockFd, &sctpCb.localAddrLst, sctpCb.sctpCfg.xnSctpInfo.port)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Failed during Binding in ODU");
+ DU_LOG("ERROR --> SCTP: Failed during Binding in ODU");
}
else if((ret = sctpSetSockOpts(&sctpCb.assocCb[assocIdx].sockFd)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to set Socket Opt in ODU");
+ DU_LOG("ERROR --> SCTP : Failed to set Socket Opt in ODU");
}
else
{
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed while establishing Req at DU");
+ DU_LOG("ERROR --> SCTP : Failed while establishing Req at DU");
ret = RFAILED;
}
else
{
if((ret = cmInetSocket(socket_type, &sctpCb.f1LstnSockFd, IPPROTO_SCTP) != ROK))
{
- DU_LOG("\nERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.f1LstnSockFd.fd);
+ DU_LOG("ERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.f1LstnSockFd.fd);
}
else if((ret = cmInetSctpBindx(&sctpCb.f1LstnSockFd, &sctpCb.localAddrLst, sctpCb.sctpCfg.f1SctpInfo.port)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Binding failed at CU");
+ DU_LOG("ERROR --> SCTP: Binding failed at CU");
}
else if(ret = cmInetListen(&sctpCb.f1LstnSockFd, 1) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Listening on socket failed");
+ DU_LOG("ERROR --> SCTP : Listening on socket failed");
cmInetClose(&sctpCb.f1LstnSockFd);
return RFAILED;
}
{
if((ret = sctpAccept(&sctpCb.f1LstnSockFd, &sctpCb.assocCb[assocIdx])) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at CU");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at CU");
}
}
}
{
if(sctpSockPoll() != ROK)
{
- DU_LOG("\nERROR --> SCTP: Polling failed to start at CU");
+ DU_LOG("ERROR --> SCTP: Polling failed to start at CU");
}
}
return (ret);
{
uint8_t ret;
- DU_LOG("\nINFO --> SCTP : Connecting");
+ DU_LOG("INFO --> SCTP : Connecting");
while(!assocCb->connUp)
{
}
else if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to accept connection");
+ DU_LOG("ERROR --> SCTP : Failed to accept connection");
return RFAILED;
}
else
break;
}
}
- DU_LOG("\nINFO --> SCTP : Connection established");
+ DU_LOG("INFO --> SCTP : Connection established");
return ROK;
}
switch(ntfy->header.nType)
{
case CM_INET_SCTP_ASSOC_CHANGE :
- DU_LOG("\nINFO --> SCTP : Assoc change notification received");
+ DU_LOG("INFO --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
assocCb->connUp = FALSE;
break;
default:
- DU_LOG("\nERROR --> Invalid event");
+ DU_LOG("ERROR --> Invalid event");
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
+ DU_LOG("INFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nINFO --> SCTP : Remote Error notification received");
+ DU_LOG("INFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
+ DU_LOG("INFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
- DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n");
+ DU_LOG("INFO --> SCTP : Shutdown Event notification received\n");
assocCb->connUp = FALSE;
exit(0);
break;
case CM_INET_SCTP_ADAPTATION_INDICATION :
- DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
+ DU_LOG("INFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
+ DU_LOG("INFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nERROR --> SCTP : Invalid notification type\n");
+ DU_LOG("ERROR --> SCTP : Invalid notification type\n");
break;
}
{
if((ret = processPolling(&pollParams, &sctpCb.assocCb[assocIdx], timeoutPtr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1 at CU\n");
+ DU_LOG("ERROR --> SCTP : Failed to RecvMsg for F1 at CU\n");
}
}
{
if((fromAddr.port == egtpCb.dstCb[destIdx].dstAddr.port) && (fromAddr.address == egtpCb.dstCb[destIdx].dstAddr.address))
{
- DU_LOG("\nINFO --> EGTP : Received UL Message [%ld] from DU Id [%d]\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId);
+ DU_LOG("INFO --> EGTP : Received UL Message [%ld] from DU Id [%d]\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId);
numMsgRcvd++;
//ODU_PRINT_MSG(egtpBuf, 0 ,0);
cuEgtpHdlRecvMsg(egtpBuf);
ret = sctpNtfyHdlr(assocCb, &pollParams->ntfy);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
+ DU_LOG("ERROR --> SCTP : Failed to process sctp notify msg\n");
}
}
else if(assocCb->connUp && assocCb->intf == F1_INTERFACE)
}
else if(assocCb->connUp && assocCb->intf == XN_INTERFACE)
{
- DU_LOG("\nDEBUG --> SCTP : Received message at XN interface");
+ DU_LOG("DEBUG --> SCTP : Received message at XN interface");
ODU_PRINT_MSG(pollParams->mBuf, 0,0);
XNAPMsgHdlr(&assocCb->destId, pollParams->mBuf);
ODU_PUT_MSG_BUF(pollParams->mBuf);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> SCTP : Send message failed");
+ DU_LOG("ERROR --> SCTP : Send message failed");
return RFAILED;
}
return ROK;
break;
}
}
- DU_LOG("\nERROR --> SCTP : Dest ID [%d] at Interface [%d] not found in SCTP DestCb list. Failed to send message", destId, intf);
+ DU_LOG("ERROR --> SCTP : Dest ID [%d] at Interface [%d] not found in SCTP DestCb list. Failed to send message", destId, intf);
return RFAILED;
} /* End of sctpSend */
ODU_PRINT_MSG(mBuf, 0,0);
if(sendOnSctpAssoc(assocCb, mBuf) != ROK)
{
- DU_LOG("\nERROR --> CU_STUB: Failed to send XN setup request to peer CU");
+ DU_LOG("ERROR --> CU_STUB: Failed to send XN setup request to peer CU");
}
}
break;
{
uint8_t cuId;
- DU_LOG("\nINFO --> CU STUB : Received XN Setup Request");
+ DU_LOG("INFO --> CU STUB : Received XN Setup Request");
CMCHKUNPK(oduUnpackUInt8, &(cuId), mBuf)
*destId = cuId;
CMCHKPK(oduPackUInt8, XN_SETUP_RSP, mBuf);
if(sctpSend(XN_INTERFACE, destId, mBuf))
{
- DU_LOG("\nERROR --> CU_STUB: Failed to send XN setup response to peer CU");
+ DU_LOG("ERROR --> CU_STUB: Failed to send XN setup response to peer CU");
}
}
}
{
uint8_t cuId;
- DU_LOG("\nINFO --> CU STUB : Received XN Setup Response");
+ DU_LOG("INFO --> CU STUB : Received XN Setup Response");
CMCHKUNPK(oduUnpackUInt8, &(cuId), mBuf)
*destId = cuId;
}
CMCHKPK(oduPackUInt8, HO_REQ, mBuf);
if(sctpSend(XN_INTERFACE, ueCb->hoInfo.tgtNodeId, mBuf) != ROK)
{
- DU_LOG("\nERROR --> CU_STUB: Failed to send handover request to peer CU");
+ DU_LOG("ERROR --> CU_STUB: Failed to send handover request to peer CU");
ueCb->state = UE_ACTIVE;
memset(&ueCb->hoInfo, 0, sizeof(HandoverInfo));
}
DuDb *duDb;
CuCellCb *cellCb;
- DU_LOG("\nINFO --> CU STUB : Received Handover Request");
+ DU_LOG("INFO --> CU STUB : Received Handover Request");
/* Find DU Db and Cell Cb from cellId */
CMCHKUNPK(oduUnpackUInt32, &(cellId), mBuf);
}
if(!cellCb)
{
- DU_LOG("\nERROR --> CU_STUB: Failed to find Cell Id [%d] received in HO Request", cellId);
+ DU_LOG("ERROR --> CU_STUB: Failed to find Cell Id [%d] received in HO Request", cellId);
return;
}
CU_ALLOC(duDb->tempUeCtxtInHo, sizeof(CuUeCb));
if(!duDb->tempUeCtxtInHo)
{
- DU_LOG("\nERROR --> XNAP : Failed to allocate memory to temporary UE context for UE in handover");
+ DU_LOG("ERROR --> XNAP : Failed to allocate memory to temporary UE context for UE in handover");
return;
}
memset(duDb->tempUeCtxtInHo, 0, sizeof(CuUeCb));
memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
if(F1APDecodeMsg(f1apMsg, mBuf, &recvBuf, &recvBufLen) != ROK)
{
- DU_LOG("\nERROR --> F1AP : F1AP PDU decode failed");
+ DU_LOG("ERROR --> F1AP : F1AP PDU decode failed");
return;
}
CU_FREE(recvBuf, recvBufLen);
CMCHKPK(oduPackUInt8, HO_REQ_ACK, mBuf);
if(sctpSend(XN_INTERFACE, ueCb->hoInfo.srcNodeId, mBuf) != ROK)
{
- DU_LOG("\nERROR --> CU_STUB: Failed to send handover request ack to peer CU");
+ DU_LOG("ERROR --> CU_STUB: Failed to send handover request ack to peer CU");
}
}
}
DuDb *duDb;
CuUeCb *ueCb;
- DU_LOG("\nINFO --> CU STUB : Received Handover Request Acknowledgement");
+ DU_LOG("INFO --> CU STUB : Received Handover Request Acknowledgement");
/* Fetch UE CB and DU DB in Source CU for UE under Inter-CU Handover */
CMCHKUNPK(oduUnpackUInt8, &(cuUeF1apIdSrc), mBuf);
}
if(!duDb || !ueCb)
{
- DU_LOG("\nERROR --> CU STUB : UE CB not found for CU UE F1AP ID [%d]", cuUeF1apIdSrc);
+ DU_LOG("ERROR --> CU STUB : UE CB not found for CU UE F1AP ID [%d]", cuUeF1apIdSrc);
return;
}
CU_ALLOC(rrcCont.buf, rrcCont.size);
if(rrcCont.buf == NULLP)
{
- DU_LOG("\nERROR --> XNAP : Memory allocation failed");
+ DU_LOG("ERROR --> XNAP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, rrcCont.size, (Data *)rrcCont.buf, ©Cnt) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed while copying %d", copyCnt);
+ DU_LOG("ERROR --> F1AP : Failed while copying %d", copyCnt);
return;
}
* Xn Handover Request Ack */
if(BuildAndSendUeContextModificationReq(duDb->duId, ueCb, STOP_DATA_TX) != ROK)
{
- DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
+ DU_LOG("ERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
return;
}
}
CMCHKPK(oduPackUInt8, UE_CTXT_REL, mBuf);
if(sctpSend(XN_INTERFACE, ueCb->hoInfo.srcNodeId, mBuf) != ROK)
{
- DU_LOG("\nERROR --> CU_STUB: Failed to send UE context release to peer CU");
+ DU_LOG("ERROR --> CU_STUB: Failed to send UE context release to peer CU");
}
}
DuDb *duDb;
CuUeCb *ueCb;
- DU_LOG("\nINFO --> CU STUB : Received UE Context Release");
+ DU_LOG("INFO --> CU STUB : Received UE Context Release");
/* Fetch UE CB and DU DB in Source CU for UE under Inter-CU Handover */
CMCHKUNPK(oduUnpackUInt8, &(cuUeF1apIdSrc), mBuf);
}
if(!duDb || !ueCb)
{
- DU_LOG("\nERROR --> CU STUB : UE CB not found for CU UE F1AP ID [%d]", cuUeF1apIdSrc);
+ DU_LOG("ERROR --> CU STUB : UE CB not found for CU UE F1AP ID [%d]", cuUeF1apIdSrc);
return;
}
break;
}
default:
- DU_LOG("\nERROR --> CU_STUB : Invalid event [%d] received at XN interface", event);
+ DU_LOG("ERROR --> CU_STUB : Invalid event [%d] received at XN interface", event);
break;
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : No Cell found for NCI %d", nci);
+ DU_LOG("ERROR --> DU APP : No Cell found for NCI %d", nci);
return RFAILED;
}
}
if(duBuildAndSendMacCellCfg(cellCb->cellId) != ROK)
{
- DU_LOG("\nERROR --> DU APP : macCellCfg build and send failed");
+ DU_LOG("ERROR --> DU APP : macCellCfg build and send failed");
/* Delete cell from actvCellList */
duCb.actvCellLst[cellCb->cellId -1] = NULLP;
--(duCb.numActvCells);
******************************************************************/
void duProcF1SetupRsp()
{
- DU_LOG("\nINFO --> DU_APP : F1 Setup Response received");
+ DU_LOG("INFO --> DU_APP : F1 Setup Response received");
duCb.f1Status = TRUE; //Set F1 status as true
}
if(!*cellCb)
{
- DU_LOG("\nERROR --> DU APP : Cell Id %d not found in DU APP", cellId);
+ DU_LOG("ERROR --> DU APP : Cell Id %d not found in DU APP", cellId);
return RFAILED;
}
{
if(BuildAndSendDlPcchIndToMac(cellCb->cellId, pf, pagInfo->i_s, &(pagInfo->pagUeList)) != ROK)
{
- DU_LOG("\nERROR --> DU APP: Issue in Building Page RRC PDU i_s:%d",pagInfo->i_s);
+ DU_LOG("ERROR --> DU APP: Issue in Building Page RRC PDU i_s:%d",pagInfo->i_s);
return RFAILED;
}
handlePageInfoLL(pf, pagInfo->i_s, &(pagInfoLLFromPF->pagInfoList), DELETE);
ret = (*packMacDlPcchIndOpts[pst.selector])(&pst, pcchInd);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : sendDlPcchIndToMac(): Failed to DL PCCH indication to MAC");
+ DU_LOG("ERROR --> DU APP : sendDlPcchIndToMac(): Failed to DL PCCH indication to MAC");
}
}
else
{
- DU_LOG("\nERROR --> DU APP: sendDlPcchIndToMac(): Received pcchInd is NULLP");
+ DU_LOG("ERROR --> DU APP: sendDlPcchIndToMac(): Received pcchInd is NULLP");
ret = RFAILED;
}
return ret;
}
else
{
- DU_LOG("\nERROR --> DU APP : CellId[%d] doesnot exist", slotIndInfo->cellId);
+ DU_LOG("ERROR --> DU APP : CellId[%d] doesnot exist", slotIndInfo->cellId);
ret = RFAILED;
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, slotIndInfo, sizeof(SlotTimingInfo));
}
else
{
- DU_LOG("\nERROR --> DU APP : Recevied null pointer from MAC");
+ DU_LOG("ERROR --> DU APP : Recevied null pointer from MAC");
ret = RFAILED;
}
return(ret);
if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
{
- DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId);
+ DU_LOG("ERROR --> DU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId);
return RFAILED;
}
if((cellCb != NULL) && (cellCb->cellStatus == ACTIVATION_IN_PROGRESS))
{
- DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is UP", cellId->cellId);
+ DU_LOG("INFO --> DU APP : 5G-NR Cell %d is UP", cellId->cellId);
cellCb->cellStatus = ACTIVATED;
gConfigInfo.gCellStatus = CELL_UP;
if(duCfgParam.tempSliceCfg.numOfRrmPolicy)
BuildAndSendSliceConfigReq();
#ifdef O1_ENABLE
- DU_LOG("\nINFO --> DU APP : Raise cell UP alarm for cell id=%d", cellId->cellId);
+ DU_LOG("INFO --> DU APP : Raise cell UP alarm for cell id=%d", cellId->cellId);
raiseCellAlrm(CELL_UP_ALARM_ID, cellId->cellId);
setCellOpState(cellId->cellId, ENABLED, ACTIVE);
#endif
if(deleteRsp->status == SUCCESSFUL)
{
GET_CELL_IDX(deleteRsp->cellId, cellIdx);
- DU_LOG("\nINFO --> DU APP : MAC CELL Delete Response : SUCCESS [CELL IDX : %d]", deleteRsp->cellId);
+ DU_LOG("INFO --> DU APP : MAC CELL Delete Response : SUCCESS [CELL IDX : %d]", deleteRsp->cellId);
if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->cellId == deleteRsp->cellId))
{
for(pfIdx =0; pfIdx < MAX_SFN; pfIdx++)
gConfigInfo.gCellStatus = CELL_DOWN;
#ifdef O1_ENABLE
- DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", deleteRsp->cellId);
+ DU_LOG("INFO --> DU APP : Raise cell down alarm for cell id=%d", deleteRsp->cellId);
raiseCellAlrm(CELL_DOWN_ALARM_ID, deleteRsp->cellId);
setCellOpState(deleteRsp->cellId, DISABLED, INACTIVE);
#endif
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacCellDeleteRsp(): CellId [%d] doesnot exist", deleteRsp->cellId);
+ DU_LOG("ERROR --> DU APP : DuProcMacCellDeleteRsp(): CellId [%d] doesnot exist", deleteRsp->cellId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacCellDeleteRsp(): MAC CELL Delete Response : FAILED\
+ DU_LOG("ERROR --> DU APP : DuProcMacCellDeleteRsp(): MAC CELL Delete Response : FAILED\
[CELL IDX : %d]", deleteRsp->cellId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacCellDeleteRsp(): Received MAC cell delete response is NULL");
+ DU_LOG("ERROR --> DU APP : DuProcMacCellDeleteRsp(): Received MAC cell delete response is NULL");
ret = RFAILED;
}
return ret;
cellDelete->cellId = cellId;
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_DELETE_REQ);
- DU_LOG("\nINFO --> DU APP : Sending Cell Delete Request to MAC");
+ DU_LOG("INFO --> DU APP : Sending Cell Delete Request to MAC");
/* Processing one Cell at a time to MAC */
ret = (*packMacCellDeleteReqOpts[pst.selector])(&pst, cellDelete);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : sendCellDeleteReqToMac(): Failed to send Cell delete Req to MAC");
+ DU_LOG("ERROR --> DU APP : sendCellDeleteReqToMac(): Failed to send Cell delete Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cellDelete, sizeof(MacCellDeleteReq));
}
}
else
{
- DU_LOG("\nERROR --> DU APP : sendCellDeleteReqToMac(): Failed to allocate memory");
+ DU_LOG("ERROR --> DU APP : sendCellDeleteReqToMac(): Failed to allocate memory");
ret = RFAILED;
}
return ret;
uint8_t duSendCellDeletReq(uint16_t cellId)
{
uint16_t cellIdx = 0;
- DU_LOG("\nINFO --> DU APP : Processing Cell Delete Request ");
+ DU_LOG("INFO --> DU APP : Processing Cell Delete Request ");
GET_CELL_IDX(cellId, cellIdx);
if(duCb.actvCellLst[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP : duSendCellDeletReq(): CellId[%d] is not found", cellId);
+ DU_LOG("ERROR --> DU APP : duSendCellDeletReq(): CellId[%d] is not found", cellId);
return RFAILED;
}
if(duCb.actvCellLst[cellIdx]->cellId != cellId)
{
- DU_LOG("\nERROR --> DU APP : duSendCellDeletReq(): CellId[%d] is not found", cellId);
+ DU_LOG("ERROR --> DU APP : duSendCellDeletReq(): CellId[%d] is not found", cellId);
return RFAILED;
}
if(duCb.actvCellLst[cellIdx]->cellStatus != DELETION_IN_PROGRESS)
{
- DU_LOG("\nERROR --> DU APP : duSendCellDeletReq(): CellStatus[%d] of cellId[%d] is not correct.\
+ DU_LOG("ERROR --> DU APP : duSendCellDeletReq(): CellStatus[%d] of cellId[%d] is not correct.\
Expected CellStatus is DELETION_IN_PROGRESS",duCb.actvCellLst[cellIdx]->cellStatus, cellId);
return RFAILED;
}
if(duBuildAndSendMacCellStop(cellId) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duSendCellDeletReq(): Failed to build and send cell stop request to MAC for\
+ DU_LOG("ERROR --> DU APP : duSendCellDeletReq(): Failed to build and send cell stop request to MAC for\
cellId[%d]",cellId);
return RFAILED;
}
if(pageUeLL == NULLP || pageUeLL->count == 0)
{
- DU_LOG("\nERROR --> DU APP: UE Page Record LL is empty");
+ DU_LOG("ERROR --> DU APP: UE Page Record LL is empty");
return RFAILED;
}
DU_ALLOC(pcchMsg , sizeof(PCCH_Message_t));
if(pcchMsg == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(): (pccchMsg) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(): (pccchMsg) Memory Alloction failed!");
break;
}
pcchMsg->message.present = PCCH_MessageType_PR_c1;
DU_ALLOC(pcchMsg->message.choice.c1 , sizeof(PCCH_MessageType_t));
if(pcchMsg->message.choice.c1 == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (C1) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (C1) Memory Alloction failed!");
break;
}
pcchMsg->message.choice.c1->present = PCCH_MessageType__c1_PR_paging;
pagingMsg = pcchMsg->message.choice.c1->choice.paging;
if(pagingMsg == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Paging) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Paging) Memory Alloction failed!");
break;
}
DU_ALLOC(pagingMsg->pagingRecordList, sizeof(PagingRecordList_t));
if(pagingMsg->pagingRecordList == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Paging Record List) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Paging Record List) Memory Alloction failed!");
break;
}
DU_ALLOC(pagingMsg->pagingRecordList->list.array, pagingMsg->pagingRecordList->list.size);
if(pagingMsg->pagingRecordList->list.array == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Array) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Array) Memory Alloction failed!");
break;
}
for(recordIdx = 0; recordIdx < pageUeLL->count; recordIdx++)
DU_ALLOC(pagingMsg->pagingRecordList->list.array[recordIdx], sizeof(PagingRecord_t));
if(pagingMsg->pagingRecordList->list.array[recordIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Record) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (Record) Memory Alloction failed!");
break;
}
}
pagingMsg->pagingRecordList->list.array[recordIdx]->ue_Identity.choice.ng_5G_S_TMSI.size);
if(pagingMsg->pagingRecordList->list.array[recordIdx]->ue_Identity.choice.ng_5G_S_TMSI.buf == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (5gsTmsi buffer) Memory Allocation failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (5gsTmsi buffer) Memory Allocation failed!");
break;
}
fillBitString(&pagingMsg->pagingRecordList->list.array[recordIdx]->ue_Identity.choice.ng_5G_S_TMSI,\
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode Paging structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode Paging structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC PDU for Pcch indication \n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RRC PDU for Pcch indication \n");
DU_ALLOC_SHRABL_BUF(macPcchInd, sizeof(DlPcchInd));
if(macPcchInd == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (macPcchInd) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (macPcchInd) Memory Alloction failed!");
break;
}
DU_ALLOC_SHRABL_BUF(macPcchInd->pcchPdu, macPcchInd->pduLen);
if(macPcchInd->pcchPdu == NULLP)
{
- DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (PcchPDU) Memory Alloction failed!");
+ DU_LOG("ERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (PcchPDU) Memory Alloction failed!");
break;
}
memcpy(macPcchInd->pcchPdu, encBuf, macPcchInd->pduLen);
maxIterations = MAX_SFN/rcvdF1apPagingParam->T;
if(iterations >= maxIterations)
{
- DU_LOG("\nERROR --> DU APP: MAX Iterations reached for UEID:%d, thus Paging is dropped!", rcvdF1apPagingParam->pagUeId);
+ DU_LOG("ERROR --> DU APP: MAX Iterations reached for UEID:%d, thus Paging is dropped!", rcvdF1apPagingParam->pagUeId);
return RFAILED;
}
if(ueRecord == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Unable to create UE Record in PagingList");
+ DU_LOG("ERROR --> DU APP: Unable to create UE Record in PagingList");
return RFAILED;
}
- DU_LOG("\nDEBUG --> DU APP: UE Record created successfully in PagingList");
+ DU_LOG("DEBUG --> DU APP: UE Record created successfully in PagingList");
return ROK;
}
else
{
/*Since MAX Page record has reached for this PF thus calculating and
*moving this UE to next Paging Cycle*/
- DU_LOG("\nINFO --> DU APP: Max Page Record reached for PagingFrame:%d",rcvdF1apPagingParam->pagingFrame);
+ DU_LOG("INFO --> DU APP: Max Page Record reached for PagingFrame:%d",rcvdF1apPagingParam->pagingFrame);
rcvdF1apPagingParam->pagingFrame = ((rcvdF1apPagingParam->pagingFrame + rcvdF1apPagingParam->T) % MAX_SFN);
iterations++;
if(pagInfoLLFromPF == NULLP)
{
- DU_LOG("\nERROR --> DU APP: PageInfo Map allocation failed.");
+ DU_LOG("ERROR --> DU APP: PageInfo Map allocation failed.");
return RFAILED;
}
pagInfoLLFromPF->pf = rcvdF1apPagingParam->pagingFrame;
ueRecord = handlePageUeLL(rcvdF1apPagingParam->pagUeId, rcvdF1apPagingParam->sTmsi, &(pageUeLL->pagUeList), CREATE);
if(cmHashListInsert(&(cellCb->pagingInfoMap), (PTR)pagInfoLLFromPF, (uint8_t *)&(pagInfoLLFromPF->pf), sizeof(uint16_t)) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP: Hash Map Insertion Failed for PF:%d.",rcvdF1apPagingParam->pagingFrame);
+ DU_LOG("ERROR --> DU APP: Hash Map Insertion Failed for PF:%d.",rcvdF1apPagingParam->pagingFrame);
}
#if 0
}
else
{
- DU_LOG("\nINFO --> DU APP : calcAndFillPagingInfoInCellCb(): Received null pointer");
+ DU_LOG("INFO --> DU APP : calcAndFillPagingInfoInCellCb(): Received null pointer");
return RFAILED;
}
return ROK;
if(duCb.actvCellLst[cellIdx] == NULLP || duCb.actvCellLst[cellIdx]->cellId != cellId)
{
- DU_LOG("\nERROR --> DU APP : processPagingMsg(): CellId[%d] is not found", cellId);
+ DU_LOG("ERROR --> DU APP : processPagingMsg(): CellId[%d] is not found", cellId);
return RFAILED;
}
if(calcAndFillPagingInfoInCellCb(duCb.actvCellLst[cellIdx], rcvdF1apPagingParam) != ROK)
{
- DU_LOG("\nERROR --> DU APP : CellCb:%d not present to fill UE Paging Information",cellId);
+ DU_LOG("ERROR --> DU APP : CellCb:%d not present to fill UE Paging Information",cellId);
return RFAILED;
}
if(insertPagingRecord(duCb.actvCellLst[cellIdx], rcvdF1apPagingParam, iteration) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Insertion Failed ofUE Paging Information");
+ DU_LOG("ERROR --> DU APP : Insertion Failed ofUE Paging Information");
return RFAILED;
}
return ROK;
uint8_t ret =ROK;
MacDlBroadcastReq *dlBroadcast=NULLP;
- DU_LOG("\nDEBUG --> DU_APP : Building Dl broadcast request");
+ DU_LOG("DEBUG --> DU_APP : Building Dl broadcast request");
DU_ALLOC_SHRABL_BUF(dlBroadcast, sizeof(MacDlBroadcastReq));
if(dlBroadcast)
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_DL_BROADCAST_REQ);
- DU_LOG("\nDEBUG --> DU_APP: Sending Dl broadcast Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending Dl broadcast Request to MAC ");
ret = (*packMacDlBroadcastReqOpts[pst.selector])(&pst, dlBroadcast);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP: sendDlBroadcastReqToMac(): Failed to send Dl broadcast Req to MAC");
+ DU_LOG("ERROR --> DU_APP: sendDlBroadcastReqToMac(): Failed to send Dl broadcast Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlBroadcast, sizeof(MacDlBroadcastReq));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: sendDlBroadcastReqToMac(): Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP: sendDlBroadcastReqToMac(): Failed to allocate memory");
ret = RFAILED;
}
DU_ALLOC_SHRABL_BUF(tempSliceCfg->listOfRrmPolicy, tempSliceCfg->numOfRrmPolicy * sizeof(MacSliceRrmPolicy*));
if(!tempSliceCfg->listOfRrmPolicy)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(tempSliceCfg->listOfRrmPolicy[policyIdx], sizeof(MacSliceRrmPolicy));
if(!tempSliceCfg->listOfRrmPolicy[policyIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
return RFAILED;
}
if(!tempSliceCfg->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(tempSliceCfg->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx], sizeof(RrmPolicyMemberList));
if(!tempSliceCfg->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in cpyRrmPolicyInDuCfgParams");
return RFAILED;
}
memcpy(&tempSliceCfg->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx]->snssai.sd,\
sliceSuppLst->numSupportedSlices = atoi((char *)xmlNodeListGetString(doc, cur->xmlChildrenNode, 1));
if(sliceSuppLst->numSupportedSlices > MAX_NUM_OF_SLICE_ITEMS)
{
- DU_LOG("\nERROR --> DU_APP: %s: Number of supported slice [%d] is more than 1024",\
+ DU_LOG("ERROR --> DU_APP: %s: Number of supported slice [%d] is more than 1024",\
__func__, sliceSuppLst->numSupportedSlices);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(sliceSuppLst->snssai, (sliceSuppLst->numSupportedSlices) * sizeof(Snssai*));
if (sliceSuppLst->snssai == NULLP)
{
- DU_LOG("\nERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(sliceSuppLst->snssai[sliceIdx], sizeof(Snssai));
if (sliceSuppLst->snssai[sliceIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
else
DU_ALLOC(sysInfo->mibMsg, encBufSize);
if(!(sysInfo->mibMsg))
{
- DU_LOG("\nERROR --> DU APP : %s : Memory allocation failure at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP : %s : Memory allocation failure at line %d", __func__, __LINE__);
return RFAILED;
}
memcpy(sysInfo->mibMsg, encBuf, encBufSize);
DU_ALLOC(sysInfo->sib1Msg, encBufSize);
if(!(sysInfo->sib1Msg))
{
- DU_LOG("\nERROR --> DU APP : %s : Memory allocation failure at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP : %s : Memory allocation failure at line %d", __func__, __LINE__);
return RFAILED;
}
memcpy(sysInfo->sib1Msg, encBuf,encBufSize);
DU_ALLOC(csiRsCfg->csiFreqDomainAlloc, sizeof(uint8_t));
if(!csiRsCfg->csiFreqDomainAlloc)
{
- DU_LOG("\nERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
memcpy(csiRsCfg->csiFreqDomainAlloc, &csiFreqDomainAlloc, sizeof(uint8_t));
if(BuildMibPdu() != ROK)
{
- DU_LOG("\nERROR --> Failed to build MIB PDU");
+ DU_LOG("ERROR --> Failed to build MIB PDU");
memset(&ssbCfg->mibPdu, 0, 3*sizeof(uint8_t));
}
else
DU_ALLOC_SHRABL_BUF(sib1CellCfg->sib1Pdu, sib1CellCfg->sib1PduLen);
if(!sib1CellCfg->sib1Pdu)
{
- DU_LOG("\nERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
memcpy(sib1CellCfg->sib1Pdu, duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg, sib1CellCfg->sib1PduLen);
#ifdef O1_ENABLE
sib1Params-> tac = cellParams.nRTAC;
sib1Params->cellIdentity = CELL_IDENTITY * cellParams.cellLocalId;
- DU_LOG("\nDEBUG --> DU_APP: parseSib1Params(): OAM CellLocalId=%d", sib1Params->cellIdentity);
+ DU_LOG("DEBUG --> DU_APP: parseSib1Params(): OAM CellLocalId=%d", sib1Params->cellIdentity);
#else
if ((!xmlStrcmp(cur->name, (const xmlChar *)"TAC")) && (cur->ns == ns))
{
if(!rrmPolicy->rRMPolicyMemberList)
{
- DU_LOG("\nERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(rrmPolicy->rRMPolicyMemberList[memIdx], sizeof(RrmPolicyMemberList));
if (rrmPolicy->rRMPolicyMemberList[memIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(macSliceCfgReq->listOfRrmPolicy, macSliceCfgReq->numOfRrmPolicy * sizeof(MacSliceRrmPolicy*));
if(!macSliceCfgReq->listOfRrmPolicy)
{
- DU_LOG("\nERROR --> DU APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(macSliceCfgReq->listOfRrmPolicy[policyIdx], sizeof(MacSliceRrmPolicy));
if (macSliceCfgReq->listOfRrmPolicy[policyIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
}
if(parseMacSliceRrmPolicy(doc, ns, cur, macSliceCfgReq->listOfRrmPolicy[policyIdx]) != ROK)
DU_ALLOC(duCfgParam.duName, strlen(tempDuName));
if(!duCfgParam.duName)
{
- DU_LOG("\nERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP: %s: Memory allocation failed at line %d", __func__, __LINE__);
ret = RFAILED;
break;
}
doc = xmlParseFile(filename);
if(doc == NULL)
{
- DU_LOG("\nERROR --> DU_APP: Failed to parse the XML file");
+ DU_LOG("ERROR --> DU_APP: Failed to parse the XML file");
return RFAILED;
}
ns = xmlSearchNsByHref(doc, cur, (const xmlChar *)"urn:o-ran:odu:configuration");
if(ns == NULL)
{
- DU_LOG("\nERROR --> DU_APP: XML Namespace not found.\n");
+ DU_LOG("ERROR --> DU_APP: XML Namespace not found.\n");
xmlFreeDoc(doc);
xmlCleanupParser();
return RFAILED;
/* Timer Registration request to system services */
if (ODU_REG_TMR_MT(pst.srcEnt, pst.srcInst, duCb.duTimersInfo.tmrRes, duActvTmr) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to register timer");
+ DU_LOG("ERROR --> DU_APP : Failed to register timer");
return RFAILED;
}
if(ODU_GET_MSG_BUF(DFLT_REGION, DU_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed in duReadCfg");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed in duReadCfg");
return RFAILED;
}
if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : ODU_POST_TASK failed in duReadCfg");
+ DU_LOG("ERROR --> DU_APP : ODU_POST_TASK failed in duReadCfg");
return RFAILED;
}
TDDCfg *tddCfg;
#endif
- DU_LOG("\n ** DU CONFIGURATION ** \n");
+ DU_LOG(" ** DU CONFIGURATION ** \n");
DU_LOG("DU ID %d\n", duCfgParam.duId);
DU_LOG("DU Name %s\n", duCfgParam.duName);
- DU_LOG("\n ** Thread Affinity ** \n");
+ DU_LOG(" ** Thread Affinity ** \n");
DU_LOG("DU APP CORE ID %d\n", duCfgParam.threadInfo.duAppCoreId);
DU_LOG("EGTP CORE ID %d\n", duCfgParam.threadInfo.egtpCoreId);
DU_LOG("SCTP CORE ID %d\n", duCfgParam.threadInfo.sctpCoreId);
DU_LOG("MAX NUM DRB %d\n", duCfgParam.maxNumDrb);
sctp = &duCfgParam.sctpParams;
- DU_LOG("\n ** SCTP PARAMETER ** \n");
+ DU_LOG(" ** SCTP PARAMETER ** \n");
DU_LOG("DU IPv4 Address present %u\n", sctp->duIpAddr.ipV4Pres);
DU_LOG("DU IP Address %u\n", sctp->duIpAddr.ipV4Addr);
DU_LOG("CU IPv4 Address present %u\n", sctp->cuIpAddr.ipV4Pres);
#endif
egtp = &duCfgParam.egtpParams;
- DU_LOG("\n ** EGTP PARAMETER ** \n");
+ DU_LOG(" ** EGTP PARAMETER ** \n");
DU_LOG("DU IP Address %d\n", egtp->localIp.ipV4Addr);
DU_LOG("CU IP Address %d\n", egtp->destIp.ipV4Addr);
DU_LOG("EGTP Port at DU %d\n", egtp->localPort);
DU_LOG("Maximum Tunnel ID %d\n",egtp->maxTunnelId);
mib = &duCfgParam.mibParams;
- DU_LOG("\n ** MIB PARAMETER ** \n");
+ DU_LOG(" ** MIB PARAMETER ** \n");
DU_LOG("System Frame Number %d\n", mib->sysFrmNum);
DU_LOG("Subcarrier Spacing Common %ld\n", mib->subCarrierSpacingCommon);
DU_LOG("SSB Subcarrier Offset %ld\n", mib->ssb_SubcarrierOffset);
DU_LOG("Intra Frequency Reselection %ld\n", mib->intraFreqReselection);
duSysInfo = &duCfgParam.srvdCellLst[0].duSysInfo;
- DU_LOG("\n ** DU System Information ** \n");
+ DU_LOG(" ** DU System Information ** \n");
DU_LOG("MIB length %d\n", duSysInfo->mibLen);
DU_LOG("MIB message %s\n", duSysInfo->mibMsg);
DU_LOG("SIB1 length %d\n", duSysInfo->sib1Len);
DU_LOG("SIB1 message %s\n", duSysInfo->sib1Msg);
f1DuCellInfo = &duCfgParam.srvdCellLst[0].duCellInfo;
- DU_LOG("\n ** DU Cell Information ** \n");
+ DU_LOG(" ** DU Cell Information ** \n");
f1CellInfo = &f1DuCellInfo->cellInfo;
DU_LOG("NR PCI %d\n", f1CellInfo->nrPci);
DU_LOG("Cell Direction %d\n", f1DuCellInfo->cellDir);
DU_LOG("Cell Type %d\n", f1DuCellInfo->cellType);
- DU_LOG("\n ** Cell Info : NR CGI ** \n");
+ DU_LOG(" ** Cell Info : NR CGI ** \n");
DU_LOG("Cell Id %d\n",f1CellInfo->nrCgi.cellId);
DU_LOG("PLMN : mcc[0] %d\n", f1CellInfo->nrCgi.plmn.mcc[0]);
DU_LOG("PLMN : mcc[1] %d\n", f1CellInfo->nrCgi.plmn.mcc[1]);
DU_LOG("PLMN : mnc[2] %d\n", f1CellInfo->nrCgi.plmn.mnc[2]);
srvdPlmn = &f1CellInfo->srvdPlmn[0];
- DU_LOG("\n ** Cell Info : Served PLMN ** \n");
+ DU_LOG(" ** Cell Info : Served PLMN ** \n");
DU_LOG("PLMN : mcc[0] %d\n", srvdPlmn->plmn.mcc[0]);
DU_LOG("PLMN : mcc[1] %d\n", srvdPlmn->plmn.mcc[1]);
DU_LOG("PLMN : mcc[2] %d\n", srvdPlmn->plmn.mcc[2]);
DU_LOG("EXT_PLMN : mnc[2] %d\n", srvdPlmn->extPlmn.mnc[2]);
sliceSuppLst = &srvdPlmn->taiSliceSuppLst;
- DU_LOG("\n ** Cell Info : Served PLMN : Supported Slice List ** \n");
+ DU_LOG(" ** Cell Info : Served PLMN : Supported Slice List ** \n");
DU_LOG("Number of Slices supported %d\n", sliceSuppLst->numSupportedSlices);
for (sliceIdx = 0; sliceIdx < sliceSuppLst->numSupportedSlices; sliceIdx++)
{
}
brdcstPlmnInfo = &f1DuCellInfo->brdcstPlmnInfo[0];
- DU_LOG("\n ** DU Cell Information : Broadcast PLMN Info ** \n");
+ DU_LOG(" ** DU Cell Information : Broadcast PLMN Info ** \n");
DU_LOG("TAC %d\n", brdcstPlmnInfo->tac);
DU_LOG("NR Cell Id %d\n", brdcstPlmnInfo->nrCellId);
DU_LOG("RANAC %d\n", brdcstPlmnInfo->ranac);
nrModeInfo = &f1DuCellInfo->f1Mode;
f1NrFddInfo = &nrModeInfo->mode.fdd;
- DU_LOG("\n ** DU Cell Information : NR Mode Info ** \n");
+ DU_LOG(" ** DU Cell Information : NR Mode Info ** \n");
#ifndef NR_TDD
- DU_LOG("\n ** NR Mode Info : FDD ** \n");
- DU_LOG("\n ** NR Mode Info : FDD : UL NR Frequency ** \n");
+ DU_LOG(" ** NR Mode Info : FDD ** \n");
+ DU_LOG(" ** NR Mode Info : FDD : UL NR Frequency ** \n");
DU_LOG("NR ARFCN %d\n", f1NrFddInfo->ulNrFreqInfo.nrArfcn);
DU_LOG("SUL : ARFCN %d\n",f1NrFddInfo->ulNrFreqInfo.sulInfo.sulArfcn);
DU_LOG("SUL : Transmission BW Subcarrier Spacing %d\n", f1NrFddInfo->ulNrFreqInfo.sulInfo.sulTxBw.nrScs);
DU_LOG("NR Frequency Band %d\n", f1NrFddInfo->ulNrFreqInfo.freqBand[0].nrFreqBand);
DU_LOG("SUL Band %d\n", f1NrFddInfo->ulNrFreqInfo.freqBand[0].sulBand[0]);
- DU_LOG("\n ** NR Mode Info : FDD : DL NR Frequency ** \n");
+ DU_LOG(" ** NR Mode Info : FDD : DL NR Frequency ** \n");
DU_LOG("NR ARFCN %d\n", f1NrFddInfo->dlNrFreqInfo.nrArfcn);
DU_LOG("SUL : ARFCN %d\n",f1NrFddInfo->dlNrFreqInfo.sulInfo.sulArfcn);
DU_LOG("SUL : Transmission BW Subcarrier Sapcing %d\n", f1NrFddInfo->dlNrFreqInfo.sulInfo.sulTxBw.nrScs);
DU_LOG("NR Frequency Band %d\n", f1NrFddInfo->dlNrFreqInfo.freqBand[0].nrFreqBand);
DU_LOG("SUL Band %d\n", f1NrFddInfo->dlNrFreqInfo.freqBand[0].sulBand[0]);
- DU_LOG("\n ** NR Mode Info : FDD : UL Transmission Bandwidth ** \n");
+ DU_LOG(" ** NR Mode Info : FDD : UL Transmission Bandwidth ** \n");
DU_LOG("Subscarrier spacing %d\n", f1NrFddInfo->ulTxBw.nrScs);
DU_LOG("Number of RBs %d\n", f1NrFddInfo->ulTxBw.nrb);
- DU_LOG("\n ** NR Mode Info : FDD : DL Transmission Bandwidth ** \n");
+ DU_LOG(" ** NR Mode Info : FDD : DL Transmission Bandwidth ** \n");
DU_LOG("Subcarrier Spacing %d\n", f1NrFddInfo->dlTxBw.nrScs);
DU_LOG("Number of RBs %d\n", f1NrFddInfo->dlTxBw.nrb);
f1NrTddInfo = &nrModeInfo ->mode.tdd;
- DU_LOG("\n ** NR Mode Info : TDD : NR Frequency ** \n");
+ DU_LOG(" ** NR Mode Info : TDD : NR Frequency ** \n");
DU_LOG("NR ARFCN %d\n", f1NrTddInfo->nrFreqInfo.nrArfcn);
DU_LOG("SUL : ARFCN %d\n",f1NrTddInfo->nrFreqInfo.sulInfo.sulArfcn);
DU_LOG("SUL : Transmission BW Subscarrier Spacing %d\n", f1NrTddInfo->nrFreqInfo.sulInfo.sulTxBw.nrScs);
DU_LOG("NR Frequency Band %d\n", f1NrTddInfo->nrFreqInfo.freqBand[0].nrFreqBand);
DU_LOG("SUL Band %d\n", f1NrTddInfo->nrFreqInfo.freqBand[0].sulBand[0]);
- DU_LOG("\n ** NR Mode Info : TDD : NR Transmission Bandwidth ** \n");
+ DU_LOG(" ** NR Mode Info : TDD : NR Transmission Bandwidth ** \n");
DU_LOG("Subcarrier Spacing %d\n", f1NrTddInfo->nrTxBw.nrScs);
DU_LOG("Number of RBs %d\n", f1NrTddInfo->nrTxBw.nrb);
#endif
macCellCfg = &duCfgParam.macCellCfg;
- DU_LOG("\n ** MAC CELL CONFIGURATION ** \n");
+ DU_LOG(" ** MAC CELL CONFIGURATION ** \n");
DU_LOG("Cell Id %d\n", macCellCfg->cellId);
- DU_LOG("\n ** MAC Cell Configuration : Carrier Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Carrier Configuration ** \n");
carrierCfg = &macCellCfg ->carrCfg;
DU_LOG("DL Bandwidth %d\n", carrierCfg->dlBw);
DU_LOG("DL ARFCN %d\n", carrierCfg->arfcnDL);
DU_LOG("Number of Transmission Antenna %d\n", carrierCfg->numTxAnt);
DU_LOG("Number of Received Antenna %d\n", carrierCfg->numRxAnt);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration ** \n");
cellCfg = &macCellCfg ->cellCfg;
DU_LOG("Operational State %d\n", cellCfg->opState);
DU_LOG("Administration State %d\n", cellCfg->adminState);
DU_LOG("Subcarrier Spacing: %d\n", cellCfg->subCarrSpacing);
DU_LOG("Duplex Mode %d\n", cellCfg->dupType);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : PLMN Info List ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : PLMN Info List ** \n");
plmnInfoList = &cellCfg ->plmnInfoList[0];
DU_LOG("PLMN : mcc[0] %d\n", plmnInfoList->plmn.mcc[0]);
DU_LOG("PLMN : mcc[1] %d\n", plmnInfoList->plmn.mcc[1]);
for(sliceIdx = 0; sliceIdx < plmnInfoList->suppSliceList.numSupportedSlices; sliceIdx++)
{
DU_LOG("Slice\n");
- DU_LOG("\nSST %d\n", (*plmnInfoList->suppSliceList.snssai[sliceIdx]).sst);
- DU_LOG("\nSD %d %d %d\n", (*plmnInfoList->suppSliceList.snssai[sliceIdx]).sd[0], \
+ DU_LOG("SST %d\n", (*plmnInfoList->suppSliceList.snssai[sliceIdx]).sst);
+ DU_LOG("SD %d %d %d\n", (*plmnInfoList->suppSliceList.snssai[sliceIdx]).sd[0], \
(*plmnInfoList->suppSliceList.snssai[sliceIdx]).sd[1],(*plmnInfoList->suppSliceList.snssai[sliceIdx]).sd[2]);
}
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : SIB1 ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : SIB1 ** \n");
sib1Cfg = &cellCfg->sib1Cfg;
DU_LOG("SIB1 PDU Length %d\n", sib1Cfg->sib1PduLen);
DU_LOG("SIB1 PDU %s\n", sib1Cfg->sib1Pdu);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : SIB1 : Paging Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : SIB1 : Paging Configuration ** \n");
pageCfg = &sib1Cfg->pagingCfg;
DU_LOG("Number of Paging Occassion %d\n", pageCfg->numPO);
}
pdcchConfigSib1 = &sib1Cfg->pdcchCfgSib1;
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : SIB1 : PDCCH ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : SIB1 : PDCCH ** \n");
DU_LOG("Coreset Zero Index %d\n", pdcchConfigSib1->coresetZeroIndex);
DU_LOG("Search Space Zero Index %d\n", pdcchConfigSib1->searchSpaceZeroIndex);
bwpDlCfg = &cellCfg->initialDlBwp;
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : DL BWP Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : DL BWP Configuration ** \n");
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : DL BWP : BWP ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : DL BWP : BWP ** \n");
bwp = &bwpDlCfg->bwp;
DU_LOG("First PRB %d\n", bwp->firstPrb);
DU_LOG("Number of PRBs %d\n", bwp->numPrb);
DU_LOG("Subcarrier Spacing %d\n", bwp->scs);
DU_LOG("Cyclic Perfix %d\n", bwp->cyclicPrefix);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : DL BWP : PDCCH Config Common ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : DL BWP : PDCCH Config Common ** \n");
pdcchCfgCmn = &bwpDlCfg->pdcchCommon;
DU_LOG("RA Search Space ID %d\n", pdcchCfgCmn->raSearchSpaceId);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : DL BWP : PDCCH Config Common : Search Space ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : DL BWP : PDCCH Config Common : Search Space ** \n");
searchSpaceCfg = &pdcchCfgCmn->commonSearchSpace;
DU_LOG("Search Space ID %d\n", searchSpaceCfg->searchSpaceId);
DU_LOG("Coreset ID %d\n", searchSpaceCfg->coresetId);
DU_LOG("Number of Candidates in Aggregation Level_8 %d\n", candidateInfo->aggLevel8);
DU_LOG("Number of Candidates in Aggregation Level_16 %d\n", candidateInfo->aggLevel16);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : DL BWP : PDSCH Config Common ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : DL BWP : PDSCH Config Common ** \n");
pdschCfgCmn = &bwpDlCfg->pdschCommon;
DU_LOG("Number of Time Domain Resource Allocation %d\n", pdschCfgCmn->numTimeDomAlloc);
DU_LOG("\tPDSCH Symbol Length %d\n", pdschCmnTimeDomRsrcAlloc->lengthSymbol);
}
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : UL BWP Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : UL BWP Configuration ** \n");
bwpUlCfg = &cellCfg->initialUlBwp;
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : UL BWP : BWP ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : UL BWP : BWP ** \n");
DU_LOG("First PRB %d\n", bwpUlCfg->bwp.firstPrb);
DU_LOG("Number of PRBs %d\n", bwpUlCfg->bwp.numPrb);
DU_LOG("Subcarrier Spacing %d\n", bwpUlCfg->bwp.scs);
DU_LOG("Cyclic Prefix %d\n", bwpUlCfg->bwp.cyclicPrefix);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : UL BWP : PUCCH Config Common ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : UL BWP : PUCCH Config Common ** \n");
pucchCfgCmn = &bwpUlCfg->pucchCommon;
DU_LOG("PUCCH Resource Common %d\n", pucchCfgCmn->pucchResourceCommon);
DU_LOG("Group Hopping %d\n", pucchCfgCmn->pucchGroupHopping);
- DU_LOG("\n ** MAC Cell Configuration : Cell Configuration : UL BWP : PUSCH Config Common ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Cell Configuration : UL BWP : PUSCH Config Common ** \n");
puschCfgCmn = &bwpUlCfg ->puschCommon;
DU_LOG("Number of Time Domain Resource Allocation %d\n", puschCfgCmn->numTimeDomRsrcAlloc);
for (rsrcIdx = 0; rsrcIdx < puschCfgCmn->numTimeDomRsrcAlloc; rsrcIdx++)
DU_LOG("\tPUSCH Start Symbol And Length %d\n", puschTimeDomRsrcAlloc->startSymbolAndLength);
}
- DU_LOG("\n ** MAC Cell Configuration : SSB Configuration** \n");
+ DU_LOG(" ** MAC Cell Configuration : SSB Configuration** \n");
ssbCfg = &macCellCfg ->ssbCfg;
DU_LOG("SSB PDCH Power %d\n", ssbCfg->ssbPbchPwr);
DU_LOG("Subcarrier Spacing Common %d\n", ssbCfg->scsCmn);
DU_LOG("MIB PDU %d %d %d \n", ssbCfg->mibPdu[0], ssbCfg->mibPdu[1], ssbCfg->mibPdu[2]);
DU_LOG("DMRS Type-A Position %d\n", ssbCfg->dmrsTypeAPos);
- DU_LOG("\n ** MAC Cell Configuration : CSI RS Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : CSI RS Configuration ** \n");
csiRsCfg = &macCellCfg->csiRsCfg;
DU_LOG("Frequency Domain Allocation %s\n", csiRsCfg->csiFreqDomainAlloc);
DU_LOG("Number of Ports %d\n", csiRsCfg->csiNrofPorts);
DU_LOG("Power Control Offset Search Space %d\n", csiRsCfg->powerControlOffsetSS);
DU_LOG("Periodicity And Offset %d\n", csiRsCfg->periodicityAndOffset);
- DU_LOG("\n ** MAC Cell Configuration : PRACH Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : PRACH Configuration ** \n");
prachCfg = &macCellCfg->prachCfg;
DU_LOG("PRACH Sequence Length %d\n", prachCfg->prachSeqLen);
DU_LOG("Subcarrier Spacing %d\n", prachCfg->prachSubcSpacing);
}
#ifdef NR_TDD
- DU_LOG("\n ** MAC Cell Configuration : TDD Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : TDD Configuration ** \n");
tddCfg = &macCellCfg->tddCfg;
DU_LOG("TDD Slot Periodicity %d\n", tddCfg->tddPeriod);
DU_LOG("Number of DL Slots %d\n", tddCfg->nrOfDlSlots);
DU_LOG("Number of UL Symbols %d\n", tddCfg->nrOfUlSymbols);
#endif
- DU_LOG("\n ** MAC Cell Configuration : Precoding Configuration ** \n");
+ DU_LOG(" ** MAC Cell Configuration : Precoding Configuration ** \n");
precodCfg = &macCellCfg->precodingConf;
DU_LOG("Number of Layers %d\n", precodCfg->numLayers);
DU_LOG("Number of Antenna Ports %d\n", precodCfg->numAntPorts);
- DU_LOG("\n ** MAC Cell Config : BEAM FORMING CFG ** \n");
+ DU_LOG(" ** MAC Cell Config : BEAM FORMING CFG ** \n");
beamFormingCfg = &macCellCfg ->beamCfg;
DU_LOG("Number of Beams %d\n", beamFormingCfg->numOfBeams);
DU_LOG("Number of Tx RUs %d\n", beamFormingCfg->numTxRUs);
DU_LOG("Digitak Tilt %d\n",beamFormingCfg ->digitalTilt);
DU_LOG("Digital Azimuth %d\n", beamFormingCfg->digitalAzimuth);
- DU_LOG("\n ** SIB1 Configuration ** \n");
+ DU_LOG(" ** SIB1 Configuration ** \n");
sib1Params = &duCfgParam.sib1Params;
DU_LOG("TAC %d\n", sib1Params->tac);
DU_LOG("RANAC %ld\n", sib1Params->ranac);
DU_LOG("PLMN : mnc[1] %d\n", sib1Params->plmn.mnc[1]);
DU_LOG("PLMN : mnc[2] %d\n", sib1Params->plmn.mnc[2]);
- DU_LOG("\n ** SIB1 : SI Scheduling Info ** \n");
+ DU_LOG(" ** SIB1 : SI Scheduling Info ** \n");
siSchedInfo = &sib1Params ->siSchedInfo;
DU_LOG("Windown Length %ld\n", siSchedInfo->winLen);
DU_LOG("Broadcast Status %ld\n", siSchedInfo->broadcastSta);
DU_LOG("SIB Type %ld\n", siSchedInfo->sibType);
DU_LOG("SIB Value Tag %ld\n", siSchedInfo->sibValTag);
- DU_LOG("\n ** SIB1 : Serving Cell Configuration Common SIB ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Configuration Common SIB ** \n");
srvCellCfgCmnSib = &sib1Params->srvCellCfgCommSib;
DU_LOG("Subcarrier Spacing %ld\n", srvCellCfgCmnSib->scs);
DU_LOG("SSB Position in Burst %d\n", srvCellCfgCmnSib->ssbPosInBurst);
DU_LOG("SSB Periodicity %ld\n", srvCellCfgCmnSib->ssbPrdServingCell);
DU_LOG("SS PBCH Power %ld\n", srvCellCfgCmnSib->ssPbchBlockPwr);
- DU_LOG("\n ** SIB1 : Serving Cell Config Common SIB : DL Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common SIB : DL Config Common ** \n");
dlCfgCmn = &srvCellCfgCmnSib->dlCfg;
DU_LOG("Frequency Band Indicator %ld\n", dlCfgCmn->freqBandInd);
DU_LOG("Offset to Point A %ld\n", dlCfgCmn->offsetToPointA);
DU_LOG("Subcarrier Spacing %ld\n", dlCfgCmn->dlScsCarrier.scs);
DU_LOG("Bandwidth considering Subcarrier Spacing %ld\n", dlCfgCmn->dlScsCarrier.scsBw);
- DU_LOG("\n ** SIB1 : Serving Cell Config Common SIB : DL Config Common : PDCCH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common SIB : DL Config Common : PDCCH Config Common ** \n");
pdcchCfgCommon = &dlCfgCmn->pdcchCfg;
if(pdcchCfgCommon->present)
{
DU_LOG("PDCCH Config Common not Present");
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : DL Config Common : PDSCH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : DL Config Common : PDSCH Config Common ** \n");
pdschCfgCommon = &dlCfgCmn->pdschCfg;
DU_LOG("PDSCH Config Common Present %d\n", pdschCfgCommon->present);
if(pdschCfgCommon->present)
DU_LOG("PDSCH Config Common not Present");
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : DL Config Common : BCCH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : DL Config Common : BCCH Config Common ** \n");
bcchCfg = &dlCfgCmn->bcchCfg;
DU_LOG("Modification Period Coefficient %ld\n", bcchCfg->modPrdCoeff);
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : DL Config Common : PCCH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : DL Config Common : PCCH Config Common ** \n");
pcchCfg = &dlCfgCmn->pcchCfg;
DU_LOG("Default Paging Cycle %d\n", pcchCfg->dfltPagingCycle);
DU_LOG("Number of PF in Paging Cycle %d\n", pcchCfg->nAndPagingFrmOffsetType);
DU_LOG("First PDCCH Monitoring Occassion in P0 [%d] %d\n", poIdx, pcchCfg->firstPDCCHMontioringInfo[poIdx]);
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : UL Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : UL Config Common ** \n");
ulCfgCmn = &srvCellCfgCmnSib->ulCfg;
DU_LOG("Frequency Band Indicator %ld\n", ulCfgCmn->freqBandInd);
DU_LOG("Maximum Transmission Power %ld\n", ulCfgCmn->pMax);
DU_LOG("Subcarrier Spacing %ld\n", ulCfgCmn->ulScsCarrier.scs);
DU_LOG("Carrier BW considering Subcarrier Spacing %ld\n", ulCfgCmn->ulScsCarrier.scsBw);
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : UL Config Common : RACH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : UL Config Common : RACH Config Common ** \n");
rachCfgCmn = &ulCfgCmn ->rachCfg;
if(rachCfgCmn->present)
{
DU_LOG("RACH Config Common not present\n");
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : UL Config Common : PUSCH Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : UL Config Common : PUSCH Config Common ** \n");
puschCfgCommon = &ulCfgCmn ->puschCfg;
if(puschCfgCommon->puschCfgPresent)
{
DU_LOG("PUSCH Config Common not present\n");
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : UL Config Common : PUCCH Config Common **\n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : UL Config Common : PUCCH Config Common **\n");
pucchCfgCommon = &ulCfgCmn->pucchCfg;
if(pucchCfgCommon->present)
{
DU_LOG("PUCCH Config Common not present\n");
}
- DU_LOG("\n ** SIB1 : Serving Cell Config Common : TDD UL DL Config Common ** \n");
+ DU_LOG(" ** SIB1 : Serving Cell Config Common : TDD UL DL Config Common ** \n");
tddUlDlCfgCmn = &srvCellCfgCmnSib->tddCfg;
DU_LOG("Reference Subcarrier Spacing %ld\n", tddUlDlCfgCmn->refScs);
DU_LOG("Transmission Periodicity %ld\n", tddUlDlCfgCmn->txPrd);
DU_LOG("Number of UL Slots %ld\n", tddUlDlCfgCmn->numUlSlots);
DU_LOG("Number of UL Symbols %ld\n", tddUlDlCfgCmn->numUlSymbols);
- DU_LOG("\n ** MAC SLICE CONFIG REQUEST ** \n");
+ DU_LOG(" ** MAC SLICE CONFIG REQUEST ** \n");
macSliceCfg = &duCfgParam.tempSliceCfg;
DU_LOG("Number of RRM Policy %d\n",macSliceCfg->numOfRrmPolicy);
}
}
- DU_LOG("\n ** E2 configuration ** \n");
+ DU_LOG(" ** E2 configuration ** \n");
e2apDb = &duCb.e2apDb;
DU_LOG("E2 node id %lu\n", e2apDb->e2NodeId);
DU_LOG("Number of RAN function %d\n", e2apDb->numOfRanFunction);
return 60;
default:
- DU_LOG("\nERROR --> F1AP: Invalid value of E2 Wait timer");
+ DU_LOG("ERROR --> F1AP: Invalid value of E2 Wait timer");
}
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : MAC mesurement type [%d] not supported", macMeasName);
+ DU_LOG("ERROR --> E2AP : MAC mesurement type [%d] not supported", macMeasName);
return RFAILED;
}
}
if(!measInfo)
{
- DU_LOG("\nERROR --> E2AP : fetchMeasInfoFromMeasTypeName: Measurement [%s] not found", e2MeasTypeName);
+ DU_LOG("ERROR --> E2AP : fetchMeasInfoFromMeasTypeName: Measurement [%s] not found", e2MeasTypeName);
}
return measInfo;
if(!actionInfoDb)
{
- DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
+ DU_LOG("ERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
if(!ricSubscriptionInfo)
{
- DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
+ DU_LOG("ERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
}
}
else
{
- DU_LOG("\nERROR --> E2AP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
+ DU_LOG("ERROR --> E2AP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
}
return ranFuncDb;
if(sctpSend(mBuf, E2_INTERFACE) != ROK)
{
- DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
+ DU_LOG("ERROR --> E2AP : SCTP Send for E2 failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("ERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
+ DU_LOG("ERROR --> E2AP : Failed to allocate memory");
return RFAILED;
}
{
if(BuildAndSendE2ResetRequest(resetCause) != ROK)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest failed");
+ DU_LOG("ERROR --> E2AP : BuildAndSendE2ResetRequest failed");
return RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid measurement name");
+ DU_LOG("ERROR --> E2AP : Invalid measurement name");
break;
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : fillRicSubsInMacStatsReq: Only Action Definition Format 1 supported");
+ DU_LOG("ERROR --> E2AP : fillRicSubsInMacStatsReq: Only Action Definition Format 1 supported");
break;
}
}
if(pendingSubsModRsp == NULLP)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
pendingSubsModRsp->addActionCompleted =true;
if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
return ROK;
if(pendingSubsRsp == NULLP)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid event trigger format of RIC subscription");
+ DU_LOG("ERROR --> E2AP : Invalid event trigger format of RIC subscription");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> E2AP : RIC Subscription reporting timer already running for RIC Subscription");
+ DU_LOG("ERROR --> E2AP : RIC Subscription reporting timer already running for RIC Subscription");
return RFAILED;
}
/* [ Step 6] */
if(BuildAndSendRicSubscriptionRsp(pendingSubsRsp) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send RIC Subscription rsp");
+ DU_LOG("ERROR --> E2AP : Failed to build and send RIC Subscription rsp");
return RFAILED;
}
}
/* [Step -1] */
if(fetchSubsInfoFromSubsId(statsRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
if(procStatsRspForSubsReq(statsRsp, ranFuncDb, ricSubscriptionNode, ricSubscriptionInfo) != ROK)
{
rejectAllStatsGroup(ranFuncDb, ricSubscriptionNode, statsRsp);
- DU_LOG("\nERROR --> E2AP : Failed to build and send RIC Subscription rsp");
+ DU_LOG("ERROR --> E2AP : Failed to build and send RIC Subscription rsp");
return RFAILED;
}
}
/* [Step -2.2] */
if(procStatsRspForSubsModReq(statsRsp, ranFuncDb, ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send RIC Subscription rsp");
+ DU_LOG("ERROR --> E2AP : Failed to build and send RIC Subscription rsp");
return RFAILED;
}
}
* in statistics response */
if(fetchSubsInfoFromSubsId(statsInd->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s : Failed to fetch subscriprtion details",__func__);
+ DU_LOG("ERROR --> E2AP : %s : Failed to fetch subscriprtion details",__func__);
return RFAILED;
}
actionInfo = fetchActionInfoFromActionId(statsInd->groupId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
if(actionInfo == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fetch action ID [%d]",__func__, statsInd->groupId);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fetch action ID [%d]",__func__, statsInd->groupId);
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : %s: Action Format [%d] is not supported", __func__,\
+ DU_LOG("ERROR --> E2AP : %s: Action Format [%d] is not supported", __func__,\
actionInfo->definition.formatType);
return RFAILED;
}
/* Convert Measurement type from MAC-supported format to E2-supported format */
if(convertMacMeasTypeToE2MeasType(statsInd->measuredStatsList[statsIdx].type, e2MeasTypeName) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to convert measurement type from MAC-supported\
+ DU_LOG("ERROR --> E2AP : %s: Failed to convert measurement type from MAC-supported\
MAC-supported format to E2-supported format",__func__);
continue;
}
measInfo = fetchMeasInfoFromMeasTypeName(e2MeasTypeName, &actionFormat->measurementInfoList, &measInfoNode);
if(measInfo == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Measurement Type Name [%s] not found", __func__,e2MeasTypeName);
+ DU_LOG("ERROR --> E2AP : %s: Measurement Type Name [%s] not found", __func__,e2MeasTypeName);
continue;
}
DU_ALLOC(measValue, sizeof(double));
if(!measValue)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line [%d]",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line [%d]",__func__, __LINE__);
return RFAILED;
}
*measValue = statsInd->measuredStatsList[statsIdx].value;
DU_ALLOC(measValueNode, sizeof(CmLList));
if(!measValueNode)
{
- DU_LOG("\nERROR --> E2AP : %s : Memory allocation failed at line [%d]",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s : Memory allocation failed at line [%d]",__func__, __LINE__);
DU_FREE(measValue, sizeof(double));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed in %s at line %d", __func__, __LINE__);
return;
}
}
e2NodeComponentInfo = fetchE2NodeComponentInfo(interfaceType, componentId, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Unable to find the node");
+ DU_LOG("ERROR --> E2AP : Unable to find the node");
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid action %d received",action);
+ DU_LOG("ERROR --> E2AP : Invalid action %d received",action);
return RFAILED;
}
}
if(configInfo->componentRequestPart== NULLP)
{
- DU_LOG("\nERROR --> E2AP : E2 node Component request part is not present");
+ DU_LOG("ERROR --> E2AP : E2 node Component request part is not present");
return RFAILED;
}
DU_ALLOC(configInfo->componentResponsePart, bufSize);
if(configInfo->componentResponsePart == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed to store the encoding of rsp");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed to store the encoding of rsp");
return RFAILED;
}
memcpy(configInfo->componentResponsePart, bufString, configInfo->rspBufSize);
DU_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent));
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
return RFAILED;
}
e2NodeComponentInfo->interfaceType =interfaceType;
DU_ALLOC(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
if(!e2NodeComponentInfo->addConfiguration)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
return RFAILED;
}
DU_ALLOC(e2NodeComponentInfo->addConfiguration->componentRequestPart, bufSize);
if(e2NodeComponentInfo->addConfiguration->componentRequestPart == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, bufSize);
DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
e2NodeComponentInfo = fetchE2NodeComponentInfo(interfaceType, componentId, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null information in %s",__func__);
+ DU_LOG("ERROR --> E2AP : Received null information in %s",__func__);
return RFAILED;
}
DU_ALLOC(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
if(!e2NodeComponentInfo->updateConfiguration)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
return RFAILED;
}
DU_ALLOC(e2NodeComponentInfo->updateConfiguration->componentRequestPart, bufSize);
if(e2NodeComponentInfo->updateConfiguration->componentRequestPart == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
return RFAILED;
}
e2NodeComponentInfo = fetchE2NodeComponentInfo(interfaceType, componentId, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null information in %s",__func__);
+ DU_LOG("ERROR --> E2AP : Received null information in %s",__func__);
return RFAILED;
}
{
if(addE2NodeComponent(interfaceType, componentId, bufSize, bufString) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to add e2 node component");
+ DU_LOG("ERROR --> E2AP : Failed to add e2 node component");
return RFAILED;
}
break;
{
if(updateE2NodeComponent(interfaceType, componentId, bufSize, bufString) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to update e2 node component");
+ DU_LOG("ERROR --> E2AP : Failed to update e2 node component");
return RFAILED;
}
break;
{
if(deleteE2NodeComponent(interfaceType, componentId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to delete e2 node component");
+ DU_LOG("ERROR --> E2AP : Failed to delete e2 node component");
return RFAILED;
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid action %d received",action);
+ DU_LOG("ERROR --> E2AP : Invalid action %d received",action);
return RFAILED;
}
}
case 5:
default:
{
- DU_LOG("\nERROR --> E2AP : Format %d does not supported", definition->formatType);
+ DU_LOG("ERROR --> E2AP : Format %d does not supported", definition->formatType);
break;
}
}
DU_ALLOC(subsToDelNode, sizeof(CmLList));
if(!subsToDelNode)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failure at %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failure at %d", __func__, __LINE__);
return;
}
subsToDelNode->node = subsNode->node;
{
uint16_t ranFuncIdx = 0;
- DU_LOG("\nINFO --> E2AP : Deleting all the E2 node configuration");
+ DU_LOG("INFO --> E2AP : Deleting all the E2 node configuration");
for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
{
if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
* in statistics delete response */
if(fetchSubsInfoFromSubsId(statsDeleteRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : e2ProcStatsDeleteRsp: Failed to fetch subscriprtion details");
+ DU_LOG("ERROR --> E2AP : e2ProcStatsDeleteRsp: Failed to fetch subscriprtion details");
return RFAILED;
}
ranFuncId = ricSubscriptionInfo->ranFuncId;
if(BuildAndSendRicSubscriptionDeleteFailure(ranFuncId, requestId, failureCause) != ROK)
{
- DU_LOG("\nERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete failure");
+ DU_LOG("ERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete failure");
return RFAILED;
}
}
{
if(BuildAndSendRicSubscriptionDeleteResponse(ranFuncId, requestId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete rsp");
+ DU_LOG("ERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete rsp");
return RFAILED;
}
}
/* [Step-1] */
if(fetchSubsInfoFromSubsId(statsDeleteRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
if(pendingSubsModRsp == NULLP)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
pendingSubsModRsp->removeActionCompleted = true;
if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed to process subscription modification rsp");
+ DU_LOG("ERROR --> E2AP : failed to process subscription modification rsp");
return RFAILED;
}
return ROK;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid event trigger format of RIC subscription");
+ DU_LOG("ERROR --> E2AP : Invalid event trigger format of RIC subscription");
break;
}
}
if(reportingPeriod == 0)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
break;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : RIC Subscription reporting timer already running for RIC Subscription");
+ DU_LOG("ERROR --> E2AP : RIC Subscription reporting timer already running for RIC Subscription");
break;
}
if(BuildAndSendRicSubscriptionModificationResponse(pendingSubsModRsp) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
break;
}
memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo));
- DU_LOG("\nProcessing of RIC subscription modification completed");
+ DU_LOG("Processing of RIC subscription modification completed");
ret = ROK;
break;
}
/* [Step-1] */
if(fetchSubsInfoFromSubsId(statsModificationRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
}
if(pendingSubsModRsp == NULLP)
{
- DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
pendingSubsModRsp->modActionCompleted = true;
if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed to process subscription modification rsp");
+ DU_LOG("ERROR --> E2AP : failed to process subscription modification rsp");
return RFAILED;
}
return ROK;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid measurement name");
+ DU_LOG("ERROR --> E2AP : Invalid measurement name");
break;
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : fillRicSubsInMacStatsModificationReq: Only Action Definition Format 1 supported");
+ DU_LOG("ERROR --> E2AP : fillRicSubsInMacStatsModificationReq: Only Action Definition Format 1 supported");
break;
}
}
E2RemovalFailure_t *e2RemovalFailure=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Removal Failure Message\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
if(!e2RemovalFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Removal Failure");
break;
}
E2RemovalResponse_t *e2RemovalResponse=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Removal Response Message\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
if(!e2RemovalResponse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Removal Response");
break;
}
E2FailureCause failureCause;
E2RemovalRequest_t *removalReq=NULLP;
- DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+ DU_LOG("INFO --> E2AP : E2 Removal request received");
removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid IE recevied [%d]", transId);
break;
}
}
{
if(BuildAndSendRemovalResponse(transId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send Removal response");
}
}
else
if(BuildAndSendRemovalFailure(transId, failureCause) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send Removal response");
}
}
freeAperDecodingOfE2RemovalReq(removalReq);
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
+ DU_LOG("INFO --> E2AP : Building Error Indication Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
if(errorIndicationMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
break;
}
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
+ DU_LOG("INFO --> E2AP : Sending Error Indication Message");
}
ret = ROK;
uint16_t transId =0;
E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
- DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
+ DU_LOG("INFO --> E2AP : E2 Node Config Update failure received");
e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
}
break;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
+ DU_LOG("ERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
}
break;
}
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("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
+ DU_LOG("ERROR --> 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("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for gnb buffer");
ret = RFAILED;
}
else
DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
if(gNbId->gNB_DU_ID == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
ret = RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
+ DU_LOG("ERROR --> E2AP : Configuration type %d does not supported ", configType);
return RFAILED;
}
}
DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
configuration->e2nodeComponentRequestPart.size);
if(configuration->e2nodeComponentRequestPart.buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
+ DU_LOG("ERROR --> E2AP: componentRequestPart is null ");
return RFAILED;
}
DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
if(configuration->e2nodeComponentResponsePart.buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
return RFAILED;
}
memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeConfig->componentResponsePart, configuration->\
}
else
{
- DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
+ DU_LOG("ERROR --> E2AP: componentResponsePart is null");
return RFAILED;
}
DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
if(e2NodeAddList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
return RFAILED;
}
DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
if(e2NodeAddList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
return RFAILED;
}
}
if(!node)
{
- DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
+ DU_LOG("ERROR --> E2AP : E2 node component list node is null");
return RFAILED;
}
e2NodeComponentInfo = (E2NodeComponent*)node->node;
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
+ DU_LOG("ERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
return RFAILED;
}
e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
+ DU_LOG("ERROR --> E2AP : Failed to fill the E2 node configuration");
return RFAILED;
}
}
DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
if(e2NodeUpdateList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
return RFAILED;
}
DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
return RFAILED;
}
e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].componentId, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
+ DU_LOG("ERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
return RFAILED;
}
if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
+ DU_LOG("ERROR --> E2AP : Failed to fill the E2 node configuration");
return RFAILED;
}
DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
if(e2NodeRemoveList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
return RFAILED;
}
DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
return RFAILED;
}
e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface,updateE2Node[arrIdx].componentId, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
+ DU_LOG("ERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
return RFAILED;
}
if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
+ DU_LOG("ERROR --> E2AP : Failed to fill the E2 node configuration");
return RFAILED;
}
DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
if(!ricReportStyle->list.array)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
return RFAILED;
}
DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
if(!ricReportStyle->list.array[styleIdx])
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
DU_ALLOC(measInfo->list.array, measInfo->list.size);
if(!measInfo->list.array)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
{
if(!node)
{
- DU_LOG("\nERROR --> E2AP: Measurement info node is null");
+ DU_LOG("ERROR --> E2AP: Measurement info node is null");
return RFAILED;
}
DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
if(!measInfo->list.array[measInfoIdx])
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
if(!measInfo->list.array[measInfoIdx]->measID)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
if(!measInfo->list.array[measInfoIdx]->measName.size)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
if(!ricEventTriggerStyle->list.array)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
return RFAILED;
}
DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
if(!ricEventTriggerStyle->list.array[styleIdx])
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
return RFAILED;
}
memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
if(!ranFuncItem->ranFunctionOID.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
if(!ranFuncDefinition)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
if(!ranFuncName->ranFunction_ShortName.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
if(!ranFuncName->ranFunction_E2SM_OID.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
if(!ranFuncName->ranFunction_Description.buf)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
if(!ranFuncDefinition->ric_EventTriggerStyle_List)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
{
- DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
+ DU_LOG("ERROR --> E2AP: failed to fill ric event trigger style");
break;
}
DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
if(!ranFuncDefinition->ric_ReportStyle_List)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
break;
}
if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
{
- DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
+ DU_LOG("ERROR --> E2AP: failed to fill ric report style");
break;
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
{
printf("%x",encBuf[measIeIdx]);
DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
if(ranFunctionDefinition->buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
break;
}
memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
if(ranFunctionsList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
return RFAILED;
}
if(procedureCode == ProcedureCodeE2_id_E2setup)
}
default:
- DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
+ DU_LOG("ERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
(e2SetupReq->protocolIEs.list.array[arrIdx]->id));
break;
}
E2setupRequest_t *e2SetupReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
+ DU_LOG("INFO --> E2AP : Building E2 Setup Request\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> 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("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
e2SetupReq->protocolIEs.list.size);
if(e2SetupReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array elements");
break;
}
for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
{
memAllocFailed = true;
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
break;
}
}
if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
GlobalE2node_ID.choice.gNB == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for gNbId");
break;
}
else
choice.GlobalE2node_ID.choice.gNB);
if(ret != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
+ DU_LOG("ERROR --> E2AP : Failed to build Global Gnb Id");
break;
}
}
e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
+ DU_LOG("ERROR --> E2AP : Failed to create RAN Function");
break;
}
e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
+ DU_LOG("ERROR --> E2AP : Failed to create E2 Node config list");
break;
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Setup request failed");
}
break;
}while(true);
DU_ALLOC(admitList->list.array, admitList->list.size);
if(admitList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
if(admitList->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
if(notAdmitList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
if(notAdmitList->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
return RFAILED;
}
}
subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
+ DU_LOG("ERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
return RFAILED;
}
subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
+ DU_LOG("ERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
return RFAILED;
}
}
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Response\n");
DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
if(e2apRicMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apRicMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RIC subscription Response failed");
break;
}
if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC Subscription Response failed");
break;
}
e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
+ DU_LOG("ERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
return;
}
break;
E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
- DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
+ DU_LOG("INFO --> E2AP : E2 Setup Response received");
duCb.e2Status = TRUE; //Set E2 status as true
e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
invalidTransId = true;
}
break;
for(idx =0; idx <ranFuncAcceptedList->list.count; idx++)
{
ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[idx];
- DU_LOG("\nINFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID);
+ DU_LOG("INFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID);
}
break;
}
for(idx =0; idx <ranFuncRejectedList->list.count; idx++)
{
ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[idx];
- DU_LOG("\nINFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID);
+ DU_LOG("INFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID);
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
+ DU_LOG("ERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
break;
}
{
if(duSendE2NodeConfigurationUpdate() != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 node config update");
}
}
}
ricEventTriggerDef->size, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
+ DU_LOG("ERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
failureCause->causeType = E2_PROTOCOL;
failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
return RFAILED;
default:
{
- DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
+ DU_LOG("ERROR -> DUAPP: Invalid Measurement-type identifier in \
E2SM-KPM Action Definition Format");
break;
}
ricActionDef->size, 0, 0);
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
+ DU_LOG("ERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
failureCause->causeType = E2_PROTOCOL;
failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
return RFAILED;
default :
{
- DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
+ DU_LOG("ERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
break;
}
} /* End of switch for E2SM-KPM Action definition formats */
DU_ALLOC(actionDb, sizeof(ActionInfo));
if(actionDb==NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
return NULLP;
}
if(ricActionType== RICactionType_report)
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
DU_FREE(actionDb, sizeof(ActionInfo));
return NULLP;
}
break;
}
default:
- DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
+ DU_LOG("ERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
break;
}
}
RicSubscription *ricSubscriptionInfo = NULLP;
E2FailureCause failureCause;
- DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
+ DU_LOG("INFO --> E2AP : RIC Subscription request received");
memset(&failureCause, 0, sizeof(E2FailureCause));
memset(&ricReqId, 0, sizeof(RicRequestId));
DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
if(!ricSubscriptionInfo)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
failureCause.causeType = E2_MISCELLANEOUS;
failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
ret = RFAILED;
break;
default:
- DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
+ DU_LOG("ERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
ricSubsReq->protocolIEs.list.array[idx]->id);
break;
}
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Failure\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
break;
}
e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
if(!ricSubscriptionFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
break;
}
DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
+ DU_LOG("ERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
__func__, __LINE__, elemIdx);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
+ DU_LOG("INFO --> E2AP : Sending RIC Subscription Failure");
}
ret = ROK;
DU_ALLOC(measRecord->list.array, measRecord->list.size);
if(!measRecord->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
if(!measRecord->list.array[measRecIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
}
DU_ALLOC(measData->list.array, measData->list.size);
if(!measData->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
if(!measData->list.array[measIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
measRecord = &measData->list.array[measIdx]->measRecord;
if(fillMeasRecord(measRecord, measInfoDb) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
+ DU_LOG("ERROR --> E2AP : Failed to fill measurement record");
return RFAILED;
}
measIdx++;
DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
if(!measInfoList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
if(!measInfoList->list.array[measInfoIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
if(!measInfoItem->measType.choice.measName.buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
/* Measurement Data */
if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
+ DU_LOG("ERROR --> E2AP : Failed to fill measurement data");
return RFAILED;
}
DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
if(!format1Msg->measInfoList)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
+ DU_LOG("ERROR --> E2AP : Failed to fill measurement information list");
return RFAILED;
}
DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
if(!format1Msg->granulPeriod)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
*(format1Msg->granulPeriod) = format1->granularityPeriod;
sizeof(E2SM_KPM_IndicationMessage_Format1_t));
if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
failedInFormat = true;
break;
}
if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
&actionInfo->definition.choice.format1) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
+ DU_LOG("ERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
failedInFormat = true;
break;
}
case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
default:
{
- DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
+ DU_LOG("ERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
failedInFormat = true;
break;
}
encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
if(!ricIndMsgBuf->buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
break;
}
memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
if(ranFunc == NULLP)
{
- DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
+ DU_LOG("ERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
break;
}
sizeof(E2SM_KPM_IndicationHeader_Format1_t));
if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
formatFailure = true;
break;
}
DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
if(!format1->colletStartTime.buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
formatFailure = true;
break;
}
case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
default:
{
- DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
+ DU_LOG("ERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
formatFailure = true;
break;
}
encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
if(!ricIndHdr->buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
break;
}
memset(ricIndHdr->buf, 0, ricIndHdr->size);
DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
if(ricIndicationMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
return RFAILED;
}
}
if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
+ DU_LOG("ERROR --> E2AP : Failed to fill RIC Indication header");
return RFAILED;
}
if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
actionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
+ DU_LOG("ERROR --> E2AP : Failed to fill RIC Indication Message");
return RFAILED;
}
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Indication Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
+ DU_LOG("ERROR --> E2AP : Failed to fill RIC Indication message");
break;
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
+ DU_LOG("INFO --> E2AP : Sending RIC Indication Message");
}
ret = ROK;
asn_enc_rval_t encRetVal; /* Encoder return value */
E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
- DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
+ DU_LOG("INFO --> E2AP : Building E2 Node config update\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
break;
}
if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
break;
}
}
if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
+ DU_LOG("ERROR --> E2AP : Failed to create E2 Node config list");
break;
}
}
e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
+ DU_LOG("ERROR --> E2AP : Failed to update the E2 node configuration");
break;
}
}
e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
+ DU_LOG("ERROR --> E2AP : Failed to remove the E2 node configuration");
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
{
- DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 node config update failed");
break;
}
ResetRequestE2_t *resetReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
+ DU_LOG("INFO --> E2AP : Building E2 Reset Request\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
+ DU_LOG("ERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
break;
}
DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
if(!resetReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
+ DU_LOG("ERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
Reset Request IE array");
break;
}
DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
if(!resetReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
+ DU_LOG("ERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
Reset Request IE array element");
break;
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for reset request\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Setup request failed");
break;
}
uint16_t ranFuncIdx=0;
ResetResponseE2_t *resetResponse =NULLP;
- DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
+ DU_LOG("INFO --> E2AP : E2 Reset Response received");
resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
invalidTransId = true;
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
+ DU_LOG("ERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
resetResponse->protocolIEs.list.array[ieIdx]->id);
break;
}
uint8_t arrIdx =0, timerValue=0;
E2setupFailure_t *e2SetupFailure;
- DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
+ DU_LOG("INFO --> E2AP : E2 Setup failure received");
e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
return ;
}
break;
}
else
{
- DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
+ DU_LOG("ERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
return;
}
break;
DU_ALLOC(deleteList->list.array, deleteList->list.size);
if(deleteList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
return RFAILED;
}
for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
if(deleteList->list.array[ranFuncIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
return RFAILED;
}
delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
break;
}
default:
- DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
+ DU_LOG("ERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
break;
}
RICserviceUpdate_t *ricServiceUpdate = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
+ DU_LOG("INFO --> E2AP : Building Ric Service Update\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> 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("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
if(ricServiceUpdate->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array elements");
break;
}
if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
{
memAllocFailed = true;
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Setup request failed");
break;
}
ret = ROK;
RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
RANfunctionsID_List_t *ranFuncAddedList;
- DU_LOG("\nINFO --> E2AP : RIC Service Query received");
+ DU_LOG("INFO --> E2AP : RIC Service Query received");
memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
ricUpdate.dir = RIC_INITIATED;
ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
+ DU_LOG("ERROR --> E2AP : Failed to build and send ric service update message");
}
freeAperDecodingOfRicServiceQuery(ricServiceQuery);
RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
- DU_LOG("\nINFO --> E2AP : RIC service update ack received");
+ DU_LOG("INFO --> E2AP : RIC service update ack received");
memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
return ;
}
break;
uint8_t arrIdx =0, timerValue=0;
RICserviceUpdateFailure_t *ricServiceFailure=NULL;
- DU_LOG("\nINFO --> E2AP : RIC service update failure received");
+ DU_LOG("INFO --> E2AP : RIC service update failure received");
ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
}
else
{
- DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
+ DU_LOG("ERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
return;
}
break;
if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
+ DU_LOG("ERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
return RFAILED;
}
return ROK;
DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
if(!actionToBeModList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
if(!actionToBeModList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
if(!actionToBeRmvList->list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
if(!actionToBeRmvList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
if(!ricSubsModReqd->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
return RFAILED;
}
}
if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
return RFAILED;
}
}
if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
return RFAILED;
}
}
RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Modification Required \n");
while(true)
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
break;
}
e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC Subscription Modification Required failed");
}
ret = ROK;
RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
- DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
+ DU_LOG("INFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
do{
if(!e2apMsg)
{
- DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: E2AP Message is NULL", __func__);
break;
}
if(!e2apMsg->choice.successfulOutcome)
{
- DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
break;
}
ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
if(!ricSubsModCfm->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
break;
}
{
if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
+ DU_LOG("ERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
break;
}
ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
+ DU_LOG("ERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
procFailure = true;
break;
}
ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(!ricSubsDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
+ DU_LOG("ERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
__func__, ricReqId.requestorId, ricReqId.instanceId);
procFailure = true;
break;
actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
if(!actionDb)
{
- DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
+ DU_LOG("ERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
if(!actionDb)
{
- DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
+ DU_LOG("ERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
if(!actionDb)
{
- DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
+ DU_LOG("ERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
if(!actionDb)
{
- DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
+ DU_LOG("ERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
ResetResponseE2_t *resetResponse;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Reset Response Message\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
break;
}
DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
if(!resetResponse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
break;
}
DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
if(!resetResponse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Reset Response");
break;
}
uint16_t ranFuncIdx=0;
ResetRequestE2_t *resetReq;
- DU_LOG("\nINFO --> E2AP : E2 Reset request received");
+ DU_LOG("INFO --> E2AP : E2 Reset request received");
resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
}
if(BuildAndSendResetResponse(transId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send reset response");
}
freeAperDecodingOfE2ResetReq(resetReq);
}
RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
CauseE2_t *cause = NULLP;
- DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
+ DU_LOG("INFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
do{
if(!e2apMsg)
{
- DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: E2AP Message is NULL", __func__);
break;
}
if(!e2apMsg->choice.unsuccessfulOutcome)
{
- DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
break;
}
ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
if(!ricSubsModRefuse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
break;
}
{
if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
+ DU_LOG("ERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
break;
}
case ProtocolIE_IDE2_id_CauseE2:
{
- DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
+ DU_LOG("DEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
ricReqId.instanceId, ranFuncId);
DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
if(!ricSubsList->list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
return RFAILED;
}
DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
if(!ricSubsList->list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
return RFAILED;
}
fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
if(ricSubsToBeDelList.count == 0)
{
- DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
+ DU_LOG("DEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
return ROK;
}
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Delete Required Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
__func__, ieIdx, __LINE__);
break;
}
if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
!= ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
}
ret = ROK;
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
__func__, ieIdx, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
break;
}
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Delete Response Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
__func__, ieIdx, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
break;
}
RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
- DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
+ DU_LOG("INFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
do{
if(!e2apMsg)
{
- DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: E2AP Message is NULL", __func__);
break;
}
if(!e2apMsg->choice.initiatingMessage)
{
- DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
break;
}
ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
if(!ricSubsDelReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
break;
}
{
if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
+ DU_LOG("ERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
break;
}
ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
+ DU_LOG("ERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
procFailure = true;
break;
}
ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(!ricSubsDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
+ DU_LOG("ERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
__func__, ricReqId.requestorId, ricReqId.instanceId);
procFailure = true;
break;
if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
+ DU_LOG("ERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
}
break;
}
E2RemovalRequest_t *removalReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
+ DU_LOG("INFO --> E2AP : Building Removal Request\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
if(!removalReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
if(!removalReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for removal request\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending removal request failed");
+ DU_LOG("ERROR --> E2AP : Sending removal request failed");
break;
}
if(!e2RemovalFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
+ DU_LOG("ERROR --> E2AP : e2RemovalFailure array pointer is null");
return;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
}
break;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
break;
}
}
if(!removalRsp->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
+ DU_LOG("ERROR --> E2AP : removalRsp array pointer is null");
return;
}
if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
(duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
{
- DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
+ DU_LOG("INFO --> E2AP : Sending request to close the sctp connection");
cmInetClose(&ricParams.sockFd);
memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
removeE2NodeInformation();
}
else
{
- DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid transaction id [%d]", transId);
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
break;
}
}
E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Connection Update Failure Message\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Connection Update Failure");
break;
}
DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
if(!tnlInformation->tnlAddress.buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
if(connectionSetupList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
+ DU_LOG("ERROR --> E2AP : Failed to fill E2 connection update item");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
return ROK;
DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
if(setupFailedList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
+ DU_LOG("ERROR --> E2AP : Failed to fill E2 connection failed to update item");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
return ROK;
asn_enc_rval_t encRetVal;
E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
- DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
do
{
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Connection setup list");
break;
}
}
if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Connection failed to setup list");
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
break;
}
E2ConnectionList connectionInfoList;
E2connectionUpdate_t *connectionUpdate=NULLP;
- DU_LOG("\nINFO --> E2AP : E2 connection update received");
+ DU_LOG("INFO --> E2AP : E2 connection update received");
connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
+ DU_LOG("ERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
break;
}
}
{
if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
+ DU_LOG("ERROR --> E2AP : Failed to build and send E2 connection update failure");
}
}
else
{
if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
+ DU_LOG("ERROR --> E2AP : Failed to build and send E2 connection update ack");
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
break;
}
break;
}
default:
- DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
+ DU_LOG("ERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
break;
}
}
break;
}
default:
- DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
+ DU_LOG("ERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
break;
}
}
break;
}
default:
- DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
+ DU_LOG("ERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
break;
}
}
RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
- DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
+ DU_LOG("INFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
do{
if(!e2apMsg)
{
- DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: E2AP Message is NULL", __func__);
break;
}
if(!e2apMsg->choice.initiatingMessage)
{
- DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
break;
}
{
if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
+ DU_LOG("ERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
break;
}
ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
+ DU_LOG("ERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
procFailure = true;
break;
}
ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(!ricSubsDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
+ DU_LOG("ERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
__func__, ricReqId.requestorId, ricReqId.instanceId);
procFailure = true;
break;
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
if(ricSubsModFailure->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
__func__, ieIdx, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
break;
}
DU_ALLOC(removedActionList->list.array, removedActionList->list.size);
if(!removedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
if(!removedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx];
DU_ALLOC(addedActionList->list.array, addedActionList->list.size);
if(!addedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
if(!addedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size);
if(!modifiedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
if(!modifiedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx];
DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size);
if(!failedToBeRemovedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
if(!failedToBeRemovedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx];
DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size);
if(!failedToBeModifiedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
if(!failedToBeModifiedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx];
DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size);
if(!failedToBeAddedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
if(!failedToBeAddedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx];
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Modification Response Message\n");
DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
if(ricSubsModResponse->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\
pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\
pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\
pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\
pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\
pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\
pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message");
break;
}
asn_dec_rval_t rval ={0}; /* Decoder return value */
E2AP_PDU_t e2apasnmsg={0} ;
- DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
+ DU_LOG("DEBUG --> E2AP : Received E2AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
if(recvBuf == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
+ DU_LOG("ERROR --> E2AP : Failed while copying %d", copyCnt);
return;
}
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> E2AP : ASN decode failed");
+ DU_LOG("ERROR --> E2AP : ASN decode failed");
return;
}
printf("\n");
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
+ DU_LOG("ERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
e2apMsg->choice.unsuccessfulOutcome->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
+ DU_LOG("ERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
e2apMsg->choice.successfulOutcome->value.present);
return;
}
}
case InitiatingMessageE2__value_PR_ErrorIndicationE2:
{
- DU_LOG("\nINFO --> E2AP : Error indication received");
+ DU_LOG("INFO --> E2AP : Error indication received");
break;
}
case InitiatingMessageE2__value_PR_ResetRequestE2:
{
- DU_LOG("\nINFO --> E2AP : Reset request received");
+ DU_LOG("INFO --> E2AP : Reset request received");
procE2ResetRequest(e2apMsg);
break;
}
case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
{
- DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
+ DU_LOG("INFO --> E2AP : RIC Subscription Delete Request received");
procRicSubscriptionDeleteRequest(e2apMsg);
break;
}
case InitiatingMessageE2__value_PR_E2RemovalRequest:
{
- DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+ DU_LOG("INFO --> E2AP : E2 Removal request received");
procE2RemovalRequest(e2apMsg);
break;
}
case InitiatingMessageE2__value_PR_E2connectionUpdate:
{
- DU_LOG("\nINFO --> E2AP : E2 coneection update received");
+ DU_LOG("INFO --> E2AP : E2 coneection update received");
procE2ConnectionUpdate(e2apMsg);
break;
}
case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
{
- DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
+ DU_LOG("INFO --> E2AP : RIC Subscription Modification Request received");
procRicSubscriptionModificationRequest(e2apMsg);
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
+ DU_LOG("ERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
e2apMsg->choice.initiatingMessage->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
+ DU_LOG("ERROR --> 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\nDEBUG --> EGTP : Initializing");
+ DU_LOG("DEBUG --> EGTP : Initializing");
memset (&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
strcpy(sourceTask,"Invalid Source Entity Id");
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
+ DU_LOG("ERROR --> EGTP : Invalid event %d", pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
{
case EVTSTARTPOLL:
{
- DU_LOG("\nDEBUG --> EGTP : Starting Socket Polling");
+ DU_LOG("DEBUG --> EGTP : Starting Socket Polling");
egtpRecvMsg();
ODU_PUT_MSG_BUF(mBuf);
break;
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
+ DU_LOG("ERROR --> EGTP : Invalid event %d", pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid event %d", pst->event);
+ DU_LOG("ERROR --> EGTP : Invalid event %d", pst->event);
ret = RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid source entity %d", pst->srcEnt);
+ DU_LOG("ERROR --> EGTP : Invalid source entity %d", pst->srcEnt);
ret = RFAILED;
}
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
+ DU_LOG("ERROR --> EGTP : TeId hash list initialization failed");
cfgCfm.status = LCM_PRIM_NOK;
cfgCfm.reason = LCM_REASON_HASHING_FAILED;
}
else
{
- DU_LOG("\nDEBUG --> EGTP : EGTP configuration successful");
+ DU_LOG("DEBUG --> 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("\nDEBUG --> EGTP : Received EGTP open server request");
+ DU_LOG("DEBUG --> EGTP : Received EGTP open server request");
sockType = CM_INET_DGRAM;
ret = egtpSrvOpenPrc(sockType);
/* Opening and Binding receiver socket */
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed while opening receiver transport server");
+ DU_LOG("ERROR --> EGTP : Failed while opening receiver transport server");
return ret;
}
- DU_LOG("\nDEBUG --> EGTP : Socket [%d] is open", egtpCb.sockFd.fd);
+ DU_LOG("DEBUG --> EGTP : Socket [%d] is open", egtpCb.sockFd.fd);
/* Start Socket polling */
memset(&egtpPst, 0, sizeof(egtpPst));
ret = cmInetSocket(sockType, &(egtpCb.sockFd), protType);
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
+ DU_LOG("ERROR --> EGTP : Failed to open UDP socket");
return ret;
}
ret = cmInetBind(&(egtpCb.sockFd), &(egtpCb.localAddr));
if(ret != ROK)
{
- DU_LOG("\nERROR --> EGTP : Failed to bind socket");
+ DU_LOG("ERROR --> EGTP : Failed to bind socket");
return ret;
}
uint8_t ret = ROK;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTEGTP : TNL_MGMT\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTEGTP : TNL_MGMT\n");
#endif
- DU_LOG("\nDEBUG --> EGTP : Received tunnel management request");
+ DU_LOG("DEBUG --> EGTP : Received tunnel management request");
switch(tnlEvt.action)
{
case EGTP_TNL_MGMT_ADD:
}
default:
{
- DU_LOG("\nERROR --> EGTP : Invalid tunnel management action[%d]", tnlEvt.action);
+ DU_LOG("ERROR --> EGTP : Invalid tunnel management action[%d]", tnlEvt.action);
ret = LCM_REASON_INVALID_ACTION;
}
}
tnlEvt.cfmStatus.reason = ret;
}
- DU_LOG("\nDEBUG --> EGTP : Sending Tunnel management confirmation");
+ DU_LOG("DEBUG --> EGTP : Sending Tunnel management confirmation");
duHdlEgtpTnlMgmtCfm(tnlEvt);
return ret;
EgtpTeIdCb *teidCb; /* Tunnel endpoint control block */
EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
- DU_LOG("\nINFO --> EGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("INFO --> EGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
DU_ALLOC(teidCb, sizeof(EgtpTeIdCb));
if(teidCb == NULLP)
{
- DU_LOG("\nERROR --> EGTP : Memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> EGTP : Failed to insert in hash list");
+ DU_LOG("ERROR --> EGTP : Failed to insert in hash list");
DU_FREE(teidCb, sizeof(EgtpTeIdCb));
return LCM_REASON_HASHING_FAILED;
}
{
EgtpTeIdCb *teidCb = NULLP;
- DU_LOG("\nINFO --> EGTP : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("INFO --> EGTP : Tunnel modification : LocalTeid[%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("\nERROR --> EGTP : Tunnel id not found");
+ DU_LOG("ERROR --> EGTP : Tunnel id not found");
return RFAILED;
}
teidCb->teId = tnlEvt.remTeid;
{
EgtpTeIdCb *teidCb = NULLP;
- DU_LOG("\nINFO --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
+ DU_LOG("INFO --> 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("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
+ DU_LOG("ERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
return LCM_REASON_INVALID_PAR_VAL;
}
EgtpMsgHdr *msgHdr;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTEGTP : DATA_INDICATION\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTEGTP : DATA_INDICATION\n");
#endif
- DU_LOG("\nDEBUG --> EGTP : Received Data Indication");
+ DU_LOG("DEBUG --> EGTP : Received Data Indication");
cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg.msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
- DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg.msgHdr.teId);
+ DU_LOG("ERROR --> 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("\nDEBUG --> EGTP : UL Data buffer before encoding header");
+ DU_LOG("DEBUG --> 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("\nDEBUG --> EGTP : UL Data buffer after encoding header");
+ DU_LOG("DEBUG --> EGTP : UL Data buffer after encoding header");
ODU_PRINT_MSG(egtpMsg.msg, 0, 0);
/* Send over UDP */
ret = cmInetSendMsg(&egtpCb.sockFd, &egtpCb.dstCb.dstAddr, &info, mBuf, (int16_t *)&txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> EGTP : Failed sending the message");
+ DU_LOG("ERROR --> EGTP : Failed sending the message");
return RFAILED;
}
else
{
- DU_LOG("\nDEBUG --> EGTP : Sent UL Message [%ld]", numDataSent+1);
+ DU_LOG("DEBUG --> EGTP : Sent UL Message [%ld]", numDataSent+1);
numDataSent++;
}
ret = cmInetRecvMsg(&egtpCb.sockFd, &egtpCb.dstCb.dstAddr, &memInfo, &recvBuf, (int16_t *)&bufLen, CM_INET_NO_FLAG);
if(ret == ROK && recvBuf != NULLP)
{
- DU_LOG("\nDEBUG --> EGTP : Received DL Message[%ld]\n", gConfigInfo.gDlDataRcvdCnt + 1);
+ DU_LOG("DEBUG --> EGTP : Received DL Message[%ld]\n", gConfigInfo.gDlDataRcvdCnt + 1);
//ODU_PRINT_MSG(recvBuf, 0 ,0);
egtpHdlRecvData(recvBuf);
gConfigInfo.gDlDataRcvdCnt++;
/* Extracting version fro 1st byte */
version = tmpByte[0] >> 5;
- //DU_LOG("\nDEBUG --> EGTP : Version %d", version);
+ //DU_LOG("DEBUG --> EGTP : Version %d", version);
/* Decode message type */
ODU_REM_PRE_MSG((Data*)&(egtpMsg->msgHdr.msgType), mBuf);
- //DU_LOG("\nDEBUG --> EGTP : msgType %d", egtpMsg->msgHdr.msgType);
+ //DU_LOG("DEBUG --> EGTP : msgType %d", egtpMsg->msgHdr.msgType);
/****************************************************************************
* Message length param is 2 bytes. So decode next 2 bytes from msg hdr and
msgLen = (tmpByte[1] << 8) | tmpByte[2];
UNUSED(msgLen);
UNUSED(version);
- //DU_LOG("\nDEBUG --> EGTP : msgLen %d", msgLen);
+ //DU_LOG("DEBUG --> 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("\nDEBUG --> EGTP : teId %d",egtpMsg->msgHdr.teId);
+ //DU_LOG("DEBUG --> 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("\nDEBUG --> EGTP : DL Data Buffer after decoding header ");
+ //DU_LOG("DEBUG --> EGTP : DL Data Buffer after decoding header ");
//ODU_PRINT_MSG(mBuf, 0, 0);
/* Forward the data to duApp/RLC */
pollRetxTmr = 800;
break;
default:
- DU_LOG("\nERROR --> F1AP: Invalid value of Poll Retransmit timer");
+ DU_LOG("ERROR --> F1AP: Invalid value of Poll Retransmit timer");
pollRetxTmr = 0;
}
}
pollPdu = -1;
break;
default:
- DU_LOG("\nERROR --> F1AP: Invalid value of poll pdu");
+ DU_LOG("ERROR --> F1AP: Invalid value of poll pdu");
pollPdu = 0;
break;
}
pollBytes = -1;
break;
default:
- DU_LOG("\nERROR --> F1AP: Invalid value of poll bytes");
+ DU_LOG("ERROR --> F1AP: Invalid value of poll bytes");
pollBytes = 0;
}
return pollBytes;
maxRetx = 32;
break;
default:
- DU_LOG("\nERROR --> F1AP: Invalid configuration for Max retransmission threshold");
+ DU_LOG("ERROR --> F1AP: Invalid configuration for Max retransmission threshold");
maxRetx = 0;
}
return maxRetx;
}
else
{
- DU_LOG("\nERROR --> F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
+ DU_LOG("ERROR --> F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
reAsmblTmr = -1;
}
return reAsmblTmr;
}
}
}
- DU_LOG("\nERROR --> DU_APP: fetchLcId() failed for drbId %d", drbId);
+ DU_LOG("ERROR --> DU_APP: fetchLcId() failed for drbId %d", drbId);
return RFAILED;
}
if(tddInfo == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Null pointer received at fillNrTddInfo");
+ DU_LOG("ERROR --> DU APP : Null pointer received at fillNrTddInfo");
return RFAILED;
}
DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
if(!freqInfo->freqBandListNr.list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
return RFAILED;
}
DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx], sizeof(FreqBandNrItem_t ));
if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
return RFAILED;
}
freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
return RFAILED;
}
sizeof(SupportedSULFreqBandItem_t));
if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed at fillNrTddInfo");
return RFAILED;
}
DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
if(mode->choice.fDD == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in BuildNrMode");
+ DU_LOG("ERROR --> Memory allocation failed in BuildNrMode");
return RFAILED;
}
BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
if(BuildULNRInforet != ROK)
{
- DU_LOG("\nERROR --> Failed to build UlNrFreqInfo");
+ DU_LOG("ERROR --> Failed to build UlNrFreqInfo");
return RFAILED;
}
BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
if(BuildDLNRInforet != ROK)
{
- DU_LOG("\nERROR --> Failed to build DlNrFreqInfo");
+ DU_LOG("ERROR --> Failed to build DlNrFreqInfo");
return RFAILED;
}
mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
if(mode->choice.tDD == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in BuildNrMode");
+ DU_LOG("ERROR --> Memory allocation failed in BuildNrMode");
return RFAILED;
}
if(fillNrTddInfo(mode->choice.tDD) != ROK)
{
- DU_LOG("\nERROR --> Failed to fill Nr TDD information");
+ DU_LOG("ERROR --> Failed to fill Nr TDD information");
return RFAILED;
}
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Measurement Timing Configuration \n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for Measurement Timing Configuration \n");
#ifdef DEBUG_ASN_PRINT
for(measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
{
DU_ALLOC(measTimingConf->buf, encBufSize);
if(measTimingConf->buf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer");
return RFAILED;
}
memcpy(measTimingConf->buf, &encBuf, encBufSize);
if(sctpSend(mBuf, F1_INTERFACE) != ROK)
{
- DU_LOG("\nERROR --> F1AP : SCTP Send failed");
+ DU_LOG("ERROR --> F1AP : SCTP Send failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("ERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory");
return RFAILED;
}
return ROK;
FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
break;
default:
- DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
break;
}
}
asn_enc_rval_t encRetVal; /* Encoder return value */
ret= RFAILED;
- DU_LOG("\nINFO --> F1AP : Building F1 Setup Request\n");
+ DU_LOG("INFO --> F1AP : Building F1 Setup Request\n");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1SetupRequest\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for F1SetupRequest\n");
#ifdef DEBUG_ASN_PRINT
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Setup request failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Setup request failed");
break;
}
if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_ADD, encBufSize, encBuf) !=ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to add the e2 node in the list");
+ DU_LOG("ERROR --> F1AP : Failed to add the e2 node in the list");
break;
}
array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillNrFddInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillNrFddInfo");
return RFAILED;
}
sizeof(FreqBandNrItem_t));
if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillNrFddInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillNrFddInfo");
return RFAILED;
}
DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillNrFddInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillNrFddInfo");
return RFAILED;
}
DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0], sizeof(FreqBandNrItem_t));
if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillNrFddInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillNrFddInfo");
return RFAILED;
}
srvCellInfo->nRCGI.pLMN_Identity.size);
if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
srvCellInfo->nRCGI.nRCellIdentity.size);
if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
if(srvCellInfo->servedPLMNs.list.array == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
}
if(fillServedPlmns(&srvCellInfo->servedPLMNs))
{
- DU_LOG("\nERROR --> Failed to fill Served Plmn info");
+ DU_LOG("ERROR --> Failed to fill Served Plmn info");
return RFAILED;
}
DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
{
- DU_LOG("\nERROR --> Failed to fill the Nr FDD information");
+ DU_LOG("ERROR --> Failed to fill the Nr FDD information");
return RFAILED;
}
#else
DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillServedCellInfo");
+ DU_LOG("ERROR --> Memory allocation failed in fillServedCellInfo");
return RFAILED;
}
if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
{
- DU_LOG("\nERROR --> Failed to fill the Nr TDD information");
+ DU_LOG("ERROR --> Failed to fill the Nr TDD information");
return RFAILED;
}
#endif
DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
if(cellsToDelete->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
return RFAILED;
}
DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
if(cellsToDelete->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
return RFAILED;
}
}
arrIdx=0;
if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
{
- DU_LOG("\nERROR --> F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
+ DU_LOG("ERROR --> F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
return RFAILED;
}
return ROK;
while(true)
{
- DU_LOG("\nINFO --> F1AP : Building DU config update\n");
+ DU_LOG("INFO --> F1AP : Building DU config update\n");
/* Allocate the memory for F1DuCfg */
DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
if(f1apDuCfg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
break;
}
DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
if(f1apDuCfg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DUConfigUpdate\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for DUConfigUpdate\n");
#ifdef DEBUG_ASN_PRINT
for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update failed");
+ DU_LOG("ERROR --> F1AP : Sending GNB-DU Config Update failed");
break;
}
if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, encBufSize, encBuf)!=ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to update the e2 node in the list");
+ DU_LOG("ERROR --> F1AP : Failed to update the e2 node in the list");
break;
}
while(true)
{
- DU_LOG("\nINFO --> F1AP : Building UL RRC Message Transfer Message\n");
+ DU_LOG("INFO --> F1AP : Building UL RRC Message Transfer Message\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending UL RRC Message Transfer Failed");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
DU_ALLOC(tagList->list.array, tagList->list.size);
if(!tagList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
if(!tagList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildTagConfig");
return RFAILED;
}
}
DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
if(!phrConfig->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
return RFAILED;
}
DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildBsrConfig");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildBsrConfig");
return RFAILED;
}
*(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
if(!schedulingRequestConfig->schedulingRequestToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
DU_ALLOC(schReqList->list.array, schReqList->list.size);
if(!schReqList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
if(!schReqList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
*(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
if(!schReqList->list.array[idx]->sr_ProhibitTimer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
*(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
if(!rlcConfig->choice.am)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
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("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
return RFAILED;
}
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("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigAm");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
if(rlcConfig->choice.um_Bi_Directional == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
return RFAILED;
}
DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
return RFAILED;
}
DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
if(!macLcConfig->ul_SpecificParameters)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
if(!rlcBearerList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
}
DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
if(!rlcBearerList->list.array[idx]->servedRadioBearer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildRlcConfig failed");
return RFAILED;
}
DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildMacLCConfig failed");
return RFAILED;
}
}
DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
if(!rlcBearerList->list.array[idx]->servedRadioBearer)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
rlcBearerList->list.array[idx]->servedRadioBearer->present = \
DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
if(BuildRlcConfig(&ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildRlcConfig failed");
return RFAILED;
}
DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
return RFAILED;
}
for(macLcIdx = 0; macLcIdx < ueCb->duMacUeCfg.numLcs; macLcIdx++)
{
if(BuildMacLCConfig(&ueCb->duMacUeCfg.lcCfgList[macLcIdx].lcConfig, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildMacLCConfig failed");
return RFAILED;
}
break;
DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
if(!controlRSetList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
if(!controlRSetList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
if(!controlRSet->frequencyDomainResources.buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
if(!controlRset->tci_StatesPDCCH_ToAddList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
controlRset->tci_StatesPDCCH_ToAddList->list.size)
if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
}
DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
if(!controlRset->tci_PresentInDCI)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
/* TODO */
DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
if(!controlRSet->pdcch_DMRS_ScramblingID)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
if(!searchSpcList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
if(!searchSpcList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
}
DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
if(!searchSpc->controlResourceSetId)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
if(!searchSpc->monitoringSlotPeriodicityAndOffset)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
if(!searchSpc->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
if(!searchSpc->monitoringSymbolsWithinSlot->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpc->nrofCandidates)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
if(!searchSpc->searchSpaceType)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
if(!searchSpc->searchSpaceType->choice.ue_Specific)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
return RFAILED;
}
if(pdcchCfg == NULLP)
DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
if(!pdcchCfg->controlResourceSetToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed in BuildControlRSetToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed in BuildControlRSetToAddModList()");
return RFAILED;
}
DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
if(!pdcchCfg->searchSpacesToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
return RFAILED;
}
if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed in BuildSearchSpcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed in BuildSearchSpcToAddModList()");
return RFAILED;
}
DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
if(!dmrsDlCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
return RFAILED;
}
DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
return RFAILED;
}
if(pdschCfg == NULLP)
DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
if(!timeDomAllocList->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
sizeof(struct PDSCH_TimeDomainResourceAllocation));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
}
DU_ALLOC(timeDomAlloc->k0, sizeof(long));
if(!timeDomAlloc->k0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k0) = 0;
DU_ALLOC(timeDomAlloc->k0, sizeof(long));
if(!timeDomAlloc->k0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k0) = 1;
DU_ALLOC(timeDomAlloc->k0, sizeof(long));
if(!timeDomAlloc->k0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
*(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
if(!prbBndlType->choice.staticBundling)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
return RFAILED;
}
prbBndlType->choice.staticBundling->bundleSize = NULLP;
DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
if(!pdschCfg->pdsch_TimeDomainAllocationList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
return RFAILED;
}
if(pdschCfgDb == NULLP)
DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
if(!dlBwp->pdcch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
if(!dlBwp->pdsch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
return RFAILED;
}
DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
if(!dmrsUlCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
if(ulDmrsCfgDb == NULLP)
DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
sizeof(long));
if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
return RFAILED;
}
if(ulDmrsCfgDb == NULLP)
DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
if(!timeDomAllocList->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
if(!timeDomAllocList->choice.setup->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
}
DU_ALLOC(timeDomAlloc->k2, sizeof(long));
if(!timeDomAlloc->k2)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
if(puschCfgDb == NULLP)
DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
if(!puschCfg->dataScramblingIdentityPUSCH)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
if(puschCfgDb == NULLP)
DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
if(!puschCfg->pusch_TimeDomainAllocationList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
if(!puschCfg->transformPrecoder)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
return RFAILED;
}
if(puschCfgDb == NULLP)
DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
if(resourceSetToAddModList->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
return RFAILED;
}
for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
return RFAILED;
}
}
DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
if(rsrcSet->resourceList.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
return RFAILED;
}
DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
return RFAILED;
}
}
DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
if(rsrcSet->maxPayloadMinus1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
return RFAILED;
}
*(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
if(resourceToAddModList->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
}
DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
if(rsrc->format.choice.format1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format1->initialCyclicShift = 0;
DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
if(rsrc->intraSlotFrequencyHopping == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
*(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
if(rsrc->secondHopPRB == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
*(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
if(rsrc->format.choice.format0 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
if(rsrc->format.choice.format1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
if(rsrc->format.choice.format2 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
if(rsrc->format.choice.format3 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
if(rsrc->format.choice.format4 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
return RFAILED;
}
rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
if(format->interslotFrequencyHopping)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
*(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
DU_ALLOC(format->additionalDMRS, sizeof(long));
if(format->additionalDMRS)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
*(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
DU_ALLOC(format->maxCodeRate, sizeof(long));
if(format->maxCodeRate)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
*(format->maxCodeRate) = formatDb->maxCodeRate;
DU_ALLOC(format->nrofSlots, sizeof(long));
if(format->nrofSlots == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
if(formatDb == NULLP)
DU_ALLOC(format->pi2BPSK, sizeof(long));
if(format->pi2BPSK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
*(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
if(format->simultaneousHARQ_ACK_CSI)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
return RFAILED;
}
*(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
if(schReqRsrcToAddModList->list.array == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
return RFAILED;
}
DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
return RFAILED;
}
}
DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
if(schReqRsrc->periodicityAndOffset == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
return RFAILED;
}
DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
if(schReqRsrc->resource == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
return RFAILED;
}
*(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
if(multiCsiRsrcList->list.array == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
return RFAILED;
}
DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
return RFAILED;
}
}
DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
if(dlDataToUlACKList->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
return RFAILED;
}
DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
if(pucchCfg->resourceSetToAddModList == NULL)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
if(pucchCfg->resourceToAddModList == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
if(pucchCfg->format1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
if(pucchCfg->format1->choice.setup == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
if(pucchCfg->format2 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
if(pucchCfg->format2->choice.setup == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
if(pucchCfg->format3 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
if(pucchCfg->format3->choice.setup == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
if(pucchCfg->format4 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
if(pucchCfg->format4->choice.setup == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
if(pucchCfg->dl_DataToUL_ACK == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
return RFAILED;
}
DU_ALLOC(resourceList->list.array, resourceList->list.size);
if(!resourceList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
}
sizeof(struct SRS_Resource__transmissionComb__n2));
if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
return RFAILED;
}
DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
if(!rsrcSetList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
if(!rsrcIdList->list.array)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
return RFAILED;
}
}
sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
return RFAILED;
}
DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
if(!puschCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
return RFAILED;
}
*(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
if(!ulBwp->pucch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
if(!ulBwp->pucch_Config->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
if(!ulBwp->pusch_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
return RFAILED;
}
DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
if(!ulCfg->initialUplinkBWP)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
if(!ulCfg->firstActiveUplinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
if(servCellRecfg == NULLP)
DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
if(!ulCfg->pusch_ServingCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ DU_LOG("ERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
if(!pdschCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
if(pdschCfg->choice.setup->xOverhead == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
*(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
if(pdschCfg->choice.setup->ext1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
return RFAILED;
}
*(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
if(dlBwpAddModList->list.array == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
return RFAILED;
}
DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
if(dlBwpAddModList->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
+ DU_LOG("ERROR --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
return RFAILED;
}
}
DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
if(!srvCellCfg->initialDownlinkBWP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildInitialDlBWP failed");
+ DU_LOG("ERROR --> F1AP : BuildInitialDlBWP failed");
return RFAILED;
}
DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildDlBwpToAddModList(&ueCb->duMacUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildInitialDlBWP failed");
+ DU_LOG("ERROR --> F1AP : BuildInitialDlBWP failed");
return RFAILED;
}
}
DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->firstActiveDownlinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(ueCb == NULLP)
DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->defaultDownlinkBWP_Id)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(ueCb == NULLP)
DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
if(!srvCellCfg->uplinkConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildUlCfg(servCellRecfg, srvCellCfg->uplinkConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildUlCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildUlCfg failed");
return RFAILED;
}
srvCellCfg->supplementaryUplink = NULLP;
DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
if(!srvCellCfg->pdsch_ServingCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPdschSrvCellCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildPdschSrvCellCfg failed");
return RFAILED;
}
DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
if(!srvCellCfg->csi_MeasConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
return RFAILED;
}
if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
{
- DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
+ DU_LOG("F1AP : BuildCsiMeasCfg failed");
return RFAILED;
}
#endif
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for scs carrier list array \
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for scs carrier list array \
in BuildScsSpecificCarrierListDl()");
return RFAILED;
}
DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[listIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for SCS Specific Carrier list array \
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for SCS Specific Carrier list array \
element in BuildScsSpecificCarrierListDl()");
return RFAILED;
}
DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
if(!frequencyInfoDL->absoluteFrequencySSB)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
return RFAILED;
}
frequencyInfoDL->absoluteFrequencySSB = ?;
DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
if(!frequencyInfoDL->frequencyBandList.list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
return RFAILED;
}
DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
return RFAILED;
}
}
/* Subcarrier Spacing specifc carrier List */
if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
+ DU_LOG("ERROR --> DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
return RFAILED;
}
DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
if(!dlCfgCommon->frequencyInfoDL)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
return RFAILED;
}
if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
return RFAILED;
}
DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
if(!dlCfgCommon->initialDownlinkBWP)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
return RFAILED;
}
if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
return RFAILED;
}
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[listIdx])
{
- DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
return RFAILED;
}
}
DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
if(!frequencyInfoUL->frequencyBandList)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
return RFAILED;
}
DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
if(!frequencyInfoUL->frequencyBandList->list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
return RFAILED;
}
DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
return RFAILED;
}
}
DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
if(!frequencyInfoUL->absoluteFrequencyPointA)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
return RFAILED;
}
*(frequencyInfoUL->absoluteFrequencyPointA) = ?;
/* Subcarrier Spacing specifc carrier */
if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
+ DU_LOG("ERROR --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
return RFAILED;
}
DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
if(!frequencyInfoUL->p_Max)
{
- DU_LOG("\nERROR --> DU APP : UL Frequency Infoo memory allocation failure");
+ DU_LOG("ERROR --> DU APP : UL Frequency Infoo memory allocation failure");
return RFAILED;
}
*frequencyInfoUL->p_Max = ulCfg.pMax;
DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
if(!ulCfgCommon->frequencyInfoUL)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
return RFAILED;
}
if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
return RFAILED;
}
DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
if(!ulCfgCommon->initialUplinkBWP)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
return RFAILED;
}
if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
return RFAILED;
}
DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
if(!ssbPosInBurst->choice.mediumBitmap.buf)
{
- DU_LOG("\nERROR --> DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
+ DU_LOG("ERROR --> DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
return RFAILED;
}
if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
+ DU_LOG("ERROR --> DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
return RFAILED;
}
DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
if(!spCellConfigCommon->physCellId)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
return RFAILED;
}
*(spCellConfigCommon->physCellId) = NR_PCI;
DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
if(!spCellConfigCommon->downlinkConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
return RFAILED;
}
if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
return RFAILED;
}
DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
if(!spCellConfigCommon->uplinkConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
return RFAILED;
}
if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
return RFAILED;
}
DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
if(!spCellConfigCommon->n_TimingAdvanceOffset)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
return RFAILED;
}
*(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
if(!spCellConfigCommon->ssb_PositionsInBurst)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
return RFAILED;
}
if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
return RFAILED;
}
DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
if(!spCellConfigCommon->ssb_periodicityServingCell)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
BuildSpCellConfigCommon()");
return RFAILED;
}
DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
if(!spCellConfigCommon->ssbSubcarrierSpacing)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
return RFAILED;
}
*(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
return RFAILED;
}
if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
return RFAILED;
}
DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
if(!rachCfgDed->choice.uplink)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
return RFAILED;
}
DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
if(!rachCfgDed->choice.uplink->cfra)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
return RFAILED;
}
cfra = rachCfgDed->choice.uplink->cfra;
DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
if(!cfra->occasions)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
return RFAILED;
}
DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
if(!cfra->occasions->ssb_perRACH_Occasion)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
return RFAILED;
}
*(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
if(!cfra->resources.choice.ssb)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
return RFAILED;
}
ssbResource = cfra->resources.choice.ssb;
DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
if(!ssbResource->ssb_ResourceList.list.array)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
return RFAILED;
}
DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
if(!ssbResource->ssb_ResourceList.list.array[listIdx])
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
return RFAILED;
}
ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
if(!recfgWithSync->spCellConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
return RFAILED;
}
if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
+ DU_LOG("ERROR --> DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
return RFAILED;
}
DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
if(!recfgWithSync->rach_ConfigDedicated)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
return RFAILED;
}
if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
+ DU_LOG("ERROR --> DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
return RFAILED;
}
DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
if(!spCellCfg->servCellIndex)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
if(!spCellCfg->reconfigurationWithSync)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
return RFAILED;
}
}
DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSpCellCfgDed failed");
+ DU_LOG("ERROR --> F1AP : BuildSpCellCfgDed failed");
return RFAILED;
}
DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
if(!phyCellGrpCfg->p_NR_FR1)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
return RFAILED;
}
DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
if(!drxCfg->choice.setup)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDrxConfigRrc");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDrxConfigRrc");
return RFAILED;
}
if(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDrxConfigRrc");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDrxConfigRrc");
return RFAILED;
}
}
DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
if(!macCellGrpCfg->drx_ConfigRrc)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
{
- DU_LOG("\nERROR --> F1AP : failed to build drx config");
+ DU_LOG("ERROR --> F1AP : failed to build drx config");
return RFAILED;
}
}
DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
if(!macCellGrpCfg->schedulingRequestConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSchedulingReqConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildSchedulingReqConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
if(!macCellGrpCfg->bsr_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildBsrConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildBsrConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
if(!macCellGrpCfg->tag_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildTagConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildTagConfig failed");
return RFAILED;
}
DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
if(!macCellGrpCfg->phr_Config)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
return RFAILED;
}
if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPhrConfig failed");
+ DU_LOG("ERROR --> F1AP : BuildPhrConfig failed");
return RFAILED;
}
DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
if(!cellGrpCfg.rlc_BearerToAddModList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildRlcBearerToAddModList failed");
+ DU_LOG("ERROR --> F1AP : BuildRlcBearerToAddModList failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
if(!cellGrpCfg.mac_CellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildMacCellGrpCfg failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
if(!cellGrpCfg.physicalCellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildPhyCellGrpCfg failed");
ret = RFAILED;
break;
}
DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
if(!cellGrpCfg.spCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
+ DU_LOG("ERROR --> F1AP : BuildSpCellCfg failed");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
if(!duToCuRrcContainer->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
+ DU_LOG("ERROR --> DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
return RFAILED;
}
return ROK;
while(true)
{
- DU_LOG("\n INFO --> F1AP : Building RRC Setup Request\n");
+ DU_LOG(" INFO --> F1AP : Building RRC Setup Request\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Initial UL RRC\
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for Initial UL RRC\
Message transfer\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending Initial UL RRC Message Transfer Failed");
+ DU_LOG("ERROR --> F1AP : Sending Initial UL RRC Message Transfer Failed");
ret = RFAILED;
break;
}
break;
}
default:
- DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
+ DU_LOG("ERROR --> DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
break;
}
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
break;
}
default:
- DU_LOG("\nERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
+ DU_LOG("ERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
break;
}
}
DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
if(snssaiToBeShared == NULLP)
{
- DU_LOG("\nERROR --> DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
+ DU_LOG("ERROR --> DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
+ DU_LOG("ERROR --> DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
return RFAILED;
}
}
drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->rlcBearerCfg.snssai) != ROK)
{
- DU_LOG("\nERROR --> DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
+ DU_LOG("ERROR --> DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
return;
}
}
QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
{
qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
- DU_LOG("\nDEBUG --> DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
+ DU_LOG("DEBUG --> DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
}
}
}
DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
if(upTnlInfo->tnlCfg1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
+ DU_LOG("ERROR --> F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
return RFAILED;
}
bitStringToInt(>pTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
if(macLcToAdd->drbQos == NULLP)
{
- DU_LOG("\nERROR --> DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
+ DU_LOG("ERROR --> DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
return RFAILED;
}
}
if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
{
- DU_LOG("\nERROR --> DUAPP: Unable to extract Snssai information at extractDrbQosCfg()");
+ DU_LOG("ERROR --> DUAPP: Unable to extract Snssai information at extractDrbQosCfg()");
return RFAILED;
}
return ROK;
{
if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
return RFAILED;
}
if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
return RFAILED;
}
}
if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
return RFAILED;
}
if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
return RFAILED;
}
if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
return RFAILED;
}
if(drbModItem->qoSInformation != NULLP)
drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
+ DU_LOG("ERROR --> DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> No components present in Bearer config to ADD/MOD");
+ DU_LOG("ERROR --> No components present in Bearer config to ADD/MOD");
return RFAILED;
}
/* MAC UL LC Config */
}
else
{
- DU_LOG("\nERROR --> DUAPP: Received RadioBearer config is NULL");
+ DU_LOG("ERROR --> DUAPP: Received RadioBearer config is NULL");
return RFAILED;
}
/* RLC Mode Config */
procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
+ DU_LOG("ERROR --> DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
return RFAILED;
}
(ueCfgDb->numRlcLcs)++;
(ueCfgDb->numMacLcs)++;
- DU_LOG("\nDEBUG -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
+ DU_LOG("DEBUG -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs, ueCfgDb->numDrb);
}
//TODO: To send the failure cause in UeContextSetupRsp
}
if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for k0 at extractPdschCfg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for k0 at extractPdschCfg()");
return;
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
return RFAILED;
}
}
DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
return RFAILED;
}
macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
return RFAILED;
}
macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
return RFAILED;
}
macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
return RFAILED;
}
macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
+ DU_LOG("ERROR --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
return RFAILED;
}
macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
break;
}
default :
- DU_LOG("\nERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
+ DU_LOG("ERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
}
}
DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
if(macPucchCfg->resrcSet == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
if(macPucchCfg->resrc == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
if(macPucchCfg->format1 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract format 1 Cfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
if(macPucchCfg->format2 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract format 2 Cfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
if(macPucchCfg->format3 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract format 3 Cfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
if(macPucchCfg->format4 == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract format 4 Cfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
if(macPucchCfg->schedReq == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract schedReqCfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
if(macPucchCfg->multiCsiCfg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract multiCsiCfg in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
}
if(macPucchCfg->dlDataToUlAck == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
return RFAILED;
}
memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
if(macPucchCfg->powerControl == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
+ DU_LOG("ERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
return RFAILED;
}
extractPucchPowerControl(macPucchCfg->powerControl,\
}
else
{
- DU_LOG("\nERROR --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
+ DU_LOG("ERROR --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
return RFAILED;
}
}
ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
+ DU_LOG("ERROR --> F1AP : Failed at extractPdschServingCellCfg()");
return RFAILED;
}
}
}
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
+ DU_LOG("ERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
}
}
}
}
break;
default:
- DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
+ DU_LOG("ERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
rrcMsg->iE_Extensions->list.array[ieIdx]->id);
break;
}
cellGrp = (CellGroupConfigRrc_t *)cellInfo;
ret = extractUeRecfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> F1AP : Failed at procUeRecfgCellInfo()");
+ DU_LOG("ERROR --> F1AP : Failed at procUeRecfgCellInfo()");
}
if(ret == RFAILED)
{
}
default:
{
- DU_LOG("\nERROR --> DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
+ DU_LOG("ERROR --> DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
if(oldUeCfg)
memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
break;
}
default:
{
- DU_LOG("\nERROR --> DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
+ DU_LOG("ERROR --> DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
if(oldUeCfg)
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("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("ERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
return RFAILED;
}
xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
case ProtocolIE_ID_id_HandoverPreparationInformation:
{
- DU_LOG("\nINFO --> F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
+ DU_LOG("INFO --> F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
break;
}
default:
- DU_LOG("\nERROR --> F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
+ DU_LOG("ERROR --> F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
break;
}
}
/* Filling MAC INFO */
if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, duMacLcToAdd, NULL) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
+ DU_LOG("ERROR --> F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
return RFAILED;
}
srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
if(ueCfgDb->numMacLcs > MAX_NUM_LC)
{
- DU_LOG("\nERROR --> F1AP: MAX LC Reached in MAC");
+ DU_LOG("ERROR --> F1AP: MAX LC Reached in MAC");
ret = RFAILED;
break;
}
if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
{
- DU_LOG("\nERROR --> F1AP: MAX LC Reached in RLC");
+ DU_LOG("ERROR --> F1AP: MAX LC Reached in RLC");
ret = RFAILED;
break;
}
ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
- DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
+ DU_LOG("DEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs, ueCfgDb->numDrb);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP: Failed at extractSrbListToSetup()");
+ DU_LOG("ERROR --> F1AP: Failed at extractSrbListToSetup()");
break;
}
}
/* Filling MAC INFO */
if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
return RFAILED;
}
}
if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
return RFAILED;
}
}
procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
return RFAILED;
}
}
if(ueCfgDb->numMacLcs > MAX_NUM_LC)
{
- DU_LOG("\nERROR --> F1AP : MAX LC Reached in MAC at extractDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : MAX LC Reached in MAC at extractDrbListToSetupMod()");
ret = RFAILED;
break;
}
if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
{
- DU_LOG("\nERROR --> F1AP : MAX LC Reached in RLC at extractDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : MAX LC Reached in RLC at extractDrbListToSetupMod()");
ret = RFAILED;
break;
}
lcId = fetchLcId(drbId);
if(lcId < MIN_DRB_LCID)
{
- DU_LOG("\nERROR --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
+ DU_LOG("ERROR --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
break;
}
ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
+ DU_LOG("ERROR --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
break;
}
ueCfgDb->numDrbModified++;
lcId = getDrbLcId(drbBitMap);
if(lcId == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : InCorrect LCID extractDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : InCorrect LCID extractDrbListToSetupMod()");
ret = RFAILED;
break;
}
ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
+ DU_LOG("ERROR --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
break;
}
}
macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
+ DU_LOG("ERROR --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
break;
}
ueCfgDb->numDrbSetupMod++;
}
ueCfgDb->numDrb++;
- DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
+ DU_LOG("DEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs, ueCfgDb->numDrb);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToSetupMod()");
+ DU_LOG("ERROR --> F1AP : Failed at extractDrbListToSetupMod()");
break;
}
}
lcId = fetchLcId(drbId);
if(lcId < MIN_DRB_LCID)
{
- DU_LOG("\nERROR --> F1AP : Failed fetching LCID %d in extractDrbListToRelease() for Modified List", lcId);
+ DU_LOG("ERROR --> F1AP : Failed fetching LCID %d in extractDrbListToRelease() for Modified List", lcId);
break;
}
/* Filling MAC INFO */
if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_DEL, NULL, NULL, NULL, NULL, macLcCtxt, NULLP) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at RLC LC Cfg in extractDrbListToRelease()");
+ DU_LOG("ERROR --> F1AP : Failed at RLC LC Cfg in extractDrbListToRelease()");
return RFAILED;
}
ueCfgDb->upTnlInfo[ueCfgDb->numDrb].configType = CONFIG_DEL;
ueCfgDb->numDrb++;
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed at extractDrbListToRelease() for Modified List");
+ DU_LOG("ERROR --> F1AP : Failed at extractDrbListToRelease() for Modified List");
break;
}
- DU_LOG("\nDEBUG --> DUAPP: extractDrbListToRelease():lcId:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
+ DU_LOG("DEBUG --> DUAPP: extractDrbListToRelease():lcId:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
lcId,ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs, ueCfgDb->numDrb);
}
}
DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
if(!dlRrcMsg->rrcMsgPdu)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
ret = RFAILED;
}
else
DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
if(!ueCapRatContList)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in extractUeCapability");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation failed in extractUeCapability");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
+ DU_LOG("ERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
return NULLP;
}
xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
}
#endif
default:
- DU_LOG("\nERROR --> F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
}
free(ueSetReq->protocolIEs.list.array[ieIdx]);
}
GET_CELL_IDX(nrCellId, cellIdx);
if(!duCb.actvCellLst[cellIdx])
{
- DU_LOG("\nERROR --> F1AP : Cell Id [%lu] not found", nrCellId);
+ DU_LOG("ERROR --> F1AP : Cell Id [%lu] not found", nrCellId);
ret = RFAILED;
}
break;
gnbDuUeF1apId = ueIdx +1;
else
{
- DU_LOG("\nERROR --> F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
+ DU_LOG("ERROR --> F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
+ DU_LOG("ERROR --> F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nERROR --> F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
+ DU_LOG("ERROR --> F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
ret = RFAILED;
break;
}
{
if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP: Failed to extract CU to DU RRC information extension IE");
+ DU_LOG("ERROR --> F1AP: Failed to extract CU to DU RRC information extension IE");
//TODO: Update the failure cause in ue context Setup Response
ret = RFAILED;
}
if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
&duUeCb->f1UeDb->duUeCfg))
{
- DU_LOG("\nERROR --> DU APP : Failed at extractSrbListToSetup()");
+ DU_LOG("ERROR --> DU APP : Failed at extractSrbListToSetup()");
//TODO: Update the failure cause in ue context Setup Response
ret = RFAILED;
}
if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
{
- DU_LOG("\nERROR --> DU APP : Failed at extractDrbListToSetupMod()");
+ DU_LOG("ERROR --> DU APP : Failed at extractDrbListToSetupMod()");
//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("\nERROR --> DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
ret = RFAILED;
}
else
}
else
{
- DU_LOG("\nERROR --> Ignoring delivery report, since rrcContainer is not present");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
ret = RFAILED;
}
else
if(ret == RFAILED)
{
// BuildAndSendUeContextSetupRsp(cellId,ueId);
- DU_LOG("\nERROR --> F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
+ DU_LOG("ERROR --> F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
break;
}
} /* End of for loop of IEs */
break;
}
default:
- DU_LOG("\nERROR --> DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
+ DU_LOG("ERROR --> DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
ueSetRsp->protocolIEs.list.array[idx]->id);
break;
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
if(!duToCuCellGrp->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
}
memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
return ROK;
UEContextSetupResponse_t *ueSetRsp = NULLP;
DuUeCb *ueCb = NULLP;
- DU_LOG("\n INFO --> F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
+ DU_LOG(" INFO --> F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
while(true)
{
&ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
+ DU_LOG("ERROR --> F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
freeF1UeDb(ueCb->f1UeDb);
ueCb->f1UeDb = NULLP;
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UE Context Setup Response\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for UE Context Setup Response\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending UE Context Setup Response failed");
+ DU_LOG("ERROR --> F1AP : Sending UE Context Setup Response failed");
ret = RFAILED;
break;
}
{
if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at BuildAndSendUeContextSetupRsp()");
+ DU_LOG("ERROR --> F1AP : Failed at BuildAndSendUeContextSetupRsp()");
return RFAILED;
}
break;
{
if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed at BuildAndSendUeContextModRsp");
+ DU_LOG("ERROR --> F1AP : Failed at BuildAndSendUeContextModRsp");
return RFAILED;
}
break;
Reset_t *f1ResetMsg = NULLP;
F1AP_PDU_t *f1apMsg = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Reset request \n");
+ DU_LOG("INFO --> F1AP : Building F1 Reset request \n");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
#ifdef DEBUG_ASN_PRINT
for(idx=0; idx< encBufSize; idx++)
{
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset request failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Reset request failed");
break;
}
F1AP_PDU_t *f1apMsg = NULL;
ResetAcknowledge_t *f1ResetAck = NULLP;
asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Reset Acknowledgment \n");
+ DU_LOG("INFO --> 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("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
break;
}
DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ DU_LOG("ERROR --> 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("\nERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDUBUG --> F1AP : Created APER encoded buffer for F1ResetAck\n");
+ DU_LOG("DUBUG --> F1AP : Created APER encoded buffer for F1ResetAck\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset Acknowledgement failed");
+ DU_LOG("ERROR --> F1AP : Sending F1 Reset Acknowledgement failed");
break;
}
uint8_t ret = ROK;
Reset_t *f1ResetMsg = NULLP;
- DU_LOG("\nINFO --> Processing F1 reset request");
+ DU_LOG("INFO --> Processing F1 reset request");
f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
}
}
ret = BuildAndSendF1ResetAck();
- DU_LOG("\nINFO --> UE release is not supported for now");
+ DU_LOG("INFO --> UE release is not supported for now");
freeAperDecodeF1ResetMsg(f1ResetMsg);
do{
- DU_LOG("\nINFO --> F1AP : Building RRC delivery Message Transfer Message\n");
+ DU_LOG("INFO --> F1AP : Building RRC delivery Message Transfer Message\n");
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
#ifdef DEBUG_ASN_PRINT
for(idx=0; idx< encBufSize; idx++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending RRC delivery msg request failed");
+ DU_LOG("ERROR --> F1AP : Sending RRC delivery msg request failed");
break;
}
ret = ROK;
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
+ DU_LOG("ERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
}
}
memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
- DU_LOG("\nINFO --> F1AP : F1 Setup Response received");
+ DU_LOG("INFO --> 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("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
+ DU_LOG("ERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
f1SetRspMsg->protocolIEs.list.array[idx]->id);
}
}
if(fillE2NodeComponentRspInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_ADD, recvBufLen, recvBuf) !=ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to add the e2 node in the list");
+ DU_LOG("ERROR --> F1AP : Failed to add the e2 node in the list");
return RFAILED;
}
if(BuildAndSendE2SetupReq() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to build and send E2 setup request ");
+ DU_LOG("ERROR --> F1AP : Failed to build and send E2 setup request ");
return RFAILED;
}
return ret;
Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
- DU_LOG("\nINFO --> DU APP: GNB-DU config update Ack received ");
+ DU_LOG("INFO --> DU APP: GNB-DU config update Ack received ");
f1apPduNode = searchFromReservedF1apPduList(transId);
f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
ret = duSendCellDeletReq(cellId);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
+ DU_LOG("ERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
request for cellId[%lu]", cellId);
}
}
ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
+ DU_LOG("ERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
request for cellId[%lu]", cellId);
}
ueIdx++;
}
else
{
- DU_LOG("\nERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
+ DU_LOG("ERROR --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
ret = RFAILED;
}
break;
uint8_t ieIdx=0,transId=0;
GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
- DU_LOG("\nINFO --> F1AP : GNB-DU config update acknowledgment");
+ DU_LOG("INFO --> F1AP : GNB-DU config update acknowledgment");
gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
}
default :
{
- DU_LOG("\nERROR --> F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
+ DU_LOG("ERROR --> F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
gnbDuAck->protocolIEs.list.array[ieIdx]->id);
break;
}
if(fillE2NodeComponentRspInfo(F1,duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, recvBufLen, recvBuf) !=ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to update the e2 node in the list");
+ DU_LOG("ERROR --> F1AP : Failed to update the e2 node in the list");
return RFAILED;
}
F1DlRrcMsg dlMsg;
memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
- DU_LOG("\nINFO --> DU_APP : DL RRC message transfer Recevied");
+ DU_LOG("INFO --> DU_APP : DL RRC message transfer Recevied");
f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
ret = ROK;
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
+ DU_LOG("ERROR --> DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : RRC Container Size is invalid:%ld",\
+ DU_LOG("ERROR --> DU_APP : RRC Container Size is invalid:%ld",\
f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
return RFAILED;
}
break;
}
default:
- DU_LOG("\nERROR --> DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
+ DU_LOG("ERROR --> DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
f1DlRrcMsg->protocolIEs.list.array[idx]->id);
}
}
DU_ALLOC(srbList->list.array, srbList->list.size);
if(srbList->list.array == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in BuildSrbSetupModList");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in BuildSrbSetupModList");
return RFAILED;
}
DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
if(srbList->list.array[srbIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed in BuildSrbSetupModList");
+ DU_LOG("ERROR --> DU APP : Memory allocation failed in BuildSrbSetupModList");
return RFAILED;
}
}
DU_ALLOC(drbSet->list.array, drbSet->list.size);
if(drbSet->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
return RFAILED;
}
for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
if(drbSet->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
return RFAILED;
}
if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
&ueCfg->upTnlInfo[arrIdx])!= ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
+ DU_LOG("ERROR --> F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
return RFAILED;
}
DU_ALLOC(drbModList->list.array, drbModList->list.size);
if(drbModList->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbModList()");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbModList()");
return RFAILED;
}
DU_ALLOC(drbModList->list.array[drbIdx], sizeof(DRBs_Modified_ItemIEs_t));
if(drbModList->list.array[drbIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDrbModList");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed in BuildDrbModList");
return RFAILED;
}
if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Modified_Item.dLUPTNLInformation_ToBeSetup_List,\
&ueCfg->upTnlInfo[arrIdx])!= ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to fill DlTnl SetupList in BuildDrbModList");
+ DU_LOG("ERROR --> F1AP : Failed to fill DlTnl SetupList in BuildDrbModList");
return RFAILED;
}
drbIdx++;
asn_enc_rval_t encRetVal;
UEContextModificationResponse_t *ueContextModifyRes = NULLP;
- DU_LOG("\nINFO --> F1AP : Building UE context modification response\n");
+ DU_LOG("INFO --> F1AP : Building UE context modification response\n");
while(true)
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
break;
}
DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ DU_LOG("ERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
break;
}
f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
if(ueContextModifyRes->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
break;
}
DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
break;
}
}
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UE Context Modification Response\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for UE Context Modification Response\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
/* Sending msg */
if(sendF1APMsg() != ROK && (ret == ROK))
{
- DU_LOG("\nERROR --> F1AP : Sending UE Modification Res Failed");
+ DU_LOG("ERROR --> F1AP : Sending UE Modification Res Failed");
ret = RFAILED;
break;
}
}
if(duUeCb == NULLP)
{
- DU_LOG("\nERROR --> DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
+ DU_LOG("ERROR --> DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
ret = RFAILED;
}
break;
DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
if(!duUeCb->f1UeDb->dlRrcMsg)
{
- DU_LOG("\nERROR --> DU APP : procF1UeContextReleaseCommand(): \
+ DU_LOG("ERROR --> DU APP : procF1UeContextReleaseCommand(): \
Memory allocation failed ");
ret = RFAILED;
}
if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
&duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
{
- DU_LOG("\nERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
+ DU_LOG("ERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
ret = RFAILED;
}
}
if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
&duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->duRlcUeCfg))
{
- DU_LOG("\nERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
+ DU_LOG("ERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
ret = RFAILED;
}
}
if(extractDrbListToRelease(gnbDuUeF1apId, drbToRelease, drbToRelease->list.count,\
&duUeCb->f1UeDb->duUeCfg, &duUeCb->duRlcUeCfg))
{
- DU_LOG("\nERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
+ DU_LOG("ERROR --> DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
ret = RFAILED;
}
}
case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
{
- DU_LOG("\nINFO --> DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
+ DU_LOG("INFO --> DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
if(duUeCb->f1UeDb)
{
duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
F1AP_PDU_t *f1apMsg = NULLP;
UEContextReleaseRequest_t *ueReleaseReq = NULLP;
- DU_LOG("\nINFO --> Building the UE Context Release Request");
+ DU_LOG("INFO --> Building the UE Context Release Request");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
break;
}
DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
initiatingMessage");
break;
}
DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
if(ueReleaseReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
break;
}
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
sizeof(UEContextReleaseRequest_t));
if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
memAllocFail = true;
break;
}
GET_CELL_IDX(cellId, cellIdx);
if(duCb.actvCellLst[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
break;
}
else
GET_CRNTI(crnti, ueId);
if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
break;
}
gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
#ifdef DEBUG_ASN_PRINT
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending UE Context Release Request failed");
+ DU_LOG("ERROR --> F1AP : Sending UE Context Release Request failed");
break;
}
ret = ROK;
F1AP_PDU_t *f1apMsg = NULLP;
UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
- DU_LOG("\nINFO --> Building the UE Context Release Complete");
+ DU_LOG("INFO --> Building the UE Context Release Complete");
do
{
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
break;
}
DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
if(f1apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
successfulOutcome");
break;
}
DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
if(ueReleaseComplete->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
break;
}
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
sizeof(UEContextReleaseComplete_t));
if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
+ DU_LOG("ERROR --> F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
elements");
memAllocFail = true;
break;
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
+ DU_LOG("ERROR --> F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
+ DU_LOG("DEBUG --> F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
#ifdef DEBUG_ASN_PRINT
for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
{
/* Sending msg */
if(sendF1APMsg() != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending UE Context Release Complete failed");
+ DU_LOG("ERROR --> F1AP : Sending UE Context Release Complete failed");
break;
}
ret = ROK;
ret = duSendCellDeletReq(cellId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
+ DU_LOG("ERROR --> F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
Delete req for CellId");
}
}
break;
}
default :
- DU_LOG("\nERROR --> F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
+ DU_LOG("ERROR --> F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
break;
}
if(!ueIdxFound)
{
- DU_LOG("\nERROR --> F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
+ DU_LOG("ERROR --> F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
ret = RFAILED;
}
break;
DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
if(!duUeCb->f1UeDb->dlRrcMsg)
{
- DU_LOG("\nERROR --> DU APP : procF1UeContextReleaseCommand(): \
+ DU_LOG("ERROR --> DU APP : procF1UeContextReleaseCommand(): \
Memory allocation failed ");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : procF1UeContextReleaseCommand(): \
+ DU_LOG("ERROR --> DU APP : procF1UeContextReleaseCommand(): \
Memory allocation failed ");
ret = RFAILED;
break;
}
default :
- DU_LOG("\nERROR --> F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
+ DU_LOG("ERROR --> F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
break;
}
DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
if(tmpPagingParam == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Memory Allocation Failure in procPagingMsg");
+ DU_LOG("ERROR --> DU APP : Memory Allocation Failure in procPagingMsg");
freeAperDecodePagingMsg(paging);
return RFAILED;
}
bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
if(processPagingMsg(cellId, tmpPagingParam) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
+ DU_LOG("ERROR --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
continue;
}
}
}
default:
{
- DU_LOG("\nERROR --> F1AP : Incorrect Paging IE option");
+ DU_LOG("ERROR --> F1AP : Incorrect Paging IE option");
break;
}
}
F1AP_PDU_t *f1apMsg =NULLP;
asn_dec_rval_t rval; /* Decoder return value */
F1AP_PDU_t f1apasnmsg ;
- DU_LOG("\nINFO --> F1AP : Received F1AP message buffer");
+ DU_LOG("INFO --> F1AP : Received F1AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
if(recvBuf == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed");
+ DU_LOG("ERROR --> F1AP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed while copying %d", copyCnt);
+ DU_LOG("ERROR --> F1AP : Failed while copying %d", copyCnt);
return;
}
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> F1AP : ASN decode failed");
+ DU_LOG("ERROR --> F1AP : ASN decode failed");
return;
}
printf("\n");
{
case SuccessfulOutcome__value_PR_ResetAcknowledge:
{
- DU_LOG("\nINFO --> F1AP : F1ResetAcknowledge is received successfully ");
+ DU_LOG("INFO --> F1AP : F1ResetAcknowledge is received successfully ");
break;
}
case SuccessfulOutcome__value_PR_F1SetupResponse:
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
+ DU_LOG("ERROR --> F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
f1apMsg->choice.successfulOutcome->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
+ DU_LOG("ERROR --> F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
f1apMsg->choice.initiatingMessage->value.present);
return;
}
default:
{
- DU_LOG("\nERROR --> F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
+ DU_LOG("ERROR --> F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
return;
}
free(f1apMsg);
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : DU APP created and registered \
+ DU_LOG("INFO --> DU_APP : DU APP created and registered \
to %d sys task", sysTskId);
return ROK;
}
uint8_t setRrmPolicy(RrmPolicyList rrmPolicy[], uint8_t policyNum)
{
- DU_LOG("\nINFO --> DU_APP : DU APP RRM number of policy %d,", \
+ DU_LOG("INFO --> DU_APP : DU APP RRM number of policy %d,", \
policyNum);
for(uint8_t i=0; i<policyNum ; i++)
{
- DU_LOG("\nINFO --> DU_APP : DU APP id = %s",rrmPolicy[i].id);
- DU_LOG("\nINFO --> DU_APP : DU APP resourceType = %d", \
+ DU_LOG("INFO --> DU_APP : DU APP id = %s",rrmPolicy[i].id);
+ DU_LOG("INFO --> DU_APP : DU APP resourceType = %d", \
rrmPolicy[i].resourceType);
- DU_LOG("\nINFO --> DU_APP : DU APP rRMPolicyMaxRatio = %d", \
+ DU_LOG("INFO --> DU_APP : DU APP rRMPolicyMaxRatio = %d", \
rrmPolicy[i].rRMPolicyMaxRatio);
- DU_LOG("\nINFO --> DU_APP : DU APP rRMPolicyMinRatio = %d", \
+ DU_LOG("INFO --> DU_APP : DU APP rRMPolicyMinRatio = %d", \
rrmPolicy[i].rRMPolicyMinRatio);
- DU_LOG("\nINFO --> DU_APP : DU APP rRMPolicyDedicatedRatio = %d", \
+ DU_LOG("INFO --> DU_APP : DU APP rRMPolicyDedicatedRatio = %d", \
rrmPolicy[i].rRMPolicyDedicatedRatio);
- DU_LOG("\nINFO --> DU_APP : DU APP rRMMemberNum = %d", \
+ DU_LOG("INFO --> DU_APP : DU APP rRMMemberNum = %d", \
rrmPolicy[i].rRMMemberNum);
for(uint8_t j=0; j<rrmPolicy[i].rRMMemberNum ; j++)
{
- DU_LOG("\nINFO --> DU_APP : DU APP mcc = %d%d%d", \
+ DU_LOG("INFO --> DU_APP : DU APP mcc = %d%d%d", \
rrmPolicy[i].rRMPolicyMemberList[j].mcc[0], \
rrmPolicy[i].rRMPolicyMemberList[j].mcc[1], \
rrmPolicy[i].rRMPolicyMemberList[j].mcc[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP mnc = %d%d%d", \
+ DU_LOG("INFO --> DU_APP : DU APP mnc = %d%d%d", \
rrmPolicy[i].rRMPolicyMemberList[j].mnc[0], \
rrmPolicy[i].rRMPolicyMemberList[j].mnc[1], \
rrmPolicy[i].rRMPolicyMemberList[j].mnc[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP sd = %d%d%d", \
+ DU_LOG("INFO --> DU_APP : DU APP sd = %d%d%d", \
rrmPolicy[i].rRMPolicyMemberList[j].sd[0], \
rrmPolicy[i].rRMPolicyMemberList[j].sd[1], \
rrmPolicy[i].rRMPolicyMemberList[j].sd[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP sst = %d\n", \
+ DU_LOG("INFO --> DU_APP : DU APP sst = %d\n", \
rrmPolicy[i].rRMPolicyMemberList[j].sst);
}
uint8_t setCellParam()
{
//Read all the configs from smo edit-config into cellParams
- DU_LOG("\nO1 configurecell du_app enterd");
- DU_LOG("\nDU_APP configurecell cellLocalId value:%d",cellParams.cellLocalId);
- DU_LOG("\nDU_APP configurecell operationalState value:%d", \
+ DU_LOG("O1 configurecell du_app enterd");
+ DU_LOG("DU_APP configurecell cellLocalId value:%d",cellParams.cellLocalId);
+ DU_LOG("DU_APP configurecell operationalState value:%d", \
cellParams.operationalState);
- DU_LOG("\nDU_APP configurecell administrativeState value:%d", \
+ DU_LOG("DU_APP configurecell administrativeState value:%d", \
cellParams.administrativeState);
- DU_LOG("\nDU_APP configurecell cellState value:%d",cellParams.cellState);
- DU_LOG("\nDU_APP configurecell nRPCI value:%d",cellParams.nRPCI);
- DU_LOG("\nDU_APP configurecell nRTAC value:%d",cellParams.nRTAC);
- DU_LOG("\nDU_APP configurecell arfcnDL value:%d",cellParams.arfcnDL);
- DU_LOG("\nDU_APP configurecell arfcnUL value:%d",cellParams.arfcnUL);
- DU_LOG("\nDU_APP configurecell arfcnSUL value:%d",cellParams.arfcnSUL);
- DU_LOG("\nDU_APP configurecell ssbFrequency value:%d",cellParams.ssbFrequency);
- DU_LOG("\nDU_APP configurecell ssbPeriodicity value:%d", \
+ DU_LOG("DU_APP configurecell cellState value:%d",cellParams.cellState);
+ DU_LOG("DU_APP configurecell nRPCI value:%d",cellParams.nRPCI);
+ DU_LOG("DU_APP configurecell nRTAC value:%d",cellParams.nRTAC);
+ DU_LOG("DU_APP configurecell arfcnDL value:%d",cellParams.arfcnDL);
+ DU_LOG("DU_APP configurecell arfcnUL value:%d",cellParams.arfcnUL);
+ DU_LOG("DU_APP configurecell arfcnSUL value:%d",cellParams.arfcnSUL);
+ DU_LOG("DU_APP configurecell ssbFrequency value:%d",cellParams.ssbFrequency);
+ DU_LOG("DU_APP configurecell ssbPeriodicity value:%d", \
cellParams.ssbPeriodicity);
- DU_LOG("\nDU_APP configurecell ssbSubCarrierSpacing value:%d", \
+ DU_LOG("DU_APP configurecell ssbSubCarrierSpacing value:%d", \
cellParams.ssbSubCarrierSpacing);
- DU_LOG("\nDU_APP configurecell ssbOffset value:%d",cellParams.ssbOffset);
- DU_LOG("\nDU_APP configurecell ssbDuration value:%d",cellParams.ssbDuration);
- DU_LOG("\nDU_APP configurecell bSChannelBwUL value:%d", \
+ DU_LOG("DU_APP configurecell ssbOffset value:%d",cellParams.ssbOffset);
+ DU_LOG("DU_APP configurecell ssbDuration value:%d",cellParams.ssbDuration);
+ DU_LOG("DU_APP configurecell bSChannelBwUL value:%d", \
cellParams.bSChannelBwUL);
- DU_LOG("\nDU_APP configurecell bSChannelBwDL value:%d", \
+ DU_LOG("DU_APP configurecell bSChannelBwDL value:%d", \
cellParams.bSChannelBwDL);
- DU_LOG("\nDU_APP configurecell bSChannelBwSUL value:%d", \
+ DU_LOG("DU_APP configurecell bSChannelBwSUL value:%d", \
cellParams.bSChannelBwSUL);
for (int i=0 ; i<MAX_SUPPORTED_PLMN; i++)
{
- DU_LOG("\nINFO --> DU_APP : DU APP mcellParams.plmnList[%d].mcc = %d%d%d", i,\
+ DU_LOG("INFO --> DU_APP : DU APP mcellParams.plmnList[%d].mcc = %d%d%d", i,\
cellParams.plmnList[i].mcc[0], \
cellParams.plmnList[i].mcc[1], \
cellParams.plmnList[i].mcc[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP cellParams.plmnList[%d].mnc = %d%d%d", i,\
+ DU_LOG("INFO --> DU_APP : DU APP cellParams.plmnList[%d].mnc = %d%d%d", i,\
cellParams.plmnList[i].mnc[0], \
cellParams.plmnList[i].mnc[1], \
cellParams.plmnList[i].mnc[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP cellParams.plmnList[%d].sd = %d%d%d", i,\
+ DU_LOG("INFO --> DU_APP : DU APP cellParams.plmnList[%d].sd = %d%d%d", i,\
cellParams.plmnList[i].sd[0], \
cellParams.plmnList[i].sd[1], \
cellParams.plmnList[i].sd[2]);
- DU_LOG("\nINFO --> DU_APP : DU APP cellParams.plmnList[%d].sst = %d\n", i,\
+ DU_LOG("INFO --> DU_APP : DU APP cellParams.plmnList[%d].sst = %d\n", i,\
cellParams.plmnList[i].sst);
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : EGTP created and registered \
+ DU_LOG("INFO --> DU_APP : EGTP created and registered \
to %d sys task", sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : SCTP TAPA task created and registered to %d sys task",
+ DU_LOG("INFO --> DU_APP : SCTP TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
}
- DU_LOG("\nINFO --> DU_APP : SCH TAPA task created and registered to \
+ DU_LOG("INFO --> DU_APP : SCH TAPA task created and registered to \
%d sys task", sysTskId);
return ROK;
}
{
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : RLC UL TAPA task created and registered to \
+ DU_LOG("INFO --> DU_APP : RLC UL TAPA task created and registered to \
%d sys task", sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : LWR MAC TAPA task created and registered to %d sys task",
+ DU_LOG("INFO --> DU_APP : LWR MAC TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : PHY stub slot indication TAPA task created and registered to %d sys task",
+ DU_LOG("INFO --> DU_APP : PHY stub slot indication TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : UDP P7 TAPA task created and registered to %d sys task",
+ DU_LOG("INFO --> DU_APP : UDP P7 TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
return RFAILED;
}
- DU_LOG("\nINFO --> DU_APP : NFAPI P7 CLK TAPA task created and registered to %d sys task",
+ DU_LOG("INFO --> DU_APP : NFAPI P7 CLK TAPA task created and registered to %d sys task",
sysTskId);
return ROK;
}
/* system task for DU APP */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.duAppSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for DU APP failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for DU APP failed");
return RFAILED;
}
/* system task for EGTP */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.egtpSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for EGTP failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for EGTP failed");
return RFAILED;
}
/* system task for RLC_DL and MAC */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.rlcMacSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for RLC DL/MAC failed");
+ DU_LOG("ERROR --> 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, &duCfgParam.threadInfo.rlcUlSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for RLC UL failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for RLC UL failed");
return RFAILED;
}
/* system task for SCH */
if(ODU_CREATE_TASK(PRIOR1, &duCfgParam.threadInfo.schSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for SCH failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for SCH failed");
return RFAILED;
}
/* system task for SCTP receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.sctpSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for SCTP failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for SCTP failed");
return RFAILED;
}
/* system task for lower-mac receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.lwrMacSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for Lower MAC failed");
+ DU_LOG("ERROR --> DU_APP : System Task creation for Lower MAC failed");
return RFAILED;
}
/* system task for phy stub's slot indication generator thread */
if(ODU_CREATE_TASK(PRIOR0, &phyStubSlotIndSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for Phy stub slot indication generator failed. MAX STSK [%d]", SS_MAX_STSKS);
+ DU_LOG("ERROR --> DU_APP : System Task creation for Phy stub slot indication generator failed. MAX STSK [%d]", SS_MAX_STSKS);
return RFAILED;
}
#else
/* system task for UDP-P7 thread */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.udpP7STskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for UDP P7 Interface failed. MAX STSK [%d]", SS_MAX_STSKS);
+ DU_LOG("ERROR --> DU_APP : System Task creation for UDP P7 Interface failed. MAX STSK [%d]", SS_MAX_STSKS);
return RFAILED;
}
/* system task for NFAPI-P7-CLK thread */
if(ODU_CREATE_TASK(PRIOR0, &duCfgParam.threadInfo.nfapiP7ClkSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : System Task creation for NFAPI P7 CLK Interface failed. MAX STSK [%d]", SS_MAX_STSKS);
+ DU_LOG("ERROR --> DU_APP : System Task creation for NFAPI P7 CLK Interface failed. MAX STSK [%d]", SS_MAX_STSKS);
return RFAILED;
}
#endif
/* Create TAPA tasks */
if(duAppInit(duCfgParam.threadInfo.duAppSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : DU APP TAPA Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : DU APP TAPA Task initialization failed");
return RFAILED;
}
if(egtpInit(duCfgParam.threadInfo.egtpSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : EGTP TAPA Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : EGTP TAPA Task initialization failed");
return RFAILED;
}
if(sctpInit(duCfgParam.threadInfo.sctpSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : SCTP TAPA Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : SCTP TAPA Task initialization failed");
return RFAILED;
}
if(rlcDlInit(duCfgParam.threadInfo.rlcMacSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : RLC DL Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : RLC DL Tapa Task initialization failed");
return RFAILED;
}
if(rlcUlInit(duCfgParam.threadInfo.rlcUlSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : RLC UL Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : RLC UL Tapa Task initialization failed");
return RFAILED;
}
if(schInit(duCfgParam.threadInfo.schSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : SCH Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : SCH Tapa Task initialization failed");
return RFAILED;
}
if(lwrMacInit(duCfgParam.threadInfo.lwrMacSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Lower MAC Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : Lower MAC Tapa Task initialization failed");
return RFAILED;
}
#if !(defined(NFAPI_ENABLED) || defined (INTEL_WLS_MEM))
if(phyStubInit(phyStubSlotIndSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : PHY stub slot indication Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : PHY stub slot indication Tapa Task initialization failed");
return RFAILED;
}
#else
#ifdef NFAPI_ENABLED
if(udpP7Init(duCfgParam.threadInfo.udpP7STskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : UDP P7 Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : UDP P7 Tapa Task initialization failed");
return RFAILED;
}
if(nfapiP7ClkInit(duCfgParam.threadInfo.nfapiP7ClkSTskId) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : NFAPI P7 CLK Tapa Task initialization failed");
+ DU_LOG("ERROR --> DU_APP : NFAPI P7 CLK Tapa Task initialization failed");
return RFAILED;
}
#endif
break;
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
{
case EVTCFG:
{
- DU_LOG("\n****** Received initial configs at DU APP ******\n");
+ DU_LOG("****** Received initial configs at DU APP ******\n");
duProcCfgComplete();
ODU_PUT_MSG_BUF(mBuf);
break;
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTDUAPP");
+ DU_LOG("ERROR --> DU_APP : Invalid event received at duActvTsk from ENTDUAPP");
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
+ DU_LOG("ERROR --> DU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
pst->event);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTMAC");
+ DU_LOG("ERROR --> DU_APP : Invalid event received at duActvTsk from ENTMAC");
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event received at duActvTsk from ENTSCTP");
+ DU_LOG("ERROR --> DU_APP : Invalid event received at duActvTsk from ENTSCTP");
ret = RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
+ DU_LOG("ERROR --> DU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
ret = RFAILED;
}
}
#endif
default:
{
- DU_LOG("\nERROR --> DU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
+ DU_LOG("ERROR --> DU_APP : Invalid event[%d] received at duActvTsk from ENTEGTP", pst->event);
ret = RFAILED;
}
}
}
default:
{
- DU_LOG("\nERROR --> DU_APP : DU APP can not process message from Entity %d", pst->srcEnt);
+ DU_LOG("ERROR --> DU_APP : DU APP can not process message from Entity %d", pst->srcEnt);
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
}
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDEBUG --> DU_APP : RLC Gen Cfg Req sent for inst %d", inst);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
+ DU_LOG("DEBUG --> 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("\nERROR --> DU_APP : Memory Allocation failed in duProcCfgComplete");
+ DU_LOG("ERROR --> DU_APP : Memory Allocation failed in duProcCfgComplete");
ret = RFAILED;
}
else
{
if (pst->srcInst == RLC_DL_INST)
{
- DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL");
+ DU_LOG("DEBUG --> DU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL");
macCfgInst++;
if(macCfgInst < DEFAULT_CELLS)
{
}
else
{
- DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
+ DU_LOG("DEBUG --> DU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
macCfgInst++;
if(macCfgInst < DEFAULT_CELLS)
{
{
uint8_t ret;
- DU_LOG("\nDEBUG --> DU_APP : RLC UL Cfg Status %d", cfm->cfm.status);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> 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("\nERROR --> DU_APP : Config confirm NOK from RLC UL");
+ DU_LOG("ERROR --> DU_APP : Config confirm NOK from RLC UL");
ret = RFAILED;
}
return ret;
***************************************************************************/
uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm)
{
- DU_LOG("\nDEBUG --> DU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> 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("\nERROR --> DU_APP : Config confirm NOK from RLC DL");
+ DU_LOG("ERROR --> DU_APP : Config confirm NOK from RLC DL");
}
return ROK;
}
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- DU_LOG("\nDEBUG --> DU_APP : MAC Gen Cfg Req sent");
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : MAC Rgu USap Cfg Req sent");
+ DU_LOG("DEBUG --> DU_APP : MAC Rgu USap Cfg Req sent");
/* Send the request to MAC */
cmPkLrgCfgReq(&pst, &rgMngmt);
default:
break;
}
- DU_LOG("\nDEBUG --> DU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : Completed sending Configs");
+ DU_LOG("DEBUG --> DU_APP : Completed sending Configs");
macCfgInst = 0;
duBindUnbindRlcToMacSap(RLC_DL_INST, ABND);
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : Config confirm NOK from MAC");
+ DU_LOG("ERROR --> DU_APP : Config confirm NOK from MAC");
ret = RFAILED;
}
return ret;
if (action == ABND)
{
- DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst);
+ DU_LOG("DEBUG --> DU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst);
}
else
{
- DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
+ DU_LOG("DEBUG --> DU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
}
cntrl = &(rlcMngmt.t.cntrl);
}
else
{
- DU_LOG("\nERROR --> DU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
+ DU_LOG("ERROR --> DU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
return RFAILED;
}
return ROK;
Pst pst;
EgtpConfig egtpCfg;
- DU_LOG("\nDEBUG --> DU_APP : Sending EGTP config request");
+ DU_LOG("DEBUG --> 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("\nDEBUG --> DU_APP : EGTP configuraton complete");
+ DU_LOG("DEBUG --> DU_APP : EGTP configuraton complete");
duSendEgtpSrvOpenReq();
}
else
{
- DU_LOG("\nERROR --> DU_APP : EGTP configuraton failed");
+ DU_LOG("ERROR --> DU_APP : EGTP configuraton failed");
ret = RFAILED;
}
{
Pst pst;
- DU_LOG("\nDEBUG --> DU_APP : Sending EGTP server open request");
+ DU_LOG("DEBUG --> DU_APP : Sending EGTP server open request");
duFillEgtpPst(&pst, EVTSRVOPENREQ);
packEgtpSrvOpenReq(&pst);
if(cfm.status == LCM_PRIM_OK)
{
- DU_LOG("\nDEBUG --> DU_APP : EGTP server opened successfully");
+ DU_LOG("DEBUG --> DU_APP : EGTP server opened successfully");
}
else
{
- DU_LOG("\nERROR --> DU_APP : EGTP server opening failed");
+ DU_LOG("ERROR --> DU_APP : EGTP server opening failed");
ret = RFAILED;
}
Pst pst;
EgtpTnlEvt tnlEvt;
- DU_LOG("\nDEBUG --> DU_APP : Sending EGTP tunnel management request for teId [%d]", ueCbTnlCfg->teId);
+ DU_LOG("DEBUG --> DU_APP : Sending EGTP tunnel management request for teId [%d]", ueCbTnlCfg->teId);
/* ADD/MOD/DEL per tunnel */
tnlEvt.action = action;
if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
{
- DU_LOG("\nDEBUG --> DU_APP: Tunnel management confirm OK");
+ DU_LOG("DEBUG --> DU_APP: Tunnel management confirm OK");
}
else
{
- DU_LOG("\nERROR --> DU_APP: Tunnel management failed");
+ DU_LOG("ERROR --> DU_APP: Tunnel management failed");
ret = RFAILED;
}
pst.region = duCb.init.region;
pst.event = (Event) EVTMACSCHGENCFGREQ;
- DU_LOG("\nDEBUG --> DU_APP : MAC Sch Cfg sent");
+ DU_LOG("DEBUG --> DU_APP : MAC Sch Cfg sent");
/* Send the request to MAC */
cmPkLrgSchCfgReq(&pst, &rgMngmt);
{
uint8_t ret = ROK;
- DU_LOG("\nINFO --> DU_APP : Configuring all Layer is complete");
+ DU_LOG("INFO --> DU_APP : Configuring all Layer is complete");
if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed configuring Sctp Params");
+ DU_LOG("ERROR --> DU_APP : Failed configuring Sctp Params");
ret = RFAILED;
}
if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq F1");
+ DU_LOG("ERROR --> DU_APP : Failed to send AssocReq F1");
ret = RFAILED;
}
if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq E2");
+ DU_LOG("ERROR --> DU_APP : Failed to send AssocReq E2");
ret = RFAILED;
}
#ifdef NFAPI_ENABLED
if((ret = duSctpAssocReq(PNF_P5_INTERFACE)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq PNF P5");
+ DU_LOG("ERROR --> DU_APP : Failed to send AssocReq PNF P5");
ret = RFAILED;
}
#endif
{
case STSCHINST:
{
- DU_LOG("\nDEBUG --> DU_APP : Received SCH CFG CFM at DU APP");
+ DU_LOG("DEBUG --> 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("\nERROR --> DU_APP : Mac cell cfg failed");
+ DU_LOG("ERROR --> DU_APP : Mac cell cfg failed");
ret = RFAILED;
}
return ret;
Pst pst;
CellStartInfo *cellStart = NULL;
- DU_LOG("\nINFO --> DU APP : Building and Sending cell start request to MAC");
+ DU_LOG("INFO --> DU APP : Building and Sending cell start request to MAC");
/* Send Cell Start Request to MAC */
DU_ALLOC_SHRABL_BUF(cellStart, sizeof(CellStartInfo));
if(!cellStart)
{
- DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request");
+ DU_LOG("ERROR --> DU APP : Memory alloc failed while building cell start request");
return RFAILED;
}
uint16_t cellIdx=0;
CellStopInfo *cellStop = NULL;
- DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC");
+ DU_LOG("INFO --> DU APP : Building and Sending cell stop request to MAC");
GET_CELL_IDX(cellId, cellIdx);
if(duCb.actvCellLst[cellIdx] != NULLP)
DU_ALLOC_SHRABL_BUF(cellStop, sizeof(CellStopInfo));
if(!cellStop)
{
- DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request");
+ DU_LOG("ERROR --> DU APP : Memory alloc failed while building cell stop request");
return RFAILED;
}
memset(cellStop, 0, sizeof(CellStopInfo));
}
else
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): cellId[%d] doesnot exists", cellId);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendMacCellStop(): cellId[%d] doesnot exists", cellId);
return RFAILED;
}
return ROK;
if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
{
- DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
+ DU_LOG("ERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
}
if(duGetCellCb(cellId->cellId, &cellCb) != ROK)
if((cellCb->cellStatus == ACTIVATED) || (cellCb->cellStatus == DELETION_IN_PROGRESS))
{
- DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
+ DU_LOG("INFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
if(sendCellDeleteReqToMac(cellId->cellId) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duHandleStopInd(): Failed to send Cell delete req to MAC for\
+ DU_LOG("ERROR --> DU APP : duHandleStopInd(): Failed to send Cell delete req to MAC for\
cellId[%d]", cellId->cellId);
return RFAILED;
}
#ifdef O1_ENABLE
- DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
+ DU_LOG("INFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
raiseCellAlrm(CELL_DOWN_ALARM_ID, cellId->cellId);
setCellOpState(cellId->cellId, DISABLED, INACTIVE);
#endif
uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
{
- DU_LOG("\nINFO --> DU APP : UL CCCH Indication received");
+ DU_LOG("INFO --> DU APP : UL CCCH Indication received");
return (duProcUlCcchInd(ulCcchIndInfo));
}
memset(&ueCb->cfraResource, 0, sizeof(MacCfraResource));
if(duBuildAndSendRachRsrcRelToMac(ulRrcMsgInfo->cellId, ueCb) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to send RACH resource release to MAC");
+ DU_LOG("ERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to send RACH resource release to MAC");
}
}
if(BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, ulRrcMsgInfo->rrcMsg) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to build and send UL RRC Message Transfer");
+ DU_LOG("ERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to build and send UL RRC Message Transfer");
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : UE ID [%d] not found", ulRrcMsgInfo->ueId);
+ DU_LOG("ERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : UE ID [%d] not found", ulRrcMsgInfo->ueId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Invalid UE ID [%d]", ulRrcMsgInfo->ueId);
+ DU_LOG("ERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Invalid UE ID [%d]", ulRrcMsgInfo->ueId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Cell ID [%d] not found", ulRrcMsgInfo->cellId);
+ DU_LOG("ERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Cell ID [%d] not found", ulRrcMsgInfo->cellId);
ret = RFAILED;
}
EgtpMsg egtpMsg;
Buffer *mBuf;
- DU_LOG("\nDEBUG --> DU APP : Received UL user data");
+ DU_LOG("DEBUG --> DU APP : Received UL user data");
/* Fill EGTP header */
egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
if (ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans");
+ DU_LOG("ERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans");
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
return RFAILED;
if(cfgRsp->rsp == MAC_DU_APP_RSP_OK)
{
duCb.sliceState = SLICE_CONFIGURED;
- DU_LOG("\nINFO --> DU_APP : Slice configured successfully ");
+ DU_LOG("INFO --> DU_APP : Slice configured successfully ");
}
else
{
- DU_LOG("\nERROR --> DU_APP : Slice not available");
+ DU_LOG("ERROR --> DU_APP : Slice not available");
}
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp));
}
DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq));
if(sliceCfgReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq");
return RFAILED;
}
else
memcpy(sliceCfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceCfgReq));
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ);
- DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP : Sending Slice Cfg Request to MAC ");
if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send Slice Cfg Req to MAC");
+ DU_LOG("ERROR --> DU_APP : Failed to send Slice Cfg Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceCfgReq, sizeof(MacSliceCfgReq));
}
}
Pst pst;
MacSliceRecfgReq *sliceRecfgReq = NULLP;
- DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received");
+ DU_LOG("INFO --> DU_APP : Slice ReConfiguration Request received");
DU_ALLOC_SHRABL_BUF(sliceRecfgReq, sizeof(MacSliceRecfgReq));
if(sliceRecfgReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq");
return RFAILED;
}
else
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ);
- DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending Slice ReCfg Request to MAC ");
if( (*packMacSliceRecfgReqOpts[pst.selector])(&pst, sliceRecfgReq) == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC");
+ DU_LOG("ERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceRecfgReq, sizeof(MacSliceRecfgReq));
}
}
if(recfgRsp->rsp == MAC_DU_APP_RSP_OK)
{
duCb.sliceState = SLICE_RECONFIGURED;
- DU_LOG("\nINFO --> DU_APP : Slice Reconfigured successfully ");
+ DU_LOG("INFO --> DU_APP : Slice Reconfigured successfully ");
}
else
{
- DU_LOG("\nERROR --> DU_APP : Slice not available");
+ DU_LOG("ERROR --> DU_APP : Slice not available");
}
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, recfgRsp, sizeof(MacSliceCfgRsp));
}
{
uint8_t sliceRecord = 0;
- DU_LOG("\nDEBUG --> DU APP : Received Slice Metrics");
+ DU_LOG("DEBUG --> DU APP : Received Slice Metrics");
if(sliceStats == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Empty Metrics");
+ DU_LOG("ERROR --> DU APP : Empty Metrics");
return RFAILED;
}
for(sliceRecord = 0; sliceRecord < sliceStats->numSlice; sliceRecord++)
{
- DU_LOG("\nINFO --> DU_APP: SliceId[SST-SD]:%d-%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sst,\
+ DU_LOG("INFO --> DU_APP: SliceId[SST-SD]:%d-%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sst,\
sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sd,sliceStats->sliceRecord[sliceRecord].ThpDl,\
sliceStats->sliceRecord[sliceRecord].ThpUl);
}
DU_ALLOC_SHRABL_BUF(macStatsReq, sizeof(MacStatsReq));
if(macStatsReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsReq in BuildAndSendStatsReqToMac");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed for macStatsReq in BuildAndSendStatsReqToMac");
return RFAILED;
}
/* Fill E2 Subscription Info in MAC Statistics Request and send to MAC */
if(fillRicSubsInMacStatsReq(macStatsReq, ricSubscriptionInfo) == ROK)
{
- DU_LOG("\nDEBUG --> DU_APP: Sending Statistics Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending Statistics Request to MAC ");
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATISTICS_REQ);
if( (*packMacStatsReqOpts[pst.selector])(&pst, macStatsReq) == ROK)
return ROK;
- DU_LOG("\nERROR --> DU_APP: Failed to send Statistics Request to MAC");
+ DU_LOG("ERROR --> DU_APP: Failed to send Statistics Request to MAC");
}
- DU_LOG("\nERROR --> DU_APP: No Statistics group found valid. Hence statistics request is not sent to MAC");
+ DU_LOG("ERROR --> DU_APP: No Statistics group found valid. Hence statistics request is not sent to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsReq, sizeof(MacStatsReq));
return RFAILED;
}
/* Build and sent subscription information to MAC in Statistics Request */
if(BuildAndSendStatsReqToMac(ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToMac()");
+ DU_LOG("ERROR --> DU_APP : Failed at BuildAndSendStatsReqToMac()");
return RFAILED;
}
#if 0
if(BuildAndSendStatsReqToRlc() != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToRlc()");
+ DU_LOG("ERROR --> DU_APP : Failed at BuildAndSendStatsReqToRlc()");
return RFAILED;
}
#endif
uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp)
{
uint8_t ret = RFAILED;
- DU_LOG("\nINFO --> DU_APP : DuProcMacStatsRsp: Received Statistics Response from MAC");
+ DU_LOG("INFO --> DU_APP : DuProcMacStatsRsp: Received Statistics Response from MAC");
if(statsRsp)
{
#ifdef DEBUG_PRINT
uint8_t idx = 0;
- DU_LOG("\n Subscription Id [%ld]", statsRsp->subscriptionId);
+ DU_LOG(" Subscription Id [%ld]", statsRsp->subscriptionId);
- DU_LOG("\n Number of Accepted Groups [%d]", statsRsp->numGrpAccepted);
+ DU_LOG(" Number of Accepted Groups [%d]", statsRsp->numGrpAccepted);
for(idx=0; idx<statsRsp->numGrpAccepted; idx++)
{
- DU_LOG("\n Group Id [%d]", statsRsp->statsGrpAcceptedList[idx]);
+ DU_LOG(" Group Id [%d]", statsRsp->statsGrpAcceptedList[idx]);
}
- DU_LOG("\n Number of Rejected Groups [%d]", statsRsp->numGrpRejected);
+ DU_LOG(" Number of Rejected Groups [%d]", statsRsp->numGrpRejected);
for(idx=0; idx<statsRsp->numGrpRejected; idx++)
{
- DU_LOG("\n Group Id [%d]", statsRsp->statsGrpRejectedList[idx].groupId);
+ DU_LOG(" Group Id [%d]", statsRsp->statsGrpRejectedList[idx].groupId);
}
#endif
* Ric subscription response/failure accordingly */
if((ret = e2ProcStatsRsp(statsRsp)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : DuProcMacStatsRsp: Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP : DuProcMacStatsRsp: Failed in %s at line %d", __func__, __LINE__);
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp));
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcMacStatsRsp: Received NULL Pointer");
+ DU_LOG("ERROR --> DU_APP : DuProcMacStatsRsp: Received NULL Pointer");
}
return ret;
}
if(statsInd)
{
#ifdef DEBUG_PRINT
- DU_LOG("\nDEBUG --> DU_APP : DuProcMacStatsInd: Received Statistics Indication");
- DU_LOG("\n Subscription Id [%ld]", statsInd->subscriptionId);
- DU_LOG("\n Group Id [%d]", statsInd->groupId);
+ DU_LOG("DEBUG --> DU_APP : DuProcMacStatsInd: Received Statistics Indication");
+ DU_LOG(" Subscription Id [%ld]", statsInd->subscriptionId);
+ DU_LOG(" Group Id [%d]", statsInd->groupId);
for(int idx = 0; idx < statsInd->numStats; idx++)
{
- DU_LOG("\n Meas type [%d] Meas Value [%lf]", statsInd->measuredStatsList[idx].type,\
+ DU_LOG(" Meas type [%d] Meas Value [%lf]", statsInd->measuredStatsList[idx].type,\
statsInd->measuredStatsList[idx].value);
}
#endif
/* Extract statistics from statistics indication message and store in E2 DB */
if((ret = e2ProcStatsInd(statsInd)) != ROK)
{
- DU_LOG("\nINFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("INFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
}
/* Free statistics indication */
}
else
{
- DU_LOG("\nINFO --> DU_APP : DuProcMacStatsInd: Received NULL Pointer");
+ DU_LOG("INFO --> DU_APP : DuProcMacStatsInd: Received NULL Pointer");
}
return ret;
}
uint8_t DuProcMacStatsDeleteRsp(Pst *pst, MacStatsDeleteRsp *statsDeleteRsp)
{
uint8_t ret = RFAILED;
- DU_LOG("\nINFO --> DU_APP : DuProcMacStatsDeleteRsp: Received Statistics Response from MAC");
+ DU_LOG("INFO --> DU_APP : DuProcMacStatsDeleteRsp: Received Statistics Response from MAC");
if(statsDeleteRsp)
{
{
if((ret = e2ProcStatsDeleteRsp(statsDeleteRsp)) != ROK)
{
- DU_LOG("\nINFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("INFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
}
}
else
{
if((ret = e2ProcActionDeleteRsp(statsDeleteRsp)) != ROK)
{
- DU_LOG("\nINFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("INFO --> DU_APP : Failed in %s at line %d", __func__, __LINE__);
}
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsDeleteRsp, sizeof(MacStatsDeleteRsp));
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcMacStatsDeleteRsp: Received NULL Pointer");
+ DU_LOG("ERROR --> DU_APP : DuProcMacStatsDeleteRsp: Received NULL Pointer");
}
return ret;
}
DU_ALLOC_SHRABL_BUF(macStatsDelete, sizeof(MacStatsDeleteReq));
if(macStatsDelete == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsDelete in BuildAndSendStatsDeleteReqToMac");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed for macStatsDelete in BuildAndSendStatsDeleteReqToMac");
failureCause.causeType = E2_MISCELLANEOUS;
failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
if(BuildAndSendRicSubscriptionDeleteFailure(ricSubscriptionInfo->ranFuncId, ricSubscriptionInfo->requestId, failureCause) != ROK)
{
- DU_LOG("\nERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete failure");
+ DU_LOG("ERROR --> E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete failure");
return RFAILED;
}
return RFAILED;
macStatsDelete->numStatsGroupToBeDeleted=actionIdx;
}
- DU_LOG("\nDEBUG --> DU_APP: Sending Statistics delete req to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending Statistics delete req to MAC ");
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATS_DELETE_REQ);
if( (*packMacStatsDeleteReqOpts[pst.selector])(&pst, macStatsDelete) != ROK)
{
- DU_LOG("\nERROR --> DU_APP: Failed to send Statistics delete req to MAC");
+ DU_LOG("ERROR --> DU_APP: Failed to send Statistics delete req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsDelete, sizeof(MacStatsDeleteReq));
return RFAILED;
}
/* Build and sent subscription information to MAC in Statistics delete */
if(BuildAndSendStatsDeleteReqToMac(ricSubscriptionInfo, deleteAllStats) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsDeleteReqToMac()");
+ DU_LOG("ERROR --> DU_APP : Failed at BuildAndSendStatsDeleteReqToMac()");
return RFAILED;
}
return ROK;
DU_ALLOC_SHRABL_BUF(macStatsModificationReq, sizeof(MacStatsModificationReq));
if(macStatsModificationReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsModificationReq in BuildAndSendStatsModificationReqToMac");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed for macStatsModificationReq in BuildAndSendStatsModificationReqToMac");
return RFAILED;
}
/* Fill E2 Subscription Info in MAC Statistics Modification Request and send to MAC */
if(fillRicSubsInMacStatsModificationReq(macStatsModificationReq, ricSubscriptionInfo) == ROK)
{
- DU_LOG("\nDEBUG --> DU_APP: Sending Statistics Modification Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending Statistics Modification Request to MAC ");
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATISTICS_MODIFY_REQ);
if( (*packMacStatsModificationReqOpts[pst.selector])(&pst, macStatsModificationReq) == ROK)
return ROK;
- DU_LOG("\nERROR --> DU_APP: Failed to send Statistics Modification Request to MAC");
+ DU_LOG("ERROR --> DU_APP: Failed to send Statistics Modification Request to MAC");
}
- DU_LOG("\nERROR --> DU_APP: No Statistics group found valid. Hence statistics Modification request is not sent to MAC");
+ DU_LOG("ERROR --> DU_APP: No Statistics group found valid. Hence statistics Modification request is not sent to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsModificationReq, sizeof(MacStatsModificationReq));
return RFAILED;
}
/* Build and sent subscription information to MAC in Statistics Modification Request */
if(BuildAndSendStatsModificationReqToMac(ricSubscriptionInfo) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsModificationReqToMac()");
+ DU_LOG("ERROR --> DU_APP : Failed at BuildAndSendStatsModificationReqToMac()");
return RFAILED;
}
uint8_t DuProcMacStatsModificationRsp(Pst *pst, MacStatsModificationRsp *statsModificationRsp)
{
uint8_t ret = RFAILED;
- DU_LOG("\nINFO --> DU_APP : DuProcMacStatsModificationRsp: Received Statistics Modification Response from MAC");
+ DU_LOG("INFO --> DU_APP : DuProcMacStatsModificationRsp: Received Statistics Modification Response from MAC");
if(statsModificationRsp)
{
#ifdef DEBUG_PRINT
uint8_t idx = 0;
- DU_LOG("\n Subscription Id [%ld]", statsModificationRsp->subscriptionId);
+ DU_LOG(" Subscription Id [%ld]", statsModificationRsp->subscriptionId);
- DU_LOG("\n Number of Accepted Groups [%d]", statsModificationRsp->numGrpAccepted);
+ DU_LOG(" Number of Accepted Groups [%d]", statsModificationRsp->numGrpAccepted);
for(idx=0; idx<statsModificationRsp->numGrpAccepted; idx++)
{
- DU_LOG("\n Group Id [%d]", statsModificationRsp->statsGrpAcceptedList[idx]);
+ DU_LOG(" Group Id [%d]", statsModificationRsp->statsGrpAcceptedList[idx]);
}
- DU_LOG("\n Number of Rejected Groups [%d]", statsModificationRsp->numGrpRejected);
+ DU_LOG(" Number of Rejected Groups [%d]", statsModificationRsp->numGrpRejected);
for(idx=0; idx<statsModificationRsp->numGrpRejected; idx++)
{
- DU_LOG("\n Group Id [%d]", statsModificationRsp->statsGrpRejectedList[idx].groupId);
+ DU_LOG(" Group Id [%d]", statsModificationRsp->statsGrpRejectedList[idx].groupId);
}
#endif
if((ret = e2ProcStatsModificationRsp(statsModificationRsp)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : DuProcMacStatsModificationRsp: Failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> DU_APP : DuProcMacStatsModificationRsp: Failed in %s at line %d", __func__, __LINE__);
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsModificationRsp, sizeof(MacStatsModificationRsp));
}
else
{
- DU_LOG("\nERROR --> DU_APP : DuProcMacStatsModificationRsp: Received NULL Pointer");
+ DU_LOG("ERROR --> DU_APP : DuProcMacStatsModificationRsp: Received NULL Pointer");
}
return ret;
}
DU_ALLOC_SHRABL_BUF(p7UdpCfg, sizeof(NfapiP7UdpCfg));
if(p7UdpCfg == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendNfapiP7UdpConfig");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed in BuildAndSendNfapiP7UdpConfig");
return RFAILED;
}
else
memcpy(p7UdpCfg, &duCfgParam.tempNFapiP7UdpCfg, sizeof(NfapiP7UdpCfg));
FILL_PST_DUAPP_TO_NFAPIUDPP7(pst, EVENT_NFAPI_P7_UDP_CFG);
- DU_LOG("\nDEBUG --> DU_APP : Sending NFAPI P7 UDP Cfg to NFAPI P7 (VNF)");
+ DU_LOG("DEBUG --> DU_APP : Sending NFAPI P7 UDP Cfg to NFAPI P7 (VNF)");
if((*packNfapiP7UdpCfgOpts[pst.selector])(&pst, p7UdpCfg) == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send NFAPI P7 UDP Cfg to NFAPI P7");
+ DU_LOG("ERROR --> DU_APP : Failed to send NFAPI P7 UDP Cfg to NFAPI P7");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, p7UdpCfg, sizeof(NfapiP7UdpCfg));
return RFAILED;
}
***************************************************************************/
uint8_t sctpActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
- DU_LOG("\n\nDEBUG --> SCTP : Initializing");
+ DU_LOG("DEBUG --> SCTP : Initializing");
ODU_SET_PROC_ID(DU_PROC);
connUp = FALSE;
break;
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
/**************************************************************************
uint8_t ret = ROK;
if(cfm->status != LCM_PRIM_OK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to process the request successfully");
+ DU_LOG("ERROR --> DU_APP : Failed to process the request successfully");
ret = RFAILED;
}
return (ret);
CmStatus cfm;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_CFG_REQ_TO_SCTP\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTSCTP : EVENT_CFG_REQ_TO_SCTP\n");
#endif
/* Fill F1 Params */
f1Params.destIpAddr.ipV4Pres = sctpCfg.cuIpAddr.ipV4Pres;
if((ret = cmInetSocket(socket_type, ¶mPtr->sockFd, IPPROTO_SCTP)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed while opening a socket in ODU");
+ DU_LOG("ERROR --> SCTP : Failed while opening a socket in ODU");
}
else if((ret = cmInetSctpBindx(¶mPtr->sockFd, &localAddrLst, paramPtr->srcPort)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Failed during Binding in ODU");
+ DU_LOG("ERROR --> SCTP: Failed during Binding in ODU");
}
else if((ret = sctpSetSockOpts(¶mPtr->sockFd)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to set Socket Opt in ODU");
+ DU_LOG("ERROR --> SCTP : Failed to set Socket Opt in ODU");
}
else
{
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed while establishing Req at DU");
+ DU_LOG("ERROR --> SCTP : Failed while establishing Req at DU");
ret = RFAILED;
}
else
DuSctpDestCb *paramPtr = NULLP;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_ASSOC_REQ_TO_SCTP\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTSCTP : EVENT_ASSOC_REQ_TO_SCTP\n");
#endif
DU_ALLOC(paramPtr, sizeof(DuSctpDestCb));
if(paramPtr == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
switch(itfType)
#endif
default:
{
- DU_LOG("\nERROR --> SCTP : Invalid Interface Type %d", itfType);
+ DU_LOG("ERROR --> SCTP : Invalid Interface Type %d", itfType);
break;
}
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : ASSOC Req Failed.");
+ DU_LOG("ERROR --> 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)
{
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP : Failed to allocate memory");
return RFAILED;
}
memset(pst, 0, sizeof(Pst));
void sendToDuApp(Buffer *mBuf, Event event)
{
Pst pst;
- DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp");
+ DU_LOG("DEBUG --> SCTP : Forwarding received message to duApp");
ODU_PRINT_MSG(mBuf, 0, 0);
if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nERROR --> SCTP : ODU_POST_TASK failed in sendToDuApp");
+ DU_LOG("ERROR --> SCTP : ODU_POST_TASK failed in sendToDuApp");
}
}
void sendToLwrMac(Buffer *mBuf, Event event)
{
Pst pst;
- DU_LOG("\nDEBUG --> SCTP : Forwarding received message to Lwr MAC");
+ DU_LOG("DEBUG --> SCTP : Forwarding received message to Lwr MAC");
memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nERROR --> SCTP : ODU_POST_TASK failed in sendToLwrMac");
+ DU_LOG("ERROR --> SCTP : ODU_POST_TASK failed in sendToLwrMac");
}
}
#endif
switch(ntfy->header.nType)
{
case CM_INET_SCTP_ASSOC_CHANGE :
- DU_LOG("\nDEBUG --> SCTP : Assoc change notification received");
+ DU_LOG("DEBUG --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
*itfState = DU_SCTP_DOWN;
break;
default:
- DU_LOG("\nERROR --> Invalid event %d", ntfy->u.assocChange.state);
+ DU_LOG("ERROR --> Invalid event %d", ntfy->u.assocChange.state);
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
+ DU_LOG("INFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nINFO --> SCTP : Remote Error notification received");
+ DU_LOG("INFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
+ DU_LOG("INFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
{
- DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n");
+ DU_LOG("INFO --> SCTP : Shutdown Event notification received\n");
*itfState = DU_SCTP_DOWN;
switch(interface)
{
break;
}
case CM_INET_SCTP_ADAPTATION_INDICATION :
- DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
+ DU_LOG("INFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
+ DU_LOG("INFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nERROR --> SCTP : Invalid sctp notification type %d", ntfy->header.nType);
+ DU_LOG("ERROR --> SCTP : Invalid sctp notification type %d", ntfy->header.nType);
break;
}
if(interface == PNF_P5_INTERFACE)
{
/*TODO: Need to check if SCTP Notification for this interface has to be handled*/
- DU_LOG("\nDEBUG --> SCTP : SCTP Notification received for PNF_P5 Interface");
+ DU_LOG("DEBUG --> SCTP : SCTP Notification received for PNF_P5 Interface");
return ROK;
}
else
#endif
{
/* Pack notification and send to APP */
- DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp");
+ DU_LOG("DEBUG --> SCTP : Forwarding received message to duApp");
memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
if(cmPkSctpNtfy(&pst, ntfy) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to pack SCTP notification");
+ DU_LOG("ERROR --> SCTP : Failed to pack SCTP notification");
return RFAILED;
}
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP: Failed to receive sctp msg for sockFd[%d]\n", sockFd->fd);
+ DU_LOG("ERROR --> SCTP: Failed to receive sctp msg for sockFd[%d]\n", sockFd->fd);
}
else
{
#ifdef CALL_FLOW_DEBUG_LOG
if(pollParams->port == f1Params.destPort)
- DU_LOG("\nCall Flow: CU -> ENTSCTP : EVENT_SCTP_MSG\n");
+ DU_LOG("Call Flow: CU -> ENTSCTP : EVENT_SCTP_MSG\n");
else
- DU_LOG("\nCall Flow: RIC -> ENTSCTP : EVENT_SCTP_MSG\n");
+ DU_LOG("Call Flow: RIC -> ENTSCTP : EVENT_SCTP_MSG\n");
#endif
if((((pollParams->flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0)) && ret == ROK)
{
if(pollParams->port == f1Params.destPort)
{
f1Params.assocId = pollParams->ntfy.u.assocChange.assocId;
- DU_LOG("\nDEBUG --> SCTP : AssocId assigned to F1Params from PollParams [%d]\n", f1Params.assocId);
+ DU_LOG("DEBUG --> SCTP : AssocId assigned to F1Params from PollParams [%d]\n", f1Params.assocId);
ret = sctpNtfyHdlr(&pollParams->ntfy, &f1Params.itfState, F1_INTERFACE);
}
else if(pollParams->port == ricParams.destPort)
{
ricParams.assocId = pollParams->ntfy.u.assocChange.assocId;
- DU_LOG("\nDEBUG --> SCTP : AssocId assigned to ricParams from PollParams [%d]\n", ricParams.assocId);
+ DU_LOG("DEBUG --> SCTP : AssocId assigned to ricParams from PollParams [%d]\n", ricParams.assocId);
ret = sctpNtfyHdlr(&pollParams->ntfy, &ricParams.itfState, E2_INTERFACE);
}
#ifdef NFAPI_ENABLED
else if(pollParams->port == pnfP5Params.destPort)
{
pnfP5Params.assocId = pollParams->ntfy.u.assocChange.assocId;
- DU_LOG("\nDEBUG --> SCTP : AssocId assigned to PNF_P5 Params from PollParams [%d]\n", pnfP5Params.assocId);
+ DU_LOG("DEBUG --> SCTP : AssocId assigned to PNF_P5 Params from PollParams [%d]\n", pnfP5Params.assocId);
ret = sctpNtfyHdlr(&pollParams->ntfy, &pnfP5Params.itfState, PNF_P5_INTERFACE);
}
#endif
else
{
- DU_LOG("\nERROR --> SCTP : Failed to fill AssocId\n");
+ DU_LOG("ERROR --> SCTP : Failed to fill AssocId\n");
return RFAILED;
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
+ DU_LOG("ERROR --> SCTP : Failed to process sctp notify msg\n");
}
}
else if(f1Params.itfState & (pollParams->port == f1Params.destPort))
CM_INET_FD_ZERO(&pnfP5PollParams.readFd);
#endif
- DU_LOG("\nINFO --> SCTP : Polling started at DU\n");
+ DU_LOG("INFO --> SCTP : Polling started at DU\n");
while(true)
{
if(f1Params.itfState)
{
if((ret = processPolling(&f1PollParams, &f1Params.sockFd, timeout_Ptr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1\n");
+ DU_LOG("ERROR --> SCTP : Failed to RecvMsg for F1\n");
}
}
if(ricParams.itfState)
{
if((ret = processPolling(&e2PollParams, &ricParams.sockFd, timeout_Ptr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for E2\n");
+ DU_LOG("ERROR --> SCTP : Failed to RecvMsg for E2\n");
}
}
#ifdef NFAPI_ENABLED
{
if((ret = processPolling(&pnfP5PollParams, &pnfP5Params.sockFd, timeout_Ptr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for E2\n");
+ DU_LOG("ERROR --> SCTP : Failed to RecvMsg for E2\n");
}
}
#endif
#ifdef CALL_FLOW_DEBUG_LOG
if(itfType == F1_INTERFACE)
{
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_F1AP_MSG_TO_SCTP\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTSCTP : EVENT_F1AP_MSG_TO_SCTP\n");
}
else
{
- DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_E2AP_MSG_TO_SCTP\n");
+ DU_LOG("Call Flow: ENTDUAPP -> ENTSCTP : EVENT_E2AP_MSG_TO_SCTP\n");
}
#endif
if(itfType == F1_INTERFACE)
{
- DU_LOG("\nDEBUG --> SCTP : sending the message to CU");
+ DU_LOG("DEBUG --> SCTP : sending the message to CU");
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCTP -> CU : EVENT_F1AP_MSG_TO_CU\n");
+ DU_LOG("Call Flow: ENTSCTP -> CU : EVENT_F1AP_MSG_TO_CU\n");
#endif
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("\nDEBUG --> SCTP : sending the message to ric");
+ DU_LOG("DEBUG --> SCTP : sending the message to ric");
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCTP -> RIC : EVENT_E2AP_MSG_TO_RIC\n");
+ DU_LOG("Call Flow: ENTSCTP -> RIC : EVENT_E2AP_MSG_TO_RIC\n");
#endif
ret = cmInetSctpSendMsg(&ricParams.sockFd, &ricParams.destIpNetAddr, ricParams.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
#ifdef NFAPI_ENABLED
if(itfType == PNF_P5_INTERFACE)
{
- DU_LOG("\nDEBUG --> SCTP : sending the message to PNF");
+ DU_LOG("DEBUG --> SCTP : sending the message to PNF");
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTSCTP -> PNF : EVENT_P5_MSG_TO_PNF\n");
+ DU_LOG("Call Flow: ENTSCTP -> PNF : EVENT_P5_MSG_TO_PNF\n");
#endif
ret = cmInetSctpSendMsg(&pnfP5Params.sockFd, &pnfP5Params.destIpNetAddr, pnfP5Params.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
#endif
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> SCTP : Failed sending the message");
+ DU_LOG("ERROR --> SCTP : Failed sending the message");
return RFAILED;
}
DU_ALLOC(mib->systemFrameNumber.buf, mib->systemFrameNumber.size);
if(!(mib->systemFrameNumber.buf))
{
- DU_LOG("\nERROR --> DU APP: MIB msg memory allocation failure");
+ DU_LOG("ERROR --> DU APP: MIB msg memory allocation failure");
return RFAILED;
}
DU_ALLOC(mib->spare.buf, mib->spare.size);
if(!mib->spare.buf)
{
- DU_LOG("\nERROR --> DU APP: MIB msg memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> Memory allocation failure in BuildMibPdu");
+ DU_LOG("ERROR --> Memory allocation failure in BuildMibPdu");
break;
}
DU_ALLOC(bcchMsg->message.choice.mib, sizeof(MIB_t));
if(!bcchMsg->message.choice.mib)
{
- DU_LOG("\nERROR --> Memory allocation failure in BuildMibPdu");
+ DU_LOG("ERROR --> Memory allocation failure in BuildMibPdu");
break;
}
if(BuildMib(bcchMsg->message.choice.mib) != ROK)
printf("\nencbufSize:%d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nERROR --> DU APP: Could not encode BCCH BCH Message Type structure(at %s)\n",
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: MIB msg memory allocation failure");
+ DU_LOG("ERROR --> DU APP: MIB msg memory allocation failure");
return RFAILED;
}
if(BuildMib(mibMsg) != ROK)
printf("\nencbufSize:%d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nERROR --> DU APP: Could not encode MIB structure(at %s)\n",
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: CellIdentity memory allocation failure");
+ DU_LOG("ERROR --> DU APP: CellIdentity memory allocation failure");
return RFAILED;
}
fillBitString(cellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
DU_ALLOC(ranac, sizeof(RAN_AreaCode_t));
if(!ranac)
{
- DU_LOG("\nERROR --> DU APP: RANAC memory allocation failure");
+ DU_LOG("ERROR --> DU APP: RANAC memory allocation failure");
return RFAILED;
}
*ranac = duCfgParam.sib1Params.ranac;
DU_ALLOC(tac, sizeof(TrackingAreaCode_t));
if(!tac)
{
- DU_LOG("\nERROR --> DU APP: TAC memory allocation failure");
+ DU_LOG("ERROR --> DU APP: TAC memory allocation failure");
return RFAILED;
}
DU_ALLOC(tac->buf, tac->size);
if(!tac->buf)
{
- DU_LOG("\nERROR --> DU APP: TAC memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
sizeof(PLMN_IdentityInfo_t));
if(!cellAccessInfo->plmn_IdentityList.list.array[idx])
{
- DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(plmnIdInfo->list.array, plmnIdInfo->list.size);
if(!plmnIdInfo->list.array)
{
- DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
DU_ALLOC(plmnIdInfo->list.array[idx1], sizeof(PLMN_IdentitY_t));
if(!(plmnIdInfo->list.array[idx1]))
{
- DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc, sizeof(MCC_t));
if(!plmnIdInfo->list.array[idx1]->mcc)
{
- DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array, plmnIdInfo->list.array[idx1]->mcc->list.size);
if(!(plmnIdInfo->list.array[idx1]->mcc->list.array))
{
- DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(sibTypeInfo->valueTag, sizeof(long));
if(!sibTypeInfo->valueTag)
{
- DU_LOG("\nERROR --> DU APP: BuildSibMapInfoList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildSiSchedInfoList memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: BuildSiSchedInfoList memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BuildSiSchedInfoList memory allocation failure");
return RFAILED;
}
}
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(searchSpace->controlResourceSetId, sizeof(ControlResourceSetId_t));
if(!searchSpace->controlResourceSetId)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
*searchSpace->controlResourceSetId = duPdcchCfg.ctrlRsrcSetId;
sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
if(!searchSpace->monitoringSlotPeriodicityAndOffset)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSlotPeriodicityAndOffset->present = duPdcchCfg.monitorSlotPrdAndOffPresent;
}
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid value:Montoring slot periodicity and offset");
+ DU_LOG("ERROR --> DU APP : Invalid value:Montoring slot periodicity and offset");
return RFAILED;
}
}
DU_ALLOC(searchSpace->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
if(!searchSpace->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSymbolsWithinSlot->size = 2 * sizeof(uint8_t);
DU_ALLOC(searchSpace->monitoringSymbolsWithinSlot->buf, searchSpace->monitoringSymbolsWithinSlot->size);
if(!searchSpace->monitoringSymbolsWithinSlot->buf)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSymbolsWithinSlot->buf[0] = duPdcchCfg.monitorSymbolsInSlot[0];
DU_ALLOC(searchSpace->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpace->nrofCandidates)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->nrofCandidates->aggregationLevel1 = duPdcchCfg.numCandAggLvl1;
DU_ALLOC(searchSpace->searchSpaceType, sizeof( struct SearchSpace__searchSpaceType));
if(!searchSpace->searchSpaceType)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
sizeof(struct SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
if(!searchSpace->searchSpaceType->choice.common->dci_Format0_0_AndFormat1_0)
{
- DU_LOG("\nERROR --> DU APP : Common search space list memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Common search space list memory alloc failed");
return RFAILED;
}
}
default:
{
- DU_LOG("\nERROR --> DU_APP: Invalid Search Space type");
+ DU_LOG("ERROR --> DU_APP: Invalid Search Space type");
return RFAILED;
}
}
DU_ALLOC(pdcchCfg->choice.setup, sizeof(PDCCH_ConfigCommon_t));
if(!pdcchCfg->choice.setup)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->searchSpaceZero = duPdcchCfg.searchSpcZero;
DU_ALLOC(pdcchSetup->commonSearchSpaceList, sizeof(struct PDCCH_ConfigCommon__commonSearchSpaceList));
if(!pdcchSetup->commonSearchSpaceList)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
elementCnt = ODU_VALUE_ONE;
ret = BuildCommonSerachSpaceList(pdcchSetup->commonSearchSpaceList);
if(ret != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill common search space list");
+ DU_LOG("ERROR --> DU APP : Failed to fill common search space list");
return RFAILED;
}
CommonSerachSpaceListret=ROK;
DU_ALLOC(pdcchSetup->searchSpaceSIB1, sizeof(SearchSpaceId_t));
if(!pdcchSetup->searchSpaceSIB1)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*pdcchSetup->ra_SearchSpace = duPdcchCfg.raSearchSpc;
}
default :
{
- DU_LOG("\nERROR --> DU APP : Invalid PDCCH Config type");
+ DU_LOG("ERROR --> DU APP : Invalid PDCCH Config type");
return RFAILED;
}
}
DU_ALLOC(pdschCfg->choice.setup, sizeof(PDSCH_ConfigCommon_t));
if(!pdschCfg->choice.setup)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
pdschSetup = pdschCfg->choice.setup;
DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList, sizeof(PDSCH_TimeDomainResourceAllocationList_t));
if(!pdschSetup->pdsch_TimeDomainAllocationList)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
pdschSetup->pdsch_TimeDomainAllocationList->list.size);
if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
sizeof(PDSCH_TimeDomainResourceAllocation_t));
if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx])
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
if(!timeDomRsrcAllocInfo->k0)
{
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
*timeDomRsrcAllocInfo->k0 = duPdschCfg.timeDomAlloc[idx].k0;
}
default:
{
- DU_LOG("\nERROR --> DU APP: Invalid PDSCH Configuration type");
+ DU_LOG("ERROR --> DU APP: Invalid PDSCH Configuration type");
return RFAILED;
}
}
DU_ALLOC(bwp->pdcch_ConfigCommon, sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
if(!bwp->pdcch_ConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : DL BWP memory allocation failed");
+ DU_LOG("ERROR --> DU APP : DL BWP memory allocation failed");
return RFAILED;
}
if((BuildPdcchCfgCommon(bwp->pdcch_ConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill PDCCH config common in BuildBwpDlCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill PDCCH config common in BuildBwpDlCommon()");
return RFAILED;
}
DU_ALLOC(bwp->pdsch_ConfigCommon, sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
if(!bwp->pdsch_ConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : DL BWP memory allocation failed");
+ DU_LOG("ERROR --> DU APP : DL BWP memory allocation failed");
return RFAILED;
}
if((BuildPdschCfgCommon(bwp->pdsch_ConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill PDSCH config common in BuildBwpDlCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill PDSCH config common in BuildBwpDlCommon()");
return RFAILED;
}
numPO = srcPcchCfg->ns;
if(numPO == 0)
{
- DU_LOG("\nINFO --> DU APP : Paging Occasions is ZERO, no need to fill further");
+ DU_LOG("INFO --> DU APP : Paging Occasions is ZERO, no need to fill further");
return ROK;
}
if(firstPO->choice.sCS15KHZoneT == NULLP)
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
firstPO->choice.sCS15KHZoneT->list.count = numPO;
DU_ALLOC(firstPO->choice.sCS15KHZoneT->list.array, firstPO->choice.sCS15KHZoneT->list.size);
if(!firstPO->choice.sCS15KHZoneT->list.array)
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
* Since FirstPDCCHMonitoring_PO is not valid thus no need to continue further*/
if(srcPcchCfg->firstPDCCHMontioringInfo[poIdx] > 139)
{
- DU_LOG("\nERROR --> DU APP : Invalid Paging Ocassion value for 15kHz");
+ DU_LOG("ERROR --> DU APP : Invalid Paging Ocassion value for 15kHz");
return RFAILED;
}
DU_ALLOC(firstPO->choice.sCS15KHZoneT->list.array[poIdx], sizeof(long));
if(!firstPO->choice.sCS15KHZoneT->list.array[poIdx])
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
}
if(firstPO->choice.sCS30KHZoneT_SCS15KHZhalfT == NULLP)
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
firstPO->choice.sCS30KHZoneT_SCS15KHZhalfT->list.count = numPO;
if(!firstPO->choice.sCS30KHZoneT_SCS15KHZhalfT->list.array)
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
* Since FirstPDCCHMonitoring_PO is not valid thus no need to continue further*/
if(srcPcchCfg->firstPDCCHMontioringInfo[poIdx] > 279)
{
- DU_LOG("\nERROR --> DU APP : Invalid Paging Ocassion value for 30kHz or 15kHz HAlFT");
+ DU_LOG("ERROR --> DU APP : Invalid Paging Ocassion value for 30kHz or 15kHz HAlFT");
return RFAILED;
}
DU_ALLOC(firstPO->choice.sCS30KHZoneT_SCS15KHZhalfT->list.array[poIdx], sizeof(long));
if(!firstPO->choice.sCS30KHZoneT_SCS15KHZhalfT->list.array[poIdx])
{
- DU_LOG("\nERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
+ DU_LOG("ERROR --> DU APP : FirstPdcchMonitoringPO Memory allocation failure");
return RFAILED;
}
}
//TODO for other cases
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid firstPDCCH-MonitoringOccasionOfPO");
+ DU_LOG("ERROR --> DU APP : Invalid firstPDCCH-MonitoringOccasionOfPO");
return RFAILED;
break;
/*Spec 38.331: PCCH_Config: nAndPagingFrameOffset [MAX value of halfT] */
if(duPcchCfg.pageFrameOffset > 1)
{
- DU_LOG("\nERROR --> DU APP : Invalid PagingFrameOffset for HALF_T");
+ DU_LOG("ERROR --> DU APP : Invalid PagingFrameOffset for HALF_T");
return RFAILED;
}
pcchCfg->nAndPagingFrameOffset.choice.halfT = duPcchCfg.pageFrameOffset;
/*Spec 38.331: PCCH_Config: nAndPagingFrameOffset [MAX value of quarterT] */
if(duPcchCfg.pageFrameOffset > 3)
{
- DU_LOG("\nERROR --> DU APP : Invalid PagingFrameOffset for QUARTER_T");
+ DU_LOG("ERROR --> DU APP : Invalid PagingFrameOffset for QUARTER_T");
return RFAILED;
}
pcchCfg->nAndPagingFrameOffset.choice.quarterT = duPcchCfg.pageFrameOffset;
/*Spec 38.331: PCCH_Config: nAndPagingFrameOffset [MAX value of oneEighthT] */
if(duPcchCfg.pageFrameOffset > 7)
{
- DU_LOG("\nERROR --> DU APP : Invalid PagingFrameOffset for ONE_EIGHTH_T");
+ DU_LOG("ERROR --> DU APP : Invalid PagingFrameOffset for ONE_EIGHTH_T");
return RFAILED;
}
pcchCfg->nAndPagingFrameOffset.choice.oneEighthT = duPcchCfg.pageFrameOffset;
/*Spec 38.331: PCCH_Config: nAndPagingFrameOffset [MAX value of oneSixteenthT] */
if(duPcchCfg.pageFrameOffset > 15)
{
- DU_LOG("\nERROR --> DU APP : Invalid PagingFrameOffset for ONE_SIXTEENTH_T");
+ DU_LOG("ERROR --> DU APP : Invalid PagingFrameOffset for ONE_SIXTEENTH_T");
return RFAILED;
}
pcchCfg->nAndPagingFrameOffset.choice.oneSixteenthT = duPcchCfg.pageFrameOffset;
}
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid nAndPagingFrameOffset configuration");
+ DU_LOG("ERROR --> DU APP : Invalid nAndPagingFrameOffset configuration");
return RFAILED;
}
}
sizeof(struct PCCH_Config__firstPDCCH_MonitoringOccasionOfPO));
if(pcchCfg->firstPDCCH_MonitoringOccasionOfPO == NULLP)
{
- DU_LOG("\nERROR --> DU APP : BuildPcchConfig >> Memory Allocation fails");
+ DU_LOG("ERROR --> DU APP : BuildPcchConfig >> Memory Allocation fails");
return RFAILED;
}
if(fillFirstPdcchMonitoringOcc(pcchCfg->firstPDCCH_MonitoringOccasionOfPO, &duPcchCfg) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : BuildPcchConfig >> Filling of Paging Occ failed");
+ DU_LOG("ERROR --> DU APP : BuildPcchConfig >> Filling of Paging Occ failed");
return RFAILED;
}
return ROK;
frequencyInfoDL->frequencyBandList.list.size);
if(!frequencyInfoDL->frequencyBandList.list.array)
{
- DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("ERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
return RFAILED;
}
sizeof(NR_MultiBandInfo_t));
if(!frequencyInfoDL->frequencyBandList.list.array[idx])
{
- DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("ERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
return RFAILED;
}
}
DU_ALLOC(multiBandInfo->freqBandIndicatorNR, sizeof(FreqBandIndicatorNR_t));
if(!multiBandInfo->freqBandIndicatorNR)
{
- DU_LOG("\nERROR --> DU APP : SIB1 DL Configuration memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : SCS Specific Carrier list memory allocation failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : UL Frequency Infoo memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Rach Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Rach Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Rach Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present = duRachCfg.numSsbPerRachOcc;
}
default:
{
- DU_LOG("\nERROR --> DU APP: Invalid value for ssb_PerRach_OccassionAndCB_PreamblesPerSSB");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Rach Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
*setup->rsrp_ThresholdSSB = duRachCfg.rsrpThreshSsb;
}
default:
{
- DU_LOG("\nERROR --> DU APP: Inavlid PRACH root sequence index type");
+ DU_LOG("ERROR --> DU APP: Inavlid PRACH root sequence index type");
return RFAILED;
}
}
DU_ALLOC(setup->msg1_SubcarrierSpacing, sizeof(SubcarrierSpacing_t));
if(!setup->msg1_SubcarrierSpacing)
{
- DU_LOG("\nERROR --> DU APP : Rach Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : Rach Config memory alloc failed");
return RFAILED;
}
*setup->msg1_SubcarrierSpacing = duRachCfg.msg1Scs;
}
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid RACH Config type ");
+ DU_LOG("ERROR --> DU APP : Invalid RACH Config type ");
return RFAILED;
}
}
DU_ALLOC(puschCfg->choice.setup, sizeof(PUSCH_ConfigCommon_t));
if(!puschCfg->choice.setup)
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
setup = puschCfg->choice.setup;
DU_ALLOC(setup->pusch_TimeDomainAllocationList, sizeof(PUSCH_TimeDomainResourceAllocationList_t));
if(!setup->pusch_TimeDomainAllocationList)
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
elementCnt = duPuschCfg.numTimeDomRsrcAlloc;
DU_ALLOC(setup->pusch_TimeDomainAllocationList->list.array, setup->pusch_TimeDomainAllocationList->list.size);
if(!setup->pusch_TimeDomainAllocationList->list.array)
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
sizeof(PUSCH_TimeDomainResourceAllocation_t));
if(!setup->pusch_TimeDomainAllocationList->list.array[idx])
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
}
DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
if(!timeDomRsrcAllocInfo->k2)
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
*timeDomRsrcAllocInfo->k2 = duPuschCfg.timeDomAllocList[idx].k2;
DU_ALLOC(setup->msg3_DeltaPreamble, sizeof(long));
if(!setup->msg3_DeltaPreamble)
{
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
*setup->p0_NominalWithGrant = duPuschCfg.p0NominalWithGrant;
}
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid PUSCH configuration type ");
+ DU_LOG("ERROR --> DU APP : Invalid PUSCH configuration type ");
return RFAILED;
}
}
DU_ALLOC(pucchCfg->choice.setup, sizeof(PUCCH_ConfigCommon_t));
if(!pucchCfg->choice.setup)
{
- DU_LOG("\nERROR --> DU APP : PUCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PUCCH Config memory alloc failed");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : PUCCH Config memory alloc failed");
+ DU_LOG("ERROR --> DU APP : PUCCH Config memory alloc failed");
return RFAILED;
}
*setup->p0_nominal = duPucchCfg.p0Nominal;
}
default:
{
- DU_LOG("\nERROR --> DU APP : Invalid PUCCH Config type");
+ DU_LOG("ERROR --> DU APP : Invalid PUCCH Config type");
return RFAILED;
}
}
DU_ALLOC(bwp->rach_ConfigCommon, sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
if(!bwp->rach_ConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
+ DU_LOG("ERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
if((BuildRachCfgCommon(bwp->rach_ConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill RACH config common in BuildBwpUlCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill RACH config common in BuildBwpUlCommon()");
return RFAILED;
}
RachCfgCommonret=ROK;
DU_ALLOC(bwp->pusch_ConfigCommon, sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
if(!bwp->pusch_ConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
+ DU_LOG("ERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
if((BuildPuschCfgCommon(bwp->pusch_ConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill PUSCH config common in BuildBwpUlCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill PUSCH config common in BuildBwpUlCommon()");
return RFAILED;
}
PuschCfgCommonret = ROK;
DU_ALLOC(bwp->pucch_ConfigCommon, sizeof(struct BWP_UplinkCommon__pucch_ConfigCommon));
if(!bwp->pucch_ConfigCommon)
{
- DU_LOG("\nERROR --> DU APP : UL BWP memory allocation failed");
+ DU_LOG("ERROR --> DU APP : UL BWP memory allocation failed");
return RFAILED;
}
if((BuildPucchCfgCommon(bwp->pucch_ConfigCommon)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill PUCCH config common in BuildBwpUlCommon()");
+ DU_LOG("ERROR --> DU APP : Failed to fill PUCCH config common in BuildBwpUlCommon()");
return RFAILED;
}
DU_ALLOC(ssbPosInBurst->buf, ssbPosInBurst->size * sizeof(uint8_t));
if(!ssbPosInBurst->buf)
{
- DU_LOG("\nERROR --> DU APP : Serving cell config common memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Serving cell config common memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Serving cell config common memory allocation failure");
+ DU_LOG("ERROR --> DU APP : Serving cell config common memory allocation failure");
return RFAILED;
}
ret = BuildTddUlDlCfgComm(srvCellCfg->tdd_UL_DL_ConfigurationCommon);
DU_ALLOC(bcchMsg.message.choice.c1, sizeof(struct BCCH_DL_SCH_MessageType__c1));
if(!bcchMsg.message.choice.c1)
{
- DU_LOG("\nERROR --> DU APP: BCCH-DL-SCH msg memory allocation failure");
+ DU_LOG("ERROR --> DU APP: BCCH-DL-SCH msg memory allocation failure");
break;
}
bcchMsg.message.choice.c1->present = BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1;
DU_ALLOC(bcchMsg.message.choice.c1->choice.systemInformationBlockType1, sizeof(SIB1_t));
if(!bcchMsg.message.choice.c1->choice.systemInformationBlockType1)
{
- DU_LOG("\nERROR --> DU APP: SIB1 msg memory allocation failure");
+ DU_LOG("ERROR --> DU APP: SIB1 msg memory allocation failure");
break;
}
sib1Msg = bcchMsg.message.choice.c1->choice.systemInformationBlockType1;
DU_ALLOC(sib1Msg->cellSelectionInfo, sizeof(struct SIB1__cellSelectionInfo));
if(!sib1Msg->cellSelectionInfo)
{
- DU_LOG("\nERROR --> DU APP: SIB1 Cell Selection Info memory allocation failed");
+ DU_LOG("ERROR --> DU APP: SIB1 Cell Selection Info memory allocation failed");
break;
}
DU_ALLOC(sib1Msg->cellSelectionInfo->q_RxLevMinSUL, sizeof(Q_RxLevMin_t));
if(!sib1Msg->cellSelectionInfo->q_RxLevMinSUL)
{
- DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_RxLevMinSUL");
+ DU_LOG("ERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_RxLevMinSUL");
break;
}
*(sib1Msg->cellSelectionInfo->q_RxLevMinSUL) = -50;
DU_ALLOC(sib1Msg->cellSelectionInfo->q_QualMin, sizeof(Q_QualMin_t));
if(!sib1Msg->cellSelectionInfo->q_QualMin)
{
- DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_QualMin");
+ DU_LOG("ERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_QualMin");
break;
}
*(sib1Msg->cellSelectionInfo->q_QualMin) = -30;
DU_ALLOC(sib1Msg->connEstFailureControl, sizeof(ConnEstFailureControl_t));
if(!sib1Msg->connEstFailureControl)
{
- DU_LOG("\nERROR --> DU APP: sib1Msg->connEstFailureControl memory allocation failure");
+ DU_LOG("ERROR --> DU APP: sib1Msg->connEstFailureControl memory allocation failure");
break;
}
sib1Msg->connEstFailureControl->connEstFailCount = duCfgParam.sib1Params.connEstFailCnt;
DU_ALLOC(sib1Msg->connEstFailureControl->connEstFailOffset, sizeof(long));
if(!sib1Msg->connEstFailureControl->connEstFailOffset)
{
- DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for connEstFailOffset");
+ DU_LOG("ERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for connEstFailOffset");
break;
}
*(sib1Msg->connEstFailureControl->connEstFailOffset) = duCfgParam.sib1Params.connEstFailOffset;
DU_ALLOC(sib1Msg->si_SchedulingInfo, sizeof(SI_SchedulingInfo_t));
if(!sib1Msg->si_SchedulingInfo)
{
- DU_LOG("\nERROR --> DU APP: sib1Msg->si_SchedulingInfo memory allocation failure");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
+ DU_LOG("ERROR --> DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
break;
}
ret1 = BuildServCellCfgCommonSib(sib1Msg->servingCellConfigCommon);
printf("\nencbufSize: %d\n", encBufSize);
if(encRetVal.encoded == -1)
{
- DU_LOG("\nERROR --> DU APP : Could not encode BCCH-DL-SCH structure (at %s)\n",\
+ DU_LOG("ERROR --> DU APP : Could not encode BCCH-DL-SCH structure (at %s)\n",\
encRetVal.failed_type ?
encRetVal.failed_type->name :
"unknown");
{
if(((CmTimer *)cb)->tmrEvnt == EVENT_E2_SETUP_TMR)
{
- DU_LOG("\nERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
return TRUE;
}
break;
{
if(((RicServiceUpdateTimer*)cb)->timer.tmrEvnt == EVENT_RIC_SERVICE_UPDATE_TMR)
{
- DU_LOG("\nERROR --> DU_APP : duChkTmr: Timer already running for event [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU_APP : duChkTmr: Timer already running for event [%d]", tmrEvnt);
return TRUE;
}
break;
{
if(((E2NodeConfigUpdateTimer *)cb)->timer.tmrEvnt == EVENT_E2_NODE_CONFIG_UPDATE_TMR)
{
- DU_LOG("\nERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
return TRUE;
}
break;
{
if(((RicSubscription *)cb)->ricSubsReportTimer.tmrEvnt == EVENT_RIC_SUBSCRIPTION_REPORTING_TMR)
{
- DU_LOG("\nERROR --> DU_APP : duChkTmr: Timer already running for event [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU_APP : duChkTmr: Timer already running for event [%d]", tmrEvnt);
return TRUE;
}
break;
}
default:
{
- DU_LOG("\nERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU_APP : duChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
}
default:
{
- DU_LOG("\nERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
return;
}
}
}
default:
{
- DU_LOG("\nERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("ERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
break;
}
}
}
default:
{
- DU_LOG("\nERROR --> RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
+ DU_LOG("ERROR --> RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
break;
}
}
ret = ROK;
}
else
- DU_LOG("\nERROR --> DU APP : DuProcRlcMaxRetransInd(): CRNTI [%d] not found", crnti);
+ DU_LOG("ERROR --> DU APP : DuProcRlcMaxRetransInd(): CRNTI [%d] not found", crnti);
}
else
- DU_LOG("\nERROR --> DU APP : DuProcRlcMaxRetransInd(): Cell Id[%d] is not found", maxRetransInfo->cellId);
+ DU_LOG("ERROR --> DU APP : DuProcRlcMaxRetransInd(): Cell Id[%d] is not found", maxRetransInfo->cellId);
DU_FREE_SHRABL_BUF(pst->region, pst->pool, maxRetransInfo, sizeof(RlcMaxRetransInfo));
bitPos++;
}
}
- DU_LOG("\nERROR --> DU_APP: Max LC Reached in getDrbLcId()");
+ DU_LOG("ERROR --> DU_APP: Max LC Reached in getDrbLcId()");
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
if(!dlDataMsgInfo)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed for dlDataMsgInfo in duHdlEgtpDlData()");
+ DU_LOG("ERROR --> DU_APP : Memory allocation failed for dlDataMsgInfo in duHdlEgtpDlData()");
return RFAILED;
}
memset(dlDataMsgInfo, 0, sizeof(RlcDlUserDataInfo));
{
/* Filling post structure and sending msg */
FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_USER_DATA_TRANS_TO_RLC);
- DU_LOG("\nDEBUG --> DU_APP : Sending User Data Msg to RLC [TEID, nPDU]:[%d, %d]\n",\
+ DU_LOG("DEBUG --> DU_APP : Sending User Data Msg to RLC [TEID, nPDU]:[%d, %d]\n",\
egtpMsg->msgHdr.teId, egtpMsg->msgHdr.nPdu.val);
ret = (*duSendRlcDlUserDataToRlcOpts[pst.selector])(&pst, dlDataMsgInfo);
}
if(ret != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send User Data to RLC in duHdlEgtpDlData()");
+ DU_LOG("ERROR --> DU_APP : Failed to send User Data to RLC in duHdlEgtpDlData()");
ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg);
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
}
uint16_t msgLen = 0;
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTEGTP -> ENTDUAPP : EVENT_HDL_RECV_DL_DATA\n");
+ DU_LOG("Call Flow: ENTEGTP -> ENTDUAPP : EVENT_HDL_RECV_DL_DATA\n");
#endif
- DU_LOG("\nDEBUG --> DU_APP : Processing DL data in duHdlEgtpDlData()");
+ DU_LOG("DEBUG --> DU_APP : Processing DL data in duHdlEgtpDlData()");
if(!egtpMsg->msg)
{
- DU_LOG("\nERROR --> DU_APP : Recevied Dl Data is NULLP in duHdlEgtpDlData()");
+ DU_LOG("ERROR --> DU_APP : Recevied Dl Data is NULLP in duHdlEgtpDlData()");
return RFAILED;
}
ODU_GET_MSG_LEN(egtpMsg->msg, (MsgLen *)&msgLen);
if(duBuildAndSendDlUserDataToRlc(msgLen, egtpMsg) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to build DL USer Data in duHdlEgtpDlData()");
+ DU_LOG("ERROR --> DU_APP : Failed to build DL USer Data in duHdlEgtpDlData()");
return RFAILED;
}
return ROK;
DlCcchIndInfo *dlCcchIndInfo = NULLP;
Pst pst;
- DU_LOG("\nDEBUG --> DU APP : Building and Sending DL CCCH Ind to MAC");
+ DU_LOG("DEBUG --> DU APP : Building and Sending DL CCCH Ind to MAC");
DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
if(!dlCcchIndInfo)
{
- DU_LOG("\nERROR --> DU APP : Memory alloc failed while building DL CCCH Ind");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Memory alloc failed while building DL CCCH Ind");
+ DU_LOG("ERROR --> 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("\nERROR --> DU_APP : Failure in sending DL CCCH to MAC");
+ DU_LOG("ERROR --> 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("\nERROR --> DU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
+ DU_LOG("ERROR --> DU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
return RFAILED;
}
/*As per Spec ORAN WG8 AAD, lcId for DL RRC range from 1...3*/
if((f1DlRrcMsg->srbId < SRB1_LCID) || (f1DlRrcMsg->srbId > SRB3_LCID))
{
- DU_LOG("\nERROR --> DU APP : Received SRBID for this Dl RRC Msg is not valid");
+ DU_LOG("ERROR --> DU APP : Received SRBID for this Dl RRC Msg is not valid");
return RFAILED;
}
if(!dlRrcMsgInfo)
{
- DU_LOG("\nERROR --> DU APP : Memory allocation failed for dlRrcMsgInfo in \
+ DU_LOG("ERROR --> 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;
}
if(lcIdx == (MAX_NUM_LC + 1))
{
- DU_LOG("\nERROR --> DU APP : (duBuildAndSendDlRrcMsgToRlc) SRB for this DL_RRC msg is not configured.");
+ DU_LOG("ERROR --> DU APP : (duBuildAndSendDlRrcMsgToRlc) SRB for this DL_RRC msg is not configured.");
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("\nDEBUG --> DU_APP: Sending Dl RRC Msg to RLC \n");
+ DU_LOG("DEBUG --> 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("\nERROR --> DU APP : Failed to build DlCcch Ind at procDlRrcMsgTrans()");
+ DU_LOG("ERROR --> DU APP : Failed to build DlCcch Ind at procDlRrcMsgTrans()");
}
else
{
if(duCb.actvCellLst[cellId-1] == NULLP)
{
- DU_LOG("\nERROR --> DU APP : cellId [%d] does not exist", cellId);
+ DU_LOG("ERROR --> DU APP : cellId [%d] does not exist", cellId);
ret = RFAILED;
}
if(duCb.actvCellLst[cellId-1]->numActvUes < MAX_NUM_UE)
ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], dlRrcMsg->gnbCuUeF1apId);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
+ DU_LOG("ERROR --> DU APP : Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
duCb.ueCcchCtxt[ueIdx].cellId);
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
+ DU_LOG("ERROR --> DU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
ret = RFAILED;
}
}
duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg, dlRrcMsg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP: duBuildAndSendDlRrcMsgToRlc() Failed for UE ID:%d", dlRrcMsg->gnbDuUeF1apId);
+ DU_LOG("ERROR --> DU_APP: duBuildAndSendDlRrcMsgToRlc() Failed for UE ID:%d", dlRrcMsg->gnbDuUeF1apId);
return RFAILED;
}
break;
}
if(!ueFound)
{
- DU_LOG("\nERROR --> DU_APP: UE ID [%d] not found", dlRrcMsg->gnbDuUeF1apId);
+ DU_LOG("ERROR --> DU_APP: UE ID [%d] not found", dlRrcMsg->gnbDuUeF1apId);
ret = RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : Received invalid CRNTI [%d] ", ulCcchIndInfo->crnti);
+ DU_LOG("ERROR --> DU_APP : Received invalid CRNTI [%d] ", ulCcchIndInfo->crnti);
return RFAILED;
}
ulCcchIndInfo->ulCcchMsg));
if(ret != ROK)
{
- DU_LOG("\nERROR --> DU_APP : BuildAndSendInitialRrcMsgTransfer failed");
+ DU_LOG("ERROR --> DU_APP : BuildAndSendInitialRrcMsgTransfer failed");
}
DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
DU_ALLOC_SHRABL_BUF(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0, sizeof(uint8_t));
if(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0 == NULLP)
{
- DU_LOG("\nERROR --> DUAPP : Failed to allocate memory to K0 in fillDefaultInitDlBwp");
+ DU_LOG("ERROR --> DUAPP : Failed to allocate memory to K0 in fillDefaultInitDlBwp");
return RFAILED;
}
if(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0)
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory is NULL of InitalUlBwp");
+ DU_LOG("ERROR --> DU APP : Memory is NULL of InitalUlBwp");
}
}
/* Filling Initial Dl Bwp */
if((fillDefaultInitDlBwp(&spCell->servCellCfg.initDlBwp)) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed in fillDefaultInitDlBwp");
+ DU_LOG("ERROR --> DUAPP : Failed in fillDefaultInitDlBwp");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory is NULL for SpCellGrp");
+ DU_LOG("ERROR --> DU APP : Memory is NULL for SpCellGrp");
return RFAILED;
}
return ROK;
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory is NULL for Physical Cell Group");
+ DU_LOG("ERROR --> DU APP : Memory is NULL for Physical Cell Group");
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory is NULL for Master Cell Group");
+ DU_LOG("ERROR --> DU APP : Memory is NULL for Master Cell Group");
}
}
DU_ALLOC_SHRABL_BUF(oldLcCfg->lcConfig.drbQos, sizeof(DrbQosInfo));
if(oldLcCfg->lcConfig.drbQos == NULL)
{
- DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
+ DU_LOG("ERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
return RFAILED;
}
memcpy(oldLcCfg->lcConfig.drbQos, ueLcCfgDb->lcConfig.drbQos, sizeof(DrbQosInfo));
DU_ALLOC_SHRABL_BUF(oldLcCfg->lcConfig.snssai, sizeof(Snssai));
if(oldLcCfg->lcConfig.snssai == NULL)
{
- DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
+ DU_LOG("ERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->lcConfig.drbQos, sizeof(DrbQosInfo));
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(*oldMacAmbrCfg, sizeof(AmbrCfg));
if(*oldMacAmbrCfg == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillAmbr()");
+ DU_LOG("ERROR --> DU APP : Memory Alloc Failed at fillAmbr()");
return RFAILED;
}
memset(*oldMacAmbrCfg, 0, sizeof(AmbrCfg));
if(macUeRecfg)
{
/* Processing one Ue at a time to MAC */
- DU_LOG("\nDEBUG --> DU_APP: Sending Ue Reconfig Request to MAC");
+ DU_LOG("DEBUG --> DU_APP: Sending Ue Reconfig Request to MAC");
ret = (*packMacUeReconfigReqOpts[pst.selector])(&pst, macUeRecfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to send Reconfig Request to MAC at sendUeRecfgReqToMac()");
+ DU_LOG("ERROR --> DU APP : Failed to send Reconfig Request to MAC at sendUeRecfgReqToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeRecfg, sizeof(MacUeRecfg));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received macUeRecfg is NULLP at sendUeRecfgReqToMac()");
+ DU_LOG("ERROR --> DU_APP: Received macUeRecfg is NULLP at sendUeRecfgReqToMac()");
ret = RFAILED;
}
return ret;
if((fillDefaultSpCellGrpInfo(duMacUeCfg)) != ROK)
{
- DU_LOG("\nERROR --> DUAPP : Failed in fillDefaultSpCellGrpInfo");
+ DU_LOG("ERROR --> DUAPP : Failed in fillDefaultSpCellGrpInfo");
return RFAILED;
}
duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[duMacUeCfg->ueId-1].duMacUeCfg;
else
{
- DU_LOG("\nERROR --> DU APP : Cell Id [%d] does not exist", cellId);
+ DU_LOG("ERROR --> DU APP : Cell Id [%d] does not exist", cellId);
return RFAILED;
}
duMacDb->macUeCfgState = UE_CFG_INPROGRESS;
}
else
{
- DU_LOG("\nERROR --> DU APP : Failed to add Lc at Idx %d in updateDuMacUeCfg()", dbIdx);
+ DU_LOG("ERROR --> DU APP : Failed to add Lc at Idx %d in updateDuMacUeCfg()", dbIdx);
break;
}
}/*End of Outer FOR loop */
fillDefaultAmInfo(lcCfg->u.amCfg);
else
{
- DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
+ DU_LOG(" ERROR --> DU APP : Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg);
else
{
- DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
+ DU_LOG(" ERROR --> DU APP : Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg);
else
{
- DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
+ DU_LOG(" ERROR --> DU APP : Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg);
else
{
- DU_LOG("\n ERROR --> DU APP : Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
+ DU_LOG(" ERROR --> DU APP : Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
return RFAILED;
}
}
break;
}
default:
- DU_LOG("\nERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
+ DU_LOG("ERROR --> DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DUAPP: Received LC Config is NULL");
+ DU_LOG("ERROR --> DUAPP: Received LC Config is NULL");
return RFAILED;
}
return ROK;
if(rlcUeRecfg)
{
/* Processing one Ue at a time to RLC */
- DU_LOG("\nDEBUG --> DU_APP: Sending Ue Reconfig Request to RLC UL");
+ DU_LOG("DEBUG --> DU_APP: Sending Ue Reconfig Request to RLC UL");
ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeRecfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeRecfgReqToRlc()");
+ DU_LOG("ERROR --> DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeRecfgReqToRlc()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeRecfg, sizeof(RlcUeRecfg));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received RlcUeRecfg is NULL at sendUeRecfgReqToRlc()");
+ DU_LOG("ERROR --> DU_APP: Received RlcUeRecfg is NULL at sendUeRecfgReqToRlc()");
ret = RFAILED;
}
return ret;
DU_ALLOC_SHRABL_BUF(*oldSnssai, sizeof(Snssai));
if(*oldSnssai == NULL)
{
- DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillSnssaiInfo()");
+ DU_LOG("ERROR --> DU APP : Memory Alloc Failed at fillSnssaiInfo()");
return RFAILED;
}
memcpy(*oldSnssai, snssaiDb, sizeof(Snssai));
ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg.rlcMode, &ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg);
if(ret == RFAILED)
{
- DU_LOG("\n ERROR --> DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
+ DU_LOG(" ERROR --> DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
memset(rlcUeCfg, 0, sizeof(DuRlcUeCfg));
return ret;
}
if(duCb.actvCellLst[cellIdx] && (ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId))
{
GET_UE_ID(ueCcchCtxt->crnti, ueId);
- DU_LOG("\nDEBUG --> DU_APP: Filling UeCb for ueId [%d]", ueId);
+ DU_LOG("DEBUG --> DU_APP: Filling UeCb for ueId [%d]", ueId);
ueIdx = ueId-1;
duCb.actvCellLst[cellIdx]->ueCb[ueIdx].f1UeDb = NULLP;
ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, ueCcchCtxt->crnti, NULL,
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duMacUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
+ DU_LOG("ERROR --> DU APP : Failed to send UE create request to MAC");
/* Filling Rlc Ue Config */
memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg, 0, sizeof(DuRlcUeCfg));
ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, NULL,
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
+ DU_LOG("ERROR --> DU APP : Failed to send UE create request to RLC");
duCb.actvCellLst[cellIdx]->numActvUes++;
memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
ret = updateDuMacUeCfg(cellId, gnbDuUeF1apId, crnti, ueCfgDb, duMacUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG("ERROR --> DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
return RFAILED;
}
{
memset(macUeCfg, 0, sizeof(MacUeCreateReq));
fillMacUeCfg(duMacUeCfg, macUeCfg);
- DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to MAC");
+ DU_LOG("DEBUG --> 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("\nERROR --> DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG("ERROR --> DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCreateReq));
}
}
else
{
- DU_LOG("\n ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
+ DU_LOG(" ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
ret = RFAILED;
}
return ret;
GET_CELL_IDX(cellId, cellIdx);
if(duCb.actvCellLst[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP : Cell Id [%d] not found in duBuildAndSendRachRsrcReqToMac()", cellId);
+ DU_LOG("ERROR --> DU APP : Cell Id [%d] not found in duBuildAndSendRachRsrcReqToMac()", cellId);
return RFAILED;
}
DU_ALLOC_SHRABL_BUF(rachRsrcReq, sizeof(MacRachRsrcReq));
if(!rachRsrcReq)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for RACH Resource Request in \
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for RACH Resource Request in \
duBuildAndSendRachRsrcReqToMac()");
return RFAILED;
}
if(((*packMacRachRsrcReqOpts[pst.selector])(&pst, rachRsrcReq)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failure in sending RACH Resource Request to MAC at \
+ DU_LOG("ERROR --> DU_APP : Failure in sending RACH Resource Request to MAC at \
duBuildAndSendRachRsrcReqToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rachRsrcReq, sizeof(MacRachRsrcReq));
return RFAILED;
DuCellCb *cellCb = NULLP;
DuUeCb *ueCb = NULLP;
- DU_LOG("\nINFO --> DU APP : Received RACH Resource Response from MAC. Cell ID [%d] UE ID [%d]",
+ DU_LOG("INFO --> DU APP : Received RACH Resource Response from MAC. Cell ID [%d] UE ID [%d]",
rachRsrcRsp->cellId, rachRsrcRsp->ueId);
if(rachRsrcRsp->result == MAC_DU_APP_RSP_OK)
{
- DU_LOG("\nINFO : DU APP : RACH Resource Response from MAC : Result [SUCCESS]");
+ DU_LOG("INFO : DU APP : RACH Resource Response from MAC : Result [SUCCESS]");
/* Fetch Cell Cb */
GET_CELL_IDX(rachRsrcRsp->cellId, cellIdx);
/* RACH resources allocated to UE is sent to CU in UE Context Setup Response
* along with the result of UE Context setup requested by CU */
if((ret = BuildAndSendUeCtxtRsp(rachRsrcRsp->cellId, rachRsrcRsp->ueId)) != ROK)
- DU_LOG("\nERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
+ DU_LOG("ERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
}
else
- DU_LOG("\nERROR --> DU APP : UE ID [%d] not found in DuProcMacRachRsrcRsp", rachRsrcRsp->ueId);
+ DU_LOG("ERROR --> DU APP : UE ID [%d] not found in DuProcMacRachRsrcRsp", rachRsrcRsp->ueId);
}
else
- DU_LOG("\nERROR --> DU APP : Cell ID [%d] not found in DuProcMacRachRsrcRsp", rachRsrcRsp->cellId);
+ DU_LOG("ERROR --> DU APP : Cell ID [%d] not found in DuProcMacRachRsrcRsp", rachRsrcRsp->cellId);
}
else
- DU_LOG("\nINFO : DU APP : RACH Resource Response from MAC : Result [FAILURE]");
+ DU_LOG("INFO : DU APP : RACH Resource Response from MAC : Result [FAILURE]");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rachRsrcRsp, sizeof(MacRachRsrcRsp));
return ret;
GET_CELL_IDX(macUeCfg->cellId, cellIdx);
if(duCb.actvCellLst[cellIdx] == NULLP)
{
- DU_LOG("\nERROR --> DU APP: CellId[%d] not found", macUeCfg->cellId);
+ DU_LOG("ERROR --> DU APP: CellId[%d] not found", macUeCfg->cellId);
return RFAILED;
}
oldMacUeCfg = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueId-1].duMacUeCfg;
freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1].lcConfig);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
+ DU_LOG("ERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
break;
}
}
ret = fillMacLcCfgToAddMod(NULL, &f1UeDb->duUeCfg.macLcCfg[dbIdx], &macUeCfg->lcCfgList[numLcs], true);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
+ DU_LOG("ERROR --> DU APP : Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
break;
}
macUeCfg->numLcs++;
break;
}
default:
- DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcBearerCfg.rlcMode);
+ DU_LOG("ERROR --> DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcBearerCfg.rlcMode);
return RFAILED;
}
return ROK;
ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to modify LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
+ DU_LOG("ERROR --> DU APP : Failed to modify LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
break;
}
fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].rlcBearerCfg.snssai,\
freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1].rlcBearerCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
+ DU_LOG("ERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
break;
}
}
DU_ALLOC(*ueCbTnlCfg, sizeof(UpTnlCfg));
if(*ueCbTnlCfg == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for drbId[%d]", f1TnlCfg->drbId);
+ DU_LOG("ERROR --> DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for drbId[%d]", f1TnlCfg->drbId);
return RFAILED;
}
}
DU_ALLOC((*ueCbTnlCfg)->tnlCfg1, sizeof(GtpTnlCfg));
if((*ueCbTnlCfg)->tnlCfg1 == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for tnlCfg1 for drbId[%d]", f1TnlCfg->drbId);
+ DU_LOG("ERROR --> DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for tnlCfg1 for drbId[%d]", f1TnlCfg->drbId);
return RFAILED;
}
}
if(f1TnlCfg->tnlCfg1 == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Tunnel config not found");
+ DU_LOG("ERROR --> DU_APP : Tunnel config not found");
return ret;
}
drbFound = true; /* existing DRB */
if(duProcEgtpTunnelCfg(teIdx, duCb.upTnlCfg[teIdx], &duUeCfg->upTnlInfo[drbIdx]) != ROK)
{
- DU_LOG("\nERROR -> DU_APP : duUpdateTunnelCfgDb: Failed to modify tunnel req for Drb id[%d]",
+ DU_LOG("ERROR -> DU_APP : duUpdateTunnelCfgDb: Failed to modify tunnel req for Drb id[%d]",
duUeCfg->upTnlInfo[drbIdx].drbId);
ret = RFAILED;
}
{
if(duProcEgtpTunnelCfg(NULLP, NULLP, &duUeCfg->upTnlInfo[drbIdx]) != ROK)
{
- DU_LOG("\nERROR -> DU_APP : duUpdateTunnelCfgDb: Failed to add tunnel req for Drb id[%d]",
+ DU_LOG("ERROR -> DU_APP : duUpdateTunnelCfgDb: Failed to add tunnel req for Drb id[%d]",
duUeCfg->upTnlInfo[drbIdx].drbId);
ret = RFAILED;
break;
ueCb->duMacUeCfg.crnti = crnti;
ret = duUpdateMacCfg(&ueCb->duMacUeCfg, ueCb->f1UeDb);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
+ DU_LOG("ERROR --> DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
else
{
if(duUpdateTunnelCfgDb(ueId, cellId, &ueCb->f1UeDb->duUeCfg) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
+ DU_LOG("ERROR --> DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
return RFAILED;
}
}
}
else
- DU_LOG("\nERROR --> DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
+ DU_LOG("ERROR --> DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
return ret;
}
{
if(pst->event == EVENT_MAC_UE_CREATE_RSP)
{
- DU_LOG("\nINFO --> DU APP : MAC UE Create Response : SUCCESS [DU UE F1AP ID : %d]", cfgRsp->ueId);
+ DU_LOG("INFO --> DU APP : MAC UE Create Response : SUCCESS [DU UE F1AP ID : %d]", cfgRsp->ueId);
if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].gnbDuUeF1apId == cfgRsp->ueId))
{
* from MAC for CFRA */
if((duBuildAndSendRachRsrcReqToMac(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to send RACH Resource Request to MAC");
+ DU_LOG("ERROR --> DU APP : Failed to send RACH Resource Request to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR -> DU APP : Failure in updating DU UE CB");
+ DU_LOG("ERROR -> DU APP : Failure in updating DU UE CB");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, cfgRsp->ueId);
+ DU_LOG("ERROR --> DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, cfgRsp->ueId);
ret = RFAILED;
}
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
}
else
{
- DU_LOG("\nERROR --> DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCreateRsp()");
+ DU_LOG("ERROR --> DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCreateRsp()");
ret = RFAILED;
}
return ret;
{
if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
{
- DU_LOG("\nINFO --> DU APP : MAC UE Reconfig Response : SUCCESS [DU UE F1AP ID : %d]", reCfgRsp->ueId);
+ DU_LOG("INFO --> DU APP : MAC UE Reconfig Response : SUCCESS [DU UE F1AP ID : %d]", reCfgRsp->ueId);
if(duCb.actvCellLst[cellIdx] &&
(duCb.actvCellLst[cellIdx]->ueCb[reCfgRsp->ueId -1].gnbDuUeF1apId == reCfgRsp->ueId))
{
{
if((BuildAndSendUeCtxtRsp(reCfgRsp->cellId, reCfgRsp->ueId)) != ROK)
{
- DU_LOG("\nERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
+ DU_LOG("ERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, reCfgRsp, sizeof(MacUeRecfgRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR -> DU APP : Failure in updating DU UE CB");
+ DU_LOG("ERROR -> DU APP : Failure in updating DU UE CB");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, reCfgRsp, sizeof(MacUeRecfgRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : MAC UE RECFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, reCfgRsp->ueId);
+ DU_LOG("ERROR --> DU APP : MAC UE RECFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, reCfgRsp->ueId);
if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
{
//TODO: Send the failure case in Ue Context Setup Response
}
else
{
- DU_LOG("\nERROR --> DU APP : Received MAC Ue ReConfig Response is NULL at DuProcMacUeRecfgRsp()");
+ DU_LOG("ERROR --> DU APP : Received MAC Ue ReConfig Response is NULL at DuProcMacUeRecfgRsp()");
ret = RFAILED;
}
return ret;
ret = updateRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
+ DU_LOG("ERROR --> DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
return ret;
}
fillRlcUeCfg(duRlcUeCfg, rlcUeCfg);
/* Processing one Ue at a time to RLC */
- DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to RLC UL");
+ DU_LOG("DEBUG --> DU_APP: Sending UE create request to RLC UL");
ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : Failure in sending Ue Create Req to RLC");
+ DU_LOG("ERROR --> DU_APP : Failure in sending Ue Create Req to RLC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCreate));
ret = RFAILED;
}
}
else
{
- DU_LOG("\n ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
+ DU_LOG(" ERROR --> DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
ret = RFAILED;
}
return ret;
{
if(pst->event == EVENT_RLC_UE_CREATE_RSP)
{
- DU_LOG("\nINFO --> DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
+ DU_LOG("INFO --> DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].ueState == UE_HANDIN_IN_PROGRESS) &&
* from MAC for CFRA */
if((duBuildAndSendRachRsrcReqToMac(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failed to send RACH Resource Request to MAC");
+ DU_LOG("ERROR --> DU APP : Failed to send RACH Resource Request to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCreateRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
+ DU_LOG("ERROR --> DU APP : Failure in updating DU UE CB");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCreateRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: RLC UE CREATE Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
+ DU_LOG("ERROR --> DU_APP: RLC UE CREATE Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
pst->event, cfgRsp->ueId, cfgRsp->reason);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received RLC Ue Create Response is NULL at DuProcRlcUeCreateRsp()");
+ DU_LOG("ERROR --> DU_APP: Received RLC Ue Create Response is NULL at DuProcRlcUeCreateRsp()");
ret = RFAILED;
}
return ret;
{
if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
{
- DU_LOG("\nINFO --> DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
+ DU_LOG("INFO --> DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duMacUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
{
if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
- DU_LOG("\nERROR --> DU APP : Failure in BuildAndSendUeCtxtRsp");
+ DU_LOG("ERROR --> DU APP : Failure in BuildAndSendUeCtxtRsp");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeReconfigRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
+ DU_LOG("ERROR --> DU APP : Failure in updating DU UE CB");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeReconfigRsp));
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: RLC UE RE-CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
+ DU_LOG("ERROR --> DU_APP: RLC UE RE-CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
pst->event, cfgRsp->ueId, cfgRsp->reason);
if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
{
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received RLC Ue ReConfig Response is NULL at DuProcRlcUeReconfigRsp()");
+ DU_LOG("ERROR --> DU_APP: Received RLC Ue ReConfig Response is NULL at DuProcRlcUeReconfigRsp()");
ret = RFAILED;
}
return ret;
ret = updateRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed at duBuildAndSendUeRecfgReqToRlc()");
+ DU_LOG("ERROR --> DU APP : Failed at duBuildAndSendUeRecfgReqToRlc()");
else
{
fillRlcUeRecfg(duRlcUeCfg, rlcUeRecfg);
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory Alloc failed at duBuildAndSendUeRecfgReqToRlc()");
+ DU_LOG("ERROR --> DU APP : Memory Alloc failed at duBuildAndSendUeRecfgReqToRlc()");
ret = RFAILED;
}
DU_FREE(duRlcUeCfg, sizeof(DuRlcUeCfg));
ret = updateDuMacUeCfg(cellId, duUeF1apId, crnti, ueCfgDb, duMacUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeRecfgReqToMac()");
+ DU_LOG("ERROR --> DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeRecfgReqToMac()");
else
{
fillMacUeRecfg(duMacUeCfg, macUeRecfg);
}
else
{
- DU_LOG("\nERROR --> DU APP : Memory alloc failed for macUeCfg at duBuildAndSendUeRecfgReqToMac()");
+ DU_LOG("ERROR --> DU APP : Memory alloc failed for macUeCfg at duBuildAndSendUeRecfgReqToMac()");
ret = RFAILED;
}
DU_FREE(duMacUeCfg, sizeof(DuMacUeCfg));
uint16_t crnti;
DuUeCfg *duUeCfg = NULLP;
- DU_LOG("\nDEBUG --> DU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
+ DU_LOG("DEBUG --> DU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
if(!ueCb)
{
- DU_LOG("\nERROR --> DU APP : UE Cb is NULL");
+ DU_LOG("ERROR --> DU APP : UE Cb is NULL");
return RFAILED;
}
/* Since UE attach has not yet happened, crnti is unknow. Hence passing 0 */
ret = duBuildAndSendUeCreateReqToMac(cellId, ueCb->gnbDuUeF1apId, 0, duUeCfg, &ueCb->duMacUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
+ DU_LOG("ERROR --> DU APP : Failed to send UE create request to MAC");
ret = duBuildAndSendUeCreateReqToRlc(cellId, ueCb->gnbDuUeF1apId, duUeCfg, &ueCb->duRlcUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
+ DU_LOG("ERROR --> DU APP : Failed to send UE create request to RLC");
}
else
/* Filling RLC UE Reconfig */
ret = duBuildAndSendUeRecfgReqToRlc(cellId, ueCb->gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
+ DU_LOG("ERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
/* Filling MAC UE Reconfig */
ret = duBuildAndSendUeRecfgReqToMac(cellId, ueCb->gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
+ DU_LOG("ERROR --> DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
}
return ret;
{
ret = duBuildAndSendUeContextSetupReq(cellId, ueCb);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
+ DU_LOG("ERROR --> DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
}
if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
{
ret = duBuildAndSendUeContextModReq(cellId, ueCb->gnbDuUeF1apId, crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to process UE Context Mod Request in DuProcRlcDlRrcMsgRsp()");
+ DU_LOG("ERROR --> DU APP : Failed to process UE Context Mod Request in DuProcRlcDlRrcMsgRsp()");
}
if(ueCb->f1UeDb->actionType == UE_CTXT_RELEASE && ueCb->ueState == UE_ACTIVE)
ret = duBuildAndSendUeDeleteReq(cellId, crnti);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to process UE Context Release Request in DuProcRlcDlRrcMsgRsp()");
+ DU_LOG("ERROR --> DU APP : Failed to process UE Context Release Request in DuProcRlcDlRrcMsgRsp()");
}
}
}
}
else
- DU_LOG("\nERROR --> DU APP : Failed to transmit DL RRC Msg");
+ DU_LOG("ERROR --> DU APP : Failed to transmit DL RRC Msg");
return ret;
}
ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->duRlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
+ DU_LOG("ERROR --> 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);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
+ DU_LOG("ERROR --> DU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
}
}
}
{
uint8_t ret = ROK;
- DU_LOG("\nDEBUG --> DU_APP: Processing Ue Context Mod Request for cellId [%d]", cellId);
+ DU_LOG("DEBUG --> DU_APP: Processing Ue Context Mod Request for cellId [%d]", cellId);
/* Filling RLC Ue Reconfig */
ret = duBuildAndSendUeRecfgReqToRlc(cellId, gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextModReq()");
+ DU_LOG("ERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextModReq()");
/* Filling MAC Ue Reconfig */
ret = duBuildAndSendUeRecfgReqToMac(cellId, gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextModReq()");
+ DU_LOG("ERROR --> DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextModReq()");
return ret;
}
ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->duRlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextModReq()");
+ DU_LOG("ERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextModReq()");
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 = duBuildAndSendUeContextModReq(cellId, ueCb->gnbDuUeF1apId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : Failed to build ue context setup Req in duProcUeContextModReq()");
+ DU_LOG("ERROR --> DU APP : Failed to build ue context setup Req in duProcUeContextModReq()");
return RFAILED;
}
}
{
if((BuildAndSendUeContextModRsp(ueCb) != ROK))
{
- DU_LOG("\nERROR --> DU APP : Failed to build UE Context modification response");
+ DU_LOG("ERROR --> DU APP : Failed to build UE Context modification response");
return RFAILED;
}
}
DU_ALLOC_SHRABL_BUF(rachRsrcRel, sizeof(MacRachRsrcRel));
if(!rachRsrcRel)
{
- DU_LOG("\nERROR --> DU APP : Failed to allocate memory for RACH Resource Release in \
+ DU_LOG("ERROR --> DU APP : Failed to allocate memory for RACH Resource Release in \
duBuildAndSendRachRsrcRelToMac()");
return RFAILED;
}
if(((*packMacRachRsrcRelOpts[pst.selector])(&pst, rachRsrcRel)) != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Failure in sending RACH Resource Release to MAC at \
+ DU_LOG("ERROR --> DU_APP : Failure in sending RACH Resource Release to MAC at \
duBuildAndSendRachRsrcRelToMac()");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rachRsrcRel, sizeof(MacRachRsrcRel));
return RFAILED;
}
else
{
- DU_LOG("\nERROR --> DU APP : deleteUeCfg(): CellIdx[%d] is not found", cellIdx);
+ DU_LOG("ERROR --> DU APP : deleteUeCfg(): CellIdx[%d] is not found", cellIdx);
return RFAILED;
}
return ROK;
{
if(deleteRsp->status == SUCCESSFUL)
{
- DU_LOG("\nINFO --> DU APP : MAC UE Delete Response : SUCCESS [UE IDX : %d]", deleteRsp->ueId);
+ DU_LOG("INFO --> DU APP : MAC UE Delete Response : SUCCESS [UE IDX : %d]", deleteRsp->ueId);
GET_CELL_IDX(deleteRsp->cellId, cellIdx);
if(duCb.actvCellLst[cellIdx])
{
ret = BuildAndSendUeContextReleaseComplete(deleteRsp->cellId, gnbCuUeF1apId, gnbDuUeF1apId);
if(ret != ROK)
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeDeleteRsp(): failed to send UE context release complete");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeDeleteRsp(): failed to send UE context release complete");
}
}
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response : FAILURE [UE IDX : %d]",\
+ DU_LOG("ERROR --> DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response : FAILURE [UE IDX : %d]",\
deleteRsp->ueId);
ret = RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response is null");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response is null");
ret = RFAILED;
}
return ret;
if(delRsp->status == SUCCESSFUL)
{
- DU_LOG("\nINFO --> DU_APP: RLC UE Delete Response : SUCCESS [UE IDX:%d]", ueId);
+ DU_LOG("INFO --> DU_APP: RLC UE Delete Response : SUCCESS [UE IDX:%d]", ueId);
if(duCb.actvCellLst[cellIdx]!=NULLP)
{
duCb.actvCellLst[cellIdx]->ueCb[ueId-1].duRlcUeCfg.rlcUeCfgState = UE_DELETE_COMPLETE;
GET_CRNTI(crnti, ueId);
if(sendUeDeleteReqToMac(delRsp->cellId, ueId, crnti) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeDeleteReq(): Failed to build UE delete req for MAC ");
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeDeleteReq(): Failed to build UE delete req for MAC ");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: RLC UE Delete Response : FAILED [UE IDX:%d]", ueId);
+ DU_LOG("ERROR --> DU_APP: RLC UE Delete Response : FAILED [UE IDX:%d]", ueId);
ret = RFAILED;
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, delRsp, sizeof(RlcUeDeleteRsp));
ueDelete->crnti = crnti;
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_DELETE_REQ);
- DU_LOG("\nDEBUG --> DU_APP: Sending UE delete Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending UE delete Request to MAC ");
ret = (*packMacUeDeleteReqOpts[pst.selector])(&pst, ueDelete);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP: sendUeDeleteReqToMac(): Failed to send UE delete Req to MAC");
+ DU_LOG("ERROR --> DU_APP: sendUeDeleteReqToMac(): Failed to send UE delete Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueDelete, sizeof(MacUeDelete));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: sendUeDeleteReqToMac(): Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP: sendUeDeleteReqToMac(): Failed to allocate memory");
ret = RFAILED;
}
return ret;
ret = (*packRlcUeDeleteReqOpts[pst.selector])(&pst, ueDelete);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : sendUeDeleteReqToRlc():Failed to send UE Delete Req to RLC");
+ DU_LOG("ERROR --> DU_APP : sendUeDeleteReqToRlc():Failed to send UE Delete Req to RLC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueDelete, sizeof(RlcUeDelete));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: sendUeDeleteReqToRlc():Memory allocation failed");
+ DU_LOG("ERROR --> DU_APP: sendUeDeleteReqToRlc():Memory allocation failed");
ret = RFAILED;
}
return ret;
uint8_t ueId =0;
uint16_t cellIdx = 0;
- DU_LOG("\nDEBUG --> DU_APP: Processing UE Delete Request ");
+ DU_LOG("DEBUG --> DU_APP: Processing UE Delete Request ");
GET_CELL_IDX(cellId, cellIdx);
GET_UE_ID(crnti, ueId);
{
if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeDeleteReq(): CRNTI [%d] not found", crnti);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeDeleteReq(): CRNTI [%d] not found", crnti);
return RFAILED;
}
duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].ueState = UE_DELETION_IN_PROGRESS;
if(sendUeDeleteReqToRlc(cellId, ueId) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeDeleteRsp():Failed to build UE delete req for RLC ");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeDeleteRsp():Failed to build UE delete req for RLC ");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeDeleteReq(): Cell Id is not found");
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeDeleteReq(): Cell Id is not found");
return RFAILED;
}
duUeCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duProcUeContextReleaseCommand() : Failed to send DL RRC msg");
+ DU_LOG("ERROR --> DU APP : duProcUeContextReleaseCommand() : Failed to send DL RRC msg");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
duUeCb->f1UeDb->dlRrcMsg->rrcMsgSize);
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
ret = duBuildAndSendUeDeleteReq(cellId,crnti);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duProcUeContextReleaseCommand(): Failed to build and send Ue Delete request");
+ DU_LOG("ERROR --> DU APP : duProcUeContextReleaseCommand(): Failed to build and send Ue Delete request");
}
}
}
ueReset->ueId = ueId;
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_RESET_REQ);
- DU_LOG("\nDEBUG --> DU_APP: Sending UE Reset Request to MAC ");
+ DU_LOG("DEBUG --> DU_APP: Sending UE Reset Request to MAC ");
ret = (*packMacUeResetReqOpts[pst.selector])(&pst, ueReset);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP: sendUeResetReqToMac(): Failed to send UE Reset Req to MAC");
+ DU_LOG("ERROR --> DU_APP: sendUeResetReqToMac(): Failed to send UE Reset Req to MAC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueReset, sizeof(MacUeResetReq));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: sendUeResetReqToMac(): Failed to allocate memory");
+ DU_LOG("ERROR --> DU_APP: sendUeResetReqToMac(): Failed to allocate memory");
ret = RFAILED;
}
return ret;
uint8_t ueId =0;
uint16_t cellIdx = 0;
- DU_LOG("\nDEBUG --> DU_APP : Building UE reset request");
+ DU_LOG("DEBUG --> DU_APP : Building UE reset request");
GET_CELL_IDX(cellId, cellIdx);
GET_UE_ID(crnti, ueId);
{
if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeResetReq(): CRNTI [%d] not found", crnti);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeResetReq(): CRNTI [%d] not found", crnti);
return RFAILED;
}
duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].ueState = UE_RESET_IN_PROGRESS;
if(sendUeResetReqToMac(cellId, ueId) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): Failed to build UE reset req for MAC ");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeResetRsp(): Failed to build UE reset req for MAC ");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeResetReq(): Cell Id %d not found", cellId);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeResetReq(): Cell Id %d not found", cellId);
return RFAILED;
}
{
if(resetRsp->status == SUCCESSFUL)
{
- DU_LOG("\nINFO --> DU APP : MAC UE Reset Response : SUCCESS [UE IDX : %d]", resetRsp->ueId);
+ DU_LOG("INFO --> DU APP : MAC UE Reset Response : SUCCESS [UE IDX : %d]", resetRsp->ueId);
GET_CELL_IDX(resetRsp->cellId, cellIdx);
if(duCb.actvCellLst[cellIdx])
{
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response : FAILURE [UE IDX : %d]",resetRsp->ueId);
+ DU_LOG("ERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response : FAILURE [UE IDX : %d]",resetRsp->ueId);
ret = RFAILED;
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, resetRsp, sizeof(MacUeResetRsp));
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response is null");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response is null");
ret = RFAILED;
}
return ret;
break;
}
- DU_LOG("\nINFO --> DU APP : MAC UE sync status for received UeId %d is %s", ueSyncStatusInd->ueId,status);
+ DU_LOG("INFO --> DU APP : MAC UE sync status for received UeId %d is %s", ueSyncStatusInd->ueId,status);
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Ue Id [%d] not found",ueSyncStatusInd->cellId);
+ DU_LOG("ERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Ue Id [%d] not found",ueSyncStatusInd->cellId);
}
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Cell Id [%d] not found",ueSyncStatusInd->cellId);
+ DU_LOG("ERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Cell Id [%d] not found",ueSyncStatusInd->cellId);
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ueSyncStatusInd, sizeof(MacUeSyncStatusInd));
}
else
{
- DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication is null");
+ DU_LOG("ERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication is null");
}
return ret;
}
ret = (*packRlcUeReestablishReqOpts[pst.selector])(&pst, ueReestablish);
if(ret == RFAILED)
{
- DU_LOG("\nERROR --> DU_APP : sendUeReestablishReqToRlc():Failed to send UE Reestablishment Req to RLC");
+ DU_LOG("ERROR --> DU_APP : sendUeReestablishReqToRlc():Failed to send UE Reestablishment Req to RLC");
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueReestablish, sizeof(RlcUeReestablishReq));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: sendUeReestablishReqToRlc():Memory allocation failed");
+ DU_LOG("ERROR --> DU_APP: sendUeReestablishReqToRlc():Memory allocation failed");
ret = RFAILED;
}
return ret;
uint8_t ueId =0;
uint16_t cellIdx = 0;
- DU_LOG("\nDEBUG --> DU_APP: Building UE Reestablishment Request ");
+ DU_LOG("DEBUG --> DU_APP: Building UE Reestablishment Request ");
GET_CELL_IDX(cellId, cellIdx);
GET_UE_ID(crnti, ueId);
{
if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): CRNTI [%d] not found", crnti);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeReestablishReq(): CRNTI [%d] not found", crnti);
return RFAILED;
}
if(sendUeReestablishReqToRlc(cellId, ueId, numLcToReestablish, lcId) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): Failed to send UE reestablishment req for RLC ");
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeReestablishReq(): Failed to send UE reestablishment req for RLC ");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): Cell Id %d is not found", cellId);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeReestablishReq(): Cell Id %d is not found", cellId);
return RFAILED;
}
if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti == crnti)
{
/*TODO: complete the processing of UE Reestablishment Response */
- DU_LOG("\nINFO --> DU_APP: RLC UE Reestablishment Response : SUCCESS [UE IDX:%d]", ueId);
+ DU_LOG("INFO --> DU_APP: RLC UE Reestablishment Response : SUCCESS [UE IDX:%d]", ueId);
ret = ROK;
}
else
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishRsp(): CRNTI [%d] not found", crnti);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeReestablishRsp(): CRNTI [%d] not found", crnti);
}
else
- DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishRsp(): Cell Id[%d] is not found", ueReestablishRsp->cellId);
+ DU_LOG("ERROR --> DU APP : duBuildAndSendUeReestablishRsp(): Cell Id[%d] is not found", ueReestablishRsp->cellId);
}
else
{
- DU_LOG("\nERROR --> DU_APP: RLC UE Reestablishment Response : FAILED [UE IDX:%d]", ueId);
+ DU_LOG("ERROR --> DU_APP: RLC UE Reestablishment Response : FAILED [UE IDX:%d]", ueId);
}
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp));
if((pageUeLL == NULLP) ||
((pageUeLL->first == NULLP) && (action != CREATE)))
{
- DU_LOG("\nERROR --> DU APP: UE Page Record LL is empty");
+ DU_LOG("ERROR --> DU APP: UE Page Record LL is empty");
return NULLP;
}
node = pageUeLL->first;
ueRecord = (DuPagUeRecord *)node->node;
if(action == PRINT)
{
- DU_LOG("\n INFO --> DU APP ueId:%d, sTmsi:%lu",\
+ DU_LOG(" INFO --> DU APP ueId:%d, sTmsi:%lu",\
ueRecord->pagUeId, ueRecord->sTmsi);
}
else if(ueRecord && (ueRecord->pagUeId == pagUeId &&
}
else
{
- DU_LOG("\nERROR --> DU APP : Allocation of UE Record failed,ueId:%d",pagUeId);
+ DU_LOG("ERROR --> DU APP : Allocation of UE Record failed,ueId:%d",pagUeId);
return NULLP;
}
if(duAddNodeToLList(pageUeLL, ueRecord, NULLP) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : failed to Add Ue Record Node,ueId:%d",pagUeId);
+ DU_LOG("ERROR --> DU APP : failed to Add Ue Record Node,ueId:%d",pagUeId);
DU_FREE(ueRecord, sizeof(DuPagUeRecord));
return NULLP;
}
{
if(!found || ueRecord == NULLP)
{
- DU_LOG("\nERROR --> DU APP: UeId:%d not found; thus Deletion unsuccessful",pagUeId);
+ DU_LOG("ERROR --> DU APP: UeId:%d not found; thus Deletion unsuccessful",pagUeId);
}
else
{
}
default:
{
- DU_LOG("\nERROR --> DU APP: Incorrect ActionType:%d on UeRecord",action);
+ DU_LOG("ERROR --> DU APP: Incorrect ActionType:%d on UeRecord",action);
}
}
return NULLP;
if((pagInfoLL == NULLP) ||
((pagInfoLL->first == NULLP) && (action != CREATE)))
{
- DU_LOG("\nERROR --> DU APP: PagInfo LL is empty");
+ DU_LOG("ERROR --> DU APP: PagInfo LL is empty");
return NULLP;
}
node = pagInfoLL->first;
pagInfo = (DuPagUeList *)node->node;
if(action == PRINT)
{
- DU_LOG("\n INFO --> DU APP: Paging Index (i_s):%d",pagInfo->i_s);
+ DU_LOG(" INFO --> DU APP: Paging Index (i_s):%d",pagInfo->i_s);
handlePageUeLL(NULLD, NULLD, &(pagInfo->pagUeList), PRINT);
}
else if(action == TRAVERSE_ALL)
}
else
{
- DU_LOG("\nERROR --> DU APP : Allocation of List failed,i_s:%d",i_s);
+ DU_LOG("ERROR --> DU APP : Allocation of List failed,i_s:%d",i_s);
return NULLP;
}
if(duAddNodeToLList(pagInfoLL, pagInfo, NULLP) == RFAILED)
{
- DU_LOG("\nERROR --> DU APP : failed to Add Node,i_s:%d",i_s);
+ DU_LOG("ERROR --> DU APP : failed to Add Node,i_s:%d",i_s);
DU_FREE(pagInfo, sizeof(DuPagUeList));
return NULLP;
}
{
if(!found || pagInfo == NULLP)
{
- DU_LOG("\nERROR --> DU APP: i_s:%d not found; thus Deletion unsuccessful",i_s);
+ DU_LOG("ERROR --> DU APP: i_s:%d not found; thus Deletion unsuccessful",i_s);
}
else
{
}
default:
{
- DU_LOG("\nERROR --> DU APP: Incorrect ActionType:%d on PageInfo List",action);
+ DU_LOG("ERROR --> DU APP: Incorrect ActionType:%d on PageInfo List",action);
}
}
return NULLP;
ret = cmHashListGetNext(pagingInfoMap, (PTR)prevPageInfoLL, (PTR *)&pagInfoLLFromPF);
if(ret == ROK)
{
- DU_LOG("\nDEBUG --> DUAPP: Page List for PF:%d",pagInfoLLFromPF->pf);
+ DU_LOG("DEBUG --> DUAPP: Page List for PF:%d",pagInfoLLFromPF->pf);
handlePageInfoLL(NULLD, NULLD, &(pagInfoLLFromPF->pagInfoList), PRINT);
prevPageInfoLL = pagInfoLLFromPF;
}
#ifdef MEM_SIZE_CHECK
#define DU_APP_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) \
{\
- DU_LOG("\n DUAPP line = %d, func = %s, _size= %d ", _line, _func, _size); \
+ DU_LOG(" DUAPP line = %d, func = %s, _size= %d ", _line, _func, _size); \
}
#else
#define DU_APP_MEMORY_ALLOC_SIZE_LOG(_line, _func, _size) {}
ret = pthread_create(&sTsk->dep.tId, &attr, mtTskHdlr, (Ptr)sTsk);
if (ret != 0)
{
- DU_LOG("\nDU APP : Failed to create thread. Cause[%d]",ret);
+ DU_LOG("DU APP : Failed to create thread. Cause[%d]",ret);
pthread_attr_destroy(&attr);
#if (ERRCLASS & ERRCLS_DEBUG)
}
}
}
- DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+ DU_LOG("Call Flow: %s -> %s : %s\n", sourceTask, destTask, message);
}
#endif
* ****************************************************************/
uint8_t phyStubActvTsk(Pst *pst, Buffer *mBuf)
{
- DU_LOG("\nPHY_STUB: Received Event [%d]", pst->event);
+ DU_LOG("PHY_STUB: Received Event [%d]", pst->event);
#ifdef CALL_FLOW_DEBUG_LOG
callFlowPhyStubActvTsk(pst);
{
for(drbIdx = 0; drbIdx < NUM_DRB_TO_PUMP_DATA; drbIdx++) //Number of DRB times the loop will run
{
- DU_LOG("\nDEBUG --> PHY STUB: Sending UL User Data[DrbId:%d] for UEIdx %d\n",drbIdx,ueIdx);
+ DU_LOG("DEBUG --> PHY STUB: Sending UL User Data[DrbId:%d] for UEIdx %d\n",drbIdx,ueIdx);
l1SendUlUserData(drbIdx,ueIdx);
}
}
MAC_ALLOC(fapiParamRsp, sizeof(fapi_param_resp_t));
if(!fapiParamRsp)
{
- DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
+ DU_LOG("ERROR --> PHY STUB: Memory allocation failed");
return RFAILED;
}
fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
fapiParamRsp->error_code = MSG_OK;
- DU_LOG("\nINFO --> PHY_STUB: Sending Param Request to Lower Mac");
+ DU_LOG("INFO --> PHY_STUB: Sending Param Request to Lower Mac");
procPhyMessages(fapiParamRsp->header.msg_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
MAC_FREE(fapiParamRsp, sizeof(fapi_param_resp_t));
#endif
MAC_ALLOC(fapiConfigRsp, sizeof(fapi_config_resp_t));
if(!fapiConfigRsp)
{
- DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
+ DU_LOG("ERROR --> PHY STUB: Memory allocation failed");
return RFAILED;
}
memset(fapiConfigRsp, 0, sizeof(fapi_config_resp_t));
msgLen = sizeof(fapi_config_resp_t) - sizeof(fapi_msg_t);
fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
- DU_LOG("\nINFO --> PHY_STUB: Sending Config Response to Lower Mac");
+ DU_LOG("INFO --> PHY_STUB: Sending Config Response to Lower Mac");
procPhyMessages(fapiConfigRsp->header.msg_id, \
sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
void l1HdlParamReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
- DU_LOG("\nINFO --> PHY_STUB: Received Param Request in PHY");
+ DU_LOG("INFO --> PHY_STUB: Received Param Request in PHY");
/* Build and send PARAM RESPONSE */
if(l1BldAndSndParamRsp(msg)!= ROK)
{
- DU_LOG("\nERROR --> PHY_STUB: Failed Sending Param Response");
+ DU_LOG("ERROR --> PHY_STUB: Failed Sending Param Response");
}
MAC_FREE(msg, sizeof(fapi_param_req_t));
#endif
p_fapi_api_queue_elem_t configReqElem = (p_fapi_api_queue_elem_t)msg;
fapi_config_req_t *configReq = (fapi_config_req_t *)(configReqElem +1);
- DU_LOG("\nINFO --> PHY_STUB: Received Config Request in PHY");
+ DU_LOG("INFO --> PHY_STUB: Received Config Request in PHY");
/* Handling CONFIG RESPONSE */
if(l1BldAndSndConfigRsp(configReq)!= ROK)
{
- DU_LOG("\nERROR --> PHY_STUB: Failed Sending config Response");
+ DU_LOG("ERROR --> PHY_STUB: Failed Sending config Response");
}
MAC_FREE(msg, msgLen);
MAC_ALLOC(crcInd, sizeof(fapi_crc_ind_t));
if(!crcInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for CRC Indication Message");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for CRC Indication Message");
return RFAILED;
}
memset(crcInd, 0, sizeof(fapi_crc_ind_t));
sizeof(fapi_crc_ind_t) - sizeof(fapi_msg_t));
/* Sending CRC indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending CRC Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending CRC Indication to MAC");
procPhyMessages(crcInd->header.msg_id, sizeof(fapi_crc_ind_t), (void *)crcInd);
MAC_FREE(crcInd, sizeof(fapi_crc_ind_t));
#endif
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
memset(pduInfo->pduData, 0, pduInfo->pdu_length);
{
case MSG_TYPE_MSG3:
{
- DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG3 PDU ");
+ DU_LOG("DEBUG --> PHY_STUB: Forming MSG3 PDU ");
/* For Initial RRC setup Request,
MAC subheader format is R/R/LCId (1byte)
LCId is CCCH(0)
}
case MSG_TYPE_SHORT_BSR:
{
- DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
+ DU_LOG("DEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
uint8_t lcgId = 0;
uint8_t bufferSizeIdx = 6;
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG5 PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming MSG5 PDU");
uint8_t msg5PduLen = 33; /* Length of MSG5 */
msg5PduLen += 2; /* RLC subheader */
uint8_t msg5[] = {1, msg5PduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 16, 0, \
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming AUTHENTICATION RESPONSE PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming AUTHENTICATION RESPONSE PDU");
uint8_t pduLen = 37; /* Length of PDU */
pduLen += 2; /* RLC subheader */
uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x3a, \
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming NAS SECURITY MODE COMPLETE PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming NAS SECURITY MODE COMPLETE PDU");
uint8_t pduLen = 93; /* Length of PDU */
pduLen += 2; /* RLC subheader */
uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x3a, 0x2a, 0x3f,
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC SECURITY MODE COMPLETE PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming RRC SECURITY MODE COMPLETE PDU");
uint8_t pduLen = 12; /* Length of PDU */
pduLen += 2; /* RLC subheader */
uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x2a, 0x40, \
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC REGISTRATION COMPLETE PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming RRC REGISTRATION COMPLETE PDU");
uint8_t pduLen = 12; /* Length of PDU */
pduLen += 2; /* RLC subheader */
uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x3a, 0x81, \
* RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
* From 38.322, section 6.2.2.4
*/
- DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC RECONFIGURATION COMPLETE PDU");
+ DU_LOG("DEBUG --> PHY_STUB: Forming RRC RECONFIGURATION COMPLETE PDU");
uint8_t pduLen = 13; /* PDU length */
pduLen += 2; /* RLC sub header */
uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 8, 64, 0, 0,\
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Sending Rx data indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending Rx data Indication to MAC");
procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
if(pduInfo->pdu_length)
MAC_ALLOC(rachInd, sizeof(fapi_rach_indication_t));
if(!rachInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rach Indication Message");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rach Indication Message");
return RFAILED;
}
memset(rachInd, 0, sizeof(fapi_rach_indication_t));
sizeof(fapi_rach_indication_t) - sizeof(fapi_msg_t));
/* Sending RACH indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending RACH Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending RACH Indication to MAC");
procPhyMessages(rachInd->header.msg_id, sizeof(fapi_rach_indication_t), (void *)rachInd);
MAC_FREE(rachInd, sizeof(fapi_rach_indication_t));
#endif
MAC_ALLOC_SHRABL_BUF(slotIndMsg, sizeof(fapi_slot_ind_t));
if(!slotIndMsg)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for slot Indication Message");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for slot Indication Message");
return RFAILED;
}
else
slotIndMsg->slot = slotValue;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\n\nDEBUG --> PHY_STUB: Sending Slot Indication [%d : %d] to MAC", sfnValue, slotValue);
+ DU_LOG("DEBUG --> PHY_STUB: Sending Slot Indication [%d : %d] to MAC", sfnValue, slotValue);
#endif
/* increment for the next TTI */
ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
if(!mBuf)
{
- DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
+ DU_LOG("ERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
MAC_FREE_SHRABL_BUF(pst.region, pst.pool, slotIndMsg, sizeof(fapi_slot_ind_t));
return RFAILED;
}
}
else
{
- DU_LOG("\nINFO --> PHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
+ DU_LOG("INFO --> PHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
MAC_FREE(msg, msgLen);
return RFAILED;
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
if(dlTtiReq->nPdus == 0)
{
- DU_LOG("\nDEBUG --> PHY_STUB: No PDU in DL TTI Request");
+ DU_LOG("DEBUG --> PHY_STUB: No PDU in DL TTI Request");
}
else
{
- DU_LOG("\nDEBUG --> PHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot);
+ DU_LOG("DEBUG --> PHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot);
}
#endif
{
if(dlTtiReq->pdus[pduCount].pduType == 3) //SSB_PDU_TYPE
{
- DU_LOG("\nINFO --> PHY_STUB: SSB PDU");
+ DU_LOG("INFO --> PHY_STUB: SSB PDU");
}
else if(dlTtiReq->pdus[pduCount].pduType == 0)
{
- DU_LOG("\nINFO --> PHY_STUB: PDCCH PDU");
+ DU_LOG("INFO --> PHY_STUB: PDCCH PDU");
}
else if(dlTtiReq->pdus[pduCount].pduType == 1)
{
- DU_LOG("\nINFO --> PHY_STUB: PDSCH PDU");
+ DU_LOG("INFO --> PHY_STUB: PDSCH PDU");
}
}
p_fapi_api_queue_elem_t txDataElem = (p_fapi_api_queue_elem_t)msg;
fapi_tx_data_req_t *txDataReq = (fapi_tx_data_req_t *)(txDataElem +1);
- DU_LOG("\nINFO --> PHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot);
+ DU_LOG("INFO --> PHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot);
/*
if(dlDedMsg)
{
- DU_LOG("\nINFO --> PHY_STUB: TxDataPdu for DED MSG sent");
+ DU_LOG("INFO --> PHY_STUB: TxDataPdu for DED MSG sent");
dlDedMsg = false;
}
*/
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nERROR --> PHY_STUB: Invalid Pdu Type %d", uciPdu->pduType);
+ DU_LOG("ERROR --> PHY_STUB: Invalid Pdu Type %d", uciPdu->pduType);
break;
}
return ret;
MAC_ALLOC(uciInd, sizeof(fapi_uci_indication_t));
if(!uciInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for UCI Indication");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for UCI Indication");
return RFAILED;
}
memset(uciInd, 0, sizeof(fapi_uci_indication_t));
fillMsgHeader(&uciInd->header, FAPI_UCI_INDICATION, msgLen);
/* Sending UCI indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending UCI Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending UCI Indication to MAC");
procPhyMessages(uciInd->header.msg_id, sizeof(fapi_uci_indication_t), (void *)uciInd);
}
MAC_FREE(uciInd, sizeof(fapi_uci_indication_t));
#ifdef ODU_SLOT_IND_DEBUG_LOG
if(numPdus == 0)
{
- DU_LOG("\nINFO --> PHY STUB: No PDU received in UL TTI Req");
+ DU_LOG("INFO --> PHY STUB: No PDU received in UL TTI Req");
}
else
{
- DU_LOG("\nINFO --> PHY STUB: Received UL TTI Request");
+ DU_LOG("INFO --> PHY STUB: Received UL TTI Request");
}
#endif
{
if(ulTtiReq->pdus[numPdus-1].pduType == 0)
{
- DU_LOG("\nINFO --> PHY STUB: PRACH PDU");
+ DU_LOG("INFO --> PHY STUB: PRACH PDU");
/* Send RACH Ind to L2 for first UE */
if(phyDb.ueDb.ueCb[UE_IDX_0].rachIndSent == false)
}
if(ulTtiReq->pdus[numPdus-1].pduType == 1)
{
- DU_LOG("\nINFO --> PHY STUB: PUSCH PDU");
+ DU_LOG("INFO --> PHY STUB: PUSCH PDU");
if (ROK == l1BuildAndSendCrcInd(ulTtiReq->slot, ulTtiReq->sfn,ulTtiReq->pdus[numPdus-1].pdu.pusch_pdu))
{
l1BuildAndSendRxDataInd(ulTtiReq->slot, ulTtiReq->sfn, ulTtiReq->pdus[numPdus-1].pdu.pusch_pdu);
}
if(ulTtiReq->pdus[numPdus-1].pduType == 2)
{
- DU_LOG("\nINFO --> PHY STUB: PUCCH PDU");
+ DU_LOG("INFO --> PHY STUB: PUCCH PDU");
fapi_ul_tti_req_t ulTtiSlotInd;
memset(&ulTtiSlotInd, 0, sizeof(fapi_ul_tti_req_t));
MAC_ALLOC_SHRABL_BUF(stopIndMsg, sizeof(fapi_stop_ind_t));
if(!stopIndMsg)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for stop Indication Message");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for stop Indication Message");
return RFAILED;
}
else
{
fillMsgHeader(&stopIndMsg->header, FAPI_STOP_INDICATION, msgLen);
- DU_LOG("\n\nINFO --> PHY_STUB: Processing Stop indication to MAC");
+ DU_LOG("INFO --> PHY_STUB: Processing Stop indication to MAC");
memset(&pst, 0, sizeof(Pst));
FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_STOP_IND);
ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
if(!mBuf)
{
- DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
+ DU_LOG("ERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
MAC_FREE_SHRABL_BUF(pst.region, pst.pool, stopIndMsg, sizeof(fapi_stop_ind_t));
return RFAILED;
}
slotValue = 0;
memset(&phyDb.ueDb, 0, sizeof(UeDb));
- DU_LOG("\nINFO --> PHY_STUB: Slot Indication is stopped successfully");
+ DU_LOG("INFO --> PHY_STUB: Slot Indication is stopped successfully");
MAC_FREE(msg, msgLen);
}
else
{
- DU_LOG("\nINFO --> PHY_STUB: Received Stop Req in PHY State %d", lwrMacCb.phyState);
+ DU_LOG("INFO --> PHY_STUB: Received Stop Req in PHY State %d", lwrMacCb.phyState);
MAC_FREE(msg, msgLen);
return RFAILED;
}
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication for msg5");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication for msg5");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Sending Rx data indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending Rx data Indication to MAC");
procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
if(pduInfo->pdu_length)
{
if(ulDciReq->pdus[numPdus-1].pduType == 0)
{
- DU_LOG("\nINFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
+ DU_LOG("INFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
//l1BuildAndSendMsg5(ulDciReq->sfn, ulDciReq->slot);
//msg5Sent = true;
}
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
/* Send Message to peer */
while(cnt < NUM_UL_PACKETS)
{
- DU_LOG("\nDEBUG --> PHY STUB : Sending UL User Data[%d][LCID:%d] at sfn %d slot %d", cnt+1, lcId, sfnValue, slotValue);
+ DU_LOG("DEBUG --> PHY STUB : Sending UL User Data[%d][LCID:%d] at sfn %d slot %d", cnt+1, lcId, sfnValue, slotValue);
/* Sending Rx data indication to MAC */
rxDataInd->sfn = sfnValue;
rxDataInd->slot = slotValue;
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Send Message to peer */
- DU_LOG("\nDEBUG --> PHY STUB : Sending RLC status pdu at sfn %d slot %d", sfnValue, slotValue);
+ DU_LOG("DEBUG --> PHY STUB : Sending RLC status pdu at sfn %d slot %d", sfnValue, slotValue);
/* Sending Rx data indication to MAC */
rxDataInd->sfn = sfnValue;
rxDataInd->slot = slotValue;
l1HdlUlDciReq(msgLen, msg);
break;
default:
- DU_LOG("\nERROR --> PHY_STUB: Invalid message type[%x] received at PHY", msgType);
+ DU_LOG("ERROR --> PHY_STUB: Invalid message type[%x] received at PHY", msgType);
break;
#endif
}
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("ERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
return RFAILED;
}
{
case SHORT_BSR:
{
- DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
+ DU_LOG("DEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
/* For Short BSR
* MAC subheader format is R/R/LcId (1Byte)
case LONG_BSR:
{
- DU_LOG("\nDEBUG --> PHY_STUB: Forming LONG BSR PDU ");
+ DU_LOG("DEBUG --> PHY_STUB: Forming LONG BSR PDU ");
/* For Long BSR
* MAC subheader format is R/R/LcId (1Byte)
default:
{
- DU_LOG("\nERROR --> PHY_STUB: Incorrect BSR type:%d!", bsrType);
+ DU_LOG("ERROR --> PHY_STUB: Incorrect BSR type:%d!", bsrType);
if(pduInfo->pdu_length)
MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Sending Rx data indication to MAC */
- DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
+ DU_LOG("INFO --> PHY STUB: Sending Rx data Indication to MAC");
procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
if(pduInfo->pdu_length)
* The ratio must be removed once code optimization is complete */
req.tv_nsec = milisec * 1000000L * ratio;
- DU_LOG("\nPHY_STUB : GenerateTicks : Starting to generate slot indications");
+ DU_LOG("PHY_STUB : GenerateTicks : Starting to generate slot indications");
while(slotIndicationStarted)
{
/* Send Slot indication indication to lower mac */
if(l1BuildAndSendSlotIndication() != ROK)
{
- DU_LOG("\nERROR --> PHY_STUB : GenerateTicks(): Failed to build and send Slot Indication");
+ DU_LOG("ERROR --> PHY_STUB : GenerateTicks(): Failed to build and send Slot Indication");
return;
}
}
- DU_LOG("\nINFO --> PHY_STUB : Slot indication stopped");
+ DU_LOG("INFO --> PHY_STUB : Slot indication stopped");
/* Initialize all global variables */
sfnValue = 0;
if(!stopSlotInd)
{
- DU_LOG("\nPHY_STUB: Sending start slot indication event to self");
+ DU_LOG("PHY_STUB: Sending start slot indication event to self");
memset(&pst, 0, sizeof(Pst));
FILL_PST_PHY_TO_PHY(pst, EVT_PHY_START_SLOT_IND);
ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
{
for(drbIdx = 0; drbIdx < NUM_DRB_TO_PUMP_DATA; drbIdx++) //Number of DRB times the loop will run
{
- DU_LOG("\nDEBUG --> PHY STUB: Sending UL User Data[DrbId:%d] for UEIdx %d\n",drbIdx,ueIdx);
+ DU_LOG("DEBUG --> PHY STUB: Sending UL User Data[DrbId:%d] for UEIdx %d\n",drbIdx,ueIdx);
l1SendUlUserData(drbIdx,ueIdx);
/* TODO :- sleep(1) will be removed once we will be able to
* send continuous data packet */
else if(ch =='c')
{
/* Send Control PDU from PHY stub to DU */
- DU_LOG("\nDEBUG --> PHY STUB: Sending Status PDU");
+ DU_LOG("DEBUG --> PHY STUB: Sending Status PDU");
l1SendStatusPdu();
}
else if(ch == 'b')
}
}
- DU_LOG("\n");
+ DU_LOG("");
continue;
}
}
if(retVal != 0)
{
- DU_LOG("\nERROR --> PHY STUB : Thread creation failed. Cause %d", retVal);
+ DU_LOG("ERROR --> PHY STUB : Thread creation failed. Cause %d", retVal);
}
}
pthread_attr_destroy(&attr);
if(read(socket_fd, buffer, 1024)>0)
{
- DU_LOG("\n");
+ DU_LOG("");
DU_LOG("%s\n",buffer);
if (strncmp("HANDOVER_IN_PROGRESS", buffer, 19) == 0)
{
- DU_LOG("\nINFO --> PHY_STUB : Communication completed in between the source and destination PHY\n");
+ DU_LOG("INFO --> PHY_STUB : Communication completed in between the source and destination PHY\n");
//TODO: Trigger for other handover process in target PHY
}
}
if (bind(socket_fd, (struct sockaddr *)&serverPhy, sizeof(struct sockaddr_in))<0)
{
- DU_LOG("\nERROR --> PHY_STUB : bind failed");
+ DU_LOG("ERROR --> PHY_STUB : bind failed");
return RFAILED;
}
if (listen(socket_fd, 3) < 0)
{
- DU_LOG("\nERROR --> PHY_STUB : listen failed");
+ DU_LOG("ERROR --> PHY_STUB : listen failed");
return RFAILED;
}
while(true)
if ((socket_fd = accept(socket_fd, (struct sockaddr *)&clientPhy,
(socklen_t*)&addrlen))<0)
{
- DU_LOG("\nINFO --> PHY_STUB : Server is waiting");
+ DU_LOG("INFO --> PHY_STUB : Server is waiting");
}
else
{
- DU_LOG("\nINFO --> PHY_STUB : Server Connected");
+ DU_LOG("INFO --> PHY_STUB : Server Connected");
break;
}
}
{
if (bind(socket_fd, (struct sockaddr *)&serverPhy, sizeof(struct sockaddr_in ))<0)
{
- DU_LOG("\nERROR --> PHY_STUB : bind failed");
+ DU_LOG("ERROR --> PHY_STUB : bind failed");
return RFAILED;
}
{
if (connect(socket_fd, (struct sockaddr *)&destinationPhy, sizeof(struct sockaddr_in)) < 0)
{
- DU_LOG("\nERROR --> PHY_STUB : Connection Failed");
+ DU_LOG("ERROR --> PHY_STUB : Connection Failed");
}
else
{
- DU_LOG("\nINFO --> PHY_STUB : Client connected to sever");
+ DU_LOG("INFO --> PHY_STUB : Client connected to sever");
break;
}
}
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
{
- DU_LOG("\nERROR --> PHY_STUB : socket failed");
+ DU_LOG("ERROR --> PHY_STUB : socket failed");
return ret;
}
{
if(startL1AsServer(sourcePhy, destinationPhy) != ROK)
{
- DU_LOG("\nERROR --> PHY_STUB : Failed to start server");
+ DU_LOG("ERROR --> PHY_STUB : Failed to start server");
return ret;
}
}
{
if(startL1AsClient(sourcePhy, destinationPhy) != ROK)
{
- DU_LOG("\nERROR --> PHY_STUB : Failed to start client");
+ DU_LOG("ERROR --> PHY_STUB : Failed to start client");
return ret;
}
}
- DU_LOG("\nINFO --> PHY_STUB : Connection established");
+ DU_LOG("INFO --> PHY_STUB : Connection established");
receiveMsgFromPeerL1();
return ROK;
}
uint8_t cntNumVnf = 0;
uint32_t ipv4_vnf = 0, ipv4_pnf = 0;
- DU_LOG("\nDEBUG --> PNF_STUB : Reading PNF P5 configurations");
+ DU_LOG("DEBUG --> PNF_STUB : Reading PNF P5 configurations");
pnfCb.pnfCfgParams.pnfState=PNF_IDLE;
pnfCb.pnfCfgParams.pnfId = PNF_ID;
pnfCb.pnfSlotInfo.sfn++;
pnfCb.pnfSlotInfo.slot++;
- DU_LOG("\nPNF_NFAPI : Starting to generate slot indications t_ref:%llu, slotDur:%f, perTTi:%u, slotsPerFrame:%d, nanoSec:%d",\
+ DU_LOG("PNF_NFAPI : Starting to generate slot indications t_ref:%llu, slotDur:%f, perTTi:%u, slotsPerFrame:%d, nanoSec:%d",\
pnfCb.pnfP7Info.t_ref_ns, slotDur_ms, PER_TTI_TIME_USEC, NUM_SLOTS_PER_SUBFRAME, tti_req.tv_nsec);
}
else
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nVNF_NFAPI --> DEBUG: SFN/Slot:%d,%d",\
+ DU_LOG("VNF_NFAPI --> DEBUG: SFN/Slot:%d,%d",\
pnfCb.pnfSlotInfo.sfn, pnfCb.pnfSlotInfo.slot);
#endif
clock_nanosleep(CLOCK_REALTIME, 0, &tti_req, NULL);
#endif
init_log();
- DU_LOG("\nINFO --> PNF_STUB : Starting PNF_STUB\n");
+ DU_LOG("INFO --> PNF_STUB : Starting PNF_STUB\n");
/* TODO: Start thread to receive console input */
/* Read PNF configurations */
retVal = pthread_create(&conThrdId, &attr, pnfClock, NULLP);
if(retVal != 0)
{
- DU_LOG("\nERROR --> PNF_STUB : Thread creation failed. Cause %d", retVal);
+ DU_LOG("ERROR --> PNF_STUB : Thread creation failed. Cause %d", retVal);
}
pthread_attr_destroy(&attr);
#endif
CMCHKPK(oduUnpackUInt8, &(p5Hdr->more_segNum), mBuf);
CMCHKPK(oduUnpackUInt8, &(p5Hdr->seq_num), mBuf);
CMCHKPK(oduUnpackUInt32, &(p5Hdr->timeStamp), mBuf);
- DU_LOG("\nINFo --> NFAPI_PNF: seqLen:%d, moreSegNum:%d, seqNum:%d, timeStamp:%d",
+ DU_LOG("INFo --> NFAPI_PNF: seqLen:%d, moreSegNum:%d, seqNum:%d, timeStamp:%d",
p5Hdr->seg_len,p5Hdr->more_segNum,p5Hdr->seq_num,p5Hdr->timeStamp);
return;
}
CMCHKPK(oduUnpackUInt16, &(msgHdr->msg_id), mBuf);
CMCHKPK(oduUnpackUInt32, &(msgHdr->length), mBuf);
- DU_LOG("\nINFO --> NFAPI_PNF: RUType:%d, phy_id:%d, msgId:%d, len:%d",\
+ DU_LOG("INFO --> NFAPI_PNF: RUType:%d, phy_id:%d, msgId:%d, len:%d",\
msgHdr->sRU_termination_type,msgHdr->phy_id,msgHdr->msg_id,msgHdr->length );
return;
}
CMCHKPK(oduUnpackUInt32, &(p7Hdr->tot_SDU_len), mBuf);
CMCHKPK(oduUnpackUInt32, &(p7Hdr->byteOffset), mBuf);
CMCHKPK(oduUnpackUInt32, &(p7Hdr->timeStamp), mBuf);
- DU_LOG("\nINFo --> NFAPI_VNF: se1_num:%d, totSdu len:%u, byteOffset:%u, timeStamp:%u",
+ DU_LOG("INFo --> NFAPI_VNF: se1_num:%d, totSdu len:%u, byteOffset:%u, timeStamp:%u",
p7Hdr->seq_num,p7Hdr->tot_SDU_len, p7Hdr->byteOffset, p7Hdr->timeStamp);
}
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t ret = ROK;
Buffer *mBuf = NULLP;
- DU_LOG("\nINFO --> NFAPI_PNF: Building PNF_CONFIG_RSP");
+ DU_LOG("INFO --> NFAPI_PNF: Building PNF_CONFIG_RSP");
pnfCb.pnfCfgParams.pnfState=PNF_CONFIGURED;
if(ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf config rsp");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf config rsp");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t ret = ROK;
Buffer *mBuf = NULLP;
- DU_LOG("\nINFO --> NFAPI_PNF: Building PNF_START_RSP");
+ DU_LOG("INFO --> NFAPI_PNF: Building PNF_START_RSP");
pnfCb.pnfCfgParams.pnfState=PNF_RUNNING;
if(ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf start rsp");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf start rsp");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
uint8_t ret = ROK;
Buffer *mBuf = NULLP;
- DU_LOG("\nINFO --> NFAPI_PNF: Building PNF_STOP_RSP");
+ DU_LOG("INFO --> NFAPI_PNF: Building PNF_STOP_RSP");
pnfCb.pnfCfgParams.pnfState=PNF_CONFIGURED;
if(ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf stop rsp");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf stop rsp");
return RFAILED;
}
nfapiFillP5Hdr(mBuf);
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in pnf_readyInd");
return RFAILED;
}
/* MEASUREMENT TAG */
fillTlvOfSizeUint8(mBuf, FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(uint8_t), 0);
- DU_LOG("\nINFO --> NFAPI_PNF: Sending PARAM_RESP ");
+ DU_LOG("INFO --> NFAPI_PNF: Sending PARAM_RESP ");
if(pnfP5SctpSend(mBuf) == RFAILED)
{
ODU_PUT_MSG_BUF(mBuf);
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in %s",__func__);
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in %s",__func__);
return RFAILED;
}
//As per 5G nFAPI Specification, section 3.2.4 CONFIG.response
CMCHKPK(oduPackPostUInt8, 0, mBuf); //Error Code
- DU_LOG("\nINFO --> NFAPI_PNF: Sending CONFIG_RESP ");
+ DU_LOG("INFO --> NFAPI_PNF: Sending CONFIG_RESP ");
if(pnfP5SctpSend(mBuf) == RFAILED)
{
ODU_PUT_MSG_BUF(mBuf);
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in start response");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in start response");
return RFAILED;
}
CMCHKPK(oduPackPostUInt8, 0, mBuf); //Error Code
- DU_LOG("\nINFO --> NFAPI_PNF: Sending START_RESP ");
+ DU_LOG("INFO --> NFAPI_PNF: Sending START_RESP ");
if(pnfP5SctpSend(mBuf) == RFAILED)
{
ODU_PUT_MSG_BUF(mBuf);
{
case TAG_NFAPI_PNF_PARAM_REQ:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PNF_PARAM_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PNF_PARAM_REQ recevied.");
ret = buildAndSendPnfParamResp();
break;
}
case TAG_NFAPI_PNF_CONFIG_REQ:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PNF_CONFIG_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PNF_CONFIG_REQ recevied.");
ret = buildAndSendPnfConfigResp();
break;
}
case TAG_NFAPI_PNF_START_REQ:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PNF_START_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PNF_START_REQ recevied.");
ret = buildAndSendPnfStartResp();
break;
}
case TAG_NFAPI_PNF_STOP_REQ:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PNF_STOP_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PNF_STOP_REQ recevied.");
ret = buildAndSendPnfStopResp();
break;
}
case FAPI_PARAM_REQUEST:
{
sleep(1);
- DU_LOG("\nINFO --> NFAPI_PNF: PHY_PARAM_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PHY_PARAM_REQ recevied.");
ret = buildAndSendParamResp();
break;
}
case FAPI_CONFIG_REQUEST:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PHY_CONFIG_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PHY_CONFIG_REQ recevied.");
ret = buildAndSendConfigResp();
break;
}
case FAPI_START_REQUEST:
{
- DU_LOG("\nINFO --> NFAPI_PNF: PHY_START_REQ recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: PHY_START_REQ recevied.");
ret = buildAndSendStartResp();
break;
}
default:
{
- DU_LOG("\nERROR --> NFAPI_PNF: Wrong MSGID of NFAPI P5 Message:%d",msgHdr.msg_id);
+ DU_LOG("ERROR --> NFAPI_PNF: Wrong MSGID of NFAPI P5 Message:%d",msgHdr.msg_id);
}
}
}
else
{
- DU_LOG("\nINFO --> NFAPI_PNF: No Delta between PNF and VNF");
+ DU_LOG("INFO --> NFAPI_PNF: No Delta between PNF and VNF");
}
ulSyncInfo->t3 = CALC_TIME_USEC_FROM_SFNSLOT(pnfCb.pnfSlotInfo);
if (ODU_GET_MSG_BUF(PNF_APP_MEM_REG, PNF_POOL, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF : Memory allocation failed in start response");
+ DU_LOG("ERROR --> NFAPI_PNF : Memory allocation failed in start response");
return RFAILED;
}
nfapiFillP7Hdr(mBuf, (sizeof(nFapi_ul_node_sync_info) + sizeof(nFapi_msg_header)), 0, 0);
CMCHKPK(SUnpkS32, &(dlNodeSync.delta_sfnSlot), mBuf);
CMCHKPK(oduUnpackUInt8, &(dlNodeSync.scs), mBuf);
- DU_LOG("\n PNF_NFAPI: t1:%u, delta:%d, scs:%d",dlNodeSync.t1, dlNodeSync.delta_sfnSlot, dlNodeSync.scs);
+ DU_LOG(" PNF_NFAPI: t1:%u, delta:%d, scs:%d",dlNodeSync.t1, dlNodeSync.delta_sfnSlot, dlNodeSync.scs);
EXTRACT_SFN_SLOT_FROM_TIME(dlNodeSync.t1, vnfFrameInfo);
{
case TAG_NFAPI_DL_NODE_SYNC:
{
- DU_LOG("\nINFO --> NFAPI_PNF: DL_NODE_SYNC recevied.");
+ DU_LOG("INFO --> NFAPI_PNF: DL_NODE_SYNC recevied.");
ret = pnfDlNodeSyncHandler(mBuf);
break;
}
default:
{
- DU_LOG("\nERROR --> NFAPI_PNF: Wrong MSGID of NFAPI P7 Message:%d",msgHdr.msg_id);
+ DU_LOG("ERROR --> NFAPI_PNF: Wrong MSGID of NFAPI P7 Message:%d",msgHdr.msg_id);
ret = RFAILED;
break;
}
***************************************************************************/
uint8_t pnfP7UdpActvInit()
{
- DU_LOG("\n\nDEBUG --> P7_UDP : Initializing ");
+ DU_LOG("DEBUG --> P7_UDP : Initializing ");
memset (&pnfP7Cb, 0, sizeof(PnfP7UdpGlobalCb));
//Initializing with INVALID value
{
uint8_t ret = ROK;
- DU_LOG("\nINFO --> P7_UDP: Received open server request");
+ DU_LOG("INFO --> P7_UDP: Received open server request");
sockType = CM_INET_DGRAM;
if((ret = (cmInetSocket(sockType, &(pnfP7Cb.sockFd), protType))) != ROK)
{
- DU_LOG("\nERROR --> P7_UDP : Failed to open UDP socket");
+ DU_LOG("ERROR --> P7_UDP : Failed to open UDP socket");
return RFAILED;
}
ret = cmInetBind(&(pnfP7Cb.sockFd), &(pnfP7Cb.srcAddr));
if(ret != ROK)
{
- DU_LOG("\nERROR --> P7_UDP : Failed to bind socket");
+ DU_LOG("ERROR --> P7_UDP : Failed to bind socket");
return RFAILED;
}
- DU_LOG("\nINFO --> P7_UDP : Socket[%d] is open", pnfP7Cb.sockFd.fd);
+ DU_LOG("INFO --> P7_UDP : Socket[%d] is open", pnfP7Cb.sockFd.fd);
return ROK;
} /* pnfP7UdpSrvOpenReq */
ret = pnfP7UdpSrvOpenReq();
if(ret != ROK)
{
- DU_LOG("\nERROR --> P7_UDP : Transport server open request failed");
+ DU_LOG("ERROR --> P7_UDP : Transport server open request failed");
return (ret);
}
ret = cmInetSendMsg(&(pnfP7Cb.sockFd), &pnfP7Cb.destAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> P7_UDP : Message send failure");
+ DU_LOG("ERROR --> P7_UDP : Message send failure");
return RFAILED;
}
- DU_LOG("\nDEBUG --> P7_UDP : Message Sent");
+ DU_LOG("DEBUG --> P7_UDP : Message Sent");
return ROK;
}
***************************************************************************/
uint8_t pnfP5SctpActvInit()
{
- DU_LOG("\n\nDEBUG --> SCTP : Initializing");
+ DU_LOG("DEBUG --> SCTP : Initializing");
memset(&pnfP5SctpCb, 0, sizeof(PnfP5SctpGlobalCb));
pnfP5SctpCb.pnfP5SctpCfg = pnfCb.pnfCfgParams.pnfP5SctpParams;
return ROK;
if((ret = cmInetSocket(socket_type, &pnfP5SctpCb.pnfP5LstnSockFd, IPPROTO_SCTP) != ROK))
{
- DU_LOG("\nERROR --> SCTP : Socket[%d] coudnt open for listening", pnfP5SctpCb.pnfP5LstnSockFd.fd);
+ DU_LOG("ERROR --> SCTP : Socket[%d] coudnt open for listening", pnfP5SctpCb.pnfP5LstnSockFd.fd);
}
else if((ret = cmInetSctpBindx(&pnfP5SctpCb.pnfP5LstnSockFd, &pnfP5SctpCb.localAddrLst, pnfP5SctpCb.pnfP5SctpCfg.pnfP5SctpPort)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Binding failed at PNF");
+ DU_LOG("ERROR --> SCTP: Binding failed at PNF");
}
else if((ret = cmInetListen(&pnfP5SctpCb.pnfP5LstnSockFd, 1)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at PNF");
- DU_LOG("\nERROR --> SCTP : Listening on socket failed");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at PNF");
+ DU_LOG("ERROR --> SCTP : Listening on socket failed");
cmInetClose(&pnfP5SctpCb.pnfP5LstnSockFd);
return RFAILED;
}
{
if((ret = pnfP5SctpAccept(&pnfP5SctpCb.assocCb[assocIdx])) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at PNF");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at PNF");
}
}
}
{
if(pnfP5SctpSockPoll() != ROK)
{
- DU_LOG("\nERROR --> SCTP: Polling failed to start at PNF");
+ DU_LOG("ERROR --> SCTP: Polling failed to start at PNF");
}
}
return (ret);
{
uint8_t ret;
- DU_LOG("\nINFO --> SCTP : Connecting");
+ DU_LOG("INFO --> SCTP : Connecting");
while(!assocCb->connUp)
{
}
else if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to accept connection");
+ DU_LOG("ERROR --> SCTP : Failed to accept connection");
return RFAILED;
}
else
break;
}
}
- DU_LOG("\nINFO --> SCTP : Connection established");
+ DU_LOG("INFO --> SCTP : Connection established");
return ROK;
}
CM_INET_FD_ZERO(&pnfP5PollParams.readFd);
- DU_LOG("\nINFO --> SCTP : Polling started at PNF\n");
+ DU_LOG("INFO --> SCTP : Polling started at PNF\n");
while(1)
{
/* Receiving SCTP data */
{
if((ret = pnfP5ProcessPolling(&pnfP5PollParams, &pnfP5SctpCb.assocCb[assocIdx], timeoutPtr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> P5_SCTP : Failed to RecvMsg for PNF at P5 Interface \n");
+ DU_LOG("ERROR --> P5_SCTP : Failed to RecvMsg for PNF at P5 Interface \n");
}
}
{
if((fromAddr.port == pnfP7Cb.destAddr.port) && (fromAddr.address == pnfP7Cb.destAddr.address))
{
- DU_LOG("\nINFO --> P7_UDP : Received P7 Message [%ld] \n", numMsgRcvd+1);
+ DU_LOG("INFO --> P7_UDP : Received P7 Message [%ld] \n", numMsgRcvd+1);
numMsgRcvd++;
pnfP7MsgHandler(pnfP7UdpBuf);
ODU_PUT_MSG_BUF(pnfP7UdpBuf);
&pollParams->bufLen, &pollParams->info, &pollParams->flag, &pollParams->ntfy);
if(assocCb->connUp & (ret != ROK))
{
- DU_LOG("\nERROR --> SCTP: Sctp Recv Failed at PNF P5 Interface");
+ DU_LOG("ERROR --> SCTP: Sctp Recv Failed at PNF P5 Interface");
// ret = RFAILED;
}
else
ret = pnfP5SctpNtfyHdlr(assocCb, &pollParams->ntfy);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
+ DU_LOG("ERROR --> SCTP : Failed to process sctp notify msg\n");
ret = RFAILED;
}
}
/*TODO: Add the Handler of PNF P5 msgs*/
if(p5MsgHandlerAtPnf(pollParams->mBuf) != ROK)
{
- DU_LOG("\nERROR --> NFAPI_PNF: Failed to process SCTP msg received from VNF");
+ DU_LOG("ERROR --> NFAPI_PNF: Failed to process SCTP msg received from VNF");
ODU_PUT_MSG_BUF(pollParams->mBuf);
return RFAILED;
}
switch(ntfy->header.nType)
{
case CM_INET_SCTP_ASSOC_CHANGE :
- DU_LOG("\nINFO --> SCTP : Assoc change notification received");
+ DU_LOG("INFO --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
- DU_LOG("\nINFO --> Event : COMMUNICATION UP");
+ DU_LOG("INFO --> Event : COMMUNICATION UP");
assocCb->connUp = TRUE;
break;
case CM_INET_SCTP_COMM_LOST:
- DU_LOG("\nINFO --> Event : COMMUNICATION LOST");
+ DU_LOG("INFO --> Event : COMMUNICATION LOST");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_RESTART:
- DU_LOG("\nINFO --> Event : SCTP RESTART");
+ DU_LOG("INFO --> Event : SCTP RESTART");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */
- DU_LOG("\nINFO --> Event : SHUTDOWN COMPLETE");
+ DU_LOG("INFO --> Event : SHUTDOWN COMPLETE");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_CANT_STR_ASSOC:
- DU_LOG("\nINFO --> Event : CANT START ASSOC");
+ DU_LOG("INFO --> Event : CANT START ASSOC");
assocCb->connUp = FALSE;
break;
default:
- DU_LOG("\nERROR --> Invalid event");
+ DU_LOG("ERROR --> Invalid event");
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
+ DU_LOG("INFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nINFO --> SCTP : Remote Error notification received");
+ DU_LOG("INFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
+ DU_LOG("INFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
- DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n");
+ DU_LOG("INFO --> SCTP : Shutdown Event notification received\n");
assocCb->connUp = FALSE;
/*TODO: delete vnf info or database*/
//deleteE2NodeInfo(&ricCb.duInfo[0]);
exit(0);
break;
case CM_INET_SCTP_ADAPTATION_INDICATION :
- DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
+ DU_LOG("INFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
+ DU_LOG("INFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nERROR --> SCTP : Invalid notification type\n");
+ DU_LOG("ERROR --> SCTP : Invalid notification type\n");
break;
}
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> SCTP : Send message failed");
+ DU_LOG("ERROR --> SCTP : Send message failed");
return RFAILED;
}
}
RIC_ALLOC(actionDb, sizeof(ActionInfo));
if(actionDb==NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
return NULLP;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
RIC_FREE(actionDb, sizeof(ActionInfo));
return NULLP;
}
if(sctpSend(duId, mBuf) != ROK)
{
- DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
+ DU_LOG("ERROR --> E2AP : SCTP Send for E2 failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
+ DU_LOG("ERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
+ DU_LOG("ERROR --> E2AP : Failed to allocate memory");
return RFAILED;
}
E2RemovalRequest_t *removalReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
+ DU_LOG("INFO --> E2AP : Building Removal Request\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
if(!removalReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
if(!removalReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for removal request\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending removal request failed");
+ DU_LOG("ERROR --> E2AP : Sending removal request failed");
break;
}
}
else
{
- DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
+ DU_LOG("ERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
}
return ranFuncDb;
if(!ricSubscriptionInfo)
{
- DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
+ DU_LOG("ERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
}
}
if(actionInfoDb==NULLP)
{
- DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
+ DU_LOG("ERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
return RFAILED;
}
e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
+ DU_LOG("ERROR --> E2AP : Failed to find the e2 component node");
return RFAILED;
}
/* If the node is present then update the value */
e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
if(!e2NodeComponentInfo)
{
- DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
+ DU_LOG("ERROR --> E2AP : Failed to find the e2 component node");
return RFAILED;
}
/* Delete the node from the list */
bool memAllocFailed = false;
E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
- DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
+ DU_LOG("INFO --> E2AP : Building E2 Node Config Update failure\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
break;
}
RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
memAllocFailed = true;
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Node Config Update Failure failed");
break;
}
break;
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
if(!e2NodeConfigUpdate)
{
- DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate pointer is null");
+ DU_LOG("ERROR --> E2AP : e2NodeConfigUpdate pointer is null");
return;
}
if(!e2NodeConfigUpdate->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
+ DU_LOG("ERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
return;
}
{
if(!e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
+ DU_LOG("ERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
break;
}
transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
if(transId < 0 || transId > 255)
{
- DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
+ DU_LOG("ERROR --> E2AP : Received invalid transId %d",transId);
return;
}
break;
if(handleE2NodeComponentAction(duDb, (PTR)e2NodeAddItem, ProtocolIE_IDE2_id_E2nodeComponentConfigAddition,\
&tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
+ DU_LOG("ERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
}
}
}
if(handleE2NodeComponentAction(duDb, (PTR)e2NodeUpdateItem, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate,\
&tmpE2NodeList.updatedE2Node[tmpE2NodeList.updatedE2NodeCount++]) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
+ DU_LOG("ERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
}
}
}
if(handleE2NodeComponentAction(duDb, (PTR)e2NodeRemovalItem, ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval,\
&tmpE2NodeList.removedE2Node[tmpE2NodeList.removedE2NodeCount++]) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
+ DU_LOG("ERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
}
}
}
{
if(BuildAndSendE2NodeConfigUpdateAck(duDb, transId, &tmpE2NodeList) !=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config ack");
+ DU_LOG("ERROR --> E2AP : Failed to build and send E2 node config ack");
return;
}
}
{
if(BuildAndSendE2NodeConfigUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config Failure");
+ DU_LOG("ERROR --> E2AP : Failed to build and send E2 node config Failure");
return;
}
}
}
else
{
- DU_LOG("\nERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
+ DU_LOG("ERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
return RFAILED;
}
RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
return RFAILED;
}
e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
{
- DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
+ DU_LOG("ERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
return RFAILED;
}
e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = componentInfo->componentId;
}
else
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
return RFAILED;
}
}
RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
if(e2NodeConfigAdditionAckList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
return RFAILED;
}
RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
return RFAILED;
}
e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[arrIdx];
RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RAN function added list array item");
return RFAILED;
}
ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RAN function added list array");
return RFAILED;
}
return ROK;
uint8_t elementCnt;
bool memAllocFailed = false;
- DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
+ DU_LOG("INFO --> E2AP : Building E2 Setup Response\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
if(e2SetupRsp->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
break;
}
RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
memAllocFailed = true;
break;
}
if(memAllocFailed == true)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
break;
}
/* Trans Id */
if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
+ DU_LOG("ERROR --> E2AP : Failed to build Global Ric Id");
break;
}
e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
+ DU_LOG("ERROR --> E2AP : Failed to build Ran function added list");
break;
}
}
if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
value.choice.E2nodeComponentConfigAdditionAck_List, e2NodeList.addedE2NodeCount, e2NodeList.addedE2Node) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
+ DU_LOG("ERROR --> E2AP : Failed to build E2Node Component config addition ack list");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Setup Response failed");
break;
}
break;
sizeof(E2SM_KPM_ActionDefinition_Format1_t));
if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
if(actionFormat1->measInfoList.list.array == NULL)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
if(measItem->measType.choice.measName.buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
RIC_ALLOC(ricActionDef->buf, encBufSize);
if(ricActionDef->buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
memcpy(ricActionDef->buf, encBuf, encBufSize);
CmLList *actionNode=NULLP;
if(actionItem == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, ricActionId, CONFIG_ADD) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
if(ricEventTriggerDef->buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
if(subsDetails == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
/* RIC Event Trigger Definition */
if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
break;
}
RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
ricSubsInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
CmLList *ricSubsNode = NULLP;
RicSubscription *ricSubsInfo = NULLP;
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Request\n");
/* Allocate memory to store RIC subscription info in RIC DB */
RIC_ALLOC(ricSubsInfo, sizeof(RicSubscription));
if(!ricSubsInfo)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
if(e2apRicMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apRicMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
&ricSubsInfo->requestId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
break;
}
if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
ricSubsInfo) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC subscription Request failed");
break;
}
RIC_ALLOC(ricSubsNode , sizeof(CmLList));
if(!ricSubsNode)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
ricSubsNode->node = (PTR)ricSubsInfo;
RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
- DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
+ DU_LOG("INFO --> E2AP : RIC Subscription Response received");
/* Fetch DU DB */
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
+ DU_LOG("ERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
return;
}
break;
uint8_t elementCnt;
bool memAllocFailed = false;
- DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
+ DU_LOG("INFO --> E2AP : Building E2 Setup failure\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
if(e2SetupFailure->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2FailureIEs failed");
break;
}
RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2FailureIEs failed");
memAllocFailed = true;
break;
}
if(memAllocFailed == true)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2FailureIEs failed");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
+ DU_LOG("ERROR --> E2AP : Sending E2 Setup Failure failed");
break;
}
memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
if(!e2SetupReq)
{
- DU_LOG("\nERROR --> E2AP : e2SetupReq pointer is null");
+ DU_LOG("ERROR --> E2AP : e2SetupReq pointer is null");
return;
}
if(!e2SetupReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : e2SetupReq array pointer is null");
+ DU_LOG("ERROR --> E2AP : e2SetupReq array pointer is null");
return;
}
if(handleE2NodeComponentAction(duDb, (PTR)&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item,\
ProtocolIE_IDE2_id_E2nodeComponentConfigAddition, &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
+ DU_LOG("ERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
}
}
if(BuildAndSendE2SetupRsp(duDb, transId, tmpE2NodeList) !=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send E2 setup response");
}
}
/*******************************************************************
ResetResponseE2_t *resetResponse=NULL;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Reset Response Message\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
break;
}
RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
if(!resetResponse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
break;
}
RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
if(!resetResponse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Reset Response");
break;
}
asn_enc_rval_t encRetVal;
RICserviceQuery_t *ricServiceQuery;
- DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
+ DU_LOG("INFO --> E2AP : Building Ric service Query\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
if(ricServiceQuery->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
break;
}
RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
memAllocFailed = true;
break;
}
}
if(memAllocFailed == true)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
break;
}
ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
+ DU_LOG("ERROR --> E2AP : Failed to build Ran function added list");
break;
}
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
+ DU_LOG("ERROR --> E2AP : Sending of RIC service Query failed");
break;
}
uint8_t elementCnt=0;
RICserviceUpdateFailure_t *ricServiceFailure=NULL;
- DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
+ DU_LOG("INFO --> E2AP : Building Ric service update failure\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
if(ricServiceFailure->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
break;
}
RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
break;
}
}
if(arrIdx<elementCnt)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
break;
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC service update failed");
break;
}
ret = ROK;
RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
if(ranFuncRejectedList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RAN function rejected list array");
return RFAILED;
}
RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
+ DU_LOG("ERROR --> E2AP : Memory allocation for RAN function rejected list array item");
return RFAILED;
}
ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
- DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
+ DU_LOG("INFO --> E2AP : Building Ric service update Acknowledge\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
break;
}
RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
break;
}
}
if(arrIdx<elementCnt)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
break;
}
if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
&ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
+ DU_LOG("ERROR --> E2AP : Failed to build Ran function added list");
break;
}
}
if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
&ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
+ DU_LOG("ERROR --> E2AP : Failed to build Ran function rejected list");
break;
}
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC service update ack failed");
break;
}
ret =ROK;
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
if(!ricServiceUpdate)
{
- DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
+ DU_LOG("ERROR --> E2AP : ricServiceUpdate pointer is null");
return;
}
if(!ricServiceUpdate->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
+ DU_LOG("ERROR --> E2AP : ricServiceUpdate array pointer is null");
return;
}
elementCnt = ricServiceUpdate->protocolIEs.list.count;
{
if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
+ DU_LOG("ERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
return;
}
if(transId < 0 || transId > 255)
{
- DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
+ DU_LOG("ERROR --> E2AP : Received invalid transId %d",transId);
return;
}
break;
default:
{
- DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
+ DU_LOG("ERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
break;
}
}
{
if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
+ DU_LOG("ERROR --> E2AP : Failed to build and send RIC service update Failure");
return;
}
}
{
if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
+ DU_LOG("ERROR --> E2AP : Failed to build and send RIC service update acknowledge");
return;
}
}
RicRequestId ricReqId;
RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
- DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
+ DU_LOG("INFO --> E2AP : Received RIC subscription failure");
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return RFAILED;
}
ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
+ DU_LOG("ERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
return RFAILED;
}
else
RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Modification Refuse\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
if(!ricSubsModRefuse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
break;
}
RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
if(!modCfmList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
if(!modCfmList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
if(!modRefusedList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
if(!modRefusedList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
if(!rmvCfmList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
if(!rmvCfmList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
if(!rmvFailList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
if(!rmvFailList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
return RFAILED;
}
RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Modification Confirm\n");
while(true)
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
if(!ricSubsModCfm->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
break;
}
}
if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
break;
}
}
if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
break;
}
}
if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
break;
}
}
if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
{
- DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
break;
}
}
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
break;
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return RFAILED;
}
if(!ranFuncDb)
{
/* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
- DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
+ DU_LOG("ERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
CauseE2RICrequest_ran_function_id_invalid);
return RFAILED;
if(!ricSubs)
{
/* If RAN Function not found, send RIC Subscription modification refuse to DU */
- DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
+ DU_LOG("ERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
return RFAILED;
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
+ DU_LOG("INFO --> E2AP : Building Error Indication Message\n");
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
break;
}
RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
if(errorIndicationMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
break;
}
for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
break;
}
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
+ DU_LOG("INFO --> E2AP : Sending Error Indication Message");
}
ret = ROK;
ResetRequestE2_t *resetReq = NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
+ DU_LOG("INFO --> E2AP : Building Reset Request\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
break;
}
RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
break;
}
RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
if(!resetReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
Reset Request IE array");
break;
}
RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
if(!resetReq->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
+ DU_LOG("ERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
Reset Request IE array element");
break;
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for reset request\n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
}
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending reset request failed");
+ DU_LOG("ERROR --> E2AP : Sending reset request failed");
break;
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!resetRsp)
{
- DU_LOG("\nERROR --> E2AP : resetRsp pointer is null");
+ DU_LOG("ERROR --> E2AP : resetRsp pointer is null");
return;
}
if(!resetRsp->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : resetRsp array pointer is null");
+ DU_LOG("ERROR --> E2AP : resetRsp array pointer is null");
return;
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!resetReq)
{
- DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
+ DU_LOG("ERROR --> E2AP : resetReq pointer is null");
return;
}
if(!resetReq->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
+ DU_LOG("ERROR --> E2AP : resetReq array pointer is null");
return;
}
if(BuildAndSendResetResponse(duId, transId) !=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send reset response");
}
}
while(true)
{
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Request Message\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Delete Request Message\n");
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
break;
}
e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
if(ricSubsDelReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
break;
}
RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequest_IEs_t));
if(ricSubsDelReq->protocolIEs.list.array[ieIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ DU_LOG("ERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
__func__, ieIdx, __LINE__);
break;
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
#ifdef DEBUG_ASN_PRINT
for(int i=0; i< encBufSize; i++)
{
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
+ DU_LOG("ERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
break;
}
if(!ricSubsDelRqd)
{
- DU_LOG("\nERROR --> E2AP : %s: Received NULL message", __func__);
+ DU_LOG("ERROR --> E2AP : %s: Received NULL message", __func__);
return RFAILED;
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return RFAILED;
}
ranFuncDb = fetchRanFuncFromRanFuncId(duDb, subsItem->ranFunctionID);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
+ DU_LOG("ERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
return RFAILED;
}
subsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(!subsDb)
{
- DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
+ DU_LOG("ERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
__func__, subsItem->ricRequestID.ricRequestorID, subsItem->ricRequestID.ricInstanceID);
return RFAILED;
}
RIC_ALLOC(e2NodeConfigRemovalAckList->list.array, e2NodeConfigRemovalAckList->list.size);
if(e2NodeConfigRemovalAckList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
return RFAILED;
}
RIC_ALLOC(e2NodeConfigRemovalAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
if(e2NodeConfigRemovalAckList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
return RFAILED;
}
e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[arrIdx];
RIC_ALLOC(e2NodeConfigUpdateAckList->list.array, e2NodeConfigUpdateAckList->list.size);
if(e2NodeConfigUpdateAckList->list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
return RFAILED;
}
RIC_ALLOC(e2NodeConfigUpdateAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
if(e2NodeConfigUpdateAckList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
+ DU_LOG("ERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
return RFAILED;
}
e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[arrIdx];
asn_enc_rval_t encRetVal;
E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
- DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Node config update Ack Message\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
break;
}
RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
break;
}
if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
break;
}
}
e2NodeList->addedE2NodeCount, e2NodeList->addedE2Node)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
+ DU_LOG("ERROR --> E2AP : Failed to build E2Node Component config addition ack list");
break;
}
}
e2NodeList->updatedE2NodeCount, e2NodeList->updatedE2Node)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config update ack list");
+ DU_LOG("ERROR --> E2AP : Failed to build E2Node Component config update ack list");
break;
}
}
e2NodeList->removedE2NodeCount, e2NodeList->removedE2Node)!=ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config removal ack list");
+ DU_LOG("ERROR --> E2AP : Failed to build E2Node Component config removal ack list");
break;
}
}
encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Node config update ack ");
break;
}
ret = ROK;
if(!e2RemovalFailure)
{
- DU_LOG("\nERROR --> E2AP : e2RemovalFailure pointer is null");
+ DU_LOG("ERROR --> E2AP : e2RemovalFailure pointer is null");
return;
}
if(!e2RemovalFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
+ DU_LOG("ERROR --> E2AP : e2RemovalFailure array pointer is null");
return;
}
case ProtocolIE_IDE2_id_TransactionID:
{
transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
- DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
+ DU_LOG("ERROR --> E2AP : Received transID %d", transId);
break;
}
case ProtocolIE_IDE2_id_CauseE2:
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
break;
}
}
uint16_t ranFuncIdx =0;
RanFunction *ranFuncDb=NULLP;
- DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
+ DU_LOG("INFO --> E2AP : Removing all the E2 node information");
for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
{
ranFuncDb = &duDb->ranFunction[ranFuncIdx];
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!removalRsp)
{
- DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
+ DU_LOG("ERROR --> E2AP : removalRsp pointer is null");
return;
}
if(!removalRsp->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
+ DU_LOG("ERROR --> E2AP : removalRsp array pointer is null");
return;
}
{
case ProtocolIE_IDE2_id_TransactionID:
{
- DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
+ DU_LOG("INFO --> E2AP : Sending request to close the sctp connection");
cmInetClose(&sctpCb.e2LstnSockFd);
deleteE2NodeInfo(duDb);
exit(0);
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
break;
}
}
E2RemovalFailure_t *e2RemovalFailure=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Removal Failure Message\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
if(!e2RemovalFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Removal Failure");
break;
}
E2RemovalResponse_t *e2RemovalResponse=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Removal Response Message\n");
do
{
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return RFAILED;
}
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
if(!e2RemovalResponse->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Removal Response");
break;
}
uint8_t arrIdx =0;
uint16_t transId =0;
- DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+ DU_LOG("INFO --> E2AP : E2 Removal request received");
for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
{
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
+ DU_LOG("ERROR --> E2AP : Invalid IE recevied [%d]", transId);
break;
}
}
{
if(BuildAndSendRemovalResponse(duId, transId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send Removal response");
}
}
else
{
if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ DU_LOG("ERROR --> E2AP : Failed to build and send Removal response");
}
}
}
RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
if(!tnlInformation->tnlAddress.buf)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
+ DU_LOG("ERROR --> E2AP : Failed to fill E2 connection update item");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
return ROK;
RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
+ DU_LOG("ERROR --> E2AP : Failed to fill E2 connection update item");
return RFAILED;
}
}
else
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
return RFAILED;
}
return ROK;
E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
+ DU_LOG("INFO --> E2AP : Building E2 Connection Update Message\n");
do
{
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return RFAILED;
}
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
if(!e2ConnectionUpdate->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
break;
}
}
e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
+ DU_LOG("ERROR --> E2AP : Failed to build the connection update modify list");
break;
}
}
e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
+ DU_LOG("ERROR --> E2AP : Failed to build the connection update modify list");
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update");
+ DU_LOG("ERROR --> E2AP : Failed to send E2 Connection Update");
break;
}
if(!updateFailure)
{
- DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
+ DU_LOG("ERROR --> E2AP : updateFailure pointer is null");
return;
}
if(!updateFailure->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
+ DU_LOG("ERROR --> E2AP : updateFailure array pointer is null");
return;
}
case ProtocolIE_IDE2_id_TransactionID:
{
transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
- DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
+ DU_LOG("ERROR --> E2AP : Received transID %d", transId);
break;
}
case ProtocolIE_IDE2_id_CauseE2:
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", updateFailure->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", updateFailure->protocolIEs.list.array[ieIdx]->id);
break;
}
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!connectionUpdateAck)
{
- DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
+ DU_LOG("ERROR --> E2AP : connectionUpdateAck pointer is null");
return;
}
if(!connectionUpdateAck->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
+ DU_LOG("ERROR --> E2AP : connectionUpdateAck array pointer is null");
return;
}
transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
if(transId>255)
{
- DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
+ DU_LOG("ERROR --> E2AP : Received invalid trans id %d ",transId);
return;
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
break;
}
}
if(!ricSubsDeleteFail)
{
- DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsDeleteFail pointer is null");
return;
}
if(!ricSubsDeleteFail->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail array pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsDeleteFail array pointer is null");
return;
}
case ProtocolIE_IDE2_id_RICrequestID:
{
memcpy(&ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
- DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
+ DU_LOG("ERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
break;
}
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
- DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
+ DU_LOG("ERROR --> E2AP : Received ranfuncId %d", ranFuncId);
break;
}
case ProtocolIE_IDE2_id_CauseE2:
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
break;
}
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!ricSubsDeleteRsp)
{
- DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsDeleteRsp pointer is null");
return;
}
if(!ricSubsDeleteRsp->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
return;
}
for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++)
ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
+ DU_LOG("ERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
return;
}
if(ricSubs)
{
deleteRicSubscriptionNode(ricSubsNode);
- DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully");
+ DU_LOG("INFO --> E2AP : Ric subscription node deleted successfully");
}
else
{
- DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
+ DU_LOG("ERROR --> E2AP : Ric subscription node is not present ");
return;
}
break;
CauseE2_t *cause = NULLP;
RICrequestID_t ricRequestID;
- DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received");
+ DU_LOG("INFO --> E2AP : Ric subscription modification failure received");
if(!ricSubsModificationFail)
{
- DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsModificationFail pointer is null");
return;
}
if(!ricSubsModificationFail->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsModificationFail array pointer is null");
return;
}
case ProtocolIE_IDE2_id_RICrequestID:
{
memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
- DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
+ DU_LOG("ERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
break;
}
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
- DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
+ DU_LOG("ERROR --> E2AP : Received ranfuncId %d", ranFuncId);
break;
}
case ProtocolIE_IDE2_id_CauseE2:
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
break;
}
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
break;
}
RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size);
if(!modifyActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t));
if(!modifyActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx];
RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\
actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(removeActionList->list.array, removeActionList->list.size);
if(!removeActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
if(!removeActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx];
RIC_ALLOC(addedActionList->list.array, addedActionList->list.size);
if(!addedActionList->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
if(!addedActionList->list.array[arrIdx])
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \
actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
if(actionNode == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
}
E2AP_PDU_t *e2apRicMsg = NULL;
RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
- DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
+ DU_LOG("INFO --> E2AP : Building RIC Subscription Request\n");
while(true)
{
RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
if(e2apRicMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
if(e2apRicMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
if(ricSubscriptionModReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
if(ricSubscriptionModReq->protocolIEs.list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildRicSubsActionToBeRemoved(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeRemovedForModification_List,\
ricSubsModReq.numOfActionToBeRemove, ricSubsModReq.actionToBeRemove) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildRicSubsActionToBeModify(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeModifiedForModification_List,\
ricSubsModReq.numOfActionToBeModify, ricSubsModReq.actionToBeModify) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
if(BuildRicSubsActionToBeAdded(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeAddedForModification_List,\
ricSubsInfo, ricSubsModReq.numOfActionToBeAdded, ricSubsModReq.actionToBeAdded) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ DU_LOG("ERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
}
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\
+ DU_LOG("ERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
break;
}
else
{
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n");
+ DU_LOG("DEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ printf("%x",encBuf[i]);
}
}
/* Sending msg */
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
+ DU_LOG("ERROR --> E2AP : Sending RIC subscription Request failed");
break;
}
if(BuildAndSendRicSubscriptionModReq(duDb, &ricSubsInfo, ricSubsModReq) != ROK)
{
- DU_LOG("\nERROR --> E2AP : failed to build and send RIC Subscription Modification");
+ DU_LOG("ERROR --> E2AP : failed to build and send RIC Subscription Modification");
return ;
}
}
{
modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx];
actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID;
- DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId);
+ DU_LOG("Info --> E2AP : Action id %d modified successfully", actionId);
}
}
{
addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx];
actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID;
- DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId);
+ DU_LOG("Info --> E2AP : Action id %d added successfully", actionId);
}
}
{
cmLListDelFrm(&ricSubs->actionSequence, actionNode);
deleteActionSequence(actionNode);
- DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId);
+ DU_LOG("Info --> E2AP : Action id %d removed successfully", actionId);
}
}
{
failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx];
actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID;
- DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__);
+ DU_LOG("ERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__);
printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause);
}
cmLListDelFrm(&ricSubs->actionSequence, actionNode);
deleteActionSequence(actionNode);
}
- DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
+ DU_LOG("ERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause);
}
{
failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx];
actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID;
- DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
+ DU_LOG("ERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause);
}
SEARCH_DU_DB(duIdx, duId, duDb);
if(duDb == NULLP)
{
- DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ DU_LOG("ERROR --> E2AP : duDb is not present for duId %d",duId);
return;
}
if(!ricSubsModificationRsp)
{
- DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsModificationRsp pointer is null");
return;
}
if(!ricSubsModificationRsp->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null");
+ DU_LOG("ERROR --> E2AP : ricSubsModificationRsp array pointer is null");
return;
}
ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
if(!ranFuncDb)
{
- DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
+ DU_LOG("ERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
return;
}
ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(!ricSubs)
{
- DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
+ DU_LOG("ERROR --> E2AP : Ric subscription node is not present ");
return;
}
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id);
+ DU_LOG("ERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id);
break;
}
}
asn_dec_rval_t rval; /* Decoder return value */
E2AP_PDU_t e2apasnmsg ;
- DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
+ DU_LOG("INFO --> E2AP : Received E2AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
if(recvBuf == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed");
+ DU_LOG("ERROR --> E2AP : Memory allocation failed");
return;
}
if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
- DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
+ DU_LOG("ERROR --> E2AP : Failed while copying %d", copyCnt);
return;
}
- DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
+ DU_LOG("DEBUG --> E2AP : Received flat buffer to be decoded : ");
for(i=0; i< recvBufLen; i++)
{
- DU_LOG("%x",recvBuf[i]);
+ printf("%x",recvBuf[i]);
}
/* Decoding flat buffer into E2AP messsage */
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
- DU_LOG("\nERROR --> E2AP : ASN decode failed");
+ DU_LOG("ERROR --> E2AP : ASN decode failed");
return;
}
- DU_LOG("\n");
+ DU_LOG("");
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
switch(e2apMsg->present)
{
case InitiatingMessageE2__value_PR_E2setupRequest:
{
- DU_LOG("\nINFO --> E2AP : E2 setup request received");
+ DU_LOG("INFO --> E2AP : E2 setup request received");
ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
break;
}
case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
{
- DU_LOG("\nINFO --> E2AP : E2 node config update received");
+ DU_LOG("INFO --> E2AP : E2 node config update received");
ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
break;
}
case InitiatingMessageE2__value_PR_ResetRequestE2:
{
- DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
+ DU_LOG("INFO --> E2AP : E2 Reset Request received");
ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
break;
}
case InitiatingMessageE2__value_PR_RICindication:
{
- DU_LOG("\nINFO --> E2AP : RIC Indication received");
+ DU_LOG("INFO --> E2AP : RIC Indication received");
break;
}
case InitiatingMessageE2__value_PR_RICserviceUpdate:
{
- DU_LOG("\nINFO --> E2AP : RIC Service update received");
+ DU_LOG("INFO --> E2AP : RIC Service update received");
ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
break;
}
case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
{
- DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
+ DU_LOG("INFO --> E2AP : RIC Subscription Modification Required");
ProcRicSubsModReqd(*duId, \
&e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
break;
}
case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired:
{
- DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required");
+ DU_LOG("INFO --> E2AP : RIC Subscription Delete Required");
ProcRicSubsDeleteReqd(*duId, \
&e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired);
break;
case InitiatingMessageE2__value_PR_ErrorIndicationE2:
{
- DU_LOG("\nINFO --> E2AP : Error indication received");
+ DU_LOG("INFO --> E2AP : Error indication received");
break;
}
case InitiatingMessageE2__value_PR_E2RemovalRequest:
{
- DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+ DU_LOG("INFO --> E2AP : E2 Removal request received");
procE2RemovalRequest(*duId,\
&e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
+ DU_LOG("ERROR --> E2AP : Invalid type of intiating message [%d]", \
e2apMsg->choice.initiatingMessage->value.present);
return;
}
{
case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
{
- DU_LOG("\nINFO --> E2AP : Reset response received");
+ DU_LOG("INFO --> E2AP : Reset response received");
ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
break;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
+ DU_LOG("ERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
e2apMsg->choice.successfulOutcome->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
+ DU_LOG("ERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
e2apMsg->choice.unsuccessfulOutcome->value.present);
return;
}
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type message type ");
+ DU_LOG("ERROR --> E2AP : Invalid type message type ");
return;
}
{
init_log();
- DU_LOG("\nINFO --> RIC : Starting RIC_STUB");
+ DU_LOG("INFO --> RIC : Starting RIC_STUB");
/* Read RIC configurations */
readRicCfg();
uint8_t *numDu;
uint32_t ipv4_du, ipv4_ric;
- DU_LOG("\nINFO --> RIC : Reading RIC configurations");
+ DU_LOG("INFO --> RIC : Reading RIC configurations");
ricCb.ricCfgParams.ricId = RIC_ID;
strcpy(ricCb.ricCfgParams.ricName, RIC_NAME);
#ifdef O1_ENABLE
if( getStartupConfigForStub(&g_cfg) != ROK )
{
- DU_LOG("\nError --> RIC : Could not fetch startup "\
+ DU_LOG("Error --> RIC : Could not fetch startup "\
"configurations from Netconf interface\n");
exit(1);
}
if((ret = cmInetSocket(socket_type, &sctpCb.e2LstnSockFd, IPPROTO_SCTP) != ROK))
{
- DU_LOG("\nERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.e2LstnSockFd.fd);
+ DU_LOG("ERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.e2LstnSockFd.fd);
}
else if((ret = cmInetSctpBindx(&sctpCb.e2LstnSockFd, &sctpCb.localAddrLst, sctpCb.sctpCfg.e2SctpPort)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Binding failed at RIC");
+ DU_LOG("ERROR --> SCTP: Binding failed at RIC");
}
else if((ret = cmInetListen(&sctpCb.e2LstnSockFd, 1)) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at CU");
- DU_LOG("\nERROR --> SCTP : Listening on socket failed");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at CU");
+ DU_LOG("ERROR --> SCTP : Listening on socket failed");
cmInetClose(&sctpCb.e2LstnSockFd);
return RFAILED;
}
{
if((ret = sctpAccept(&sctpCb.assocCb[assocIdx])) != ROK)
{
- DU_LOG("\nERROR --> SCTP: Unable to accept the connection at RIC");
+ DU_LOG("ERROR --> SCTP: Unable to accept the connection at RIC");
}
}
}
{
if(sctpSockPoll() != ROK)
{
- DU_LOG("\nERROR --> SCTP: Polling failed to start at RIC");
+ DU_LOG("ERROR --> SCTP: Polling failed to start at RIC");
}
}
return (ret);
{
uint8_t ret;
- DU_LOG("\nINFO --> SCTP : Connecting");
+ DU_LOG("INFO --> SCTP : Connecting");
while(!assocCb->connUp)
{
}
else if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to accept connection");
+ DU_LOG("ERROR --> SCTP : Failed to accept connection");
return RFAILED;
}
else
break;
}
}
- DU_LOG("\nINFO --> SCTP : Connection established");
+ DU_LOG("INFO --> SCTP : Connection established");
return ROK;
}
switch(ntfy->header.nType)
{
case CM_INET_SCTP_ASSOC_CHANGE :
- DU_LOG("\nINFO --> SCTP : Assoc change notification received");
+ DU_LOG("INFO --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
- DU_LOG("\nINFO --> Event : COMMUNICATION UP");
+ DU_LOG("INFO --> Event : COMMUNICATION UP");
assocCb->connUp = TRUE;
break;
case CM_INET_SCTP_COMM_LOST:
- DU_LOG("\nINFO --> Event : COMMUNICATION LOST");
+ DU_LOG("INFO --> Event : COMMUNICATION LOST");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_RESTART:
- DU_LOG("\nINFO --> Event : SCTP RESTART");
+ DU_LOG("INFO --> Event : SCTP RESTART");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */
- DU_LOG("\nINFO --> Event : SHUTDOWN COMPLETE");
+ DU_LOG("INFO --> Event : SHUTDOWN COMPLETE");
assocCb->connUp = FALSE;
break;
case CM_INET_SCTP_CANT_STR_ASSOC:
- DU_LOG("\nINFO --> Event : CANT START ASSOC");
+ DU_LOG("INFO --> Event : CANT START ASSOC");
assocCb->connUp = FALSE;
break;
default:
- DU_LOG("\nERROR --> Invalid event");
+ DU_LOG("ERROR --> Invalid event");
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
+ DU_LOG("INFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nINFO --> SCTP : Remote Error notification received");
+ DU_LOG("INFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
+ DU_LOG("INFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
- DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n");
+ DU_LOG("INFO --> SCTP : Shutdown Event notification received\n");
assocCb->connUp = FALSE;
deleteE2NodeInfo(&ricCb.duInfo[0]);
exit(0);
break;
case CM_INET_SCTP_ADAPTATION_INDICATION :
- DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
+ DU_LOG("INFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
+ DU_LOG("INFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nERROR --> SCTP : Invalid notification type\n");
+ DU_LOG("ERROR --> SCTP : Invalid notification type\n");
break;
}
CM_INET_FD_ZERO(&e2PollParams.readFd);
- DU_LOG("\nINFO --> SCTP : Polling started at RIC\n");
+ DU_LOG("INFO --> SCTP : Polling started at RIC\n");
while(1)
{
/* Receiving SCTP data */
{
if((ret = processPolling(&e2PollParams, &sctpCb.assocCb[assocIdx], timeoutPtr, &memInfo)) != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for E2 at RIC \n");
+ DU_LOG("ERROR --> SCTP : Failed to RecvMsg for E2 at RIC \n");
}
}
};
ret = sctpNtfyHdlr(assocCb, &pollParams->ntfy);
if(ret != ROK)
{
- DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
+ DU_LOG("ERROR --> SCTP : Failed to process sctp notify msg\n");
}
}
else if(assocCb->connUp)
if(ret != ROK && ret != RWOULDBLOCK)
{
- DU_LOG("\nERROR --> SCTP : Send message failed");
+ DU_LOG("ERROR --> SCTP : Send message failed");
return RFAILED;
}
}
Code Review / o-du / l2.git / commitdiff