sl@0: /*
sl@0: ** 2001 September 15
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: **
sl@0: ** Memory allocation functions used throughout sqlite.
sl@0: **
sl@0: ** $Id: malloc.c,v 1.45 2008/10/12 00:27:53 shane Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include <stdarg.h>
sl@0: #include <ctype.h>
sl@0: 
sl@0: /*
sl@0: ** This routine runs when the memory allocator sees that the
sl@0: ** total memory allocation is about to exceed the soft heap
sl@0: ** limit.
sl@0: */
sl@0: static void softHeapLimitEnforcer(
sl@0:   void *NotUsed, 
sl@0:   sqlite3_int64 inUse,
sl@0:   int allocSize
sl@0: ){
sl@0:   sqlite3_release_memory(allocSize);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Set the soft heap-size limit for the library. Passing a zero or 
sl@0: ** negative value indicates no limit.
sl@0: */
sl@0: void sqlite3_soft_heap_limit(int n){
sl@0:   sqlite3_uint64 iLimit;
sl@0:   int overage;
sl@0:   if( n<0 ){
sl@0:     iLimit = 0;
sl@0:   }else{
sl@0:     iLimit = n;
sl@0:   }
sl@0:   sqlite3_initialize();
sl@0:   if( iLimit>0 ){
sl@0:     sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, iLimit);
sl@0:   }else{
sl@0:     sqlite3MemoryAlarm(0, 0, 0);
sl@0:   }
sl@0:   overage = sqlite3_memory_used() - n;
sl@0:   if( overage>0 ){
sl@0:     sqlite3_release_memory(overage);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Attempt to release up to n bytes of non-essential memory currently
sl@0: ** held by SQLite. An example of non-essential memory is memory used to
sl@0: ** cache database pages that are not currently in use.
sl@0: */
sl@0: int sqlite3_release_memory(int n){
sl@0: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
sl@0:   int nRet = 0;
sl@0: #if 0
sl@0:   nRet += sqlite3VdbeReleaseMemory(n);
sl@0: #endif
sl@0:   nRet += sqlite3PcacheReleaseMemory(n-nRet);
sl@0:   return nRet;
sl@0: #else
sl@0:   return SQLITE_OK;
sl@0: #endif
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** State information local to the memory allocation subsystem.
sl@0: */
sl@0: static SQLITE_WSD struct Mem0Global {
sl@0:   /* Number of free pages for scratch and page-cache memory */
sl@0:   u32 nScratchFree;
sl@0:   u32 nPageFree;
sl@0: 
sl@0:   sqlite3_mutex *mutex;         /* Mutex to serialize access */
sl@0: 
sl@0:   /*
sl@0:   ** The alarm callback and its arguments.  The mem0.mutex lock will
sl@0:   ** be held while the callback is running.  Recursive calls into
sl@0:   ** the memory subsystem are allowed, but no new callbacks will be
sl@0:   ** issued.  The alarmBusy variable is set to prevent recursive
sl@0:   ** callbacks.
sl@0:   */
sl@0:   sqlite3_int64 alarmThreshold;
sl@0:   void (*alarmCallback)(void*, sqlite3_int64,int);
sl@0:   void *alarmArg;
sl@0:   int alarmBusy;
sl@0: 
sl@0:   /*
sl@0:   ** Pointers to the end of sqlite3GlobalConfig.pScratch and
sl@0:   ** sqlite3GlobalConfig.pPage to a block of memory that records
sl@0:   ** which pages are available.
sl@0:   */
sl@0:   u32 *aScratchFree;
sl@0:   u32 *aPageFree;
sl@0: } mem0 = { 62560955 };
sl@0: 
sl@0: #define mem0 GLOBAL(struct Mem0Global, mem0)
sl@0: 
sl@0: /*
sl@0: ** Initialize the memory allocation subsystem.
sl@0: */
sl@0: int sqlite3MallocInit(void){
sl@0:   if( sqlite3GlobalConfig.m.xMalloc==0 ){
sl@0:     sqlite3MemSetDefault();
sl@0:   }
sl@0:   memset(&mem0, 0, sizeof(mem0));
sl@0:   if( sqlite3GlobalConfig.bCoreMutex ){
sl@0:     mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
sl@0:   }
sl@0:   if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
sl@0:       && sqlite3GlobalConfig.nScratch>=0 ){
sl@0:     int i;
sl@0:     sqlite3GlobalConfig.szScratch -= 4;
sl@0:     mem0.aScratchFree = (u32*)&((char*)sqlite3GlobalConfig.pScratch)
sl@0:                   [sqlite3GlobalConfig.szScratch*sqlite3GlobalConfig.nScratch];
sl@0:     for(i=0; i<sqlite3GlobalConfig.nScratch; i++){ mem0.aScratchFree[i] = i; }
sl@0:     mem0.nScratchFree = sqlite3GlobalConfig.nScratch;
sl@0:   }else{
sl@0:     sqlite3GlobalConfig.pScratch = 0;
sl@0:     sqlite3GlobalConfig.szScratch = 0;
sl@0:   }
sl@0:   if( sqlite3GlobalConfig.pPage && sqlite3GlobalConfig.szPage>=512
sl@0:       && sqlite3GlobalConfig.nPage>=1 ){
sl@0:     int i;
sl@0:     int overhead;
sl@0:     int sz = sqlite3GlobalConfig.szPage;
sl@0:     int n = sqlite3GlobalConfig.nPage;
sl@0:     overhead = (4*n + sz - 1)/sz;
sl@0:     sqlite3GlobalConfig.nPage -= overhead;
sl@0:     mem0.aPageFree = (u32*)&((char*)sqlite3GlobalConfig.pPage)
sl@0:                   [sqlite3GlobalConfig.szPage*sqlite3GlobalConfig.nPage];
sl@0:     for(i=0; i<sqlite3GlobalConfig.nPage; i++){ mem0.aPageFree[i] = i; }
sl@0:     mem0.nPageFree = sqlite3GlobalConfig.nPage;
sl@0:   }else{
sl@0:     sqlite3GlobalConfig.pPage = 0;
sl@0:     sqlite3GlobalConfig.szPage = 0;
sl@0:   }
sl@0:   return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Deinitialize the memory allocation subsystem.
sl@0: */
sl@0: void sqlite3MallocEnd(void){
sl@0:   if( sqlite3GlobalConfig.m.xShutdown ){
sl@0:   sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
sl@0:   }
sl@0:   memset(&mem0, 0, sizeof(mem0));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the amount of memory currently checked out.
sl@0: */
sl@0: sqlite3_int64 sqlite3_memory_used(void){
sl@0:   int n, mx;
sl@0:   sqlite3_int64 res;
sl@0:   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
sl@0:   res = (sqlite3_int64)n;  /* Work around bug in Borland C. Ticket #3216 */
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the maximum amount of memory that has ever been
sl@0: ** checked out since either the beginning of this process
sl@0: ** or since the most recent reset.
sl@0: */
sl@0: sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
sl@0:   int n, mx;
sl@0:   sqlite3_int64 res;
sl@0:   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
sl@0:   res = (sqlite3_int64)mx;  /* Work around bug in Borland C. Ticket #3216 */
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Change the alarm callback
sl@0: */
sl@0: int sqlite3MemoryAlarm(
sl@0:   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
sl@0:   void *pArg,
sl@0:   sqlite3_int64 iThreshold
sl@0: ){
sl@0:   sqlite3_mutex_enter(mem0.mutex);
sl@0:   mem0.alarmCallback = xCallback;
sl@0:   mem0.alarmArg = pArg;
sl@0:   mem0.alarmThreshold = iThreshold;
sl@0:   sqlite3_mutex_leave(mem0.mutex);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_DEPRECATED
sl@0: /*
sl@0: ** Deprecated external interface.  Internal/core SQLite code
sl@0: ** should call sqlite3MemoryAlarm.
sl@0: */
sl@0: int sqlite3_memory_alarm(
sl@0:   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
sl@0:   void *pArg,
sl@0:   sqlite3_int64 iThreshold
sl@0: ){
sl@0:   return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Trigger the alarm 
sl@0: */
sl@0: static void sqlite3MallocAlarm(int nByte){
sl@0:   void (*xCallback)(void*,sqlite3_int64,int);
sl@0:   sqlite3_int64 nowUsed;
sl@0:   void *pArg;
sl@0:   if( mem0.alarmCallback==0 || mem0.alarmBusy  ) return;
sl@0:   mem0.alarmBusy = 1;
sl@0:   xCallback = mem0.alarmCallback;
sl@0:   nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
sl@0:   pArg = mem0.alarmArg;
sl@0:   sqlite3_mutex_leave(mem0.mutex);
sl@0:   xCallback(pArg, nowUsed, nByte);
sl@0:   sqlite3_mutex_enter(mem0.mutex);
sl@0:   mem0.alarmBusy = 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Do a memory allocation with statistics and alarms.  Assume the
sl@0: ** lock is already held.
sl@0: */
sl@0: static int mallocWithAlarm(int n, void **pp){
sl@0:   int nFull;
sl@0:   void *p;
sl@0:   assert( sqlite3_mutex_held(mem0.mutex) );
sl@0:   nFull = sqlite3GlobalConfig.m.xRoundup(n);
sl@0:   sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
sl@0:   if( mem0.alarmCallback!=0 ){
sl@0:     int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
sl@0:     if( nUsed+nFull >= mem0.alarmThreshold ){
sl@0:       sqlite3MallocAlarm(nFull);
sl@0:     }
sl@0:   }
sl@0:   p = sqlite3GlobalConfig.m.xMalloc(nFull);
sl@0:   if( p==0 && mem0.alarmCallback ){
sl@0:     sqlite3MallocAlarm(nFull);
sl@0:     p = sqlite3GlobalConfig.m.xMalloc(nFull);
sl@0:   }
sl@0:   if( p ){
sl@0:     nFull = sqlite3MallocSize(p);
sl@0:     sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
sl@0:   }
sl@0:   *pp = p;
sl@0:   return nFull;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate memory.  This routine is like sqlite3_malloc() except that it
sl@0: ** assumes the memory subsystem has already been initialized.
sl@0: */
sl@0: void *sqlite3Malloc(int n){
sl@0:   void *p;
sl@0:   if( n<=0 ){
sl@0:     p = 0;
sl@0:   }else if( sqlite3GlobalConfig.bMemstat ){
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     mallocWithAlarm(n, &p);
sl@0:     sqlite3_mutex_leave(mem0.mutex);
sl@0:   }else{
sl@0:     p = sqlite3GlobalConfig.m.xMalloc(n);
sl@0:   }
sl@0:   return p;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This version of the memory allocation is for use by the application.
sl@0: ** First make sure the memory subsystem is initialized, then do the
sl@0: ** allocation.
sl@0: */
sl@0: void *sqlite3_malloc(int n){
sl@0: #ifndef SQLITE_OMIT_AUTOINIT
sl@0:   if( sqlite3_initialize() ) return 0;
sl@0: #endif
sl@0:   return sqlite3Malloc(n);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Each thread may only have a single outstanding allocation from
sl@0: ** xScratchMalloc().  We verify this constraint in the single-threaded
sl@0: ** case by setting scratchAllocOut to 1 when an allocation
sl@0: ** is outstanding clearing it when the allocation is freed.
sl@0: */
sl@0: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
sl@0: static int scratchAllocOut = 0;
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Allocate memory that is to be used and released right away.
sl@0: ** This routine is similar to alloca() in that it is not intended
sl@0: ** for situations where the memory might be held long-term.  This
sl@0: ** routine is intended to get memory to old large transient data
sl@0: ** structures that would not normally fit on the stack of an
sl@0: ** embedded processor.
sl@0: */
sl@0: void *sqlite3ScratchMalloc(int n){
sl@0:   void *p;
sl@0:   assert( n>0 );
sl@0: 
sl@0: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
sl@0:   /* Verify that no more than one scratch allocation per thread
sl@0:   ** is outstanding at one time.  (This is only checked in the
sl@0:   ** single-threaded case since checking in the multi-threaded case
sl@0:   ** would be much more complicated.) */
sl@0:   assert( scratchAllocOut==0 );
sl@0: #endif
sl@0: 
sl@0:   if( sqlite3GlobalConfig.szScratch<n ){
sl@0:     goto scratch_overflow;
sl@0:   }else{  
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     if( mem0.nScratchFree==0 ){
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0:       goto scratch_overflow;
sl@0:     }else{
sl@0:       int i;
sl@0:       i = mem0.aScratchFree[--mem0.nScratchFree];
sl@0:       i *= sqlite3GlobalConfig.szScratch;
sl@0:       sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
sl@0:       sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0:       p = (void*)&((char*)sqlite3GlobalConfig.pScratch)[i];
sl@0:     }
sl@0:   }
sl@0: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
sl@0:   scratchAllocOut = p!=0;
sl@0: #endif
sl@0: 
sl@0:   return p;
sl@0: 
sl@0: scratch_overflow:
sl@0:   if( sqlite3GlobalConfig.bMemstat ){
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
sl@0:     n = mallocWithAlarm(n, &p);
sl@0:     if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
sl@0:     sqlite3_mutex_leave(mem0.mutex);
sl@0:   }else{
sl@0:     p = sqlite3GlobalConfig.m.xMalloc(n);
sl@0:   }
sl@0: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
sl@0:   scratchAllocOut = p!=0;
sl@0: #endif
sl@0:   return p;    
sl@0: }
sl@0: void sqlite3ScratchFree(void *p){
sl@0:   if( p ){
sl@0: 
sl@0: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
sl@0:     /* Verify that no more than one scratch allocation per thread
sl@0:     ** is outstanding at one time.  (This is only checked in the
sl@0:     ** single-threaded case since checking in the multi-threaded case
sl@0:     ** would be much more complicated.) */
sl@0:     assert( scratchAllocOut==1 );
sl@0:     scratchAllocOut = 0;
sl@0: #endif
sl@0: 
sl@0:     if( sqlite3GlobalConfig.pScratch==0
sl@0:            || p<sqlite3GlobalConfig.pScratch
sl@0:            || p>=(void*)mem0.aScratchFree ){
sl@0:       if( sqlite3GlobalConfig.bMemstat ){
sl@0:         int iSize = sqlite3MallocSize(p);
sl@0:         sqlite3_mutex_enter(mem0.mutex);
sl@0:         sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
sl@0:         sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
sl@0:         sqlite3GlobalConfig.m.xFree(p);
sl@0:         sqlite3_mutex_leave(mem0.mutex);
sl@0:       }else{
sl@0:         sqlite3GlobalConfig.m.xFree(p);
sl@0:       }
sl@0:     }else{
sl@0:       int i;
sl@0:       i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pScratch;
sl@0:       i /= sqlite3GlobalConfig.szScratch;
sl@0:       assert( i>=0 && i<sqlite3GlobalConfig.nScratch );
sl@0:       sqlite3_mutex_enter(mem0.mutex);
sl@0:       assert( mem0.nScratchFree<sqlite3GlobalConfig.nScratch );
sl@0:       mem0.aScratchFree[mem0.nScratchFree++] = i;
sl@0:       sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0:     }
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate memory to be used by the page cache.  Make use of the
sl@0: ** memory buffer provided by SQLITE_CONFIG_PAGECACHE if there is one
sl@0: ** and that memory is of the right size and is not completely
sl@0: ** consumed.  Otherwise, failover to sqlite3Malloc().
sl@0: */
sl@0: #if 0
sl@0: void *sqlite3PageMalloc(int n){
sl@0:   void *p;
sl@0:   assert( n>0 );
sl@0:   assert( (n & (n-1))==0 );
sl@0:   assert( n>=512 && n<=32768 );
sl@0: 
sl@0:   if( sqlite3GlobalConfig.szPage<n ){
sl@0:     goto page_overflow;
sl@0:   }else{  
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     if( mem0.nPageFree==0 ){
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0:       goto page_overflow;
sl@0:     }else{
sl@0:       int i;
sl@0:       i = mem0.aPageFree[--mem0.nPageFree];
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0:       i *= sqlite3GlobalConfig.szPage;
sl@0:       sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
sl@0:       sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
sl@0:       p = (void*)&((char*)sqlite3GlobalConfig.pPage)[i];
sl@0:     }
sl@0:   }
sl@0:   return p;
sl@0: 
sl@0: page_overflow:
sl@0:   if( sqlite3GlobalConfig.bMemstat ){
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
sl@0:     n = mallocWithAlarm(n, &p);
sl@0:     if( p ) sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, n);
sl@0:     sqlite3_mutex_leave(mem0.mutex);
sl@0:   }else{
sl@0:     p = sqlite3GlobalConfig.m.xMalloc(n);
sl@0:   }
sl@0:   return p;    
sl@0: }
sl@0: void sqlite3PageFree(void *p){
sl@0:   if( p ){
sl@0:     if( sqlite3GlobalConfig.pPage==0
sl@0:            || p<sqlite3GlobalConfig.pPage
sl@0:            || p>=(void*)mem0.aPageFree ){
sl@0:       /* In this case, the page allocation was obtained from a regular 
sl@0:       ** call to sqlite3_mem_methods.xMalloc() (a page-cache-memory 
sl@0:       ** "overflow"). Free the block with sqlite3_mem_methods.xFree().
sl@0:       */
sl@0:       if( sqlite3GlobalConfig.bMemstat ){
sl@0:         int iSize = sqlite3MallocSize(p);
sl@0:         sqlite3_mutex_enter(mem0.mutex);
sl@0:         sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);
sl@0:         sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
sl@0:         sqlite3GlobalConfig.m.xFree(p);
sl@0:         sqlite3_mutex_leave(mem0.mutex);
sl@0:       }else{
sl@0:         sqlite3GlobalConfig.m.xFree(p);
sl@0:       }
sl@0:     }else{
sl@0:       /* The page allocation was allocated from the sqlite3GlobalConfig.pPage
sl@0:       ** buffer. In this case all that is add the index of the page in
sl@0:       ** the sqlite3GlobalConfig.pPage array to the set of free indexes stored
sl@0:       ** in the mem0.aPageFree[] array.
sl@0:       */
sl@0:       int i;
sl@0:       i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pPage;
sl@0:       i /= sqlite3GlobalConfig.szPage;
sl@0:       assert( i>=0 && i<sqlite3GlobalConfig.nPage );
sl@0:       sqlite3_mutex_enter(mem0.mutex);
sl@0:       assert( mem0.nPageFree<sqlite3GlobalConfig.nPage );
sl@0:       mem0.aPageFree[mem0.nPageFree++] = i;
sl@0:       sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
sl@0:       sqlite3_mutex_leave(mem0.mutex);
sl@0: #if !defined(NDEBUG) && 0
sl@0:       /* Assert that a duplicate was not just inserted into aPageFree[]. */
sl@0:       for(i=0; i<mem0.nPageFree-1; i++){
sl@0:         assert( mem0.aPageFree[i]!=mem0.aPageFree[mem0.nPageFree-1] );
sl@0:       }
sl@0: #endif
sl@0:     }
sl@0:   }
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** TRUE if p is a lookaside memory allocation from db
sl@0: */
sl@0: #ifndef SQLITE_OMIT_LOOKASIDE
sl@0: static int isLookaside(sqlite3 *db, void *p){
sl@0:   return db && p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
sl@0: }
sl@0: #else
sl@0: #define isLookaside(A,B) 0
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Return the size of a memory allocation previously obtained from
sl@0: ** sqlite3Malloc() or sqlite3_malloc().
sl@0: */
sl@0: int sqlite3MallocSize(void *p){
sl@0:   return sqlite3GlobalConfig.m.xSize(p);
sl@0: }
sl@0: int sqlite3DbMallocSize(sqlite3 *db, void *p){
sl@0:   if( isLookaside(db, p) ){
sl@0:     return db->lookaside.sz;
sl@0:   }else{
sl@0:     return sqlite3GlobalConfig.m.xSize(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Free memory previously obtained from sqlite3Malloc().
sl@0: */
sl@0: void sqlite3_free(void *p){
sl@0:   if( p==0 ) return;
sl@0:   if( sqlite3GlobalConfig.bMemstat ){
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
sl@0:     sqlite3GlobalConfig.m.xFree(p);
sl@0:     sqlite3_mutex_leave(mem0.mutex);
sl@0:   }else{
sl@0:     sqlite3GlobalConfig.m.xFree(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Free memory that might be associated with a particular database
sl@0: ** connection.
sl@0: */
sl@0: void sqlite3DbFree(sqlite3 *db, void *p){
sl@0:   if( isLookaside(db, p) ){
sl@0:     LookasideSlot *pBuf = (LookasideSlot*)p;
sl@0:     pBuf->pNext = db->lookaside.pFree;
sl@0:     db->lookaside.pFree = pBuf;
sl@0:     db->lookaside.nOut--;
sl@0:   }else{
sl@0:     sqlite3_free(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Change the size of an existing memory allocation
sl@0: */
sl@0: void *sqlite3Realloc(void *pOld, int nBytes){
sl@0:   int nOld, nNew;
sl@0:   void *pNew;
sl@0:   if( pOld==0 ){
sl@0:     return sqlite3Malloc(nBytes);
sl@0:   }
sl@0:   if( nBytes<=0 ){
sl@0:     sqlite3_free(pOld);
sl@0:     return 0;
sl@0:   }
sl@0:   nOld = sqlite3MallocSize(pOld);
sl@0:   if( sqlite3GlobalConfig.bMemstat ){
sl@0:     sqlite3_mutex_enter(mem0.mutex);
sl@0:     sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
sl@0:     nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
sl@0:     if( nOld==nNew ){
sl@0:       pNew = pOld;
sl@0:     }else{
sl@0:       if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nNew-nOld >= 
sl@0:             mem0.alarmThreshold ){
sl@0:         sqlite3MallocAlarm(nNew-nOld);
sl@0:       }
sl@0:       pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
sl@0:       if( pNew==0 && mem0.alarmCallback ){
sl@0:         sqlite3MallocAlarm(nBytes);
sl@0:         pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
sl@0:       }
sl@0:       if( pNew ){
sl@0:         nNew = sqlite3MallocSize(pNew);
sl@0:         sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
sl@0:       }
sl@0:     }
sl@0:     sqlite3_mutex_leave(mem0.mutex);
sl@0:   }else{
sl@0:     pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nBytes);
sl@0:   }
sl@0:   return pNew;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The public interface to sqlite3Realloc.  Make sure that the memory
sl@0: ** subsystem is initialized prior to invoking sqliteRealloc.
sl@0: */
sl@0: void *sqlite3_realloc(void *pOld, int n){
sl@0: #ifndef SQLITE_OMIT_AUTOINIT
sl@0:   if( sqlite3_initialize() ) return 0;
sl@0: #endif
sl@0:   return sqlite3Realloc(pOld, n);
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Allocate and zero memory.
sl@0: */ 
sl@0: void *sqlite3MallocZero(int n){
sl@0:   void *p = sqlite3Malloc(n);
sl@0:   if( p ){
sl@0:     memset(p, 0, n);
sl@0:   }
sl@0:   return p;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate and zero memory.  If the allocation fails, make
sl@0: ** the mallocFailed flag in the connection pointer.
sl@0: */
sl@0: void *sqlite3DbMallocZero(sqlite3 *db, int n){
sl@0:   void *p = sqlite3DbMallocRaw(db, n);
sl@0:   if( p ){
sl@0:     memset(p, 0, n);
sl@0:   }
sl@0:   return p;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate and zero memory.  If the allocation fails, make
sl@0: ** the mallocFailed flag in the connection pointer.
sl@0: **
sl@0: ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
sl@0: ** failure on the same database connection) then always return 0.
sl@0: ** Hence for a particular database connection, once malloc starts
sl@0: ** failing, it fails consistently until mallocFailed is reset.
sl@0: ** This is an important assumption.  There are many places in the
sl@0: ** code that do things like this:
sl@0: **
sl@0: **         int *a = (int*)sqlite3DbMallocRaw(db, 100);
sl@0: **         int *b = (int*)sqlite3DbMallocRaw(db, 200);
sl@0: **         if( b ) a[10] = 9;
sl@0: **
sl@0: ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
sl@0: ** that all prior mallocs (ex: "a") worked too.
sl@0: */
sl@0: void *sqlite3DbMallocRaw(sqlite3 *db, int n){
sl@0:   void *p;
sl@0: #ifndef SQLITE_OMIT_LOOKASIDE
sl@0:   if( db ){
sl@0:     LookasideSlot *pBuf;
sl@0:     if( db->mallocFailed ){
sl@0:       return 0;
sl@0:     }
sl@0:     if( db->lookaside.bEnabled && n<=db->lookaside.sz
sl@0:          && (pBuf = db->lookaside.pFree)!=0 ){
sl@0:       db->lookaside.pFree = pBuf->pNext;
sl@0:       db->lookaside.nOut++;
sl@0:       if( db->lookaside.nOut>db->lookaside.mxOut ){
sl@0:         db->lookaside.mxOut = db->lookaside.nOut;
sl@0:       }
sl@0:       return (void*)pBuf;
sl@0:     }
sl@0:   }
sl@0: #else
sl@0:   if( db && db->mallocFailed ){
sl@0:     return 0;
sl@0:   }
sl@0: #endif
sl@0:   p = sqlite3Malloc(n);
sl@0:   if( !p && db ){
sl@0:     db->mallocFailed = 1;
sl@0:   }
sl@0:   return p;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Resize the block of memory pointed to by p to n bytes. If the
sl@0: ** resize fails, set the mallocFailed flag in the connection object.
sl@0: */
sl@0: void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
sl@0:   void *pNew = 0;
sl@0:   if( db->mallocFailed==0 ){
sl@0:     if( p==0 ){
sl@0:       return sqlite3DbMallocRaw(db, n);
sl@0:     }
sl@0:     if( isLookaside(db, p) ){
sl@0:       if( n<=db->lookaside.sz ){
sl@0:         return p;
sl@0:       }
sl@0:       pNew = sqlite3DbMallocRaw(db, n);
sl@0:       if( pNew ){
sl@0:         memcpy(pNew, p, db->lookaside.sz);
sl@0:         sqlite3DbFree(db, p);
sl@0:       }
sl@0:     }else{
sl@0:       pNew = sqlite3_realloc(p, n);
sl@0:       if( !pNew ){
sl@0:         db->mallocFailed = 1;
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   return pNew;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Attempt to reallocate p.  If the reallocation fails, then free p
sl@0: ** and set the mallocFailed flag in the database connection.
sl@0: */
sl@0: void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
sl@0:   void *pNew;
sl@0:   pNew = sqlite3DbRealloc(db, p, n);
sl@0:   if( !pNew ){
sl@0:     sqlite3DbFree(db, p);
sl@0:   }
sl@0:   return pNew;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Make a copy of a string in memory obtained from sqliteMalloc(). These 
sl@0: ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
sl@0: ** is because when memory debugging is turned on, these two functions are 
sl@0: ** called via macros that record the current file and line number in the
sl@0: ** ThreadData structure.
sl@0: */
sl@0: char *sqlite3DbStrDup(sqlite3 *db, const char *z){
sl@0:   char *zNew;
sl@0:   size_t n;
sl@0:   if( z==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   n = strlen(z)+1;
sl@0:   assert( (n&0x7fffffff)==n );
sl@0:   zNew = sqlite3DbMallocRaw(db, (int)n);
sl@0:   if( zNew ){
sl@0:     memcpy(zNew, z, n);
sl@0:   }
sl@0:   return zNew;
sl@0: }
sl@0: char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
sl@0:   char *zNew;
sl@0:   if( z==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   assert( (n&0x7fffffff)==n );
sl@0:   zNew = sqlite3DbMallocRaw(db, n+1);
sl@0:   if( zNew ){
sl@0:     memcpy(zNew, z, n);
sl@0:     zNew[n] = 0;
sl@0:   }
sl@0:   return zNew;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Create a string from the zFromat argument and the va_list that follows.
sl@0: ** Store the string in memory obtained from sqliteMalloc() and make *pz
sl@0: ** point to that string.
sl@0: */
sl@0: void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
sl@0:   va_list ap;
sl@0:   char *z;
sl@0: 
sl@0:   va_start(ap, zFormat);
sl@0:   z = sqlite3VMPrintf(db, zFormat, ap);
sl@0:   va_end(ap);
sl@0:   sqlite3DbFree(db, *pz);
sl@0:   *pz = z;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This function must be called before exiting any API function (i.e. 
sl@0: ** returning control to the user) that has called sqlite3_malloc or
sl@0: ** sqlite3_realloc.
sl@0: **
sl@0: ** The returned value is normally a copy of the second argument to this
sl@0: ** function. However, if a malloc() failure has occured since the previous
sl@0: ** invocation SQLITE_NOMEM is returned instead. 
sl@0: **
sl@0: ** If the first argument, db, is not NULL and a malloc() error has occured,
sl@0: ** then the connection error-code (the value returned by sqlite3_errcode())
sl@0: ** is set to SQLITE_NOMEM.
sl@0: */
sl@0: int sqlite3ApiExit(sqlite3* db, int rc){
sl@0:   /* If the db handle is not NULL, then we must hold the connection handle
sl@0:   ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 
sl@0:   ** is unsafe, as is the call to sqlite3Error().
sl@0:   */
sl@0:   assert( !db || sqlite3_mutex_held(db->mutex) );
sl@0:   if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
sl@0:     sqlite3Error(db, SQLITE_NOMEM, 0);
sl@0:     db->mallocFailed = 0;
sl@0:     rc = SQLITE_NOMEM;
sl@0:   }
sl@0:   return rc & (db ? db->errMask : 0xff);
sl@0: }