/*
* ======== ti_sdo_ipc_Notify_Instance_finalize ========
*/
Void ti_sdo_ipc_Notify_Instance_finalize(ti_sdo_ipc_Notify_Object *obj,
Int status)
{
UInt i;
UInt16 clusterId = ti_sdo_utils_MultiProc_getClusterId(obj->remoteProcId);
switch (status) {
case 0:
/* Unregister the notify instance from the Notify module */
Notify_module->notifyHandles[clusterId][obj->lineId] = NULL;
/* Destruct the event lists */
for (i = 0; i < ti_sdo_ipc_Notify_numEvents; i++) {
List_destruct(List_struct(List_Object_get(obj->eventList, i)));
}
/* Free memory used for the List.Objects */
Memory_free(ti_sdo_ipc_Notify_Object_heap(), obj->eventList,
sizeof(List_Struct) * ti_sdo_ipc_Notify_numEvents);
/* OK to fall through */
case 1:
/* Free memory used for callbacks array */
Memory_free(ti_sdo_ipc_Notify_Object_heap(), obj->callbacks,
sizeof(ti_sdo_ipc_Notify_EventCallback) *
ti_sdo_ipc_Notify_numEvents);
}
}
/*
* ======== task1Fxn ========
*/
Void task1Fxn(UArg arg0, UArg arg1)
{
Ptr bufs[TASK1NUMBUFS];
IHeap_Handle heap = HeapMem_Handle_upCast(task1Heap);
System_printf("Initial task1 heap status\n");
/* print initial task1Heap status */
printHeapStats(heap);
bufs[0] = Memory_alloc(heap, TASK1BUFSIZE0, 0, NULL);
bufs[1] = Memory_alloc(heap, TASK1BUFSIZE1, 0, NULL);
bufs[2] = Memory_alloc(heap, TASK1BUFSIZE2, 0, NULL);
Memory_free(heap, bufs[1], TASK1BUFSIZE1);
Memory_free(heap, bufs[2], TASK1BUFSIZE2);
bufs[3] = Memory_alloc(heap, TASK1BUFSIZE3, 0, NULL);
Memory_free(heap, bufs[0], TASK1BUFSIZE0);
Memory_free(heap, bufs[3], TASK1BUFSIZE3);
System_printf("Final task1 heap status\n");
/* print task1Heap status */
printHeapStats(heap);
System_printf("Task1 Complete\n");
}
NORET Darray_destroy(Darray dyn_ary)
{
Darray_rep *temp = dlower(dyn_ary);
Memory_free((VOIDP)temp->storage);
Memory_free((VOIDP)temp);
}
Void appTaskFxn(UArg arg0, UArg arg1)
{
char* args[8];
//arg[0] is 2 chars for dev type
args[0] = Memory_alloc(NULL, 2 * sizeof(char), 0, NULL);
//arg[1] is 3 chars for channel num
args[1] = Memory_alloc(NULL, 3 * sizeof(char), 0, NULL);
//init the RPC queue
rpcInitMq();
//init the application thread to register the callbacks
appInit();
consolePrint(
"Enter device type c: Coordinator, r: Router, e: End Device:\n");
consoleGetLine(args[0], 8);
consolePrint("Enter channel 11-26:\n");
consoleGetLine(args[1], 8);
while (1)
{
appProcess(args);
Task_sleep(10);
}
Memory_free(NULL, args[0], 2 * sizeof(char));
Memory_free(NULL, args[1], 3 * sizeof(char));
}
/*
* ======== LoggerBuf_Instance_finalize ========
*/
Void LoggerBuf_Instance_finalize(LoggerBuf_Object *obj, Int status)
{
if (obj->entryArr != NULL) {
Memory_free(obj->bufHeap, obj->entryArr,
obj->numEntries * sizeof (LoggerBuf_Entry));
}
}
static int do_memoryAlloc(CodecEngine* _ce, size_t _srcBufferSize, size_t _dstBufferSize)
{
memset(&_ce->m_allocParams, 0, sizeof(_ce->m_allocParams));
_ce->m_allocParams.type = Memory_CONTIGPOOL;
_ce->m_allocParams.flags = Memory_CACHED;
_ce->m_allocParams.align = BUFALIGN;
_ce->m_allocParams.seg = 0;
_ce->m_srcBufferSize = ALIGN_UP(_srcBufferSize, BUFALIGN);
if ((_ce->m_srcBuffer = Memory_alloc(_ce->m_srcBufferSize, &_ce->m_allocParams)) == NULL)
{
fprintf(stderr, "Memory_alloc(src, %zu) failed\n", _ce->m_srcBufferSize);
_ce->m_srcBufferSize = 0;
return ENOMEM;
}
_ce->m_dstBufferSize = ALIGN_UP(_dstBufferSize, BUFALIGN);
if ((_ce->m_dstBuffer = Memory_alloc(_ce->m_dstBufferSize, &_ce->m_allocParams)) == NULL)
{
fprintf(stderr, "Memory_alloc(dst, %zu) failed\n", _ce->m_dstBufferSize);
_ce->m_dstBufferSize = 0;
Memory_free(_ce->m_srcBuffer, _ce->m_srcBufferSize, &_ce->m_allocParams);
_ce->m_srcBuffer = NULL;
_ce->m_srcBufferSize = 0;
return ENOMEM;
}
return 0;
}
/*
* ======== MessageQ_free ========
*/
Int MessageQ_free(MessageQ_Msg msg)
{
IHeap_Handle heap;
/* make sure msg is not NULL */
Assert_isTrue((msg != NULL), ti_sdo_ipc_MessageQ_A_invalidMsg);
/* Cannot free a message that was initialized via MessageQ_staticMsgInit */
Assert_isTrue((msg->heapId != ti_sdo_ipc_MessageQ_STATICMSG),
ti_sdo_ipc_MessageQ_A_cannotFreeStaticMsg);
Assert_isTrue((msg->heapId < MessageQ_module->numHeaps),
ti_sdo_ipc_MessageQ_A_heapIdInvalid);
Assert_isTrue((MessageQ_module->heaps[msg->heapId] != NULL),
ti_sdo_ipc_MessageQ_A_heapIdInvalid);
if ((ti_sdo_ipc_MessageQ_traceFlag == TRUE) ||
(msg->flags & ti_sdo_ipc_MessageQ_TRACEMASK) != 0) {
Log_write3(ti_sdo_ipc_MessageQ_LM_free, (UArg)(msg),
(UArg)(msg->seqNum), (UArg)(msg->srcProc));
}
heap = MessageQ_module->heaps[msg->heapId];
if (heap != NULL) {
Memory_free(heap, msg, msg->msgSize);
}
else {
return (MessageQ_E_FAIL);
}
return (MessageQ_S_SUCCESS);
}
/*
* ======== Power_unregisterConstraint ========
* Unregister for a power notification.
*
*/
Power_Status Power_unregisterConstraint(Power_ConstraintHandle handle)
{
Power_Status status = Power_SOK;
Power_Constraint type;
UInt key;
/* check for NULL constraintHandle */
if (handle == NULL) {
status = Power_EINVALIDHANDLE;
}
/* else, remove and delete constraint object, update aggregate constraint */
else {
key = Hwi_disable();
Queue_remove((Queue_Elem *)handle);
Hwi_restore(key);
/* recompute aggregate constraint w/absence of removed constraint */
type = ((Power_ConstraintObj *) handle)->type;
Power_rebuildConstraint(type);
/* free the constraint object */
Memory_free(Power_Object_heap(), handle, sizeof(Power_ConstraintObj));
}
return (status);
}
/*
* ======== Algorithm_delete ========
*/
Void Algorithm_delete(Algorithm_Handle alg)
{
Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
IRES_Status status;
Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)",
(IArg)alg);
if (pObject != NULL) {
if (pObject->iresFxns) {
/* Call RMAN fuction to free resources */
status = RMAN_freeResources(pObject->alg, pObject->iresFxns,
pObject->groupId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing "
"of alg resources through RMAN FAILED (0x%x)",
(IArg)status);
}
}
if (pObject->alg) {
DSKT2_freeAlg(pObject->groupId, pObject->alg);
}
Memory_free(pObject, sizeof (*pObject), NULL);
}
Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit");
}
/*
* ======== Algorithm_delete ========
*/
Void Algorithm_delete(Algorithm_Handle alg)
{
Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
IRES_Status status;
Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)",
(IArg)alg);
if (pObject != NULL) {
if (pObject->iresFxns) {
/* Call RMAN fuction to free resources */
status = RMAN_freeResources(pObject->alg, pObject->iresFxns,
pObject->groupId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing "
"of alg resources through RMAN FAILED (0x%x)",
(IArg)status);
}
}
if (pObject->idma3Fxns) {
Log_print0(Diags_USER4, "[+4] Algorithm_delete> releasing "
"DMA resources");
DMAN3_releaseDmaChannels(&(pObject->alg), &(pObject->idma3Fxns),1);
}
if (pObject->alg) {
ALG_delete(pObject->groupId, pObject->alg, pObject->useCachedMem);
}
Memory_free(pObject, sizeof (*pObject), NULL);
}
Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit");
}
void _XdmServer_freeXdaisAlgMemory(IALG_MemRec memTab[], Int numRecs)
{
Int idx;
uint8_t *handle;
uint8_t *RPE_dspIramHeapHandle = globaL2heap;
for (idx = 0; idx < numRecs; idx++)
{
if (memTab[idx].base != NULL)
{
if ( memTab[idx].space > IALG_SARAM2 )
{
handle = RPE_dspAlgHeapHandle;
}
else
{
handle = RPE_dspIramHeapHandle;
}
/* Freeing a buffer of size 0 is not possible, so we allocate */
/* 8 bytes during creation. This is taken care during deletion */
if (memTab[idx].size == 0)
{
memTab[idx].size = 8;
}
Memory_free ((IHeap_Handle) handle, memTab[idx].base, memTab[idx].size);
}
}
return;
}
/*
* ======== MEM_increaseTableSize ========
*/
Int MEM_increaseTableSize(Uns numEntries)
{
IArg key;
IHeap_Handle *tmpTable;
Error_Block eb;
Error_init(&eb);
/* Use HeapMem's gate for thread-safety */
key = HeapMem_enter();
tmpTable = Memory_calloc(MEM_table[0],
(MEM_tabSize + numEntries) * sizeof(IHeap_Handle), 0, NULL);
if (tmpTable == NULL) {
HeapMem_leave(key);
return (SYS_EALLOC);
}
memcpy(tmpTable, MEM_table, MEM_tabSize * sizeof(IHeap_Handle));
if ((MEM_tabSize != 0) && (staticTable != TRUE)) {
Memory_free(MEM_table[0], MEM_table, MEM_tabSize * sizeof(IHeap_Handle));
}
staticTable = FALSE;
MEM_table = tmpTable;
MEM_tabSize += numEntries;
HeapMem_leave(key);
return (SYS_OK);
}
/******************************************************************************
* Buffer_copy
******************************************************************************/
Int Buffer_copy(Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf)
{
assert(hSrcBuf);
assert(hDstBuf);
assert(hSrcBuf->type == Buffer_Type_BASIC ||
hSrcBuf->type == Buffer_Type_GRAPHICS);
if(hSrcBuf->type != hDstBuf->type) {
Dmai_err1("Cannot copy to Buffer type (%d)\n", hDstBuf->type);
return Dmai_EFAIL;
}
if (!hDstBuf->reference && hDstBuf->userPtr) {
Dmai_dbg3("Free Buffer of size %u at 0x%x (0x%x phys)\n",
(Uns) hDstBuf->origState.numBytes,
(Uns) hDstBuf->userPtr,
(Uns) hDstBuf->physPtr);
if (!Memory_free(hDstBuf->userPtr, hDstBuf->origState.numBytes,
&hDstBuf->memParams)) {
return Dmai_EFAIL;
}
}
if(hSrcBuf->type == Buffer_Type_GRAPHICS) {
*(_BufferGfx_Object *) hDstBuf = *(_BufferGfx_Object *) hSrcBuf;
} else {
*(_Buffer_Object *) hDstBuf = *(_Buffer_Object *) hSrcBuf;
}
hDstBuf->reference = TRUE;
return Dmai_EOK;
}
/*
* ======== Swi_Instance_finalize ========
* free hookEnv if alloced during create
*/
Void Swi_Instance_finalize(Swi_Object *swi, Int status)
{
#ifndef ti_sysbios_knl_Swi_DISABLE_ALL_HOOKS
Int i, cnt;
#endif
if (status == 1) {
return;
}
/* Can't delete a currently posted Swi */
Assert_isTrue((swi->posted == 0), NULL);
#ifndef ti_sysbios_knl_Swi_DISABLE_ALL_HOOKS
if (Swi_hooks.length > 0) {
if (status == 0) {
cnt = Swi_hooks.length;
}
else {
cnt = status - 2;
}
for (i = 0; i < cnt; i++) {
if (Swi_hooks.elem[i].deleteFxn != NULL) {
Swi_hooks.elem[i].deleteFxn(swi);
}
}
Memory_free(Swi_Object_heap(), swi->hookEnv,
Swi_hooks.length * sizeof (Ptr));
}
#endif
}
/*
* ======== NODE_delete ========
*/
Int NODE_delete(NODE_Handle node)
{
Void *handle;
/* Should be a DBC_requires */
Assert_isTrue(node != NULL, (Assert_Id)NULL);
Assert_isTrue(node->skelFxns != NULL, (Assert_Id)NULL);
Assert_isTrue(node->skelFxns->apiDestroy != NULL, (Assert_Id)NULL);
/* delete thread *before* destroying node to ensure thread has no access
* to node as we are freeing it
*/
if (node->self) {
Log_print1(Diags_ENTRY, "[+E] NODE_delete(0x%x)", (IArg)node);
Thread_delete(&(node->self));
}
handle = NODE_getEnv(node);
if (handle) {
node->skelFxns->apiDestroy(handle);
}
if (node->recv != Comm_INVALIDHANDLE) {
Comm_delete(node->recv);
}
Memory_free(NULL, node, sizeof(NODE_Obj));
return (NODE_EOK);
}
/*
* ======== task0Fxn ========
*/
Void task0Fxn(UArg arg0, UArg arg1)
{
Int i;
Ptr bufs[TASK0NUMBUFS];
IHeap_Handle heap = HeapBuf_Handle_upCast(task0Heap);
System_printf("Initial task0 heap status\n");
/* print initial task0heap status */
printHeapStats(heap);
/* allocate blocks from task0Heap */
for (i = 0; i < TASK0NUMBUFS; i++) {
bufs[i] = Memory_alloc(heap, TASK0BUFSIZE, 0, NULL);
}
/* free memory blocks */
for (i = 0; i < TASK0NUMBUFS; i++) {
Memory_free(heap, bufs[i], TASK0BUFSIZE);
}
System_printf("Final task0 heap status\n");
/* print task0Heap status */
printHeapStats(heap);
System_printf("Task0 Complete\n");
}
Int SystemCfg_deleteResources(SystemCfg_Object *obj)
{
IHeap_Handle heapH;
Int status = 0;
Log_print1(Diags_ENTRY | Diags_INFO, "--> "FXNN": (obj=0x%x)",(IArg)obj);
/* delete opencl buffer heap */
// HeapBufMP_delete(&obj->openclHeapH);
/* unregister rcm message heap with MessageQ */
MessageQ_unregisterHeap(SystemCfg_RcmMsgHeapId_CompDev);
/* delete rcm message heap instance */
HeapBuf_delete(&obj->rcmHeapH);
/* free the rcm message heap storage */
heapH = (IHeap_Handle)SharedRegion_getHeap(0);
Memory_free(heapH, obj->rcmHeapBufBase, obj->rcmHeapBufSize);
obj->rcmHeapBufBase = NULL;
obj->rcmHeapBufSize = 0;
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== Global_exit ========
* calls cleanup functions for all the modules that
* scheduled it, then cleans up itself
*/
Void Global_exit(Void)
{
ExitFxnElem *old;
if (curInit == FALSE) {
return;
}
Log_print0(Diags_ENTRY, "[+E] Global_exit> enter" );
while( exitFxnList != NULL ) {
Log_print1(Diags_USER2, "[+2] Global_exit> "
"calling function *0x%x()...", (IArg)(exitFxnList->fxn ));
exitFxnList->fxn();
old = exitFxnList;
exitFxnList = exitFxnList->next;
Memory_free(NULL, old, sizeof(ExitFxnElem));
}
/* if the tracing module has its exit function, it must have been
* the last one, so don't use trace from this point on
*/
/* do the cleanup of this module */
curInit = FALSE;
exitFxnList = NULL; /* unnecessary, NULL already */
/* we do NOT reset doRegisterAtExit, as we don't want endless pairs of
* CERuntime_init/exit to keep adding this func to the process' atexit
* table. Autoexit is a curtesy feature only for those who call
* CERuntime_init once.
*/
/* doRegisterAtExit = TRUE; */
}
/*!
* @brief Function to finalize the HAL object
*
* @param halObj Pointer to the HAL object
*
* @sa OMAPL1XX_halInit
* OMAPL1XX_phyShmemExit
*/
Int
OMAPL1XX_halExit (Ptr halObj)
{
Int status = PROCESSOR_SUCCESS;
OMAPL1XX_HalObject * halObject = NULL;
GT_1trace (curTrace, GT_ENTER, "OMAPL1XX_halExit", halObj);
GT_assert (curTrace, (halObj != NULL));
halObject = (OMAPL1XX_HalObject *) halObj ;
status = OMAPL1XX_phyShmemExit (halObj);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
if (status < 0) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"OMAPL1XX_halExit",
status,
"OMAPL1XX_phyShmemExit failed!");
}
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
if (halObj != NULL) {
/* Free the memory for the HAL object. */
Memory_free (NULL, halObj, sizeof (OMAPL1XX_HalObject));
}
GT_1trace (curTrace, GT_LEAVE, "OMAPL1XX_halExit", status);
/*! @retval PROCESSOR_SUCCESS Operation successful */
return status;
}
Int32 Utils_memFree(Ptr addr, UInt32 size)
{
UInt32 heapId = UTILS_MEM_VID_FRAME_BUF_HEAP;
SharedRegion_Entry srEntry;
SharedRegion_getEntry(SYSTEM_IPC_SR_VIDEO_FRAME, &srEntry);
/* if address falls in tiler buffer then free from that heap */
if((UInt32)addr >= (UInt32)srEntry.base && (UInt32)addr < ((UInt32)srEntry.base + srEntry.len) )
{
#ifdef UTILS_MEM_DEBUG
Vps_printf(" UTILS: MEM: FRAME FREE, addr = 0x%08x, size = %d bytes, heap = %d\n", addr, size, heapId);
#endif
/* free previously allocated memory */
Memory_free(gUtils_heapMemHandle[heapId], addr, size);
}
else
{
Int32 status;
status = SystemTiler_freeRaw(addr,size);
UTILS_assert(status == 0);
}
return 0;
}
/*!
* @brief Remove and delete entry from the Translation Table
*
* @param da Device address
*
* @sa _SysLinkMemUtils_insertMapElement
*/
static Ptr
_SysLinkMemUtils_removeMapElement (Ptr da)
{
AddrNode * node;
Ptr addr = NULL;
GT_1trace (curTrace, GT_ENTER, "_SysLinkMemUtils_removeMapElement", da);
OsalSemaphore_pend (SysLinkMemUtils_module->semList,
OSALSEMAPHORE_WAIT_FOREVER);
node = _SysLinkMemUtils_findNode (da);
if (!node || node->da != da) {
#if !defined(SYSLINK_BUILD_OPTIMIZE)
GT_setFailureReason (curTrace,
GT_4CLASS,
(Char *)__func__,
PROCMGR_E_FAIL,
"Entry not found!");
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
}
else {
addr = node->ua;
List_remove (SysLinkMemUtils_module->addrTable, &node->elem);
Memory_free (NULL, node, sizeof (AddrNode));
}
OsalSemaphore_post (SysLinkMemUtils_module->semList);
GT_1trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_removeMapElement", addr);
return addr;
}
Int IpcResource_disconnect(IpcResource_Handle handle)
{
Int status;
IpcResource_Req req;
if (!handle) {
System_printf("IpcResource_disconnect: handle is NULL\n");
}
req.resType = 0;
req.reqType = IpcResource_REQ_TYPE_DISCONN;
status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server,
handle->endPoint, &req, sizeof(req));
if (status) {
System_printf("IpcResource_disconnect: MessageQCopy_send "
"failed status %d\n", status);
return status;
}
status = MessageQCopy_delete(&handle->msgq);
if (status) {
System_printf("IpcResource_disconnect: MessageQCopy_delete "
"failed status %d\n", status);
return status;
}
Memory_free(NULL, handle, sizeof(*handle));
return 0;
}
/*
* ======== HeapMultiBuf_Instance_finalize ========
* Deletes the managed HeapBuf instances and frees the memory for the
* sorted buffer arrays.
*/
Void HeapMultiBuf_Instance_finalize(HeapMultiBuf_Object *obj, int status)
{
Int i;
/* If a create failed, handle the finalize based on the status. */
switch (status) {
/* Alloc of bufsByAddr failed. */
case 1:
return;
/* Alloc of bufsBySize failed. */
case 2:
/* bufsByAddr succeeded, so free bufsByAddr. */
Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
return;
case 3:
/* Delete any heapBufs that were successfully created. */
for (i = 0; i < obj->numBufs; i++) {
/*
* bufsBySize was calloc'd, so we can check for NULL to find
* the end of the created HeapBufs.
*/
if (&(obj->bufsBySize[i]) == NULL) {
break;
}
HeapBuf_delete(&(obj->bufsBySize[i]));
}
/* Free both the bufsByAddr and bufsBySize arrays. */
Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
Memory_free(NULL, obj->bufsBySize, obj->numBufs * sizeof(HeapBuf_Object*));
return;
}
/*
* If finalize is being called through a normal delete, rather than
* through a failed create...
*/
/* Delete all of the created HeapBufs */
for (i = 0; i < obj->numBufs; i++) {
HeapBuf_delete(&(obj->bufsBySize[i]));
}
/* Free the bufsByAddr and bufsBySize arrays. */
Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
Memory_free(NULL, obj->bufsBySize, obj->numBufs * sizeof(HeapBuf_Object*));
}
/*
* ======== Comm_create ========
*/
Comm_Handle Comm_create(String queueName, Comm_Attrs *attrs)
{
Comm_Obj *comm;
UInt32 commId;
Char commName[ MAXCOMMNAMELEN ];
key_t key;
Assert_isTrue(curInit > 0, (Assert_Id)NULL);
Log_print2(Diags_ENTRY, "[+E] Comm_create> "
"Enter(queueName='%s', attrs=0x%x)", (IArg)queueName, (IArg)attrs);
if (attrs == NULL) {
attrs = &Comm_ATTRS;
}
if (queueName == NULL) {
/* Generate a name to use */
// TODO: Increment curCommId atomically
commId = curCommId++;
sprintf(commName, "queue_%lu_%u", Global_getProcessId(), (Uns)commId);
key = nameToId(commName);
}
else {
key = nameToId(queueName);
}
comm = (Comm_Obj *)Memory_alloc(NULL, sizeof(Comm_Obj), 0, NULL);
if (comm == NULL) {
return (NULL);
}
comm->type = attrs->type;
if (comm->type == Comm_PEND) {
;
}
else if (comm->type == Comm_CALL) {
comm->callHandle = attrs->callHandle;
comm->callFxn = attrs->callFxn;
}
else {
Assert_isTrue(FALSE, (Assert_Id)NULL); /* unknown Comm type */
}
/*
* Create a new message queue id for the "name" key
*/
if ((comm->id = msgget(key, IPC_CREAT | 0644)) < 0) {
fprintf(stderr, "msgget key = 0x%x\n", key);
perror("Comm_create:msgget");
Memory_free(NULL, comm, sizeof(Comm_Obj));
return (NULL);
}
Log_print1(Diags_EXIT, "[+X] Comm_create> return (0x%x)", (IArg)comm);
return (comm);
}
/*
* ======== cleanup ========
*/
static Void cleanup(Void)
{
Assert_isTrue(curInit > 0, (Assert_Id)NULL);
if (--curInit == 0) {
/* Free library search path buffers */
if (libPath) {
Memory_free(NULL, libPath, pathLen);
libPath = NULL;
}
if (tmpPath) {
Memory_free(NULL, tmpPath, pathLen);
tmpPath = NULL;
}
pathLen = 0;
}
}
void
cont_free_frames(struct frame *frames, unsigned nf)
{
int i;
if (frames) {
for (i=0; i<nf; i++) {
if (frames[i].virt[0]) {
//Memory_registerContigBuf((UInt32) frames[i].virt[0], ce_frame_size, (UInt32)frames[i].phys[0]);
Memory_free(frames[i].virt[0], ce_frame_size, &mem_params);
}
}
}
if (frames) free(frames); //TODO: reference this
Memory_free(input_buf, INPUT_BUFFER_SIZE, &mem_params);
}
static int do_memoryFree(CodecEngine* _ce)
{
if (_ce->m_dstBuffer != NULL)
{
Memory_free(_ce->m_dstBuffer, _ce->m_dstBufferSize, &_ce->m_allocParams);
_ce->m_dstBuffer = NULL;
_ce->m_dstBufferSize = 0;
}
if (_ce->m_srcBuffer != NULL)
{
Memory_free(_ce->m_srcBuffer, _ce->m_srcBufferSize, &_ce->m_allocParams);
_ce->m_srcBuffer = NULL;
_ce->m_srcBufferSize = 0;
}
return 0;
}
void *Memory_reallocate(void *memory, u32 size)
{
void *new = Memory_allocate(size);
Memory_Header *header = Memory_Header_fromBlock(memory);
Memory_Header_assertMagic(header);
String_copy(new, memory, (size < header->size) ? size : header->size);
Memory_free(memory);
return new;
}
/*
* ======== ffcio_close ========
*/
int ffcio_close(int dev_fd)
{
f_close(filTable[dev_fd]);
Memory_free(NULL, filTable[dev_fd], sizeof(FIL));
filTable[dev_fd] = NULL;
return (0);
}
void _DSKT2_Permute_deleteHandle(_DSKT2_PERMUTE_EnumerationHandle h)
{
if (NULL != h) {
#ifdef _RTSMODE_
free(h);
#else
Memory_free(_DSKT2_heap, h, sizeof(_DSKT2_PERMUTE_Enumeration));
#endif
}
}
