# macro for output file name and makefile name
#
-PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
+PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DODU_MEMORY_DEBUG_LOG #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
ifeq ($(MODE),TDD)
PLTFRM_FLAGS += -DNR_TDD
#endif\r
default:\r
{\r
- SPutMsg(mBuf);\r
+ ODU_PUT_MSG_BUF(mBuf);\r
DU_LOG("\nERROR --> LWR MAC: Invalid event %d received", pst->event);\r
ret = RFAILED;\r
}\r
\r
default:\r
{\r
- SPutMsg(mBuf);\r
+ ODU_PUT_MSG_BUF(mBuf);\r
DU_LOG("\nERROR --> LWR MAC: Message from invalid source entity %d", pst->srcEnt);\r
ret = RFAILED;\r
}\r
{
if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
{
- memset(macCb.macCell[cellIdx], 0, sizeof(MacCellCb));
status = SUCCESSFUL_RSP;
+ MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
+ macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
}
else
if(macLcCfg->drbQos)
{
- if(!schLcCfg->drbQos)
- {
- MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
- if(!schLcCfg->drbQos)
- {
- DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
- ret = RFAILED;
- }
- }
- if(ret == ROK)
- {
- fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos);
- }
- else
- return ret;
+ if(!schLcCfg->drbQos)
+ {
+ MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
+ if(!schLcCfg->drbQos)
+ {
+ DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
+ ret = RFAILED;
+ }
+ }
+ if(ret == ROK)
+ {
+ fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos);
+ }
+ else
+ return ret;
}
else
{
schLcCfg->snssai->sst = macLcCfg->snssai->sst;
for(sdIdx = 0; sdIdx < SD_SIZE; sdIdx++)
{
- schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx];
+ schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx];
}
}
- else
- {
- schLcCfg->snssai = NULLP;
- /*Freeing the previously allocated buffer in case of failure */
- if(schLcCfg->drbQos)
- {
- MAC_FREE(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
- schLcCfg->drbQos = NULLP;
- }
- return ret;
- }
}
else
{
schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr;
}
else
+ {
schUeCfg->ambrCfg = NULLP;
-
+ }
/* Fill DL modulation infor */
schUeCfg->dlModInfo.modOrder = ueCfg->dlModInfo.modOrder;
schUeCfg->dlModInfo.mcsIndex = ueCfg->dlModInfo.mcsIndex;
#define MAC_MEM_REGION 4
#define MAC_POOL 1
+#ifdef ODU_MEMORY_DEBUG_LOG
+#define MAC_MEM_LOG(_macro, _file, _line, _func, _size, _datPtr)\
+{\
+ printf("\n%s=== %s +%d, %s, %d, %p\n", \
+ _macro, _file, _line, _func, _size, _datPtr); \
+}
+#else
+#define MAC_MEM_LOG(_macro, _file, _line, _func, _size, _dataPtr) {}
+#endif
+
/* allocate and zero out a MAC static buffer */
#define MAC_ALLOC(_datPtr, _size) \
{ \
uint8_t _ret; \
_ret = SGetSBuf(MAC_MEM_REGION, MAC_POOL, \
- (Data **)&_datPtr, _size); \
+ (Data **)&_datPtr, _size); \
if(_ret == ROK) \
{ \
- memset(_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
+ MAC_MEM_LOG("MAC_ALLOC", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
} \
else \
{ \
{ \
if(_datPtr) \
{ \
+ MAC_MEM_LOG("MAC_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
SPutSBuf(MAC_MEM_REGION, MAC_POOL, \
- (Data *)_datPtr, _size); \
- _datPtr = NULLP; \
+ (Data *)_datPtr, _size); \
+ _datPtr = NULLP; \
} \
}
#define MAC_ALLOC_SHRABL_BUF(_buf, _size) \
{ \
if(SGetStaticBuffer(MAC_MEM_REGION, MAC_POOL, \
- (Data **)&_buf, (Size) _size, 0) == ROK) \
+ (Data **)&_buf, (Size) _size, 0) == ROK) \
{ \
- memset((_buf), 0, _size); \
+ MAC_MEM_LOG("MAC_ALLOC_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
+ memset((_buf), 0, _size); \
} \
else \
{ \
{ \
if (_buf != NULLP) \
{ \
+ MAC_MEM_LOG("MAC_FREE_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutStaticBuffer(_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
/* Free shared memory, received through LWLC */
#define MAC_FREE_MEM(_region, _pool, _datPtr, _size) \
- if(_datPtr) \
- SPutSBuf(_region, _pool,(Data *)_datPtr, _size); \
- _datPtr = NULL;
+ MAC_FREE(_datPtr, _size); \
#define RG_LCG_ISCFGD(lcg) ((lcg)->lcgId != RG_INVALID_LCG_ID)
/* Corrected the check for dlCcchId */
#include "rg_env.h" /* MAC environmental includes*/
#include "rg.h" /* MAC includes*/
#include "rg_err.h" /* MAC error includes*/
-
+#include "mac_utils.h"
/* header/extern include files (.x) */
#include "rgu.x" /* RGU types */
#include "tfu.x" /* RGU types */
pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
/* Allocate a buffer for flowCntrlInd.*/
- SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
- sizeof(RguFlowCntrlInd));
+ MAC_ALLOC(cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
+ if(cell->flowCntrlInd == NULLP)
+ {
+ DU_LOG("ERROR --> MAC : rgCFGCrgCellCfg(): Memory allocation failed");
+ return RFAILED;
+ }
return ROK;
} /* rgCFGCrgCellCfg */
while (start != end)
{
start--;
- SPutMsg(rgCbP->bufToFree[start]);
+ ODU_PUT_MSG_BUF(rgCbP->bufToFree[start]);
}
rgCbP->bufCnt = end;
return;
while (start != end)
{
start--;
- SPutMsg(rgCbP->bufToFree[start]);
+ ODU_PUT_MSG_BUF(rgCbP->bufToFree[start]);
}
rgCbP->bufCnt = end;
return;
#include "rgr.h" /* LRG Interface defines */
#include "rg.h" /* MAC defines */
#include "rg_err.h" /* MAC error defines */
+#include "mac_utils.h"
/* header/extern include files (.x) */
#include "crg.x" /* CRG Interface includes */
if (sta->t.ssta.s.sysId.ptNmb != NULLP)
{
- SPutSBuf(pst->region, pst->pool, (Data *)sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ MAC_FREE(sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
}
memset(&cfm, 0, sizeof(RgMngmt));
if(rgCb[inst].rgInit.cfgDone != TRUE)
{
SGetDateTime(&cfm.t.ssta.dt);
- if (SGetSBuf(cfmPst.region, cfmPst.pool,
- (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
- != ROK)
+ MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ if(cfm.t.ssta.s.sysId.ptNmb == NULLP)
{
DU_LOG("\nERROR --> MAC : Memory Unavailable for Confirmation");
return ROK;
{
case STGEN:
SGetDateTime(&cfm.t.ssta.dt);
- if (SGetSBuf(cfmPst.region, cfmPst.pool,
- (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
- != ROK)
+ MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ if(cfm.t.ssta.s.sysId.ptNmb == NULLP)
{
DU_LOG("\nERROR --> MAC : Memory Unavailable for Confirmation");
return ROK;
}
/* allocate RGR saps */
- if (SGetSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data **)&rgCb[inst].rguSap,
- (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps)) != ROK)
+ 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");
return RFAILED;
DU_LOG("\nERROR --> MAC : Failed to register timer");
- SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
+ MAC_FREE(rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
return (LCM_REASON_MEM_NOAVAIL);
}
/* Deleting the RGU SAPs */
- SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
+ MAC_FREE(rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * rgCb[inst].numRguSaps));
- rgCb[inst].rguSap = NULLP;
rgCb[inst].inactiveCell = NULLP;
rgCb[inst].cell = NULLP;
return;
}
- if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
{
DU_LOG("\nERROR --> MAC : dstMbuf Allocation Failed");
return;
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{\
if (NULLP != (_buf)) \
{ \
- SPutMsg((_buf)); \
+ ODU_PUT_MSG_BUF((_buf)); \
_buf = NULLP; \
} \
}
{
if(datInd->lchData[i].pdu.mBuf[j])
{
- SPutMsg(datInd->lchData[i].pdu.mBuf[j]);
+ ODU_PUT_MSG_BUF(datInd->lchData[i].pdu.mBuf[j]);
}
}
}
#include "rg_env.h" /* customizable defines and macros for MAC */
#include "rg.h" /* defines and macros for MAC */
#include "rg_err.h" /* RG error defines */
+#include "mac_utils.h"
/* header/extern include files (.x) */
/* Call Ownership module for further processing */
ret = rgROMDedDatReq(inst,datReq);
- SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,sizeof(RguDDatReqInfo), SS_SHARABLE_MEMORY);
- datReq = NULLP;
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, datReq,sizeof(RguDDatReqInfo));
return (ret);
} /* RgUiRguDDatReq */
{
RG_DROP_RGUCDATREQ_MBUF(datReq);
}
- ret = SPutStaticBuffer(pst->region, pst->pool,(Data *)datReq,sizeof(RguCDatReqInfo) , SS_SHARABLE_MEMORY);
- datReq = NULLP;
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool,datReq,sizeof(RguCDatReqInfo));
return (ret);
} /* RgUiRguCDatReq */
return (ret);
}
- ret = SPutStaticBuffer(pst->region, pst->pool, (Data *)staRsp,sizeof(RguCStaRspInfo) , SS_SHARABLE_MEMORY);
- staRsp = NULLP;
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, staRsp,sizeof(RguCStaRspInfo));
return (ret);
} /* RgUiRguCStaRsp */
DU_LOG("\nERROR --> MAC : Processing Of Meas Request Failed");
}
- SPutStaticBuffer(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo) , SS_SHARABLE_MEMORY);
- measReq= NULLP;
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo));
return (ret);
} /* RgUiRguL2MUlThrpMeasReq */
#endif
DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgCfgReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
- SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
- sizeof(CrgCfgReqInfo));
- cfgReqInfo = NULLP;
+ MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
- rgUIMCrgCfgCfm(inst,transId, cfmStatus);
- return RFAILED;
+ rgUIMCrgCfgCfm(inst,transId, cfmStatus);
+ return RFAILED;
}
}
else
DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgCfgReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
- SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
- sizeof(CrgCfgReqInfo));
- cfgReqInfo = NULLP;
+ MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
return RFAILED;
}
ret = rgCOMCfgReq(inst,transId, cfgReqInfo);
- SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
- sizeof(CrgCfgReqInfo));
- cfgReqInfo = NULLP;
+ MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
if (ret != ROK)
{
DU_LOG("\nERROR --> MAC : Configuration Request Handling Failed ");
#include "tfu.h" /* TFU Interface defines */
#include "rg_sch_inf.h" /* RGR Interface defines */
#include "lrg.h" /* LRG Interface defines */
+#include "mac_utils.h"
#include "rg_prg.h" /* PRG(MAC-MAC) Interface includes */
#include "rg.h" /* MAC defines */
}
/* allocate buffer */
- if (SGetStaticBuffer(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, pData, size, 0) != ROK)
+ MAC_ALLOC_SHRABL_BUF(pData, size);
+ if(pData == NULLP)
{
dgn.type = LRG_USTA_DGNVAL_MEM;
dgn.u.mem.region = rgCb[inst].rgInit.region;
}
#ifndef ALIGN_64BIT
- DU_LOG("\nDEBUG --> MAC : SGetSBuf(Region (%d), Pool (%d), Size (%ld)), Data (0x%p))\n",
+ DU_LOG("\nDEBUG --> MAC : MAC_ALLOC(Region (%d), Pool (%d), Size (%ld)), Data (0x%p))\n",
rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
#else
- DU_LOG("\nDEBUG --> MAC : SGetSBuf(Region (%d), Pool (%d), Size (%d)), Data (0x%p))\n",
+ DU_LOG("\nDEBUG --> MAC : MAC_ALLOC(Region (%d), Pool (%d), Size (%d)), Data (0x%p))\n",
rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
#endif
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
MS_BUF_ADD_ALLOC_CALLER();
#endif /* */
- if (SGetSBuf(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, pData, size) != ROK)
+ MAC_ALLOC(pData, size);
+ if(pData == NULLP)
{
dgn.type = LRG_USTA_DGNVAL_MEM;
dgn.u.mem.region = rgCb[inst].rgInit.region;
}
/* Deallocate buffer */
- ret = SPutStaticBuffer(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, *data, size, SS_SHARABLE_MEMORY);
-
- if (ret != ROK)
+ MAC_FREE_SHRABL_BUF(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, *data, size);
+
+ if (data != NULLP)
{
return;
}
MS_BUF_ADD_CALLER();
#endif /* */
/* Deallocate buffer */
- ret = SPutSBuf(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, *data, size);
+ MAC_FREE(data, size);
- if (ret != ROK)
+ if (data != NULLP)
{
DU_LOG("\nERROR --> MAC : rgFreeSBuf failed.\n");
return;
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
MS_BUF_ADD_ALLOC_CALLER();
#endif /* */
- ret = SGetMsg(RG_GET_MEM_REGION(rgCb[inst]), RG_GET_MEM_POOL(rgCb[inst]), mBuf);
+ ret = ODU_GET_MSG_BUF(RG_GET_MEM_REGION(rgCb[inst]), RG_GET_MEM_POOL(rgCb[inst]), mBuf);
if (ROK != ret)
{
while(txBuf->pduLst.first)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
- RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
-
-#if (ERRCLASS & ERRCLS_ADD_RES)
- if (*retx == NULLP)
- {
- DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
- return;
- }
-#endif /* ERRCLASS & ERRCLS_RES */
/* Move Sdu byte segment from TX buf to retx buf*/
rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
#ifndef L2_OPTMZ
- SGetMsg(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb),&mBuf);
+ ODU_GET_MSG_BUF(RLC_MEM_REGION_DL, RLC_POOL, &mBuf);
#else
mBuf = (Buffer *)rlcAmmStaPduList[rlcAmmStaPduListCnt++];
SResetMBuf(mBuf);
{
Buffer *mBuf = NULL;
Buffer *bufPtr = NULL;
- SGetMsg(1, 0 , &mBuf);
+ ODU_GET_MSG_BUF(1, 0 , &mBuf);
ssGetDBufOfSize(1 , 1800, &bufPtr);
SUpdMsg(mBuf, bufPtr, 0);
rlcAmmStaPduList[i] = (uint32_t)mBuf;
Buffer *mBuf;
mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
Buffer *mBuf;
mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
Buffer *mBuf;
mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
Buffer *mBuf;
mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
Buffer *mBuf;
mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
cmPkUdxStruct((uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo),mBuf);
/* Need to free the cfgCfmInfo here as it is allocated
buffer call SPutStaticBuffer */
- SPutStaticBuffer(pst->region,pst->pool,(Data *) cfgCfmInfo,
- sizeof(RlcCfgCfmInfo),0);
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgCfmInfo, sizeof(RlcCfgCfmInfo));
break;
}
case UDX_SEL_LWLC:
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
{
cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu),mBuf);
cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
- SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
- sizeof(RlcUdxStaPdu),0);
+ RLC_FREE_SHRABL_BUF(pst->region,pst->pool, pStaPdu, sizeof(RlcUdxStaPdu));
break;
}
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu),mBuf);
cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
/* Free status Pdu here for LC */
- SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
- sizeof(RlcUdxDlStaPdu),0);
+ RLC_FREE_SHRABL_BUF(pst->region,pst->pool, pStaPdu, sizeof(RlcUdxDlStaPdu));
break;
}
case UDX_SEL_LWLC:
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
S16 ret1;
Buffer *mBuf = NULLP;
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
+ if((ret1 = ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, suId, spId));
} /*end of function cmUnpkUdxBndReq*/
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EUDXXXX, pst);
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, reason));
} /*end of function cmUnpkUdxUbndReq*/
\f
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EUDXXXX, pst);
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, suId, status));
} /*end of function cmUnpkUdxBndCfm*/
ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpCfgInfo,sizeof(RlcCfgInfo));
if(ret1 != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
}
#endif /* LCUDX */
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, cfgInfo));
} /* cmUnpkUdxCfgReq */
#ifdef LCUDX
case UDX_SEL_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
- sizeof(RlcCfgCfmInfo),0)) != ROK)
+ RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, cfgCfmInfo, sizeof(RlcCfgCfmInfo))
+ if(cfgCfmInfo == NULL)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- if(ret1 != ROK)
+ if(cfgCfmInfo == NULL)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- return (ret1);
+ return (RFAILED);
}
ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
}
#endif /* LCUDX */
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, suId, cfgCfmInfo));
} /* cmUnpkUdxCfgCfm */
#endif /* LCUDX */
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, suId, transId, status));
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, suId, rlcId, pBufLst));
SpId spId = 0;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
RlcUdxStaPdu *pStaPdu = NULLP; /* KW_FIX */
- S16 ret1;
CmLteRlcId tmpRlcId;
CMCHKUNPK(SUnpkS16, &spId, mBuf);
{
case UDX_SEL_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
- sizeof(RlcUdxStaPdu),0)) != ROK)
+ RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, pStaPdu, sizeof(RlcUdxStaPdu))
+ if(pStaPdu == NULLP)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- if(ret1 != ROK)
+ if(pStaPdu == NULLP)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- return (ret1);
+ return (RFAILED);
}
- ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
+ cmUnpkUdxStruct(mBuf,0,(uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu));
+ cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, rlcId, pStaPdu));
*/
S16 cmUnpkUdxStaPduReq(UdxStaPduReq func,Pst *pst,Buffer *mBuf)
{
- S16 ret1;
SpId spId = 0;
CmLteRlcId tmpRlcId;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
{
case UDX_SEL_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
- sizeof(RlcUdxDlStaPdu),0)) != ROK)
+ RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, pStaPdu, sizeof(RlcUdxDlStaPdu))
+ if(pStaPdu == NULLP)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- if(ret1 != ROK)
+ if(pStaPdu == NULLP)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
+ (ErrVal)EUDXXXX, (ErrVal)0, "ODU_GET_MSG_BUF() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- return (ret1);
+ return (RFAILED);
}
- ret1 = cmUnpkUdxStruct(mBuf,0, (uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
- rlcId = &tmpRlcId;
+ cmUnpkUdxStruct(mBuf,0, (uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu));
+ cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
+ rlcId = &tmpRlcId;
break;
}
case UDX_SEL_LWLC:
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, rlcId, pStaPdu));
} /* cmUnpkUdxUeIdChgCfm */
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, spId, rlcId));
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, measReqEvt));
} /* cmUnpkUdxL2MeasReq */
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, measType));
} /* cmUnpkUdxL2MeasReq */
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, measType));
} /* cmUnpkUdxL2MeasStopReq */
if(sendRlcUeDeleteRspToDu(cfgCfm->cellId, cfgCfm->ueId, SUCCESSFUL) != ROK)
{
DU_LOG("ERROR --> RLC_UL: rlcUlUdxCfgCfm(): Failed to send UE delete response ");
+ RLC_FREE(tRlcCb, cfgCfm, sizeof(RlcCfgCfmInfo));
return RFAILED;
}
+ RLC_FREE(tRlcCb, cfgCfm, sizeof(RlcCfgCfmInfo));
}
/* free the memory from DL */
- RLC_FREE_SHRABL_BUF(pst->region,
- pst->pool,
- cfmInfo,
- sizeof(RlcCfgCfmInfo));
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool, cfmInfo, sizeof(RlcCfgCfmInfo));
/* free the cfgInfo that came from LM */
RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
rlcUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
rlcUtlInitializeSelfPst(gCb);
- if(SGetMsg(gCb->init.region,
- gCb->init.pool,
- &(gCb->u.dlCb->selfPstMBuf)) != ROK)
+ if(ODU_GET_MSG_BUF(gCb->init.region, gCb->init.pool, &(gCb->u.dlCb->selfPstMBuf)) != ROK)
{
RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
{
if (gCb->u.dlCb->selfPstMBuf != NULL)
{
- SPutMsg(gCb->u.dlCb->selfPstMBuf);
+ ODU_PUT_MSG_BUF(gCb->u.dlCb->selfPstMBuf);
}
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
}
return RFAILED;
}
- if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
{
DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return RFAILED;
{
/* jump to specific primitive depending on configured selector */
uint8_t ret = ROK;
+ RlcCb *gCb;
RlcUeCfgRsp *ueRsp = NULLP;
+ gCb = RLC_GET_RLCCB(pst->srcInst);
RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCfgRsp));
if(!ueRsp)
{
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCfgRsp));
}
}
+ RLC_FREE(gCb, cfgRsp, sizeof(RlcCfgCfmInfo));
return ret;
} /* end of SendRlcUeCfgRspToDu */
{
uint8_t ret = ROK;
RlcCfgInfo *rlcUeCfg = NULLP;
+ RlcCb *gCb;
- RlcCb *rlcUeCb = NULLP;
- rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
- RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
+ gCb = RLC_GET_RLCCB(pst->dstInst);
+ RLC_ALLOC(gCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()");
kwuDatReqDetl = (KwuDatReqDetl *)elmIndx;
SRngIncrRIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].nPktProc++;
- SPutMsg(kwuDatReqDetl->mBuf);
+ ODU_PUT_MSG_BUF(kwuDatReqDetl->mBuf);
elmIndx = NULLP;
kwuDatReqDetl = NULLP;
if((elmIndx = SRngGetRIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC)) == NULLP)
*
*
*/
-Void TSL2AllocStatsMem(Region region,Pool pool)
+Void TSL2AllocStatsMem(Inst inst)
{
uint32_t cnt=0;
+ RlcCb *gCb;
+ gCb = RLC_GET_RLCCB(inst);
cmLListInit(&inUseL2UeStatsLst);
cmLListInit(&freeL2UeStatsLst);
for (cnt=0; cnt < L2_STATS_MAX_CELLS; cnt++)
{
if(NULL == l2CellStats[cnt])
{
- if (SGetSBuf(region, pool, (Data **)&l2CellStats[cnt],
- (Size)sizeof (TSL2CellStatsCb)) != ROK)
- {
- DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure\n");
- }
+ RLC_ALLOC(gCb, l2CellStats[cnt], (Size)sizeof (TSL2CellStatsCb));
+ if(l2CellStats[cnt] == NULL)
+ {
+ DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure\n");
+ }
}
memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
}
TSL2UeStatsCb *statsCb = l2UeStats[cnt];
if(NULL == statsCb)
{
- if (SGetSBuf(region, pool, (Data **)&statsCb,
- (Size)sizeof (TSL2UeStatsCb)) != ROK)
- {
- DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
- }
+ RLC_ALLOC(gCb, statsCb, (Size)sizeof (TSL2UeStatsCb));
+ if(NULL == statsCb)
+ {
+ DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
+ }
}
memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
statsCb->lnk.node = (PTR)statsCb;
datIndInfo->tCrnti = crnti;
datIndInfo->isOutOfSeq = 16;
- SGetMsg(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
+ ODU_GET_MSG_BUF(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
SAddPstMsgMult(rrcConReq,6,pdu);
pdcpId.rbId = 1;
pdcpId.rbType = 0;
#endif
- SGetMsg(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
+ ODU_GET_MSG_BUF(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
SAddPstMsgMult(rrcConSetupComplete,34,pdu);
pdcpId.rbId = 1;
pdcpId.rbType = 0;
#endif
- SGetMsg(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
+ ODU_GET_MSG_BUF(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
#ifndef CA_PAL_5GTF
SAddPstMsgMult(rrcUeCapabilityInfo,12,pdu);
pdcpId.rbType = 0;
#endif
- SGetMsg(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
+ ODU_GET_MSG_BUF(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
SAddPstMsgMult(rrcSecurityModeComplete,2,pdu);
pdcpId.rbType = 0;
#endif
- SGetMsg(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
+ ODU_GET_MSG_BUF(DFLT_REGION, DFLT_POOL, (Buffer **) &pdu);
SAddPstMsgMult(rrcReconfigComplete,2,pdu);
kwInitExt();
*/
#ifdef TENB_STATS
- TSL2AllocStatsMem(tRlcCb->init.region, tRlcCb->init.pool);
+ TSL2AllocStatsMem(tRlcCb->init.inst);
#endif
return ROK;
* Memory related Defines
******************************************************************************/
/* Allocate function */
+#ifdef ODU_MEMORY_DEBUG_LOG
+#define RLC_MEM_LOG(_macro, _file, _line, _func, _size, _datPtr)\
+{\
+ printf("\n%s=== %s +%d, %s, %d, %p\n", \
+ _macro, _file, _line, _func, _size, _datPtr); \
+}
+#else
+#define RLC_MEM_LOG(_macro, _file, _line, _func, _size, _dataPtr) {}
+#endif
#define RLC_ALLOC(_cb,_buf, _size) \
{ \
if (SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
(Size) _size) == ROK) \
{ \
+ RLC_MEM_LOG("RLC_ALLOC", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
memset((_buf), 0, _size); \
} \
else \
{ \
if (_buf != NULLP) \
{ \
+ RLC_MEM_LOG("RLC_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutSBuf(_cb->init.region, _cb->init.pool, \
(Data *) _buf, (Size) _size); \
_buf = NULLP; \
#define RLC_FREE_SHRABL_BUF(_region, _pool,_buf, _size) \
{ \
if (_buf != NULLP) \
- { \
+ { \
+ RLC_MEM_LOG("RLC_FREE_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutStaticBuffer(_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
#define RLC_FREE_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
{ \
+ if (_buf != NULLP){\
+ RLC_MEM_LOG("RLC_FREE_SHRABL_BUF_WC", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutStaticBuffer(_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
- _buf = NULLP; \
+ _buf = NULLP; \
+ }\
}
#define RLC_ALLOC_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
{ \
- SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
- (Size) _size, 0); \
+ if(SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
+ (Size) _size, 0)==ROK) \
+ {\
+ RLC_MEM_LOG("RLC_ALLOC_SHRABL_BUF_WC", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
+ }\
+ else\
+ {\
+ (_buf) = NULLP;\
+ }\
}
#define RLC_ALLOC_SHRABL_BUF(_region, _pool,_buf, _size) \
if (SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0) == ROK) \
{ \
+ RLC_MEM_LOG("RLC_ALLOC_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
memset((_buf), 0, _size); \
} \
else \
}
#define RLC_ALLOC_WC(_cb,_buf, _size) \
- SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, (Size) _size)
+{\
+ if(SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, (Size) _size) == ROK)\
+ {\
+ RLC_MEM_LOG("RLC_ALLOC_WC", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
+ }\
+}
#define RLC_REMOVE_SDU(_cb,_sduQ,_sdu) \
{ \
if(_sdu->mBuf) \
{ \
- SPutMsg(_sdu->mBuf); \
+ RLC_MEM_LOG("RLC_REMOVE_SDU", __FILE__, __LINE__, __FUNCTION__, _sdu->sduSz, _sdu->mBuf);\
+ ODU_PUT_MSG_BUF(_sdu->mBuf); \
} \
cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
RLC_FREE(_cb,_sdu, sizeof(RlcSdu)); \
{ \
if (_buf != NULLP) \
{ \
+ RLC_MEM_LOG("RLC_PST_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutSBuf(_region, _pool, \
(Data *) _buf, (Size) _size); \
_buf = NULLP; \
{ \
if (_buf != NULLP) \
{ \
+ RLC_MEM_LOG("RLC_SHRABL_STATIC_BUF_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutStaticBuffer(_region, _pool, \
- (Data *) _buf, (Size) _size, 0); \
+ (Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
} \
}
#define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
{ \
- SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
- (Size) _size, 0); \
+ SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
+ (Size) _size, 0); \
+ RLC_MEM_LOG("RLC_SHRABL_STATIC_BUF_ALLOC", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
}
#endif
uint8_t snIdx1;
uint8_t snIdx2;
#endif /* LTE_L2_MEAS */
- uint32_t idx;
+ uint32_t idx, ueDataIdx = 0;
//Debug
uint32_t staIndSz=0,datIndSz = 0;
for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
{
staIndTb = &(staInd->staIndTb[numTb]);
- datReqTb = &(datReqInfo->datReq[idx].datReqTb[numTb]);
+ datReqTb = &(datReqInfo->datReq[ueDataIdx].datReqTb[numTb]);
#ifdef LTE_L2_MEAS
ueCb->tbIdx = (ueCb->tbIdx+1) % RLC_MAX_TB_PER_UE;
#endif
}
#endif /* LTE_L2_MEAS */
}
- datReqInfo->datReq[idx].nmbOfTbs = staInd->nmbOfTbs;
- datReqInfo->datReq[idx].transId = staInd->transId;
- datReqInfo->datReq[idx].rnti = staInd->rnti;
+ datReqInfo->datReq[ueDataIdx].nmbOfTbs = staInd->nmbOfTbs;
+ datReqInfo->datReq[ueDataIdx].transId = staInd->transId;
+ datReqInfo->datReq[ueDataIdx].rnti = staInd->rnti;
+ ueDataIdx++;
}
- datReqInfo->cellId = staIndInfo->cellId;
- datReqInfo->nmbOfUeGrantPerTti = staIndInfo->nmbOfUeGrantPerTti;
- rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
- rlcSendDedLcDlData(&rguSap->pst,rguSap->spId,datReqInfo);
+ if(ueDataIdx > 0)
+ {
+ datReqInfo->cellId = staIndInfo->cellId;
+ datReqInfo->nmbOfUeGrantPerTti = staIndInfo->nmbOfUeGrantPerTti;
+
+ rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
+ rlcSendDedLcDlData(&rguSap->pst,rguSap->spId,datReqInfo);
+ }
+ else
+ {
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo,sizeof(RguDDatReqInfo));
+ }
return ROK;
}
/* Free from the ReTx list */
lst = &pToBeFreed->reTxLst;
-#ifndef L2_OPTMZ
- while((lst->first) && toBeFreed && (pToBeFreed->reTxLst.count > 100))
-#else
while((lst->first) && toBeFreed)
-#endif
{
RlcRetx* seg = (RlcRetx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
/* Free from the Tx list */
lst = &pToBeFreed->txLst;
-#ifndef L2_OPTMZ
- while((lst->first) && toBeFreed && (pToBeFreed->txLst.count > 100))
-#else
while((lst->first) && toBeFreed)
-#endif
{
RlcTx* pdu = (RlcTx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
/* Free from the SDU queue */
lst = &pToBeFreed->sduLst;
-#ifndef L2_OPTMZ
- while((lst->first) && toBeFreed && (pToBeFreed->sduLst.count > 100))
-#else
while((lst->first) && toBeFreed)
-#endif
{
RlcSdu* sdu = (RlcSdu *)(lst->first->node);
RLC_REMOVE_SDU(gCb, lst, sdu);
/* Free from the RBs */
lst = &pToBeFreed->rbLst;
-#ifndef L2_OPTMZ
- while((lst->first) && toBeFreed && (pToBeFreed->rbLst.count > 100))
-#else
while((lst->first) && toBeFreed)
-#endif
{
RlcDlRbCb* rbCb = (RlcDlRbCb *)(lst->first->node);
Bool moreToBeFreed = rlcUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
/* Intentionally avoiding the RLC_ALLOC macro to avoid memset */
- if (SGetSBuf(gCb->init.region,
- gCb->init.pool,
- (Data **)&curL2MeasTb,
- (Size)sizeof(RlcL2MeasTb)) != ROK)
+ RLC_ALLOC(gCb, curL2MeasTb, (Size)sizeof(RlcL2MeasTb));
+ if(curL2MeasTb == NULLP)
{
+ DU_LOG("ERROR --> RLC_DL : rlcUtlGetCurMeasTb(): Memory allocation failed");
return (NULLP);
}
rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx] = curL2MeasTb;
#include "rg_sch.h"
#include "rg_sch_err.h"
#include "rg_sch_cmn.h"
+#include "sch_utils.h"
/* header/extern include files (.x) */
#include "tfu.x" /* TFU types */
#include "rg_sch_inf.x" /* typedefs for Scheduler */
#include "rg_sch.x" /* typedefs for Scheduler */
#include "rg_sch_cmn.x"
+#include "mac_sch_interface.h"
#ifdef EMTC_ENABLE
S16 rgEmtcMacSchUeDelInd ARGS((RgSchCellCb *cell,RgInfUeDelInd *ueDelInd));
SchFillCfmPst(pst, &cfmPst, cntrl);
/* Initialize the cfg cfm structure
- if (SGetSBuf(cfmPst.region, cfmPst.pool, (Data **)&cfm, sizeof(RgMngmt))
- != ROK)
+ SCH_ALLOC(cfm, sizeof(RgMngmt));
+ if(cfm == NULLP)
{
DU_LOG("\nERROR --> SCH : Memory Unavailable for Confirmation");
- SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt));
+ SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt));
return ROK;
} */
memset(&cfm, 0, sizeof(RgMngmt));
cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
RgMiLrgSchCntrlCfm(&cfmPst, &cfm);
DU_LOG("\nERROR --> SCH : Gen Cfg not done.");
- /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
+ /* SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt)); */
return ROK;
}
cntrl->hdr.elmId.elmnt);
break;
}
- /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
+ /* SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt)); */
return (ret);
}/*-- RgMiLrgSchCntrlReq --*/
#if (ERRCLASS & ERRCLS_ADD_RES)
DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrSiCfgReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
- (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrSiCfgReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
- (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
return RFAILED;
}
#endif
rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
&warningSiCfgReqInfo->siPduLst);
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
- sizeof(RgrWarningSiCfgReqInfo));
+ SCH_FREE(warningSiCfgReqInfo, sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
return RFAILED;
#endif
rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
&warningSiCfgReqInfo->siPduLst);
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
- sizeof(RgrWarningSiCfgReqInfo));
+ SCH_FREE(warningSiCfgReqInfo,sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
return RFAILED;
#if (ERRCLASS & ERRCLS_ADD_RES)
DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrLoadInfReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
- (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_ADD_RES)
DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrLoadInfReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
- (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return RFAILED;
}
ret = rgSCHTomRaReqInd(rgSchCb[inst].tfuSap[suId].cell, raReqInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(raReqInd);
- /*SPutSBuf (pst->region, pst->pool, (Data *)raReqInd,
+ /*SCH_FREE(pst->region, pst->pool, (Data *)raReqInd,
sizeof(TfuRaReqIndInfo)); */
return (ret);
} /* RgLiTfuRaReqInd */
prbUsage->prbRprtEnabld,prbUsage->rprtPeriod);
/* ccpu00134393 : mem leak fix */
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SCH_FREE(prbRprtCfg, sizeof(RgmPrbRprtCfg));
return ROK;
}
{\
if (NULLP != (_buf)) \
{ \
- SPutMsg((_buf)); \
+ ODU_PUT_MSG_BUF((_buf)); \
_buf = NULLP; \
} \
}
#include "rg_sch_inf.h"
#include "rg_sch.h"
#include "rg_sch_cmn.h"
-
/* header/extern include files (.x) */
#include "tfu.x" /* TFU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rg_sch_inf.x" /* typedefs for Scheduler */
#include "rg_sch.x" /* typedefs for Scheduler */
#include "rg_sch_cmn.x" /* typedefs for Scheduler */
+#include "sch_utils.h"
#ifdef MAC_SCH_STATS
#include "lrg.x" /* Stats Structures */
#endif /* MAC_SCH_STATS */
if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
{
/* Mem Alloc */
- if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
- cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
- sizeof(RgmTransModeInd)) != ROK)
+ SCH_ALLOC(txModeChgInd, sizeof(RgmTransModeInd));
+ if(txModeChgInd == NULLP)
{
+ DU_LOG("ERROR --> SCH : rgSCHCmnSendTxModeInd(): Memory allocation failed");
return;
}
RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
#include "rg_sch_inf.h"
#include "rg_sch.h"
#include "rg_sch_err.h"
+#include "sch_utils.h"
/* header/extern include files (.x) */
#include "lrg.x"
#include "tfu.x"
#include "rg_sch_inf.x"
#include "rg_sch.x"
+#include "mac_sch_interface.h"
/* local defines */
static S16 rgSCHGomHndlCfgReq ARGS((RgSchCb *instCb, SpId spId,
{
DU_LOG("\nERROR --> SCH : Action.Config Type Error");
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
DU_LOG("\nERROR --> SCH : Cell with Id %d already exists "
"on sap %d", instCb->rgrSap[spId].cell->cellId, spId);
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
DU_LOG("\nERROR --> SCH : rgSCHGomHndlCfg: Enqueuing CfgReq "
"Failed ");
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
return ROK;
}
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
cfmStatus = RGR_CFG_CFM_NOK;
}
- SPutSBuf(reg, pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
#ifdef EMTC_ENABLE
{
DU_LOG("\nERROR --> SCH : Cell Control block does not exist");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
return RFAILED;
DU_LOG("\nERROR --> SCH : Rgr SI configuration "
"validation FAILED");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
return RFAILED;
RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si);
cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
}
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
cfmStatus = RGR_CFG_CFM_OK;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
}
else
{
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
return RFAILED;
/* need to add padding bytes */
nmPadBytes = (tbSz - (msgLen*8))/8;
- if ( SGetSBuf(reg,pool,&padding,nmPadBytes) != ROK)
+ SCH_ALLOC(padding,nmPadBytes);
+ if(padding == NULLP)
{
DU_LOG("\nERROR --> SCH : Rgr SI configuration "
- "SGetSBuf failed for padding failed");
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ " failed to allocate memory for padding");
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
{
DU_LOG("\nERROR --> SCH : Rgr SI configuration "
"Failed to add padding bytes");
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
- SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
+ SCH_FREE(padding,(Size)nmPadBytes);
padding = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
return RFAILED;
}
- SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
+ SCH_FREE(padding,(Size)nmPadBytes);
padding = NULLP;
}/* if (tbSz != ...*/
}/* if (RGR_SI_CFG_TYPE_SI...*/
DU_LOG("\nERROR --> SCH : Failed to get MCS and NPRB"
"value");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
DU_LOG("\nERROR --> SCH : Failed to get MCS and NPRB"
"value");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
DU_LOG("\nERROR --> SCH : Failed to get MCS and NPRB"
"value");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
DU_LOG("\nERROR --> SCH : Failed to get MCS and NPRB"
"value");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
DU_LOG("\nERROR --> SCH : Invalid cfgType "
"parameter value");
RGSCH_FREE_MSG(cfgReqInfo->pdu);
- SPutSBuf(reg, pool, (Data *)cfgReqInfo,
+ SCH_FREE(cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
return RFAILED;
}
- SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
cfmStatus = RGR_CFG_CFM_OK;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
DU_LOG("\nERROR --> SCH : Warning SI Cfg Failed for siId = %d"
"warning cellID:%d",warningSiCfgReqInfo->siId,warningSiCfgReqInfo->cellId);
rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
- SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
+ SCH_FREE(warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
"for siId = %d", warningSiCfgReqInfo->siId);
rgSCHUtlFreeWarningSiSeg(reg, pool,
&warningSiCfgReqInfo->siPduLst);
- SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
+ SCH_FREE(warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId,
{
node = warningSiCfgReqInfo->siPduLst.first;
cmLListDelFrm(&(warningSiCfgReqInfo->siPduLst), node);
- SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
+ SCH_FREE(node,sizeof(CmLList));
node = NULLP;
}
{
DU_LOG("\nDEBUG --> SCH : No SI Index is free");
rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
- SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
+ SCH_FREE(warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
return RFAILED;
}
- SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
+ SCH_FREE(warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
warningSiCfgReqInfo = NULLP;
return ROK;
{
DU_LOG("\nERROR --> SCH : Cell Control block does not exist"
"for load cellId:%d",loadInfReq->cellId);
- SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return RFAILED;
}
if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
{
DU_LOG("\nERROR --> SCH : rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
- SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return RFAILED;
}
/* Validate the received LOAD INF Configuration */
{
DU_LOG("\nERROR --> SCH : Rgr LOAD INF Configuration "
"validation FAILED");
- SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return RFAILED;
}
/* Update the RNTP info rcvd in the respective cell centre pool so that Phigh can be
}
}
- SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
return ROK;
S16 cmPkMacSchUeDelInd(Pst* pst,RgInfUeDelInd* ueDelInd)
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, &measInfo));
} /* end of cmUnpkSchMacL2MeasReq */
/**
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, &measInfo));
} /* end of cmUnpkSchMacL2MeasSendReq*/
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
if(SAddPstMsgMult((Data *)measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
return ((*func)(pst, &measCfm));
} /* end of cmUnpkMacSchL2MeasStopCfm */
{\
if (NULLP != (_buf)) \
{ \
- SPutMsg((_buf)); \
+ ODU_PUT_MSG_BUF((_buf)); \
_buf = NULLP; \
} \
}
#ifdef LTE_L2_MEAS
#include "rg_sch_cmn.h" /* typedefs for Scheduler */
#endif
-
+#include "sch_utils.h"
/* header/extern include files (.x) */
#include "rgr.x" /* RGR Interface includes */
#include "rgm.x" /* RGM Interface includes */
}
/* Free the memory held by the scheduler instance */
/* Deallocate RGR saps */
- SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool,
- (Data *)rgSchCb[inst].rgrSap,
+ SCH_FREE(rgSchCb[inst].rgrSap,
(sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
rgSchCb[inst].rgrSap = NULLP;
/* Deallocate RGM saps */
- SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool,
- (Data *)rgSchCb[inst].rgmSap,
+ SCH_FREE(rgSchCb[inst].rgmSap,
(sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
rgSchCb[inst].rgmSap = NULLP;
/* Deallocate TFU saps */
- SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool,
- (Data *)rgSchCb[inst].tfuSap,
+ SCH_FREE(rgSchCb[inst].tfuSap,
(sizeof(RgSchLowSapCb) * rgSchCb[inst].numSaps));
rgSchCb[inst].tfuSap = NULLP;
/* Deallocate bndCfmResponses */
- SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool,
- (Data *)rgSchCb[inst].genCfg.bndCfmResp,
+ SCH_FREE(rgSchCb[inst].genCfg.bndCfmResp,
(sizeof(RgSchLmResponse) * rgSchCb[inst].numSaps));
rgSchCb[inst].genCfg.bndCfmResp = NULLP;
/* De-register the Timer Service */
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
+#include "sch_utils.h"
#include "rg_env.h"
#include "rg_sch_err.h"
#include "rg_sch_inf.h"
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
MS_BUF_ADD_ALLOC_CALLER();
#endif /* */
- if (SGetSBuf(rgSchCb[inst].rgSchInit.region, rgSchCb[inst].rgSchInit.pool,
- pData, size) != ROK)
+ SCH_ALLOC(pData, size);
+ if(pData == NULLP)
{
RgUstaDgn dgn; /* Alarm diagnostics structure */
dgn.type = LRG_USTA_DGNVAL_MEM;
MS_BUF_ADD_CALLER();
#endif /* */
/* Deallocate buffer */
- ret = SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool, (*data), size);
+ SCH_FREE((*data), size);
- if (ret != ROK)
+ if (data ==NULLP)
{
DU_LOG("\nERROR --> SCH : rgSCHUtlFreeSBuf failed");
return;
pdu = (Buffer *)node->node;
cmLListDelFrm(siPduLst, node);
RGSCH_FREE_MSG(pdu);
- SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
+ SCH_FREE(node,sizeof(CmLList));
node = NULLP;
}
numUlSf = cell->prbUsage.rprtPeriod;
#endif
- if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
- cell->rgmSap->sapCfg.sapPst.pool, (Data**)&prbRprtInd,
- sizeof(RgmPrbRprtInd)) != ROK)
+ SCH_ALLOC(prbRprtInd, sizeof(RgmPrbRprtInd));
+ if(prbRprtInd == NULLP)
{
+ DU_LOG("\nERROR --> SCH : Failed to allocate memory for prbRprtInd");
return RFAILED;
}
cfm.cfm.reason = reason;
SchSendCfgCfm(&cfmPst, &cfm);
- /* SPutSBuf(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */
+ /* SCH_FREE(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */
return ROK;
}/*-- SchProcGenCfgReq --*/
SchCb schCb[SCH_MAX_INST];
/* function declarations */
+SchUeCb* schGetUeCb(SchCellCb *cellCb, uint16_t crnti);
+void schInitUlSlot(SchUlSlotInfo *schUlSlotInfo);
+void schInitDlSlot(SchDlSlotInfo *schDlSlotInfo);
+uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm);
short int schActvTmr(Ent ent,Inst inst);
uint8_t schBroadcastAlloc(SchCellCb *cell, DlBrdcstAlloc *dlBrdcstAlloc,uint16_t slot);
uint8_t schProcessSlotInd(SlotIndInfo *slotInd, Inst inst);
memcpy(&ueCb->ueCfg.spCellCfg , &ueCfg->spCellCfg, sizeof(SchSpCellCfg));
ueCb->ueCfg.spCellCfgPres = true;
}
+
ueCb->state = SCH_UE_STATE_ACTIVE;
-
- ueCb->ueCfg.ambrCfg = ueCfg->ambrCfg;
+ if(ueCfg->ambrCfg)
+ {
+ SCH_FREE(ueCb->ueCfg.ambrCfg, sizeof(SchAmbrCfg));
+ ueCb->ueCfg.ambrCfg = ueCfg->ambrCfg;
+ }
memcpy(&ueCb->ueCfg.dlModInfo, &ueCfg->dlModInfo , sizeof(SchModulationInfo));
memcpy(&ueCb->ueCfg.ulModInfo, &ueCfg->ulModInfo , sizeof(SchModulationInfo));
}
}/*End of inner for loop */
}
+
+ SCH_FREE(ueCfg->schLcCfg[lcIdx].drbQos, sizeof(SchDrbQosInfo));
+ SCH_FREE(ueCfg->schLcCfg[lcIdx].snssai, sizeof(SchSnssai));
+
}/* End of outer for loop */
return ROK;
}
}
/* allocate and zero out a static buffer */
+#ifdef ODU_MEMORY_DEBUG_LOG
+#define SCH_MEM_LOG(_macro, _file, _line, _func, _size, _datPtr)\
+{\
+ printf("\n%s=== %s +%d, %s, %d, %p\n", \
+ _macro, _file, _line, _func, _size, _datPtr); \
+}
+#else
+#define SCH_MEM_LOG(_macro, _file, _line, _func, _size, _dataPtr) {}
+#endif
+
#define SCH_ALLOC(_datPtr, _size) \
{ \
uint8_t _ret; \
_ret = SGetSBuf(SCH_MEM_REGION, SCH_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- { \
+ { \
+ SCH_MEM_LOG("SCH_ALLOC", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
memset(_datPtr, 0, _size); \
} \
else \
#define SCH_FREE(_datPtr, _size) \
{ \
if(_datPtr) \
- { \
+ {\
+ SCH_MEM_LOG("SCH_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
SPutSBuf(SCH_MEM_REGION, SCH_POOL, \
(Data *)_datPtr,(Size) _size); \
_datPtr = NULLP; \
uint16_t schCalcTbSize(uint32_t payLoadSize);
uint16_t schCalcNumPrb(uint16_t tbSize, uint16_t mcs, uint8_t numSymbols);
uint16_t schCalcTbSizeFromNPrb(uint16_t numPrb, uint16_t mcs, uint8_t numSymbols);
-SchUeCb* schGetUeCb(SchCellCb *cellCb, uint16_t crnti);
-void schInitUlSlot(SchUlSlotInfo *schUlSlotInfo);
-void schInitDlSlot(SchDlSlotInfo *schDlSlotInfo);
#ifdef NR_TDD
SlotConfig schGetSlotSymbFrmt(uint16_t slot, uint32_t bitMap);
#endif
return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgCfmInfo,
sizeof(RlcCfgCfmInfo)) != ROK)
{
SPutMsg(mBuf);
}
CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
- if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo,
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
return RFAILED;
}
CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
- if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo,
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
CMCHKPK(cmPkCmStatus, &status, mBuf);
CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
- if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo,
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
RlcCfgCfmInfo *cfgCfmInfo = NULLP;
- if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
+ if((ret1 = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgCfmInfo,\
sizeof(RlcCfgCfmInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW037, pst);
- if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
+ if((ret1 = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueInfo,\
sizeof(CkwUeInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
+ if((ret1 = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&newUeInfo,\
sizeof(CkwUeInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
CMCHKUNPK(SUnpkS16, &suId, mBuf);
CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW042, pst);
- if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
+ if((ret1 = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueInfo,\
sizeof(CkwUeInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
{ \
if (_buf != NULLP) \
{ \
- (Void) SPutStaticBuffer(_region, _pool, \
+ (Void) SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
} \
if (nmbBins)
{
#ifndef CM_MT_HASH_BIN
- if (SGetSBuf(region, pool, (Data **) &hashListCp->hl,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hl,
(Size) (nmbBins * sizeof(CmListEnt))) != ROK)
return RFAILED;
#else
- if (SGetSBuf(region, pool, (Data **) &hashListCp->hl,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hl,
(Size) (nmbBins * sizeof(CmListBinEnt))) != ROK)
return RFAILED;
#endif
/* deallocate memory for bins */
if (hashListCp->nmbBins)
#ifndef CM_MT_HASH_BIN
- (Void) SPutSBuf(hashListCp->region, hashListCp->pool,
+ (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,hashListCp->region, hashListCp->pool,
(Data *) hashListCp->hl,
(Size) (hashListCp->nmbBins * sizeof(CmListEnt)));
#else
- (Void) SPutSBuf(hashListCp->region, hashListCp->pool,
+ (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,hashListCp->region, hashListCp->pool,
(Data *) hashListCp->hl,
(Size) (hashListCp->nmbBins * sizeof(CmListBinEnt)));
#endif
{
return RFAILED;
}
- ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
return (ROUTRES);
ret = SCpyMsgFix(mBuf, 0, bufLen, sendBuf, &msgLen);
if ((ret != ROK) || (msgLen != bufLen))
{
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return RFAILED;
}
{
if (sockFd->protType == AF_INET)
{
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
/* cm_inet_c_001.main_54: CMINETLOGERROR added insted of SDisp */
ppId, flags, strmId, ttl, context);
if (ret == INET_ERR)
{
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
/* cm_inet_c_001.main_54: CMINETLOGERROR added insted of SDisp */
*len = (MsgLen)ret;
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return ROK;
}
buflen = CM_INET_MAX_MSG_LEN;
/* allocate flat receive buffer */
- ret = SGetSBuf(meminfo->region, meminfo->pool, &recvbuf, buflen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,meminfo->region, meminfo->pool, &recvbuf, buflen);
if (ret != ROK)
{
#ifdef CMINETDBG
if (ret == INET_ERR)
{
/* cleanup */
- SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,meminfo->region, meminfo->pool, recvbuf, buflen);
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
/* cm_inet_c_001.main_54: CMINETLOGERROR added insted of SDisp */
/* cm_inet_c_001.main_46: Allocate memory for data before copying */
datlen = cmStrlen(sctpNtfy->sn_remote_error.sre_data) + 1;
- ret = SGetSBuf( meminfo->region, meminfo->pool, \
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__, meminfo->region, meminfo->pool, \
&ntfy->u.remoteErr.data, datlen );
if( ret != ROK )
{
/* cm_inet_c_001.main_46: Allocate memory for data before copying */
datlen = cmStrlen(sctpNtfy->sn_send_failed.ssf_data) + 1;
- ret = SGetSBuf( meminfo->region, meminfo->pool, \
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__, meminfo->region, meminfo->pool, \
&ntfy->u.sndFailed.data, datlen );
if( ret != ROK )
{
ret = SGetMsg(meminfo->region, meminfo->pool, mBuf);
if (ret != ROK)
{
- SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,meminfo->region, meminfo->pool, recvbuf, buflen);
return RFAILED;
}
if (ret != ROK)
{
SPutMsg(*mBuf);
- SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,meminfo->region, meminfo->pool, recvbuf, buflen);
return RFAILED;
}
}
/* cleanup */
- SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,meminfo->region, meminfo->pool, recvbuf, buflen);
return ROK;
}
{
return RFAILED;
}
- ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
return (ROUTRES);
if ((ret != ROK) || (msgLen != bufLen))
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return RFAILED;
}
if (ret == INET_ERR)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
if(INET_ERR_CODE == ERR_AGAIN)
{
if (ret < bufLen)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return (RWOULDBLOCK);
}
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
#else /* end of Win NT/flat buffer specific part */
ret = SFndLenMsg(mBuf, &msgLen);
{
return RFAILED;
}
- ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
return (ROUTRES);
if ((ret != ROK) || (msgLen != bufLen))
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return RFAILED;
}
if (ret == INET_ERR)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
if(INET_ERR_CODE == ERR_AGAIN)
{
if (ret < bufLen)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
return (RWOULDBLOCK);
}
/* cleanup */
- SPutSBuf(info->region, info->pool, sendBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, sendBuf, bufLen);
#else /* end of Win NT/flat buffer specific part */
ret = SFndLenMsg(mBuf, &msgLen);
}
/* allocate mem needed to hold all HBH/Dest options */
- ret = SGetSBuf(info->region, info->pool,
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool,
(Data **)&hbhOptsArr->hbhOpts,
(Size)((sizeof(CmInetIpv6HBHHdr)) * numOpts));
if (ret != ROK)
{
/* take care of all other options having valid value field
* such as Router Alert, PADN >= 3 bytes and Jumbo */
- ret = SGetSBuf(info->region, info->pool,
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool,
(Data **)&hbhOptsArr->hbhOpts[optsIdx].value,
(Size)hbhOptsArr->hbhOpts[optsIdx].length);
if (ret != ROK)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "SPutSBuf call 1 in BuildRecvHopOptsArr\n");
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET030, 0, prntBuf);
#endif /* CMINETDBG */
- SPutSBuf(info->region, info->pool,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool,
(Data *)hbhOptsArr->hbhOpts[optsIdx - 1].value,
(Size)hbhOptsArr->hbhOpts[optsIdx - 1].length);
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "SPutSBuf call 2 in BuildRecvHopOptsArr\n");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET031, 0, prntBuf);
#endif /* CMINETDBG */
- SPutSBuf(info->region, info->pool,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool,
(Data *)hbhOptsArr->hbhOpts, numOpts * sizeof(CmInetIpv6HBHHdr));
hbhOptsArr->numHBHOpts = 0;
hbhOptsArr->hbhOpts = NULLP;
/* subtract 8 bytes for Next Hdr, Hdr Ext Len, .... + SL bit map */
rtOptsArr->numAddrs = (rtDataLen - 8)/16;
- ret = SGetSBuf(info->region, info->pool,
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool,
(Data **)&rtOptsArr->ipv6Addrs,
(Size)rtOptsArr->numAddrs * 16);
if (ret != ROK)
}
/* allocate flat receive buffer */
- ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
{
return (ROUTRES);
{
/* cleanup */
/* moved cleanup here */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
/* added check ERR_WOULDBLOCK */
if ((INET_ERR_CODE == ERR_AGAIN) ||
if ((sockFd->type == CM_INET_DGRAM) && (*len == 0))
#endif
{
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
return (ROKDNA);
}
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET068, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
return (ROKDNA);
}
if (ret != ROK)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
return (ret);
}
if (ret != ROK)
{
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
SPutMsg(mBuf);
return (ret);
}
}
/* cleanup */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
#else /* end of Win NT/flat buffer specific part */
/* allocate gather vector, it's a dynamic array */
numDBufs = CM_INET_MAX_DBUF;
- ret = SGetSBuf(info->region, info->pool, (Data**)&dBufs,
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data**)&dBufs,
numDBufs*sizeof(Buffer*));
if (ret != ROK)
{
for (i = 0; i < msg.msg_iovlen; i++)
SPutDBuf(info->region, info->pool, dBufs[i]);
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs * sizeof(Buffer*));
/* allocate flat receive buffer */
- ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
return (ROUTRES);
}
else
{
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
return (ret);
}
/* Moved up the cleanup precedures here before returning */
/* Cleanup flat buffer if allocated */
if (allocFlatBuf)
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
else
{
/* cleanup */
SPutDBuf(info->region, info->pool, dBufs[i]);
}
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
}
if (ret != ROK)
{
/* cleanup */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
return (ret);
}
ret = SAddPstMsgMult(recvBuf, recvLen, tempMsg);
if (ret != ROK)
{
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
SPutMsg(tempMsg);
return (ret);
}
*mPtr = tempMsg;
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
/* cm_inet_c_001.main_48 :flat buffers are allocated
* for non -TCP sockets. On these sockets we can receive
* only one message at a time
* mBuf */
if (*mPtr != NULLP)
SPutMsg(*mPtr);
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
return (ret);
}
/* cleanup */
SPutMsg(*mPtr);
SPutMsg(tempMsg);
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
return RFAILED;
}
SPutMsg(tempMsg);
}
- SPutSBuf(info->region, info->pool, (Data*)dBufs,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
/*
if ((MsgLen)pendLen >= bufLen)
{
/* allocate receive buffer (flat structure) */
- ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
+ ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
{
return (ROUTRES);
{
/* cleanup */
/* moved cleanup here */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
/* added check ERR_WOULDBLOCK */
if ((INET_ERR_CODE == ERR_AGAIN) ||
if (recvLen < (S32)bufLen) /* maybe happen */
{
/* cleanup */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
return (ROKDNA);
}
}
/* cleanup */
- SPutSBuf(info->region, info->pool, recvBuf, bufLen);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,info->region, info->pool, recvBuf, bufLen);
}
else
{
numOpts > 0; numOpts--) \
{ \
if (_hdrParmIpv6->ipv6ExtHdr.hbhOptsArr.hbhOpts[numOpts - 1].length) \
- SPutSBuf(_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
hbhOptsArr.hbhOpts[numOpts - 1].value, (Size)(_hdrParmIpv6-> \
ipv6ExtHdr.hbhOptsArr.hbhOpts[numOpts - 1].length)); \
- SPutSBuf(_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
hbhOptsArr.hbhOpts[numOpts - 1], \
(Size)sizeof(CmInetIpv6HBHHdr)); \
} \
for(numOpts = _hdrParmIpv6->ipv6ExtHdr.destOptsArr.numDestOpts; \
numOpts > 0; numOpts--) \
{ \
- SPutSBuf(_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
destOptsArr.destOpts[numOpts - 1].value, (Size)(_hdrParmIpv6-> \
ipv6ExtHdr.destOptsArr.destOpts[numOpts - 1].length)); \
- SPutSBuf(_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
destOptsArr.destOpts[numOpts - 1], \
(Size)sizeof(CmInetIpv6DestOptsHdr)); \
} \
} \
if( _hdrParmIpv6->ipv6ExtHdr.rtOptsPrsnt) \
{ \
- SPutSBuf(_region, _pool, \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, \
(Data *)_hdrParmIpv6->ipv6ExtHdr.rtOptsArr.ipv6Addrs, \
(Size)(_hdrParmIpv6->ipv6ExtHdr.rtOptsArr.numAddrs * 16)); \
} \
/* Allocate memory for the first Memory Chunk */
/* Allocated memory should be maxBlkSize + sizeof(CmMemList) */
#ifdef SS_LOCKLESS_MEMORY
- if(SGetStaticBuffer(sMem->region, sMem->pool, (Data **)&allocPtr,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem->region, sMem->pool, (Data **)&allocPtr,
(Size)(maxBlkSize + sizeof(CmMemList)), 0) != ROK)
#else
- if (SGetSBuf(sMem->region, sMem->pool,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem->region, sMem->pool,
(Data **)&allocPtr,
(Size)(maxBlkSize + sizeof(CmMemList))) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
/* Allocate buffer */
/* cm_mblk_c_001.101: use blkSize instead of cb->maxSize */
#ifdef SS_LOCKLESS_MEMORY
- if(SGetStaticBuffer(cb->sMem.region, cb->sMem.pool,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,cb->sMem.region, cb->sMem.pool,
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)), 0) != ROK)
#else
- if (SGetSBuf(cb->sMem.region, cb->sMem.pool,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,cb->sMem.region, cb->sMem.pool,
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)) ) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
/* Allocate memory for the first Memory Chunk */
/* Allocated memory should be maxBlkSize + sizeof(CmMemList) */
#ifdef SS_LOCKLESS_MEMORY
- if(SGetStaticBuffer(sMem->region, sMem->pool, (Data **)&allocPtr,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem->region, sMem->pool, (Data **)&allocPtr,
(Size)(maxBlkSize + sizeof(CmMemList)), 0) != ROK)
#else
- if (SGetSBuf(sMem->region, sMem->pool,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem->region, sMem->pool,
(Data **)&allocPtr,
(Size)(maxBlkSize + sizeof(CmMemList))) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
/* Allocate buffer */
/* cm_mblk_c_001.101: use blkSize instead of cb->maxSize */
#ifdef SS_LOCKLESS_MEMORY
- if(SGetStaticBuffer(cb->sMem.region, cb->sMem.pool,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,cb->sMem.region, cb->sMem.pool,
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)), 0) != ROK)
#else
- if (SGetSBuf(cb->sMem.region, cb->sMem.pool,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,cb->sMem.region, cb->sMem.pool,
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)) ) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
if( node )
{
#ifdef SS_LOCKLESS_MEMORY
- SPutStaticBuffer(sMem.region, sMem.pool,
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem.region, sMem.pool,
(Data *)node, (node->size + sizeof(CmMemList)), 0);
#else
- SPutSBuf(sMem.region,sMem.pool,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,sMem.region,sMem.pool,
(Data *)node, (node->size + sizeof(CmMemList)));
#endif /* SS_LOCKLESS_MEMORY */
}
#else
funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE);
#else /* SS_MEM_LEAK_SOL */
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* check if hashListCp is initialised yet */
if ( regCb->brdcmSsiLstCp.nmbBins == 0)
#else
free(funcNm[i]);
#endif
- /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
+ /* SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
}
#endif /* SS_MEM_LEAK_SOl */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#else
buffer = (S8 *)calloc(1, 510);
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &buffer, 510); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &buffer, 510); */
(void) cmAddrToSymStr((void *)pc, buffer, 505);
bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer;
/* allocate memory for bins */
if (nmbBins)
{
- if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
return RFAILED;
/* deallocate memory for bins */
if (hashListCp->numOfbins)
- (Void) SPutSBuf(region, pool,
+ (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool,
(Data *) hashListCp->hashList,
(Size) (hashListCp->numOfbins * sizeof(CmMmHashListEnt)));
#endif
#include "cm_lte.x"
-
+#include "du_log.h"
\f
/* local defines */
/*ccpu00142274 - UL mem based flow control changes */
return RFAILED;
}
SUnlock(&memDoubleFreeLock);
- SPutSBuf(regionCb->region, 0, (Data *)memNode, sizeof(CmMemDoubleFree));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,regionCb->region, 0, (Data *)memNode, sizeof(CmMemDoubleFree));
return ROK;
}
CmMemDoubleFree *memNode;
- SGetSBuf(regionCb->region, 0, (Data **)&memNode, sizeof(CmMemDoubleFree));
+ SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,regionCb->region, 0, (Data **)&memNode, sizeof(CmMemDoubleFree));
if(memNode == NULLP)
{
return RFAILED;
{
S16 ret;
-
if((SLock(&dynAllocFreeLock)) != ROK)
{
printf("cmDynAllocWithLock: Failed to get the dyn lock\n");
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
- if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
+ if(regCb == NULLP)
+ {
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
+ return RFAILED;
+ }
+
+ if(ptr == NULLP)
+ {
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
+ return RFAILED;
+ }
+
+ if(size == NULLP)
{
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null");
+ return RFAILED;
+ }
+
+ if(!(*size))
+ {
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block size is 0");
return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (regCb->mapTbl[idx].bktIdx == 0xFF)
- {
- printf("Failed to get the buffer of size %d\n", *size);
+ {
+ DU_LOG("\nERROR --> 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");
return RFAILED;
}
/* Dequeue the memory block and return it to the user */
if(dynMemElem == NULLP)
{
#ifndef ALIGN_64BIT
- printf("Failed to get the buffer of size %ld\n", *size);
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
#else
- printf("Failed to get the buffer of size %d\n", *size);
+ printf("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
#endif
return RFAILED;
}
*ptr = dynMemElem->nextBktPtr;
if (*ptr == NULLP)
{
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): nextBktPtr is null");
return RFAILED;
}
dynMemElem->nextBktPtr = *((CmMmEntry **)(*ptr));
/* If the size is not matching, return failure to caller */
#ifndef ALIGN_64BIT
- printf("Failed to get the buffer of size %ld\n", *size);
+ DU_LOG("\nERROR --> CM : cmDynAlloc(): Failed to get the buffer of size %ld\n", *size);
#else
- printf("Failed to get the buffer of size %d\n", *size);
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size);
#endif
return RFAILED;
*ptr = (Data *)malloc(*size);
if ( (*ptr) == NULLP)
- return RFAILED;
+ {
+ DU_LOG("\nERROR --> CM : cmDynAlloc(): Data ptr is null");
+ return RFAILED;
+ }
/* avail_size -= *size; */
return ROK;
#endif /* USE_PURE */
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
- if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
+ if(regCb == NULL)
{
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null");
+ return RFAILED;
+ }
+
+ if(ptr == NULLP)
+ {
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null");
+ return RFAILED;
+ }
+
+ if(size == NULLP)
+ {
+ DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null");
+ return RFAILED;
+ }
+
+ if(!(*size))
+ {
+ DU_LOG("\nERROR --> 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);
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");
return RFAILED;
}
#endif
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
+ DU_LOG("\nERROR --> CM : cmAlloc(): Sanity check returns failure");
/* return RFAILED */
return RFAILED;
}
}
/* No memory available */
+ DU_LOG("\nERROR --> CM : cmAlloc(): No memory available in heap");
return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
+ {
+ DU_LOG("\nERROR --> CM : cmAlloc(): ptr is null");
return RFAILED;
+ }
avail_size -= *size;
return ROK;
#endif /* USE_PURE */
)
{
S16 ret;
-
+
if((SLock(&dynAllocFreeLock)) != ROK)
{
printf("dynAllocWithLock: Failed to get the DYN lock\n");
/* 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);
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);
return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- return RFAILED;
+ DU_LOG("\nERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
+ DU_LOG("\nERROR --> CM : cmDynFree(): bktIdx is not valid");
/* Some fatal error in the map table initialization. */
return RFAILED;
}
#ifdef SS_MEM_WL_DEBUG
if (size > bkt->size)
{
- printf("Size = %d bucket size = %d\n", size, bkt->size);
+ DU_LOG("Size = %d bucket size = %d\n", size, bkt->size);
exit(-1);
bkt = &(regCb->bktTbl[bktIdx = regCb->mapTbl[++idx].bktIdx]);
}
if(size > bkt->size)
{
- printf("2nd time Size = %d bucket size = %d\n", size, bkt->size);
+ DU_LOG("2nd time Size = %d bucket size = %d\n", size, bkt->size);
exit(-1);
uint8_t *tmpptr = NULLP;
printf("Bucket Size wrong \n");
/* Check if the bucket index, if its not valid, return failure */
if(dynMemElem == NULLP)
{
+ DU_LOG("\nERROR --> CM : cmDynFree(): dynMemElem is null");
return RFAILED;
}
memset(ptr, (regCb->region+1), bkt->size);
#endif
-
/* Get the bucket node from the index returned and allocate the memory */
*((CmMmEntry **)ptr) = dynMemElem->nextBktPtr;
dynMemElem->nextBktPtr = ptr;
/* 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);
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);
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);
return RFAILED;
}
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
+ DU_LOG("\nERROR --> CM : cmFree(): Invalid bktIdx");
return RFAILED;
}
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
+ DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure");
return (RTRAMPLINGNOK);
}
}
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
+ DU_LOG("\nERROR --> 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");
return (RTRAMPLINGNOK);
}
}
#else
free(funcNm[i]);
#endif
- /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
+ /* SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
}
#endif /* SS_MEM_LEAK_SOl */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#else
funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE);
#else /* SS_MEM_LEAK_SOL */
traceSize = backtrace(trace, CM_MAX_STACK_TRACE);
#else
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
allocInfo->memAddr = addr;
allocInfo->reqSz = reqSz;
allocInfo->allocSz = allocSz;
#else
buffer = (S8 *)calloc(1, 510);
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &buffer, 510); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &buffer, 510); */
(void) cmAddrToSymStr((void *)pc, buffer, 505);
bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer;
/* allocate memory for bins */
if (nmbBins)
{
- if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
return RFAILED;
/* deallocate memory for bins */
if (hashListCp->numOfbins)
- (Void) SPutSBuf(region, pool,
+ (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool,
(Data *) hashListCp->hashList,
(Size) (hashListCp->numOfbins * sizeof(CmMmHashListEnt)));
/* unpack reserve byte & strict/loose bit map */
CMCHKUNPK(oduPackUInt32, &unpkParam->slMap, mBuf);
- retVal = SGetSBuf(memInfo->region,
+ retVal = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,memInfo->region,
memInfo->pool,
(Data **)&unpkParam->ipv6Addrs,
(unpkParam->numAddrs * 16));
CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
/* allocate static memory to hold the unpacked values */
- retVal = SGetSBuf(memInfo->region,
+ retVal = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,memInfo->region,
memInfo->pool,
(Data **)&unpkParam->value, (Size)unpkParam->length);
if (retVal != ROK)
if (unpkParam->numDestOpts)
{
/* allocate mem to hold all dest options */
- retVal = SGetSBuf(memInfo->region,
+ retVal = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,memInfo->region,
memInfo->pool,
(Data **)&unpkParam->destOpts,
(unpkParam->numDestOpts * sizeof(CmIpv6DestOptsHdr)));
/* allocate static memory to hold the unpacked values */
if (unpkParam->length)
{
- retVal = SGetSBuf(memInfo->region,
+ retVal = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,memInfo->region,
memInfo->pool,
(Data **)&unpkParam->value, (Size)unpkParam->length);
if (retVal != ROK)
if (unpkParam->numHBHOpts)
{
/* allocate space for all HBH options */
- retVal = SGetSBuf(memInfo->region,
+ retVal = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,memInfo->region,
memInfo->pool,
(Data **)&unpkParam->hbhOpts,
(unpkParam->numHBHOpts * sizeof(CmIpv6HBHHdr)));
for(numOpts = _hdrParmIpv6->ipv6ExtHdr.hbhOptsArr.numHBHOpts; \
numOpts > 0; numOpts--) \
{ \
- SPutSBuf(_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
hbhOptsArr.hbhOpts[numOpts - 1].value, (Size)(_hdrParmIpv6-> \
ipv6ExtHdr.hbhOptsArr.hbhOpts[numOpts - 1].length)); \
- SPutSBuf(_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
hbhOptsArr.hbhOpts[numOpts - 1], \
(Size)sizeof(CmInetIpv6HBHHdr)); \
} \
for(numOpts = _hdrParmIpv6->ipv6ExtHdr.destOptsArr.numDestOpts; \
numOpts > 0; numOpts--) \
{ \
- SPutSBuf(_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)_hdrParmIpv6->ipv6ExtHdr. \
destOptsArr.destOpts[numOpts - 1].value, (Size)(_hdrParmIpv6-> \
ipv6ExtHdr.destOptsArr.destOpts[numOpts - 1].length)); \
- SPutSBuf(_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, (Data *)&_hdrParmIpv6->ipv6ExtHdr. \
destOptsArr.destOpts[numOpts - 1], \
(Size)sizeof(CmInetIpv6DestOptsHdr)); \
} \
} \
if( _hdrParmIpv6->ipv6ExtHdr.rtOptsPrsnt) \
{ \
- SPutSBuf(_region, _pool, \
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,_region, _pool, \
(Data *)_hdrParmIpv6->ipv6ExtHdr.rtOpts.ipv6Addrs, \
(Size)(_hdrParmIpv6->ipv6ExtHdr.rtOpts.numAddrs * 16)); \
} \
return ROK;
}
+/*******************************************************************
+*
+* @brief SGetSBuf with debug logs
+*
+* @details
+*
+* Function : SGetSBufNewForDebug
+*
+* Functionality: SGetSBuf with debug logs
+*
+* @params[in] file name, fun name, region, pool, data ptr, size
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t SGetSBufNewForDebug(char *file, char *func, char *line, Region region, Pool pool, Data **ptr, Size size)
+{
+ if(SGetSBuf(region, pool, ptr, size) == ROK)
+ {
+#ifdef ODU_MEMORY_DEBUG_LOG
+ printf("\nCM_ALLOC=== SGetSBufNewForDebug %s +%d, %s, %d, %p\n",\
+ file, line, func, size, *ptr);
+#endif
+ return ROK;
+ }
+ else
+ return RFAILED;
+}
+
+/*******************************************************************
+*
+* @brief SPutSBuf with debug logs
+*
+* @details
+*
+* Function : SPutSBufNewForDebug
+*
+* Functionality: SPutSBuf with debug logs
+*
+* @params[in] file name, fun name, region, pool, data ptr, size
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t SPutSBufNewForDebug(char *file, char *func, char *line, Region region, Pool pool, Data *ptr, Size size)
+{
+ if(SPutSBuf(region, pool, ptr, size) == ROK)
+ {
+#ifdef ODU_MEMORY_DEBUG_LOG
+ printf("\nCM_FREE=== SPutSBufNewForDebug %s +%d, %s, %d, %p\n",\
+ file, line, func, size, ptr);
+#endif
+ return ROK;
+ }
+ else
+ return RFAILED;
+}
+
+/*******************************************************************
+*
+* @brief SGetStaticBuf with debug logs
+*
+* @details
+*
+* Function : SGetStaticBufNewForDebug
+*
+* Functionality: SGetStaticBuf with debug logs
+*
+* @params[in] file name, fun name, region, pool, data ptr, size, memType
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t SGetStaticBufNewForDebug(char *file, char *func, char *line, \
+Region region, Pool pool, Data **ptr, Size size, uint8_t memType)
+{
+ if(SGetStaticBuffer(region, pool, ptr, size, memType) == ROK)
+ {
+#ifdef ODU_MEMORY_DEBUG_LOG
+ printf("\nCM_ALLOC=== SGetStaticBufNewForDebug %s +%d, %s, %d, %p\n",\
+ file, line, func, size, *ptr);
+#endif
+ return ROK;
+ }
+ else
+ return RFAILED;
+}
+
+/*******************************************************************
+*
+* @brief SPutStaticBuf with debug logs
+*
+* @details
+*
+* Function : SPutStaticBufNewForDebug
+*
+* Functionality: SPutStaticBuf with debug logs
+*
+* @params[in] file name, fun name, region, pool, data ptr, size, memType
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t SPutStaticBufNewForDebug(char *file, char *func, char *line, \
+Region region, Pool pool, Data *ptr, Size size, uint8_t memType)
+{
+ if(SPutStaticBuffer(region, pool, ptr, size, memType) == ROK)
+ {
+#ifdef ODU_MEMORY_DEBUG_LOG
+ printf("\nCM_FREE=== SPutStaticBufNewForDebug %s +%d, %s, %d, %p\n",\
+ file, line, func, size, ptr);
+#endif
+ return ROK;
+ }
+ else
+ return RFAILED;
+}
/**********************************************************************
End of file
**********************************************************************/
void oduCpyFixBufToMsg(uint8_t *fixBuf, Buffer *mBuf, uint16_t len);
uint8_t buildPlmnId(Plmn plmn, uint8_t *buf);
+uint8_t SGetSBufNewForDebug(char *file, char *func, char *line, Region region, Pool pool, Data **ptr, Size size);
+uint8_t SPutSBufNewForDebug(char *file, char *func, char *line, Region region, Pool pool, Data *ptr, Size size);
+uint8_t SGetStaticBufNewForDebug(char *file, char *func, char *line, \
+Region region, Pool pool, Data **ptr, Size size, uint8_t memType);
+uint8_t SPutStaticBufNewForDebug(char *file, char *func, char *line, \
+Region region, Pool pool, Data *ptr, Size size, uint8_t memType);
+
#endif
/**********************************************************************
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG016, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
return RFAILED;
}
if (cmPkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG017, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
#endif
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
}
if (cmUnpkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
/* ctf_c_001.main_4: Added support for vendor specific parameters */
#ifdef CTF_VER3
if(cfgReqInfo->vendorParams.paramBuffer != NULLP) {
- SPutSBuf(pst->region, pst->pool,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool,
(Data *)cfgReqInfo->vendorParams.paramBuffer,
cfgReqInfo->vendorParams.buffLen);
}
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
return ROK;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if (SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo)) != ROK) {
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
}
pst->event = (Event)EVTCTFCNMSYNCREQ;
return (SPstTsk(pst,mBuf));
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&SyncReqMsg, sizeof(CtfCnmCellSyncReq))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&SyncReqMsg, sizeof(CtfCnmCellSyncReq))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCtfCnmCellSyncReq(SyncReqMsg, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)SyncReqMsg, sizeof(CtfCnmCellSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)SyncReqMsg, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
}
pst->event = (Event)EVTCTFCNMINITSYNCREQ;
return (SPstTsk(pst,mBuf));
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncReqInfo, sizeof(CtfCnmInitSyncReq))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&syncReqInfo, sizeof(CtfCnmInitSyncReq))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfsyncReqInfo(syncReqInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)syncReqInfo, sizeof(CtfCnmInitSyncReq));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)syncReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
}
pst->event = (Event)EVTCTFCNMINITSYNCRSP;
return (SPstTsk(pst,mBuf));
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspInfo, sizeof(CtfCnmInitSyncRsp))) != ROK) {
+ if((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&syncRspInfo, sizeof(CtfCnmInitSyncRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if(cmUnpkCtfCnmInitSyncRspMsg(syncRspInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)syncRspInfo, sizeof(CtfCnmInitSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)syncRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
}
pst->event = (Event)EVTCTFCNMSYNCRSP;
return (SPstTsk(pst,mBuf));
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspMsg, sizeof(CtfCnmCellSyncRsp))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&syncRspMsg, sizeof(CtfCnmCellSyncRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCnmSyncRspMsg(syncRspMsg, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)syncRspMsg, sizeof(CtfCnmCellSyncRsp));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)syncRspMsg, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
}
pst->event = (Event)EVTCTFCNMSYNCIND;
return (SPstTsk(pst,mBuf));
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncIndMsg, sizeof(CtfCnmCellSyncInd))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&syncIndMsg, sizeof(CtfCnmCellSyncInd))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCnmSyncIndMsg(syncIndMsg, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)syncIndMsg, sizeof(CtfCnmCellSyncInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)syncIndMsg, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&kdfReqInfo, sizeof(CtfKdfReqInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&kdfReqInfo, sizeof(CtfKdfReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CtfCfgReqInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CtfCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF027, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo)) != ROK)
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF033, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF034, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF035, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF036, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF037, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF038, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF039, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo)) != ROK) {
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo, sizeof(CtfUeInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&newUeInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ECTF046, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
return RFAILED;
}
}
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(newUeInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF048, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
return RFAILED;
}
if (cmPkCmStatus(&status, mBuf) != ROK) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF049, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF050, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF051, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF052, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF053, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
return RFAILED;
}
if (cmUnpkCmStatus(&status, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
CMCHKUNPK(oduPackUInt16, ¶m->buffLen, mBuf);
if(param->buffLen != 0) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)¶m->paramBuffer, param->buffLen)) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)¶m->paramBuffer, param->buffLen)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
return RFAILED;
}
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF018, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF019, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF020, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
}
pst->event = (Event)EVTCTFPREMCELLSRCHRSP;
return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&CellSrchRsp,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&CellSrchRsp,
sizeof(CtfPeriodicRemCellSearchRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
}
else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfPerRemCellSrch(CellSrchRsp, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)CellSrchRsp,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)CellSrchRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datReqInfo,
sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if(pst->srcEnt == ENTNH)
{
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
ret1 = SPstTsk(pst,mBuf);
if(pst->selector == ODU_SELECTOR_LC)
{
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datIndInfo,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#else
cmPkKwuDatCfmInfo( (datCfm), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datCfm,
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSduInfo,
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#else
cmPkKwuStaIndInfo( (staInd), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
#else
cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)discCfmSdu,
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- SPutStaticBuffer(pst->region,
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0);
{
cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
- if (SPutStaticBuffer(pst->region,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
* free the memory here. */
if(pst->selector == ODU_SELECTOR_LWLC)
{
- retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
+ retVal = SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY);
}
return (retVal);
* doesn't free any memory */
if(pst->dstEnt != ENTPJ)
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
* free the memory here. */
if((pst->selector == ODU_SELECTOR_LWLC) && (pst->dstEnt == ENTPJ))
{
- retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
+ retVal = SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
}
return (retVal);
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datCfm,\
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&staInd,\
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#ifdef LCKWU
case ODU_SELECTOR_LC:
{
- if(SGetStaticBuffer(pst->region,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data **)&flowCntrlInfo,
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
KwuDatAckInfo *datInd = NULLP;
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datInd,\
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
}TSL2UeStatsCb;
Void TSL2AllocStatsMem ARGS((
- Region region,
- Pool pool
+ Inst inst
));
TSL2UeStatsCb* TSL2AllocUeStatsBlk ARGS((
uint16_t rnti
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
return RFAILED;
}
if (cmPkRlcL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
}
if (cmUnpkRlcL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK)
{
- /*SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));*/
+ /*SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));*/
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
- if((ret = SGetSBuf(pst->region, pst->pool, (Data **)&measReqEvt,\
+ if((ret = SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&measReqEvt,\
sizeof(RlcL2MeasReqEvt))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
}
if (cmUnpkRlcL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(RlcL2MeasCfmEvt));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measCfmEvt, sizeof(RlcL2MeasCfmEvt));
return RFAILED;
}
CMCHKPK(cmPkSystemId, ¶m->s.sysId, mBuf);
if (param->s.sysId.ptNmb != NULLP)
{
- SPutSBuf(pst->region, pst->pool,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool,
(Data *)param->s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
}
}
if (param->s.sysId.ptNmb != NULLP)
{
CMCHKPK(cmPkSystemId, ¶m->s.sysId, mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)param->s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)param->s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
}
#endif /*end of LRG_V1 */
if (pst->event == EVTLRGSSTACFM)
{
/* After Merging */
- if((SGetSBuf(pst->region, pst->pool, (Data **)¶m->s.sysId.ptNmb,
+ if((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)¶m->s.sysId.ptNmb,
LRG_MAX_PT_NUM_SIZE)) != ROK){
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm);
uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg);
uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason);
-uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm);
uint8_t MacProcUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo);
uint8_t packMacSchRachInd(Pst *pst, RachIndInfo *rachInd);
uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd);
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
return RFAILED;
}
if(oduPackPointer((PTR)prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data*)prbRprtCfg, len);
return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
SPutMsg(mBuf);
return RFAILED;
}
if (oduUnpackPointer((PTR *)&prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
return RFAILED;
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
return RFAILED;
}
if(oduPackPointer((PTR)prbRprtInd, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
return RFAILED;
}
if (oduUnpackPointer((PTR *)&prbRprtInd, mBuf) != ROK)
{
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
return RFAILED;
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
return RFAILED;
}
if(cmPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data*)prbRprtCfg, len);
return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
SPutMsg(mBuf);
return RFAILED;
}
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
pst->event = (Event) EVTRGMCFGPRBRPRT;
return (SPstTsk(pst,mBuf));
SpId spId;
RgmPrbRprtCfg *prbRprtCfg;
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
{
SPutMsg(mBuf);
return RFAILED;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
return RFAILED;
}
if(cmPkPrbRprtInd(prbRprtInd, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
return RFAILED;
}
- SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
pst->event = (Event) EVTRGMPRBRPRTIND;
return (SPstTsk(pst,mBuf));
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
return RFAILED;
}
if(cmPkTransModeInd(transModeInd, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
SPutMsg(mBuf);
return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
SPutMsg(mBuf);
return RFAILED;
}
- SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
pst->event = (Event) EVTRGMTRANSMODEIND;
return (SPstTsk(pst,mBuf));
#endif
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR026, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR027, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
- SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
pst->event = (Event) EVTRGRTTIIND;
return (SPstTsk(pst,mBuf));
}
#endif
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK)
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
if (cmUnpkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
/*ccpu00114888- Memory Leak issue- Start*/
- SPutSBuf(pst->region, pst->pool, (Data *)ttiInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd,
sizeof(RgrTtiIndInfo));
/*ccpu00114888- Memory Leak issue- End*/
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR045, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR046, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR047, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR048, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo,
sizeof(RgrSiCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
memset(cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR061, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR062, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR063, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR064, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
return RFAILED;
/* if the application wants to retain this structure, the below
* code should be removed */
- if (SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
{
if (cmUnpkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutMsg(pdu->pdu);
}
cmLListDelFrm(¶m->siPduLst, node);
- SPutSBuf(pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
node= prevNode;
}
CMCHKPK(oduUnpackUInt32, count, mBuf);
{
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&node,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&node,
sizeof(CmLList))) != ROK)
return RFAILED;
node->node = (PTR)pdu;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR045, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR046, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR047, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR048, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfReq,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&loadInfReq,
sizeof(RgrLoadInfReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR054, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)staInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR055, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR056, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)staInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)staInd,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&staInd,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&staInd,
sizeof(RgrStaIndInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cmUnpkRgrStaIndInfo(staInd, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)staInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR054, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR055, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR056, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfInd,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&loadInfInd,
sizeof(RgrLoadInfIndInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
/* dsfr_pal_fixes ** 22-March-2013 ** SKS */
if (cmUnpkRgrLoadInfIndInfo(loadInfInd, pst, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Length */
CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR054, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR055, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
SPutMsg(mBuf);
return RFAILED;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR056, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return RFAILED;
}
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueStaInd,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueStaInd,
sizeof(RgrUeStaIndInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cmUnpkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU049, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU050, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo));
SPutMsg(mBuf);
return RFAILED;
}
- if (SPutSBuf(pst->region, pst->pool, (Data *)measReq,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
if (measReq != NULLP)
{
- SPutSBuf(pst->region, pst->pool, (Data *)measReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo));
}
SPutMsg(mBuf);
}
else
{
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&measReq,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&measReq,
sizeof(RguL2MUlThrpMeasReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ERGU055, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)measReq,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo));
return RFAILED;
}
RguHarqStatusInd *harqStaInd = NULL;
#ifdef XEON_SPECIFIC_CHANGES
- if (SGetSBuf(pst->region, pst->pool, (Data **)&harqStaInd, sizeof(RguHarqStatusInd)) != ROK)
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&harqStaInd, sizeof(RguHarqStatusInd)) != ROK)
#else
- if ((SGetStaticBuffer(pst->region, pst->pool,
+ if ((SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool,
(Data **)&harqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
#endif
{
(ErrVal)ERGU070, (ErrVal)0, "Packing failed");
#endif
#ifdef XEON_SPECIFIC_CHANGES
- SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd));
#else
- SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
return RFAILED;
}
(ErrVal)ERGU071, (ErrVal)0, "Packing failed");
#endif
#ifdef XEON_SPECIFIC_CHANGES
- SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd,
sizeof(RguHarqStatusInd));
#else
- SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
SPutMsg(mBuf);
return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
- if (SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
+ if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd,
sizeof(RguHarqStatusInd)) != ROK) {
#else
if (pst->selector != ODU_SELECTOR_LWLC)
{
- if(SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd,
+ if(SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd,
sizeof(RguHarqStatusInd), 0) != ROK)
{
#endif
return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&hqStaInd,
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&hqStaInd,
sizeof(RguHarqStatusInd))) != ROK) {
#else
if (pst->selector == ODU_SELECTOR_LWLC)
}
else
{
- if ((SGetStaticBuffer(pst->region, pst->pool,
+ if ((SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool,
(Data **)&hqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
{
#endif
SPutMsg(mBuf);
(*func)(pst, suId, hqStaInd);
#ifdef XEON_SPECIFIC_CHANGES
- SPutSBuf(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd));
#else
- SPutStaticBuffer(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
return ROK;
}
}
else
{
- if ((SGetSBuf(pst->region, pst->pool, (Data **)&flowCntrlInd, sizeof(RguFlowCntrlInd))) != ROK) {
+ if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&flowCntrlInd, sizeof(RguFlowCntrlInd))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU082, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- SPutSBuf(pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
+ SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
return RFAILED;
}
}
{
uint8_t ret = ROK;
uint16_t cellIdx=0;
+
if(deleteRsp)
{
if(deleteRsp->result == SUCCESSFUL_RSP)
void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
{
uint8_t plmnCnt=1;
- uint8_t servId=0;
- uint8_t sliceId=0;
- uint8_t ieId=0;
- uint8_t extensionCnt=1;
- uint8_t plmnidx=0;
- GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
+ uint8_t sliceId=0;
+ uint8_t extensionCnt=1;
+ uint8_t plmnIdx=0;
+ GNB_DU_Served_Cells_Item_t *srvCellItem;
+ ServedPLMNs_Item_t *servedPlmnItem;
+ SliceSupportItem_t *sliceSupportItem;
+
if(duServedCell->list.array!=NULLP)
{
if(duServedCell->list.array[0]!=NULLP)
{
- if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
- {
- if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
- list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
- freqBandListNr.list.array!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
- freqBandListNr.list.array[0]!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
- freqBandListNr.list.array)
- {
- if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
- freqBandListNr.list.array[0]!=NULLP)
- {
- if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
- {
- if(!srvCellItem->gNB_DU_System_Information)
- {
- if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
- {
- if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
- {
- DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
- srvCellItem->gNB_DU_System_Information->sIB1_message.size);
- DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
- srvCellItem->gNB_DU_System_Information->sIB1_message.size);
- }
- DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
- srvCellItem->gNB_DU_System_Information->mIB_message.size);
- DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
- strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
- }
- DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
- srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
- }
- DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
- freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
- freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
- list.array[0],sizeof(FreqBandNrItem_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
- list.array,sizeof(FreqBandNrItem_t*));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
- iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
- sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
- list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
- iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
- list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
- iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
- sNSSAI.sST.buf,sizeof(uint8_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
- extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
- array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
- array[servId]->iE_Extensions->list.array,\
- extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
- array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
- array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
- servedPLMNs.list.array[servId]->pLMN_Identity.size
- * sizeof(uint8_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
- sizeof(ServedPLMNs_Item_t *));
- }
- DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
- sizeof(ServedPLMNs_Item_t *));
- }
- DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
- sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
- }
- DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
- srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
- sizeof(uint8_t));
- }
- DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
- srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
- sizeof(uint8_t));
- }
- DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
+ srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
+
+ DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
+ srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
+ DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
+ srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
+
+ if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
+ {
+ DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
+ sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
+ DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
+ }
+
+ if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
+ {
+ if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
+ {
+ servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
+ DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size * sizeof(uint8_t));
+
+ if(servedPlmnItem->iE_Extensions != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
+ array != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
+ array[sliceId] != NULLP)
+ {
+ sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
+ SliceSupportList.list.array[sliceId];
+
+ DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
+
+ if(sliceSupportItem->sNSSAI.sD != NULLP)
+ {
+ DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
+ DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
+ }
+
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceId], sizeof(SliceSupportItem_t));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array, sizeof(SliceSupportItem_t*));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[0], sizeof(ServedPLMNs_ItemExtIEs_t));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array, extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
+ }
+ DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx], sizeof(ServedPLMNs_Item_t));
+ }
+ DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array, sizeof(ServedPLMNs_Item_t *));
+ }
+
+ if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
+ {
+ if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
+ freqBandListNr.list.array != NULLP)
+ {
+ DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
+ list.array[0],sizeof(FreqBandNrItem_t));
+ DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
+ list.array,sizeof(FreqBandNrItem_t*));
+ }
+
+ if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.array)
+ {
+ DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
+ DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
+ }
+ DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
+ }
+
+ DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
+ srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
+
+ if(srvCellItem->gNB_DU_System_Information != NULLP)
+ {
+ if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
+ {
+ DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
+ srvCellItem->gNB_DU_System_Information->mIB_message.size);
+ }
+
+ if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
+ {
+ DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
+ srvCellItem->gNB_DU_System_Information->sIB1_message.size);
+ }
+
+ DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
+ }
+
+ DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
}
- DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
+ DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
}
}
+
/*******************************************************************
*
* @brief deallocating the memory of function BuildAndSendF1SetupReq()
break;
}
}
- break;
}
for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
{
void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
{
uint8_t arrIdx=0,i=0;
- if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
+ ServedPLMNs_Item_t *servedPlmnItem = NULLP;
+ SliceSupportItem_t *sliceSupportItem = NULLP;
+
+ DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
+ DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
+
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
+
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
{
- if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
{
- if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
+ servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
+
+ DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
+
+ if(servedPlmnItem->iE_Extensions != NULLP)
{
- if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
- != NULLP)
+ if(servedPlmnItem->iE_Extensions->list.array != NULLP)
{
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
- != NULLP)
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
{
- if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx])
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array != NULLP)
{
- if(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->pLMN_Identity.buf != NULLP)
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx] != NULLP)
{
- if(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions!= NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.array != NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.array[arrIdx])
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
- list.array !=NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
- list.array[arrIdx]!=NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sST.buf!=NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
- SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sD != NULLP)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.\
- choice.SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sD->buf!=NULLP)
- {
- if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
- !=NULLP)
- {
- if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
- fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
- {
- if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
- fDD->uL_NRFreqInfo.freqBandListNr.list.array[arrIdx]!=NULLP)
- {
- if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
- fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
- {
- if(modifyItem->served_Cell_Information.nR_Mode_Info.\
- choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
- array[arrIdx]!= NULLP)
- {
- if(modifyItem->served_Cell_Information.\
- measurementTimingConfiguration.buf !=NULLP)
- {
- DU_FREE(modifyItem->served_Cell_Information.\
- measurementTimingConfiguration.\
- buf,modifyItem->served_Cell_Information.\
- measurementTimingConfiguration.size);
- }
- DU_FREE(modifyItem->served_Cell_Information.\
- nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
- freqBandListNr.\
- list.array[arrIdx],sizeof(FreqBandNrItem_t));
- }
- DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
- .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
- modifyItem->served_Cell_Information.nR_Mode_Info.\
- choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
- }
- DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
- choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
- array[arrIdx],sizeof(FreqBandNrItem_t));
- }
- DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
- choice.\
- fDD->uL_NRFreqInfo.freqBandListNr.list.\
- array,modifyItem->served_Cell_Information.nR_Mode_Info.\
- choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
- }
- DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
- fDD,sizeof(FDD_Info_t));
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.array[arrIdx]->extensionValue.\
- choice.SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sD->buf,modifyItem->\
- served_Cell_Information.\
- servedPLMNs.list.array[arrIdx]->iE_Extensions->list.\
- array[arrIdx]->\
- extensionValue.choice.SliceSupportList.list.array[arrIdx]->\
- sNSSAI.sD->size);
+ sliceSupportItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->iE_Extensions->\
+ list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx];
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
- SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
- SliceSupportList.\
- list.array[arrIdx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
- servedPLMNs.\
- list.array[arrIdx]->iE_Extensions->list.array[arrIdx]->\
- extensionValue.choice.\
- SliceSupportList.list.array[arrIdx]->sNSSAI.sST.size);
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
- list.array[arrIdx],sizeof(SliceSupportItem_t));
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
- list.array,\
- modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
- iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
- SliceSupportList.list.size);
- }
- }
- for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.count;i++)
- {
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.array[i],\
- sizeof(ServedPLMNs_ItemExtIEs_t ));
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.\
- servedPLMNs.list.array[arrIdx]->iE_Extensions->list.size);
- }
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
+ DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
+ if(sliceSupportItem->sNSSAI.sD != NULLP)
+ {
+ DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
+ DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
}
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
- array[arrIdx]->pLMN_Identity.buf,
- modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->pLMN_Identity.size);
- }
- }
- for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
- {
- if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
- != NULLP)
- {
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
- sizeof(ServedPLMNs_Item_t));
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[arrIdx], sizeof(SliceSupportItem_t));
}
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array,
+ servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.size);
}
- DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
- modifyItem->served_Cell_Information.servedPLMNs.list.size);
}
- DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
- modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
+ for(i=0; i < servedPlmnItem->iE_Extensions->list.count ; i++)
+ {
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[i], sizeof(ServedPLMNs_ItemExtIEs_t ));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
}
- DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
- modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
+ DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
}
- DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
- modifyItem->oldNRCGI.nRCellIdentity.size);
}
- DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
- modifyItem->oldNRCGI.pLMN_Identity.size);
+ for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i], sizeof(ServedPLMNs_Item_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
+ modifyItem->served_Cell_Information.servedPLMNs.list.size);
}
+
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array[arrIdx], sizeof(FreqBandNrItem_t));
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
+ }
+
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
+ array[arrIdx], sizeof(FreqBandNrItem_t));
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
+ }
+
+ DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
+ modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
}
+
/*******************************************************************
*
* @brief Deallocating memory of BuildAndSendDUConfigUpdate
break;
}
- case GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID:
+ case ProtocolIE_ID_id_gNB_DU_ID:
{
DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
switch(lcCfg->rlcMode)
{
case RLC_AM :
- {
- if(lcCfg->u.amCfg)
- {
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
- lcCfg->u.amCfg = NULLP;
- }
- break;
- }
+ {
+ if(lcCfg->u.amCfg)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
+ }
+ break;
+ }
case RLC_UM_BI_DIRECTIONAL :
- {
- if(lcCfg->u.umBiDirCfg)
- {
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
- lcCfg->u.umBiDirCfg = NULLP;
+ {
+ if(lcCfg->u.umBiDirCfg)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
+ }
+ break;
}
- break;
- }
case RLC_UM_UNI_DIRECTIONAL_UL :
- {
- if(lcCfg->u.umUniDirUlCfg)
- {
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
- lcCfg->u.umUniDirUlCfg = NULLP;
- }
- break;
+ {
+ if(lcCfg->u.umUniDirUlCfg)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
+ }
+ break;
- }
+ }
case RLC_UM_UNI_DIRECTIONAL_DL :
- {
- if(lcCfg->u.umUniDirDlCfg)
- {
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
- lcCfg->u.umUniDirDlCfg = NULLP;
+ {
+ if(lcCfg->u.umUniDirDlCfg)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
+ }
+ break;
}
- break;
- }
default:
DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
- break;
+ break;
}
- memset(lcCfg, 0, sizeof(LcCfg));
}
+
/*******************************************************************
*
* @brief Function to free MacLcCfg
if(lcCfg->drbQos)
{
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
- lcCfg->drbQos = NULLP;
}
/* Deleting SNSSAI */
if(lcCfg->snssai)
{
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
- lcCfg->snssai = NULLP;
}
- memset(lcCfg, 0, sizeof(LcCfg));
}
/*******************************************************************
*
}
if(ueCfg->ambrCfg)
{
- memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
}
for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
{
DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
- memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
}
}
{
uint8_t arrIdx = 0;
- for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
+ if(tnlInfo)
{
- DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
+ for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
+ {
+ DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
+ tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
+ DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
+ tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
+ DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
+ DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
+ }
+ DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
}
}
{
drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
+ DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
}
+ DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
}
/*******************************************************************
{
drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
+ DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
}
+ DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
}
/*******************************************************************
* @brief Free the memory allocated for UE Context Mod Response
# See the License for the specific language governing permissions and #
# limitations under the License. #
################################################################################
- *******************************************************************************/
+*******************************************************************************/
/* This file contains UE management handling functionality for DU APP */
#include "common_def.h"
#include "lrg.h"
*
*****************************************************************/
-uint8_t fillMacLcCfgToAddMod(LcCfg *lcCfg, LcCfg *ueSetReqDb)
+uint8_t fillMacLcCfgToAddMod(LcCfg *macLcCfgToSend, LcCfg *ueLcCfgDb, LcCfg *oldLcCfg, Bool toUpdate)
{
- uint8_t ret = ROK;
- lcCfg->lcId = ueSetReqDb->lcId;
- lcCfg->configType = ueSetReqDb->configType;
- /* Filling DRBQOS */
- if(ueSetReqDb->drbQos)
+ if(!toUpdate)
{
- if(!lcCfg->drbQos)
+ if(macLcCfgToSend)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->drbQos, sizeof(DrbQosInfo));
- if(!lcCfg->drbQos)
- {
- DU_LOG("\nERROR --> DU APP : Memory Alloc failed at drQos at fillMacLcCfgToAddMod()");
- return RFAILED;
- }
- }
- if(ret == ROK)
- {
- memcpy(lcCfg->drbQos, ueSetReqDb->drbQos, sizeof(DrbQosInfo));
+ macLcCfgToSend->lcId = ueLcCfgDb->lcId;
+ macLcCfgToSend->configType = ueLcCfgDb->configType;
+
+ if(ueLcCfgDb->drbQos)
+ macLcCfgToSend->drbQos = ueLcCfgDb->drbQos;
+ else if(oldLcCfg)
+ macLcCfgToSend->drbQos = oldLcCfg->drbQos;
+ else
+ macLcCfgToSend->drbQos = NULL;
+
+ if(ueLcCfgDb->snssai)
+ macLcCfgToSend->snssai = ueLcCfgDb->snssai;
+ else if(oldLcCfg)
+ macLcCfgToSend->snssai = oldLcCfg->snssai;
+ else
+ macLcCfgToSend->snssai = NULL;
+
+ macLcCfgToSend->ulLcCfgPres = ueLcCfgDb->ulLcCfgPres;
+ memcpy(&macLcCfgToSend->ulLcCfg, &ueLcCfgDb->ulLcCfg, sizeof(UlLcCfg));
+ memcpy(&macLcCfgToSend->dlLcCfg, &ueLcCfgDb->dlLcCfg, sizeof(DlLcCfg));
}
}
else
{
- lcCfg->drbQos = NULLP;
- }
+ oldLcCfg->lcId = ueLcCfgDb->lcId;
+ oldLcCfg->configType = ueLcCfgDb->configType;
- if(ret == ROK)
- {
- if(ueSetReqDb->snssai)
+ if(ueLcCfgDb->drbQos)
{
- if(!lcCfg->snssai)
+ if(oldLcCfg->drbQos)
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->drbQos, sizeof(DrbQosInfo));
+
+ DU_ALLOC_SHRABL_BUF(oldLcCfg->drbQos, sizeof(DrbQosInfo));
+ if(oldLcCfg->drbQos == NULL)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->snssai, sizeof(Snssai));
- if(!lcCfg->snssai)
- {
- DU_LOG("\nERROR --> DU APP : Memory Alloc failed at snnsai at fillMacLcCfgToAddMod()");
- ret = RFAILED;
- }
+ DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
+ return RFAILED;
}
- if(ret == ROK)
+ memcpy(oldLcCfg->drbQos, ueLcCfgDb->drbQos, sizeof(DrbQosInfo));
+ }
+
+ if(ueLcCfgDb->snssai)
+ {
+ if(oldLcCfg->snssai)
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->snssai, sizeof(Snssai));
+
+ DU_ALLOC_SHRABL_BUF(oldLcCfg->snssai, sizeof(Snssai));
+ if(oldLcCfg->snssai == NULL)
{
- /* Filling SNSSAI */
- memcpy(lcCfg->snssai, ueSetReqDb->snssai, sizeof(Snssai));
+ DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->drbQos, sizeof(DrbQosInfo));
+ return RFAILED;
}
- else
- {
- lcCfg->snssai = NULLP;
- if(lcCfg->drbQos)
- {
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
- lcCfg->drbQos = NULLP;
- }
- return ret;
- }
+ memcpy(oldLcCfg->snssai, ueLcCfgDb->snssai, sizeof(Snssai));
}
- else
- lcCfg->snssai = NULLP;
+
+ oldLcCfg->ulLcCfgPres = ueLcCfgDb->ulLcCfgPres;
+ memcpy(&oldLcCfg->ulLcCfg, &ueLcCfgDb->ulLcCfg, sizeof(UlLcCfg));
+ memcpy(&oldLcCfg->dlLcCfg, &ueLcCfgDb->dlLcCfg, sizeof(DlLcCfg));
}
- lcCfg->ulLcCfgPres = ueSetReqDb->ulLcCfgPres;
- memcpy(&lcCfg->ulLcCfg, &ueSetReqDb->ulLcCfg, sizeof(UlLcCfg));
- memcpy(&lcCfg->dlLcCfg, &ueSetReqDb->dlLcCfg, sizeof(DlLcCfg));
- return ret;
+ return ROK;
}
/******************************************************************
*
*****************************************************************/
-uint8_t fillAmbr(AmbrCfg **macAmbr, AmbrCfg *ueDbAmbr)
+uint8_t fillAmbr(AmbrCfg **macAmbrCfgToSend, AmbrCfg *ueDbAmbr, AmbrCfg **oldMacAmbrCfg, Bool toUpdate)
{
- if(ueDbAmbr)
+ if(!toUpdate)
+ {
+ if(ueDbAmbr)
+ {
+ *macAmbrCfgToSend = ueDbAmbr;
+ }
+ else
+ *macAmbrCfgToSend = *oldMacAmbrCfg;
+ }
+ else
{
- if(*macAmbr == NULLP)
+ if(ueDbAmbr)
{
- DU_ALLOC_SHRABL_BUF(*macAmbr, sizeof(AmbrCfg));
- if(*macAmbr == NULLP)
+ if(*oldMacAmbrCfg)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, *oldMacAmbrCfg, sizeof(AmbrCfg));
+ }
+ DU_ALLOC_SHRABL_BUF(*oldMacAmbrCfg, sizeof(AmbrCfg));
+ if(*oldMacAmbrCfg == NULLP)
{
DU_LOG("\nERROR --> DU APP : Memory Alloc Failed at fillAmbr()");
return RFAILED;
}
+ memset(*oldMacAmbrCfg, 0, sizeof(AmbrCfg));
+ (*oldMacAmbrCfg)->ulBr = ueDbAmbr->ulBr;
}
- memset(*macAmbr, 0, sizeof(AmbrCfg));
- (*macAmbr)->ulBr = ueDbAmbr->ulBr;
- }
- else
- {
- *macAmbr = NULLP;
}
+
return ROK;
}
NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
}
}
- ret = fillAmbr(&macUeCfg->ambrCfg, ueCfgDb->ambrCfg);
+ ret = fillAmbr(&macUeCfg->ambrCfg, ueCfgDb->ambrCfg , &duMacDb->ambrCfg, FALSE);
duFillModulationDetails(macUeCfg, duMacDb, ueCfgDb->ueNrCapability);
}
(ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_MOD))
{
ueCfgDb->macLcCfg[dbIdx].configType = CONFIG_MOD;
- ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
+ ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx], &duMacDb->lcCfgList[lcIdx], FALSE);
}
}
else
if(!lcIdFound)
{
/* ADD/DEL CONFIG */
- ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
+ ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx], NULL, FALSE);
}
if(ret == ROK)
{
MacUeCfg *oldMacUeCfg;
ret = ROK;
+ GET_CELL_IDX(macUeCfg->cellId, cellIdx);
+ oldMacUeCfg = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueIdx-1].macUeCfg;
+
/*Filling Cell Group Cfg*/
ret = procUeReCfgCellInfo(macUeCfg, f1UeDb->duUeCfg.cellGrpCfg);
if(ret == ROK)
fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
}
- ret = fillAmbr(&macUeCfg->ambrCfg, f1UeDb->duUeCfg.ambrCfg);
-
- GET_CELL_IDX(macUeCfg->cellId, cellIdx);
- oldMacUeCfg = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueIdx-1].macUeCfg;
+ ret = fillAmbr(NULL, f1UeDb->duUeCfg.ambrCfg, &oldMacUeCfg->ambrCfg, true);
duFillModulationDetails(macUeCfg, oldMacUeCfg, f1UeDb->duUeCfg.ueNrCapability);
}
{
if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD)
{
- ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcIdx],&f1UeDb->duUeCfg.macLcCfg[dbIdx]);
+ ret = fillMacLcCfgToAddMod(NULL, &f1UeDb->duUeCfg.macLcCfg[dbIdx], &macUeCfg->lcCfgList[lcIdx], true);
}
else if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_DEL)
{
for(lcDelIdx = lcIdx; lcDelIdx < macUeCfg->numLcs; lcDelIdx++)
{
/* moving all elements one index ahead */
- ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcDelIdx], &macUeCfg->lcCfgList[lcDelIdx+1]);
+ ret = fillMacLcCfgToAddMod(NULL, &macUeCfg->lcCfgList[lcDelIdx+1], &macUeCfg->lcCfgList[lcDelIdx], true);
freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]);
if(ret == RFAILED)
{
}
if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_ADD)
{
- ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[numLcs], &f1UeDb->duUeCfg.macLcCfg[dbIdx]);
+ 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);
* ****************************************************************/
uint8_t fillTnlCfgToAddMod(UpTnlCfg **ueCbTnlCfg, UpTnlCfg *f1TnlCfg)
{
+ if(*ueCbTnlCfg)
+ {
+ DU_FREE((*ueCbTnlCfg)->tnlCfg1, sizeof(GtpTnlCfg));
+ DU_FREE(*ueCbTnlCfg, sizeof(UpTnlCfg));
+ }
+
if(*ueCbTnlCfg == NULLP)
{
/* copying to DuCb Tnl Cfg */
{
if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, NULLP, f1TnlCfg->tnlCfg1) == ROK)
{
- if(fillTnlCfgToAddMod(&duCb.upTnlCfg[duCb.numDrb], f1TnlCfg) == ROK)
- {
- duCb.numDrb++;
- ret = ROK;
- }
+ if(fillTnlCfgToAddMod(&duCb.upTnlCfg[duCb.numDrb], f1TnlCfg) == ROK)
+ {
+ duCb.numDrb++;
+ ret = ROK;
+ }
}
}
else if(f1TnlCfg->configType == CONFIG_MOD)
{
if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_MOD, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
{
- if(fillTnlCfgToAddMod(&duTnlCfg, f1TnlCfg) == ROK)
- {
- ret = ROK;
- }
+ if(fillTnlCfgToAddMod(&duTnlCfg, f1TnlCfg) == ROK)
+ {
+ ret = ROK;
+ }
}
}
else if(f1TnlCfg->configType == CONFIG_DEL)
if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_DEL, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
{
/* Free memory at drbIdx */
- DU_FREE(duTnlCfg->tnlCfg1, sizeof(GtpTnlCfg));
duCb.numDrb--;
for(delIdx = ueCbIdx; delIdx < duCb.numDrb; delIdx++)
{
return ret;
}
}
+ if(duCb.upTnlCfg[delIdx])
+ {
+ DU_FREE(duCb.upTnlCfg[delIdx]->tnlCfg1, sizeof(GtpTnlCfg));
+ DU_FREE(duCb.upTnlCfg[delIdx], sizeof(UpTnlCfg));
+ }
}
}
return ret;
uint8_t DuProcRlcDlRrcMsgRsp(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsg)
{
uint8_t ret = ROK, ueIdx = 0;
+ uint16_t cellId, crnti;
DuUeCb *ueCb = NULLP;
+ DlMsgState state;
- if(dlRrcMsg->state == TRANSMISSION_COMPLETE)
+ state = dlRrcMsg->state;
+ cellId = dlRrcMsg->cellId;
+ crnti = dlRrcMsg->crnti;
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsg, sizeof(RlcDlRrcMsgRsp));
+
+ if(state == TRANSMISSION_COMPLETE)
{
- GET_UE_IDX(dlRrcMsg->crnti, ueIdx);
- ueCb = &duCb.actvCellLst[dlRrcMsg->cellId -1]->ueCb[ueIdx -1];
+ GET_UE_IDX(crnti, ueIdx);
+ ueCb = &duCb.actvCellLst[cellId -1]->ueCb[ueIdx -1];
+
if(ueCb->f1UeDb && ueCb->f1UeDb->dlRrcMsgPres)
{
if(ueCb->f1UeDb->actionType == UE_CTXT_SETUP)
{
- ret = duBuildAndSendUeContextSetupReq(dlRrcMsg->cellId, dlRrcMsg->crnti, &ueCb->f1UeDb->duUeCfg);
+ ret = duBuildAndSendUeContextSetupReq(cellId, crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
}
if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
{
- ret = duBuildAndSendUeContextModReq(dlRrcMsg->cellId, dlRrcMsg->crnti, &ueCb->f1UeDb->duUeCfg);
+ ret = duBuildAndSendUeContextModReq(cellId, crnti, &ueCb->f1UeDb->duUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to process UE Context Mod Request in DuProcRlcDlRrcMsgRsp()");
}
if(ueCb->f1UeDb->actionType == UE_CTXT_RELEASE && ueCb->ueState == UE_ACTIVE)
{
- ret = duBuildAndSendUeDeleteReq(dlRrcMsg->cellId,dlRrcMsg->crnti);
+ ret = duBuildAndSendUeDeleteReq(cellId, crnti);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to process UE Context Release Request in DuProcRlcDlRrcMsgRsp()");
else
DU_LOG("\nERROR --> DU APP : Failed to transmit DL RRC Msg");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsg, sizeof(RlcDlRrcMsgRsp));
return ret;
}
/*******************************************************************
#define EVENT_RIC_DATA 10
/* allocate and zero out a static buffer */
+
+#ifdef ODU_MEMORY_DEBUG_LOG
+#define DU_MEM_LOG(_macro, _file, _line, _func, _size, _datPtr)\
+{\
+ printf("\n%s=== %s +%d, %s, %d, %p\n", \
+ _macro, _file, _line, _func, _size, _datPtr); \
+}
+#else
+#define DU_MEM_LOG(_macro, _file, _line, _func, _size, _dataPtr) {}
+#endif
+
#define DU_ALLOC(_datPtr, _size) \
{ \
int _ret; \
_ret = SGetSBuf(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_datPtr, _size); \
- if(_ret == ROK) \
+ if(_ret == ROK) \
+ {\
+ DU_MEM_LOG("DU_ALLOC", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
memset(_datPtr, 0, _size); \
+ }\
else \
_datPtr = NULLP; \
}
{ \
if(_datPtr != NULLP) \
{ \
+ DU_MEM_LOG("DU_FREE", __FILE__, __LINE__, __FUNCTION__, _size, _datPtr);\
SPutSBuf(DU_APP_MEM_REGION, DU_POOL, \
(Data *)_datPtr, _size); \
_datPtr = NULLP; \
if(SGetStaticBuffer(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_buf, (Size) _size, 0) == ROK) \
{ \
+ DU_MEM_LOG("DU_ALLOC_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
memset((_buf), 0, _size); \
} \
else \
{ \
if (_buf != NULLP) \
{ \
+ DU_MEM_LOG("DU_FREE_SHRABL_BUF", __FILE__, __LINE__, __FUNCTION__, _size, _buf);\
(Void) SPutStaticBuffer(_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
Code Review / o-du / l2.git / commitdiff