diff options
Diffstat (limited to 'addons/ooh323c/src/memheap.c')
| -rw-r--r-- | addons/ooh323c/src/memheap.c | 335 |
1 files changed, 167 insertions, 168 deletions
diff --git a/addons/ooh323c/src/memheap.c b/addons/ooh323c/src/memheap.c index c7aed04e5..ada601385 100644 --- a/addons/ooh323c/src/memheap.c +++ b/addons/ooh323c/src/memheap.c @@ -1,15 +1,15 @@ /* * Copyright (C) 1997-2004 by Objective Systems, Inc. * - * This software is furnished under an open source license and may be - * used and copied only in accordance with the terms of this license. - * The text of the license may generally be found in the root - * directory of this installation in the LICENSE.txt file. It + * This software is furnished under an open source license and may be + * used and copied only in accordance with the terms of this license. + * The text of the license may generally be found in the root + * directory of this installation in the LICENSE.txt file. It * can also be viewed online at the following URL: * * http://www.obj-sys.com/open/license.html * - * Any redistributions of this file including modified versions must + * Any redistributions of this file including modified versions must * maintain this copyright notice. * *****************************************************************************/ @@ -20,7 +20,7 @@ ASN1UINT g_defBlkSize = XM_K_MEMBLKSIZ; -static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, +static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, void* pMemBlk, int blockType); typedef void OSMemElemDescr; @@ -109,39 +109,39 @@ pMemBlk->freeElemOff = (ASN1USINT)(QOFFSETOF (pElem, pMemBlk->data) + 1); \ #define SET_FREE_ELEM(pMemBlk, pElem) setLastElem (pMemBlk, pElem) /* Memory debugging macros */ -#define RTMEMDIAG1(msg) -#define RTMEMDIAG2(msg,a) +#define RTMEMDIAG1(msg) +#define RTMEMDIAG2(msg,a) #define RTMEMDIAG3(msg,a,b) #define RTMEMDIAG4(msg,a,b,c) #define FILLFREEMEM(mem,size) -#define FILLNEWMEM(mem,size) +#define FILLNEWMEM(mem,size) #define CHECKMEMELEM(memblk,elem) #define CHECKMEMBLOCK(memheap,memblk) -#define CHECKMEMHEAP(memheap) +#define CHECKMEMHEAP(memheap) #define TRACEMEMELEM(memblk, elem, name) #define TRACEFREE(memlink,name) -static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem) +static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem) { - if (pElem == 0) { - pMemBlk->freeElemOff = 0; - return; + if (pElem == 0) { + pMemBlk->freeElemOff = 0; + return; } - else if (ISLAST (pElem)) - return; + else if (ISLAST (pElem)) + return; else if (pMemBlk->freeElemOff > QOFFSETOF (pElem, pMemBlk->data) + 1) { - pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem); - FORCE_SET_FREE_ELEM (pMemBlk, pElem); - } - else if (pMemBlk->freeElemOff == 0) { - pElem_nextFreeOff (pElem) = 0; - FORCE_SET_FREE_ELEM (pMemBlk, pElem); - } - else { - SET_FREE (pElem); - pElem_nextFreeOff (pElem) = 0; + pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem); + FORCE_SET_FREE_ELEM (pMemBlk, pElem); + } + else if (pMemBlk->freeElemOff == 0) { + pElem_nextFreeOff (pElem) = 0; + FORCE_SET_FREE_ELEM (pMemBlk, pElem); + } + else { + SET_FREE (pElem); + pElem_nextFreeOff (pElem) = 0; } } @@ -170,7 +170,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) ppMemLink = &pMemHeap->phead; /* if size is greater than 2**19, then allocate as RAW block */ - + if (nunits > (1<<16) - 2) { void *data; @@ -188,9 +188,9 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) /* save size of the RAW memory block behind the pMemLink */ *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes; ast_mutex_unlock(&pMemHeap->pLock); - return data; + return data; } - + RTMEMDIAG2 ("memHeapAlloc: adjusted nbytes = %d\n", nbytes); /* Try to allocate a slot from an existing block on the list */ @@ -216,26 +216,26 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) pElem_flags (pElem) = 0; if (pMemBlk->lastElemOff != 0) - pElem_prevOff (pElem) = + pElem_prevOff (pElem) = (ASN1USINT)(pMemBlk->free_x - pMemBlk->lastElemOff + 1); - else + else pElem_prevOff (pElem) = 0; - + pPrevElem = GET_LAST_ELEM (pMemBlk); if (pPrevElem != 0) CLEAR_LAST (pPrevElem); - - pElem_nunits (pElem) = (ASN1USINT)nunits; + + pElem_nunits (pElem) = (ASN1USINT)nunits; pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); pMemBlk->lastElemOff = (ASN1USINT)(pMemBlk->free_x + 1); mem_p = (void*) (pElem_data (pElem)); - + /* sizeof (OSMemElemDescr) == 1 unit */ - pMemBlk->free_x += nunits + 1; - + pMemBlk->free_x += nunits + 1; + SET_LAST_ELEM (pMemBlk, pElem); - + FILLNEWMEM (mem_p, nunits * 8u); TRACEMEMELEM(pMemBlk, pElem, "Allocated"); CHECKMEMELEM (pMemBlk, pElem); @@ -249,54 +249,54 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) if (0 == mem_p) { for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) { if (pMemLink->blockType & RTMEMRAW) continue; - + pMemBlk = (OSMemBlk*) pMemLink->pMemBlk; if (nunits <= (ASN1UINT)pMemBlk->freeMem) { OSMemElemDescr* pElem = GET_FREE_ELEM(pMemBlk), *pPrevFree = 0; - RTMEMDIAG2 - ("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n", + RTMEMDIAG2 + ("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n", pMemBlk); while (pElem != 0) { - if (ISFREE (pElem)) { + if (ISFREE (pElem)) { if (nunits <= (ASN1UINT)pElem_nunits (pElem)) { - RTMEMDIAG3 + RTMEMDIAG3 ("memHeapAlloc: " - "found an exisiting free element 0x%x, size %d\n", + "found an exisiting free element 0x%x, size %d\n", pElem, (pElem_nunits (pElem) * 8u)); - - if (pMemBlk->freeElemOff == - QOFFSETOF (pElem, pMemBlk->data) + 1) + + if (pMemBlk->freeElemOff == + QOFFSETOF (pElem, pMemBlk->data) + 1) { - + /* modify the pMemBlk->freeElemOff value if necsry */ OSMemElemDescr* nextFree = GET_NEXT_FREE (pElem); - FORCE_SET_FREE_ELEM (pMemBlk, nextFree); + FORCE_SET_FREE_ELEM (pMemBlk, nextFree); } else if (pPrevFree != 0) { OSMemElemDescr* pNextFree = GET_NEXT_FREE (pElem); if (pNextFree != 0) - pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree, + pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree, pPrevFree); else pElem_nextFreeOff (pPrevFree) = 0; - } + } CLEAR_FREE (pElem); /* set beginOff value */ pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); - + pMemBlk->freeMem -= pElem_nunits (pElem); CHECKMEMELEM (pMemBlk, pElem); CHECKMEMBLOCK (pMemHeap, pMemBlk); - - mem_p = memHeapRealloc + + mem_p = memHeapRealloc (ppvMemHeap, pElem_data (pElem), nunits * 8u); if (mem_p != 0) { FILLNEWMEM (mem_p, nunits * 8u); @@ -310,7 +310,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) } if (mem_p != 0) break; } - } + } } /* If not successful, malloc a new block and alloc from it */ @@ -322,16 +322,16 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) RTMEMDIAG1 ("memHeapAlloc: alloc block..\n"); - allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) + + allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) + sizeof (OSMemBlk) + sizeof_OSMemElemDescr); - allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize : + allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize : ((allocSize + defBlkSize - 1) / defBlkSize * defBlkSize); dataUnits = (ASN1UINT)((allocSize - sizeof (OSMemBlk)) >> 3u); if (dataUnits >= (1u<<16)) { dataUnits = (ASN1UINT)((1u<<16) - 1); allocSize = (ASN1UINT) ((((ASN1UINT)dataUnits) * 8u) + sizeof (OSMemBlk)); - } + } pmem = (ASN1OCTET*) malloc (allocSize + sizeof (OSMemLink)); if (0 != pmem) { @@ -347,7 +347,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); /* sizeof (OSMemElemDescr) == 1 unit */ - pMemBlk->free_x = (ASN1USINT)(nunits + 1); + pMemBlk->free_x = (ASN1USINT)(nunits + 1); pMemBlk->freeMem = 0; pMemBlk->nunits = (ASN1USINT)dataUnits; @@ -355,7 +355,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) pMemBlk->freeElemOff = 0; pMemBlk->nsaved = 0; - if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0) + if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0) { free (pmem); ast_mutex_unlock(&pMemHeap->pLock); @@ -378,7 +378,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes) } RTMEMDIAG2 ("memHeapAlloc: pMemBlk = 0x%x\n", pMemBlk); RTMEMDIAG2 ("memHeapAlloc: pMemBlk->free_x = %d\n", pMemBlk->free_x); - RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n", + RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n", pMemBlk->nunits * 8u); RTMEMDIAG2 ("memHeapAlloc: mem_p = 0x%x\n", mem_p); RTMEMDIAG2 ("memHeapAlloc: sizeof (short) = %d\n", sizeof(short)); @@ -394,7 +394,7 @@ void* memHeapAllocZ (void** ppvMemHeap, int nbytes) return ptr; } -void memHeapFreePtr (void** ppvMemHeap, void* mem_p) +void memHeapFreePtr (void** ppvMemHeap, void* mem_p) { OSMemHeap* pMemHeap; OSMemLink** ppMemLink; @@ -416,7 +416,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { if ((pMemLink->blockType & RTMEMRAW) && - pMemLink->pMemBlk == mem_p) + pMemLink->pMemBlk == mem_p) { if(pMemLink->pnext != 0) { pMemLink->pnext->pprev = pMemLink->pprev; @@ -429,12 +429,12 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) } if (pPrevMemLink != 0) pPrevMemLink->pnextRaw = pMemLink->pnextRaw; - else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 && + else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 && *ppMemLink != pMemLink->pnextRaw) { (*ppMemLink)->pnextRaw = pMemLink->pnextRaw; } - if ((pMemLink->blockType & RTMEMLINK) && + if ((pMemLink->blockType & RTMEMLINK) && (pMemLink->blockType & RTMEMMALLOC)) { free (pMemLink); @@ -460,7 +460,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) RTMEMDIAG2 ("memHeapFreePtr: " "the element 0x%x is already freed!\n", pElem); ast_mutex_unlock(&pMemHeap->pLock); - return; + return; } if (ISSAVED (pElem)) { @@ -474,17 +474,17 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) CHECKMEMBLOCK(pMemHeap, pMemBlk); RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x\n", pMemBlk); - RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n", + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n", pMemBlk->nunits * 8u); if (ISLAST (pElem)) { /* is it the last? */ OSMemElemDescr* pPrevElem = GETPREV (pElem); - + CHECKMEMELEM (pMemBlk, pPrevElem); pMemBlk->free_x -= (pElem_nunits (pElem) + 1); - FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], + FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], (pElem_nunits (pElem) + 1) * 8u); if (pPrevElem != 0 && ISFREE (pPrevElem)) { @@ -493,10 +493,10 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) pMemBlk->free_x -= (pElem_nunits (pPrevElem) + 1); pMemBlk->freeMem -= pElem_nunits (pPrevElem); SET_LAST_ELEM (pMemBlk, GETPREV (pPrevElem)); - + /* wasn't it the last elem in block? */ - if (pMemBlk->lastElemOff != 0) { - + if (pMemBlk->lastElemOff != 0) { + /* correct nextFreeOff for previous free element */ pFreeElem = GET_FREE_ELEM (pMemBlk); @@ -505,7 +505,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) } else { OSMemElemDescr* pNextFree = 0; - + while (pFreeElem < pPrevElem) { pNextFree = pFreeElem; pFreeElem = GET_NEXT_FREE (pFreeElem); @@ -518,15 +518,15 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) SET_LAST_ELEM (pMemBlk, pPrevElem); } - RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n", + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n", pMemBlk->free_x); /* The question is: do we really want to get rid of the */ /* block or should we keep it around for reuse? */ if (pMemBlk->lastElemOff == 0) { /* was it the last elem in block? */ - + if ((pMemHeap->flags & RT_MH_DONTKEEPFREE) || - (pMemHeap->keepFreeUnits > 0 && + (pMemHeap->keepFreeUnits > 0 && pMemHeap->freeUnits + pMemBlk->nunits > pMemHeap->keepFreeUnits)) { ASN1OCTET blockType = pMemBlk->plink->blockType; @@ -543,7 +543,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) pMemBlk->plink->pprev->pnext = pMemBlk->plink->pnext; } else { /* head */ - if (pMemBlk->plink->pnext != 0 && + if (pMemBlk->plink->pnext != 0 && !(pMemBlk->plink->pnext->blockType & RTMEMRAW)) { pMemBlk->plink->pnext->pnextRaw = (*ppMemLink)->pnextRaw; @@ -552,14 +552,14 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) } FILLFREEMEM (pMemBlk->plink, sizeof (*pMemBlk->plink)); FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u)); - + free (pMemBlk->plink); - + if (!(blockType & RTMEMLINK)) { FILLFREEMEM (pMemBlk, sizeof (*pMemBlk)); free (pMemBlk); } - RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n", + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n", pMemBlk); } else { @@ -575,7 +575,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) } else { SET_LAST (GET_LAST_ELEM (pMemBlk)); - FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u), + FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u), (pMemBlk->nunits - pMemBlk->free_x) * 8u); CHECKMEMBLOCK (pMemHeap, pMemBlk); } @@ -586,25 +586,25 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) SET_FREE_ELEM(pMemBlk, pElem); pMemBlk->freeMem += pElem_nunits (pElem); - RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n", + RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n", pElem); /* try to unite free blocks, if possible */ if (!ISFIRST (pElem)) { if (ISFREE (GETPREV (pElem))) { OSMemElemDescr* prevelem_p = GETPREV (pElem); - + /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */ - pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1; + pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1; pElem = prevelem_p; pMemBlk->freeMem ++; /* sizeof (OSMemElemDescr) == 1 unit */ } else { /* look for nearest previous free block to correct nextFreeOff */ - + OSMemElemDescr* prevelem_p = pElem; - + do { prevelem_p = GETPREV (prevelem_p); } @@ -612,32 +612,32 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) if (prevelem_p != 0) { OSMemElemDescr* pNextFree = GET_NEXT_FREE (prevelem_p); - if (pNextFree != 0) + if (pNextFree != 0) pElem_nextFreeOff (pElem) = QOFFSETOF (pNextFree, pElem); else pElem_nextFreeOff (pElem) = 0; pElem_nextFreeOff (prevelem_p) = QOFFSETOF (pElem, prevelem_p); - + CHECKMEMELEM (pMemBlk, prevelem_p); } } } if (!ISLAST (pElem) && ISFREE (GETNEXT (pElem))) { OSMemElemDescr* nextelem_p = GETNEXT (pElem); - + /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */ - pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1; + pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1; if (pElem_nextFreeOff (nextelem_p) == 0) pElem_nextFreeOff (pElem) = 0; else - pElem_nextFreeOff (pElem) = + pElem_nextFreeOff (pElem) = QOFFSETOF (GET_NEXT_FREE (nextelem_p), pElem); pMemBlk->freeMem ++; } /* correct the prevOff field of next element */ - if (!ISLAST (pElem)) { + if (!ISLAST (pElem)) { OSMemElemDescr* nextelem_p = GETNEXT (pElem); pElem_prevOff (nextelem_p) = QOFFSETOF (nextelem_p, pElem); } @@ -648,10 +648,10 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p) CHECKMEMBLOCK (pMemHeap, pMemBlk); } ast_mutex_unlock(&pMemHeap->pLock); -} +} -static void initNewFreeElement (OSMemBlk* pMemBlk, - OSMemElemDescr* pNewElem, OSMemElemDescr* pElem) +static void initNewFreeElement (OSMemBlk* pMemBlk, + OSMemElemDescr* pNewElem, OSMemElemDescr* pElem) { OSMemElemDescr *pNextElem, *pPrevElem = 0; @@ -662,11 +662,11 @@ static void initNewFreeElement (OSMemBlk* pMemBlk, pElem_prevOff (pNewElem) = QOFFSETOF (pNewElem, pElem); - if (pMemBlk->freeElemOff != 0 && + if (pMemBlk->freeElemOff != 0 && pMemBlk->freeElemOff < QOFFSETOF (pElem, pMemBlk->data) + 1) { /* look for nearest previous free block to correct its nextFreeOff */ - + pPrevElem = pElem; do { @@ -677,21 +677,21 @@ static void initNewFreeElement (OSMemBlk* pMemBlk, if (pPrevElem != 0) { /* if it is not first free element... */ /* correct nextFreeOff for prev free element */ - + pElem_nextFreeOff (pPrevElem) = QOFFSETOF (pNewElem, pPrevElem); } else { /* if it is first free element in the block */ FORCE_SET_FREE_ELEM (pMemBlk, pNewElem); } - + pNextElem = GETNEXT (pNewElem); if (ISFREE (pNextElem)) { - + /* if the next elem is free, then unite them together */ pElem_nunits (pNewElem) += pElem_nunits (pNextElem) + 1; if (pElem_nextFreeOff (pNextElem) != 0) - pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem), + pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem), pNewElem); else pElem_nextFreeOff (pNewElem) = 0; @@ -709,7 +709,7 @@ static void initNewFreeElement (OSMemBlk* pMemBlk, pNextElem = GETNEXT (pNextElem); /* set nextFreeOff for new element */ - + if (pNextElem != 0) pElem_nextFreeOff (pNewElem) = QOFFSETOF (pNextElem, pNewElem); else @@ -745,15 +745,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { if ((pMemLink->blockType & RTMEMRAW) && - pMemLink->pMemBlk == mem_p) + pMemLink->pMemBlk == mem_p) { if (pMemLink->blockType & RTMEMMALLOC) { void *newMemBlk = realloc (pMemLink->pMemBlk, nbytes_); - if (newMemBlk == 0) + if (newMemBlk == 0) return 0; pMemLink->pMemBlk = newMemBlk; } - else + else return 0; *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes_; return pMemLink->pMemBlk; @@ -767,7 +767,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr); - RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,", mem_p, + RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,", mem_p, pElem_nunits (pElem) * 8u); RTMEMDIAG2 (" new nbytes = %d\n", nbytes); @@ -780,39 +780,39 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) CHECKMEMBLOCK(pMemHeap, pMemBlk); if ((unsigned)pElem_nunits (pElem) < nunits) { /* expanding */ - + if (nunits - pElem_nunits (pElem) <= (unsigned)pMemBlk->nunits) { /* Try to expand the existing element in the existing block */ if (ISLAST (pElem)) { /* if the last element in the block */ - + /* if the free space in the block is enough */ - - if ((int)(nunits - pElem_nunits (pElem)) <= - (int)(pMemBlk->nunits - pMemBlk->free_x)) - { + + if ((int)(nunits - pElem_nunits (pElem)) <= + (int)(pMemBlk->nunits - pMemBlk->free_x)) + { pMemBlk->free_x += nunits - pElem_nunits (pElem); pElem_nunits (pElem) = (ASN1USINT)nunits; RTMEMDIAG1 ("memHeapRealloc: " "memory element is expanded.\n"); - - FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x - - (nunits - pElem_nunits (pElem))) * 8u], + + FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x - + (nunits - pElem_nunits (pElem))) * 8u], (nunits - pElem_nunits (pElem)) * 8u); - + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); CHECKMEMELEM (pMemBlk, pElem); CHECKMEMBLOCK (pMemHeap, pMemBlk); return (mem_p); - } + } } else { - OSMemElemDescr* pNextElem, *pFreeElem; + OSMemElemDescr* pNextElem, *pFreeElem; unsigned sumSize = pElem_nunits (pElem), freeMem = 0; - + RTMEMDIAG1 ("memHeapRealloc: look for free element after " "current block.\n"); @@ -821,10 +821,10 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) pNextElem = GETNEXT (pElem); if (ISFREE (pNextElem)) { /* +1 'cos sizeof (OSMemElemDescr) == 1 unit */ - sumSize += pElem_nunits (pNextElem) + 1; + sumSize += pElem_nunits (pNextElem) + 1; freeMem++; } - + if (sumSize >= nunits) { RTMEMDIAG1 ("memHeapRealloc: reuse free element.\n"); @@ -835,15 +835,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) FORCE_SET_FREE_ELEM (pMemBlk, GET_NEXT_FREE (pNextElem)); } else if (pFreeElem < pElem) { - + /* look for previous free elem to correct nextFreeOff */ for (; pFreeElem != 0 && pFreeElem < pNextElem;) { - OSMemElemDescr* pNextFreeElem = + OSMemElemDescr* pNextFreeElem = GET_NEXT_FREE (pFreeElem); if (pNextFreeElem == pNextElem) { if (pElem_nextFreeOff (pNextElem) != 0) - pElem_nextFreeOff (pFreeElem) = QOFFSETOF + pElem_nextFreeOff (pFreeElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem), pFreeElem); else pElem_nextFreeOff (pFreeElem) = 0; @@ -856,15 +856,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) } /* reuse empty elements after the pElem */ - + pMemBlk->freeMem += freeMem; - + if (sumSize - nunits > 1) { OSMemElemDescr* pNewElem; - + /* if sumSize is too large, then create new empty element */ - pNewElem = (OSMemElemDescr*) + pNewElem = (OSMemElemDescr*) (pElem_data (pElem) + nbytes); pElem_nunits (pNewElem) = (ASN1USINT)(sumSize - nunits - 1); @@ -884,7 +884,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) if (pNextElem != 0) pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pElem); } - + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); CHECKMEMELEM (pMemBlk, pElem); CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : 0); @@ -901,14 +901,14 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) CHECKMEMHEAP (pMemHeap); newMem_p = memHeapAlloc (ppvMemHeap, nbytes); - + if (newMem_p == 0) return 0; /* if the old memory block is marked as saved then mark the new block as saved as well. */ - if (ISSAVED (pElem)) + if (ISSAVED (pElem)) memHeapMarkSaved (ppvMemHeap, newMem_p, TRUE); CHECKMEMHEAP (pMemHeap); @@ -927,7 +927,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) } else { /* shrinking */ RTMEMDIAG1 ("memHeapRealloc: shrinking ...\n"); - + /* just free the pointer, if nbytes == 0 */ if (nbytes == 0) { @@ -939,15 +939,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) /* do not shrink, if size diff is too small */ /* sizeof (OSMemElemDescr) == 1 unit */ - if (pElem_nunits (pElem) - nunits > 1) { - - /* if it is the last element in the block, then just change the size + if (pElem_nunits (pElem) - nunits > 1) { + + /* if it is the last element in the block, then just change the size and free_x. */ if (ISLAST (pElem)) { pMemBlk->free_x -= (pElem_nunits (pElem) - nunits); - FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], + FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], (pElem_nunits (pElem) - nunits) * 8u); } else { @@ -958,14 +958,14 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) pNewElem = (OSMemElemDescr*) (pElem_data (pElem) + nbytes); /* sizeof (OSMemElemDescr) == 1 unit */ - pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1); - + pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1); + initNewFreeElement (pMemBlk, pNewElem, pElem); - + pMemBlk->freeMem += (pElem_nunits (pElem) - nunits) - 1; } pElem_nunits (pElem) = (ASN1USINT)nunits; - + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); CHECKMEMELEM (pMemBlk, pElem); CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : pElem); @@ -999,9 +999,9 @@ void memHeapFreeAll (void** ppvMemHeap) pMemLink2 = pMemLink; pMemLink = pMemLink2->pnext; - RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n", + RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n", pMemLink2, pMemLink); - + #ifdef _MEMDEBUG if (pMemLink2->blockType & RTMEMSTD) { OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk; @@ -1035,9 +1035,9 @@ void memHeapFreeAll (void** ppvMemHeap) /* free link and block */ - if (((pMemLink2->blockType & RTMEMSTD) || + if (((pMemLink2->blockType & RTMEMSTD) || (pMemLink2->blockType & RTMEMMALLOC)) && - !(pMemLink2->blockType & RTMEMLINK)) + !(pMemLink2->blockType & RTMEMLINK)) free (pMemLink2->pMemBlk); free (pMemLink2); } @@ -1088,11 +1088,11 @@ void memHeapRelease (void** ppvMemHeap) /* This function is used for marking memory block as "saved". It means * that the memory block containing the specified memory pointer won't be - * freed after calls to memHeapFreeAll/memHeapReset. User is responsible + * freed after calls to memHeapFreeAll/memHeapReset. User is responsible * for freeing the marked memory block by call to memFreeBlock */ -void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, - ASN1BOOL saved) +void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, + ASN1BOOL saved) { OSMemHeap* pMemHeap; OSMemLink* pMemLink; @@ -1100,7 +1100,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, RTMEMDIAG2 ("memHeapMarkSaved: for mem_p = 0x%x\n", mem_p); - if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) + if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) return 0; pMemHeap = *(OSMemHeap**)ppvMemHeap; @@ -1113,7 +1113,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, for (; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { if ((pMemLink->blockType & RTMEMRAW) && - pMemLink->pMemBlk == mem_p) + pMemLink->pMemBlk == mem_p) { break; } @@ -1131,7 +1131,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, "already free!\n", pElem); ast_mutex_unlock(&pMemHeap->pLock); - return 0; + return 0; } if ((ISSAVED (pElem) && !saved) || (!ISSAVED (pElem) && saved)) { @@ -1143,7 +1143,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, pMemLink = pMemBlk->plink; - if (saved) + if (saved) SET_SAVED (pMemBlk, pElem); else CLEAR_SAVED (pMemBlk, pElem); @@ -1153,7 +1153,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, ast_mutex_unlock(&pMemHeap->pLock); return 0; } - if (saved && nsaved > 0) + if (saved && nsaved > 0) pMemLink->blockType |= RTMEMSAVED; else if (nsaved == 0) pMemLink->blockType &= (~RTMEMSAVED); @@ -1203,16 +1203,16 @@ void memHeapReset (void** ppvMemHeap) /* add memory block to list */ -static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, +static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, void* pMemBlk, int blockType) { OSMemLink* pMemLink; - /* if pMemBlk has RTMEMLINK flags it means that it is allocated + /* if pMemBlk has RTMEMLINK flags it means that it is allocated * cooperatively with OSMemLink, and we don't need to do additional * allocations for it. Just use pointer's arithemtic. */ - if (blockType & RTMEMLINK) + if (blockType & RTMEMLINK) pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink)); else { pMemLink = (OSMemLink*) malloc ( @@ -1222,7 +1222,7 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, to perform rtMemRealloc through malloc/memcpy/free */ *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = (int)-1; } - if (pMemLink == NULL) + if (pMemLink == NULL) return NULL; pMemLink->blockType = (ASN1OCTET)blockType; pMemLink->pMemBlk = pMemBlk; @@ -1241,15 +1241,15 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, pMemLink->pnextRaw = 0; } - *ppMemLink = pMemLink; + *ppMemLink = pMemLink; if (pMemLink->pnext != 0) pMemLink->pnext->pprev = pMemLink; ((OSMemBlk*)pMemBlk)->plink = pMemLink; /*!AB */ RTMEMDIAG2 ("memHeapAddBlock: pMemLink = 0x%x\n", pMemLink); - RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n", + RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n", pMemLink->pnext); - RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n", + RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n", pMemLink->pprev); return pMemLink; @@ -1262,7 +1262,7 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p) RTMEMDIAG2 ("memHeapCheckPtr: for mem_p = 0x%x\n", mem_p); - if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) + if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) return 0; pMemHeap = *(OSMemHeap**)ppvMemHeap; @@ -1272,7 +1272,7 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p) for (; pMemLink != 0; pMemLink = pMemLink->pnext) { if (pMemLink->blockType & RTMEMRAW) { - + /* if RAW block, the pointer should be stored in pMemBlk */ if (pMemLink->pMemBlk == mem_p) { @@ -1282,17 +1282,17 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p) } else { OSMemBlk* pMemBlk = (OSMemBlk*)pMemLink->pMemBlk; - + /* Check, is the pointer inside this memory page */ - if (mem_p > pMemLink->pMemBlk && + if (mem_p > pMemLink->pMemBlk && mem_p < (void*)(((ASN1OCTET*)pMemLink->pMemBlk) + pMemBlk->nunits * 8u)) { /* Check, is the pointer a correct element of the mem page */ OSMemElemDescr* pElem = (OSMemElemDescr*) pMemBlk->data; for (; pElem != 0; pElem = GETNEXT (pElem)) { - + void* curMem_p = (void*) pElem_data (pElem); if (curMem_p == mem_p && !ISFREE (pElem)) { ast_mutex_unlock(&pMemHeap->pLock); @@ -1311,7 +1311,7 @@ void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp) { OSMemHeap* pMemHeap; - if (ppvMemHeap == 0) + if (ppvMemHeap == 0) return; if (*ppvMemHeap == 0) @@ -1332,9 +1332,9 @@ void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp) break; } ast_mutex_unlock(&pMemHeap->pLock); -} +} -int memHeapCreate (void** ppvMemHeap) +int memHeapCreate (void** ppvMemHeap) { OSMemHeap* pMemHeap; if (ppvMemHeap == 0) return ASN_E_INVPARAM; @@ -1349,4 +1349,3 @@ int memHeapCreate (void** ppvMemHeap) *ppvMemHeap = (void*)pMemHeap; return ASN_OK; } - |