1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite364/malloc.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,789 @@
1.4 +/*
1.5 +** 2001 September 15
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** Memory allocation functions used throughout sqlite.
1.17 +**
1.18 +** $Id: malloc.c,v 1.45 2008/10/12 00:27:53 shane Exp $
1.19 +*/
1.20 +#include "sqliteInt.h"
1.21 +#include <stdarg.h>
1.22 +#include <ctype.h>
1.23 +
1.24 +/*
1.25 +** This routine runs when the memory allocator sees that the
1.26 +** total memory allocation is about to exceed the soft heap
1.27 +** limit.
1.28 +*/
1.29 +static void softHeapLimitEnforcer(
1.30 + void *NotUsed,
1.31 + sqlite3_int64 inUse,
1.32 + int allocSize
1.33 +){
1.34 + sqlite3_release_memory(allocSize);
1.35 +}
1.36 +
1.37 +/*
1.38 +** Set the soft heap-size limit for the library. Passing a zero or
1.39 +** negative value indicates no limit.
1.40 +*/
1.41 +void sqlite3_soft_heap_limit(int n){
1.42 + sqlite3_uint64 iLimit;
1.43 + int overage;
1.44 + if( n<0 ){
1.45 + iLimit = 0;
1.46 + }else{
1.47 + iLimit = n;
1.48 + }
1.49 + sqlite3_initialize();
1.50 + if( iLimit>0 ){
1.51 + sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, iLimit);
1.52 + }else{
1.53 + sqlite3MemoryAlarm(0, 0, 0);
1.54 + }
1.55 + overage = sqlite3_memory_used() - n;
1.56 + if( overage>0 ){
1.57 + sqlite3_release_memory(overage);
1.58 + }
1.59 +}
1.60 +
1.61 +/*
1.62 +** Attempt to release up to n bytes of non-essential memory currently
1.63 +** held by SQLite. An example of non-essential memory is memory used to
1.64 +** cache database pages that are not currently in use.
1.65 +*/
1.66 +int sqlite3_release_memory(int n){
1.67 +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
1.68 + int nRet = 0;
1.69 +#if 0
1.70 + nRet += sqlite3VdbeReleaseMemory(n);
1.71 +#endif
1.72 + nRet += sqlite3PcacheReleaseMemory(n-nRet);
1.73 + return nRet;
1.74 +#else
1.75 + return SQLITE_OK;
1.76 +#endif
1.77 +}
1.78 +
1.79 +/*
1.80 +** State information local to the memory allocation subsystem.
1.81 +*/
1.82 +static SQLITE_WSD struct Mem0Global {
1.83 + /* Number of free pages for scratch and page-cache memory */
1.84 + u32 nScratchFree;
1.85 + u32 nPageFree;
1.86 +
1.87 + sqlite3_mutex *mutex; /* Mutex to serialize access */
1.88 +
1.89 + /*
1.90 + ** The alarm callback and its arguments. The mem0.mutex lock will
1.91 + ** be held while the callback is running. Recursive calls into
1.92 + ** the memory subsystem are allowed, but no new callbacks will be
1.93 + ** issued. The alarmBusy variable is set to prevent recursive
1.94 + ** callbacks.
1.95 + */
1.96 + sqlite3_int64 alarmThreshold;
1.97 + void (*alarmCallback)(void*, sqlite3_int64,int);
1.98 + void *alarmArg;
1.99 + int alarmBusy;
1.100 +
1.101 + /*
1.102 + ** Pointers to the end of sqlite3GlobalConfig.pScratch and
1.103 + ** sqlite3GlobalConfig.pPage to a block of memory that records
1.104 + ** which pages are available.
1.105 + */
1.106 + u32 *aScratchFree;
1.107 + u32 *aPageFree;
1.108 +} mem0 = { 62560955 };
1.109 +
1.110 +#define mem0 GLOBAL(struct Mem0Global, mem0)
1.111 +
1.112 +/*
1.113 +** Initialize the memory allocation subsystem.
1.114 +*/
1.115 +int sqlite3MallocInit(void){
1.116 + if( sqlite3GlobalConfig.m.xMalloc==0 ){
1.117 + sqlite3MemSetDefault();
1.118 + }
1.119 + memset(&mem0, 0, sizeof(mem0));
1.120 + if( sqlite3GlobalConfig.bCoreMutex ){
1.121 + mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
1.122 + }
1.123 + if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
1.124 + && sqlite3GlobalConfig.nScratch>=0 ){
1.125 + int i;
1.126 + sqlite3GlobalConfig.szScratch -= 4;
1.127 + mem0.aScratchFree = (u32*)&((char*)sqlite3GlobalConfig.pScratch)
1.128 + [sqlite3GlobalConfig.szScratch*sqlite3GlobalConfig.nScratch];
1.129 + for(i=0; i<sqlite3GlobalConfig.nScratch; i++){ mem0.aScratchFree[i] = i; }
1.130 + mem0.nScratchFree = sqlite3GlobalConfig.nScratch;
1.131 + }else{
1.132 + sqlite3GlobalConfig.pScratch = 0;
1.133 + sqlite3GlobalConfig.szScratch = 0;
1.134 + }
1.135 + if( sqlite3GlobalConfig.pPage && sqlite3GlobalConfig.szPage>=512
1.136 + && sqlite3GlobalConfig.nPage>=1 ){
1.137 + int i;
1.138 + int overhead;
1.139 + int sz = sqlite3GlobalConfig.szPage;
1.140 + int n = sqlite3GlobalConfig.nPage;
1.141 + overhead = (4*n + sz - 1)/sz;
1.142 + sqlite3GlobalConfig.nPage -= overhead;
1.143 + mem0.aPageFree = (u32*)&((char*)sqlite3GlobalConfig.pPage)
1.144 + [sqlite3GlobalConfig.szPage*sqlite3GlobalConfig.nPage];
1.145 + for(i=0; i<sqlite3GlobalConfig.nPage; i++){ mem0.aPageFree[i] = i; }
1.146 + mem0.nPageFree = sqlite3GlobalConfig.nPage;
1.147 + }else{
1.148 + sqlite3GlobalConfig.pPage = 0;
1.149 + sqlite3GlobalConfig.szPage = 0;
1.150 + }
1.151 + return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
1.152 +}
1.153 +
1.154 +/*
1.155 +** Deinitialize the memory allocation subsystem.
1.156 +*/
1.157 +void sqlite3MallocEnd(void){
1.158 + if( sqlite3GlobalConfig.m.xShutdown ){
1.159 + sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
1.160 + }
1.161 + memset(&mem0, 0, sizeof(mem0));
1.162 +}
1.163 +
1.164 +/*
1.165 +** Return the amount of memory currently checked out.
1.166 +*/
1.167 +sqlite3_int64 sqlite3_memory_used(void){
1.168 + int n, mx;
1.169 + sqlite3_int64 res;
1.170 + sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
1.171 + res = (sqlite3_int64)n; /* Work around bug in Borland C. Ticket #3216 */
1.172 + return res;
1.173 +}
1.174 +
1.175 +/*
1.176 +** Return the maximum amount of memory that has ever been
1.177 +** checked out since either the beginning of this process
1.178 +** or since the most recent reset.
1.179 +*/
1.180 +sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
1.181 + int n, mx;
1.182 + sqlite3_int64 res;
1.183 + sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
1.184 + res = (sqlite3_int64)mx; /* Work around bug in Borland C. Ticket #3216 */
1.185 + return res;
1.186 +}
1.187 +
1.188 +/*
1.189 +** Change the alarm callback
1.190 +*/
1.191 +int sqlite3MemoryAlarm(
1.192 + void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
1.193 + void *pArg,
1.194 + sqlite3_int64 iThreshold
1.195 +){
1.196 + sqlite3_mutex_enter(mem0.mutex);
1.197 + mem0.alarmCallback = xCallback;
1.198 + mem0.alarmArg = pArg;
1.199 + mem0.alarmThreshold = iThreshold;
1.200 + sqlite3_mutex_leave(mem0.mutex);
1.201 + return SQLITE_OK;
1.202 +}
1.203 +
1.204 +#ifndef SQLITE_OMIT_DEPRECATED
1.205 +/*
1.206 +** Deprecated external interface. Internal/core SQLite code
1.207 +** should call sqlite3MemoryAlarm.
1.208 +*/
1.209 +int sqlite3_memory_alarm(
1.210 + void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
1.211 + void *pArg,
1.212 + sqlite3_int64 iThreshold
1.213 +){
1.214 + return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
1.215 +}
1.216 +#endif
1.217 +
1.218 +/*
1.219 +** Trigger the alarm
1.220 +*/
1.221 +static void sqlite3MallocAlarm(int nByte){
1.222 + void (*xCallback)(void*,sqlite3_int64,int);
1.223 + sqlite3_int64 nowUsed;
1.224 + void *pArg;
1.225 + if( mem0.alarmCallback==0 || mem0.alarmBusy ) return;
1.226 + mem0.alarmBusy = 1;
1.227 + xCallback = mem0.alarmCallback;
1.228 + nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
1.229 + pArg = mem0.alarmArg;
1.230 + sqlite3_mutex_leave(mem0.mutex);
1.231 + xCallback(pArg, nowUsed, nByte);
1.232 + sqlite3_mutex_enter(mem0.mutex);
1.233 + mem0.alarmBusy = 0;
1.234 +}
1.235 +
1.236 +/*
1.237 +** Do a memory allocation with statistics and alarms. Assume the
1.238 +** lock is already held.
1.239 +*/
1.240 +static int mallocWithAlarm(int n, void **pp){
1.241 + int nFull;
1.242 + void *p;
1.243 + assert( sqlite3_mutex_held(mem0.mutex) );
1.244 + nFull = sqlite3GlobalConfig.m.xRoundup(n);
1.245 + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
1.246 + if( mem0.alarmCallback!=0 ){
1.247 + int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
1.248 + if( nUsed+nFull >= mem0.alarmThreshold ){
1.249 + sqlite3MallocAlarm(nFull);
1.250 + }
1.251 + }
1.252 + p = sqlite3GlobalConfig.m.xMalloc(nFull);
1.253 + if( p==0 && mem0.alarmCallback ){
1.254 + sqlite3MallocAlarm(nFull);
1.255 + p = sqlite3GlobalConfig.m.xMalloc(nFull);
1.256 + }
1.257 + if( p ){
1.258 + nFull = sqlite3MallocSize(p);
1.259 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
1.260 + }
1.261 + *pp = p;
1.262 + return nFull;
1.263 +}
1.264 +
1.265 +/*
1.266 +** Allocate memory. This routine is like sqlite3_malloc() except that it
1.267 +** assumes the memory subsystem has already been initialized.
1.268 +*/
1.269 +void *sqlite3Malloc(int n){
1.270 + void *p;
1.271 + if( n<=0 ){
1.272 + p = 0;
1.273 + }else if( sqlite3GlobalConfig.bMemstat ){
1.274 + sqlite3_mutex_enter(mem0.mutex);
1.275 + mallocWithAlarm(n, &p);
1.276 + sqlite3_mutex_leave(mem0.mutex);
1.277 + }else{
1.278 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.279 + }
1.280 + return p;
1.281 +}
1.282 +
1.283 +/*
1.284 +** This version of the memory allocation is for use by the application.
1.285 +** First make sure the memory subsystem is initialized, then do the
1.286 +** allocation.
1.287 +*/
1.288 +void *sqlite3_malloc(int n){
1.289 +#ifndef SQLITE_OMIT_AUTOINIT
1.290 + if( sqlite3_initialize() ) return 0;
1.291 +#endif
1.292 + return sqlite3Malloc(n);
1.293 +}
1.294 +
1.295 +/*
1.296 +** Each thread may only have a single outstanding allocation from
1.297 +** xScratchMalloc(). We verify this constraint in the single-threaded
1.298 +** case by setting scratchAllocOut to 1 when an allocation
1.299 +** is outstanding clearing it when the allocation is freed.
1.300 +*/
1.301 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.302 +static int scratchAllocOut = 0;
1.303 +#endif
1.304 +
1.305 +
1.306 +/*
1.307 +** Allocate memory that is to be used and released right away.
1.308 +** This routine is similar to alloca() in that it is not intended
1.309 +** for situations where the memory might be held long-term. This
1.310 +** routine is intended to get memory to old large transient data
1.311 +** structures that would not normally fit on the stack of an
1.312 +** embedded processor.
1.313 +*/
1.314 +void *sqlite3ScratchMalloc(int n){
1.315 + void *p;
1.316 + assert( n>0 );
1.317 +
1.318 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.319 + /* Verify that no more than one scratch allocation per thread
1.320 + ** is outstanding at one time. (This is only checked in the
1.321 + ** single-threaded case since checking in the multi-threaded case
1.322 + ** would be much more complicated.) */
1.323 + assert( scratchAllocOut==0 );
1.324 +#endif
1.325 +
1.326 + if( sqlite3GlobalConfig.szScratch<n ){
1.327 + goto scratch_overflow;
1.328 + }else{
1.329 + sqlite3_mutex_enter(mem0.mutex);
1.330 + if( mem0.nScratchFree==0 ){
1.331 + sqlite3_mutex_leave(mem0.mutex);
1.332 + goto scratch_overflow;
1.333 + }else{
1.334 + int i;
1.335 + i = mem0.aScratchFree[--mem0.nScratchFree];
1.336 + i *= sqlite3GlobalConfig.szScratch;
1.337 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
1.338 + sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
1.339 + sqlite3_mutex_leave(mem0.mutex);
1.340 + p = (void*)&((char*)sqlite3GlobalConfig.pScratch)[i];
1.341 + }
1.342 + }
1.343 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.344 + scratchAllocOut = p!=0;
1.345 +#endif
1.346 +
1.347 + return p;
1.348 +
1.349 +scratch_overflow:
1.350 + if( sqlite3GlobalConfig.bMemstat ){
1.351 + sqlite3_mutex_enter(mem0.mutex);
1.352 + sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
1.353 + n = mallocWithAlarm(n, &p);
1.354 + if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
1.355 + sqlite3_mutex_leave(mem0.mutex);
1.356 + }else{
1.357 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.358 + }
1.359 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.360 + scratchAllocOut = p!=0;
1.361 +#endif
1.362 + return p;
1.363 +}
1.364 +void sqlite3ScratchFree(void *p){
1.365 + if( p ){
1.366 +
1.367 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.368 + /* Verify that no more than one scratch allocation per thread
1.369 + ** is outstanding at one time. (This is only checked in the
1.370 + ** single-threaded case since checking in the multi-threaded case
1.371 + ** would be much more complicated.) */
1.372 + assert( scratchAllocOut==1 );
1.373 + scratchAllocOut = 0;
1.374 +#endif
1.375 +
1.376 + if( sqlite3GlobalConfig.pScratch==0
1.377 + || p<sqlite3GlobalConfig.pScratch
1.378 + || p>=(void*)mem0.aScratchFree ){
1.379 + if( sqlite3GlobalConfig.bMemstat ){
1.380 + int iSize = sqlite3MallocSize(p);
1.381 + sqlite3_mutex_enter(mem0.mutex);
1.382 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
1.383 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
1.384 + sqlite3GlobalConfig.m.xFree(p);
1.385 + sqlite3_mutex_leave(mem0.mutex);
1.386 + }else{
1.387 + sqlite3GlobalConfig.m.xFree(p);
1.388 + }
1.389 + }else{
1.390 + int i;
1.391 + i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pScratch;
1.392 + i /= sqlite3GlobalConfig.szScratch;
1.393 + assert( i>=0 && i<sqlite3GlobalConfig.nScratch );
1.394 + sqlite3_mutex_enter(mem0.mutex);
1.395 + assert( mem0.nScratchFree<sqlite3GlobalConfig.nScratch );
1.396 + mem0.aScratchFree[mem0.nScratchFree++] = i;
1.397 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
1.398 + sqlite3_mutex_leave(mem0.mutex);
1.399 + }
1.400 + }
1.401 +}
1.402 +
1.403 +/*
1.404 +** Allocate memory to be used by the page cache. Make use of the
1.405 +** memory buffer provided by SQLITE_CONFIG_PAGECACHE if there is one
1.406 +** and that memory is of the right size and is not completely
1.407 +** consumed. Otherwise, failover to sqlite3Malloc().
1.408 +*/
1.409 +#if 0
1.410 +void *sqlite3PageMalloc(int n){
1.411 + void *p;
1.412 + assert( n>0 );
1.413 + assert( (n & (n-1))==0 );
1.414 + assert( n>=512 && n<=32768 );
1.415 +
1.416 + if( sqlite3GlobalConfig.szPage<n ){
1.417 + goto page_overflow;
1.418 + }else{
1.419 + sqlite3_mutex_enter(mem0.mutex);
1.420 + if( mem0.nPageFree==0 ){
1.421 + sqlite3_mutex_leave(mem0.mutex);
1.422 + goto page_overflow;
1.423 + }else{
1.424 + int i;
1.425 + i = mem0.aPageFree[--mem0.nPageFree];
1.426 + sqlite3_mutex_leave(mem0.mutex);
1.427 + i *= sqlite3GlobalConfig.szPage;
1.428 + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
1.429 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
1.430 + p = (void*)&((char*)sqlite3GlobalConfig.pPage)[i];
1.431 + }
1.432 + }
1.433 + return p;
1.434 +
1.435 +page_overflow:
1.436 + if( sqlite3GlobalConfig.bMemstat ){
1.437 + sqlite3_mutex_enter(mem0.mutex);
1.438 + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
1.439 + n = mallocWithAlarm(n, &p);
1.440 + if( p ) sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, n);
1.441 + sqlite3_mutex_leave(mem0.mutex);
1.442 + }else{
1.443 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.444 + }
1.445 + return p;
1.446 +}
1.447 +void sqlite3PageFree(void *p){
1.448 + if( p ){
1.449 + if( sqlite3GlobalConfig.pPage==0
1.450 + || p<sqlite3GlobalConfig.pPage
1.451 + || p>=(void*)mem0.aPageFree ){
1.452 + /* In this case, the page allocation was obtained from a regular
1.453 + ** call to sqlite3_mem_methods.xMalloc() (a page-cache-memory
1.454 + ** "overflow"). Free the block with sqlite3_mem_methods.xFree().
1.455 + */
1.456 + if( sqlite3GlobalConfig.bMemstat ){
1.457 + int iSize = sqlite3MallocSize(p);
1.458 + sqlite3_mutex_enter(mem0.mutex);
1.459 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);
1.460 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
1.461 + sqlite3GlobalConfig.m.xFree(p);
1.462 + sqlite3_mutex_leave(mem0.mutex);
1.463 + }else{
1.464 + sqlite3GlobalConfig.m.xFree(p);
1.465 + }
1.466 + }else{
1.467 + /* The page allocation was allocated from the sqlite3GlobalConfig.pPage
1.468 + ** buffer. In this case all that is add the index of the page in
1.469 + ** the sqlite3GlobalConfig.pPage array to the set of free indexes stored
1.470 + ** in the mem0.aPageFree[] array.
1.471 + */
1.472 + int i;
1.473 + i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pPage;
1.474 + i /= sqlite3GlobalConfig.szPage;
1.475 + assert( i>=0 && i<sqlite3GlobalConfig.nPage );
1.476 + sqlite3_mutex_enter(mem0.mutex);
1.477 + assert( mem0.nPageFree<sqlite3GlobalConfig.nPage );
1.478 + mem0.aPageFree[mem0.nPageFree++] = i;
1.479 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
1.480 + sqlite3_mutex_leave(mem0.mutex);
1.481 +#if !defined(NDEBUG) && 0
1.482 + /* Assert that a duplicate was not just inserted into aPageFree[]. */
1.483 + for(i=0; i<mem0.nPageFree-1; i++){
1.484 + assert( mem0.aPageFree[i]!=mem0.aPageFree[mem0.nPageFree-1] );
1.485 + }
1.486 +#endif
1.487 + }
1.488 + }
1.489 +}
1.490 +#endif
1.491 +
1.492 +/*
1.493 +** TRUE if p is a lookaside memory allocation from db
1.494 +*/
1.495 +#ifndef SQLITE_OMIT_LOOKASIDE
1.496 +static int isLookaside(sqlite3 *db, void *p){
1.497 + return db && p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
1.498 +}
1.499 +#else
1.500 +#define isLookaside(A,B) 0
1.501 +#endif
1.502 +
1.503 +/*
1.504 +** Return the size of a memory allocation previously obtained from
1.505 +** sqlite3Malloc() or sqlite3_malloc().
1.506 +*/
1.507 +int sqlite3MallocSize(void *p){
1.508 + return sqlite3GlobalConfig.m.xSize(p);
1.509 +}
1.510 +int sqlite3DbMallocSize(sqlite3 *db, void *p){
1.511 + if( isLookaside(db, p) ){
1.512 + return db->lookaside.sz;
1.513 + }else{
1.514 + return sqlite3GlobalConfig.m.xSize(p);
1.515 + }
1.516 +}
1.517 +
1.518 +/*
1.519 +** Free memory previously obtained from sqlite3Malloc().
1.520 +*/
1.521 +void sqlite3_free(void *p){
1.522 + if( p==0 ) return;
1.523 + if( sqlite3GlobalConfig.bMemstat ){
1.524 + sqlite3_mutex_enter(mem0.mutex);
1.525 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
1.526 + sqlite3GlobalConfig.m.xFree(p);
1.527 + sqlite3_mutex_leave(mem0.mutex);
1.528 + }else{
1.529 + sqlite3GlobalConfig.m.xFree(p);
1.530 + }
1.531 +}
1.532 +
1.533 +/*
1.534 +** Free memory that might be associated with a particular database
1.535 +** connection.
1.536 +*/
1.537 +void sqlite3DbFree(sqlite3 *db, void *p){
1.538 + if( isLookaside(db, p) ){
1.539 + LookasideSlot *pBuf = (LookasideSlot*)p;
1.540 + pBuf->pNext = db->lookaside.pFree;
1.541 + db->lookaside.pFree = pBuf;
1.542 + db->lookaside.nOut--;
1.543 + }else{
1.544 + sqlite3_free(p);
1.545 + }
1.546 +}
1.547 +
1.548 +/*
1.549 +** Change the size of an existing memory allocation
1.550 +*/
1.551 +void *sqlite3Realloc(void *pOld, int nBytes){
1.552 + int nOld, nNew;
1.553 + void *pNew;
1.554 + if( pOld==0 ){
1.555 + return sqlite3Malloc(nBytes);
1.556 + }
1.557 + if( nBytes<=0 ){
1.558 + sqlite3_free(pOld);
1.559 + return 0;
1.560 + }
1.561 + nOld = sqlite3MallocSize(pOld);
1.562 + if( sqlite3GlobalConfig.bMemstat ){
1.563 + sqlite3_mutex_enter(mem0.mutex);
1.564 + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
1.565 + nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
1.566 + if( nOld==nNew ){
1.567 + pNew = pOld;
1.568 + }else{
1.569 + if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nNew-nOld >=
1.570 + mem0.alarmThreshold ){
1.571 + sqlite3MallocAlarm(nNew-nOld);
1.572 + }
1.573 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
1.574 + if( pNew==0 && mem0.alarmCallback ){
1.575 + sqlite3MallocAlarm(nBytes);
1.576 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
1.577 + }
1.578 + if( pNew ){
1.579 + nNew = sqlite3MallocSize(pNew);
1.580 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
1.581 + }
1.582 + }
1.583 + sqlite3_mutex_leave(mem0.mutex);
1.584 + }else{
1.585 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nBytes);
1.586 + }
1.587 + return pNew;
1.588 +}
1.589 +
1.590 +/*
1.591 +** The public interface to sqlite3Realloc. Make sure that the memory
1.592 +** subsystem is initialized prior to invoking sqliteRealloc.
1.593 +*/
1.594 +void *sqlite3_realloc(void *pOld, int n){
1.595 +#ifndef SQLITE_OMIT_AUTOINIT
1.596 + if( sqlite3_initialize() ) return 0;
1.597 +#endif
1.598 + return sqlite3Realloc(pOld, n);
1.599 +}
1.600 +
1.601 +
1.602 +/*
1.603 +** Allocate and zero memory.
1.604 +*/
1.605 +void *sqlite3MallocZero(int n){
1.606 + void *p = sqlite3Malloc(n);
1.607 + if( p ){
1.608 + memset(p, 0, n);
1.609 + }
1.610 + return p;
1.611 +}
1.612 +
1.613 +/*
1.614 +** Allocate and zero memory. If the allocation fails, make
1.615 +** the mallocFailed flag in the connection pointer.
1.616 +*/
1.617 +void *sqlite3DbMallocZero(sqlite3 *db, int n){
1.618 + void *p = sqlite3DbMallocRaw(db, n);
1.619 + if( p ){
1.620 + memset(p, 0, n);
1.621 + }
1.622 + return p;
1.623 +}
1.624 +
1.625 +/*
1.626 +** Allocate and zero memory. If the allocation fails, make
1.627 +** the mallocFailed flag in the connection pointer.
1.628 +**
1.629 +** If db!=0 and db->mallocFailed is true (indicating a prior malloc
1.630 +** failure on the same database connection) then always return 0.
1.631 +** Hence for a particular database connection, once malloc starts
1.632 +** failing, it fails consistently until mallocFailed is reset.
1.633 +** This is an important assumption. There are many places in the
1.634 +** code that do things like this:
1.635 +**
1.636 +** int *a = (int*)sqlite3DbMallocRaw(db, 100);
1.637 +** int *b = (int*)sqlite3DbMallocRaw(db, 200);
1.638 +** if( b ) a[10] = 9;
1.639 +**
1.640 +** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
1.641 +** that all prior mallocs (ex: "a") worked too.
1.642 +*/
1.643 +void *sqlite3DbMallocRaw(sqlite3 *db, int n){
1.644 + void *p;
1.645 +#ifndef SQLITE_OMIT_LOOKASIDE
1.646 + if( db ){
1.647 + LookasideSlot *pBuf;
1.648 + if( db->mallocFailed ){
1.649 + return 0;
1.650 + }
1.651 + if( db->lookaside.bEnabled && n<=db->lookaside.sz
1.652 + && (pBuf = db->lookaside.pFree)!=0 ){
1.653 + db->lookaside.pFree = pBuf->pNext;
1.654 + db->lookaside.nOut++;
1.655 + if( db->lookaside.nOut>db->lookaside.mxOut ){
1.656 + db->lookaside.mxOut = db->lookaside.nOut;
1.657 + }
1.658 + return (void*)pBuf;
1.659 + }
1.660 + }
1.661 +#else
1.662 + if( db && db->mallocFailed ){
1.663 + return 0;
1.664 + }
1.665 +#endif
1.666 + p = sqlite3Malloc(n);
1.667 + if( !p && db ){
1.668 + db->mallocFailed = 1;
1.669 + }
1.670 + return p;
1.671 +}
1.672 +
1.673 +/*
1.674 +** Resize the block of memory pointed to by p to n bytes. If the
1.675 +** resize fails, set the mallocFailed flag in the connection object.
1.676 +*/
1.677 +void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
1.678 + void *pNew = 0;
1.679 + if( db->mallocFailed==0 ){
1.680 + if( p==0 ){
1.681 + return sqlite3DbMallocRaw(db, n);
1.682 + }
1.683 + if( isLookaside(db, p) ){
1.684 + if( n<=db->lookaside.sz ){
1.685 + return p;
1.686 + }
1.687 + pNew = sqlite3DbMallocRaw(db, n);
1.688 + if( pNew ){
1.689 + memcpy(pNew, p, db->lookaside.sz);
1.690 + sqlite3DbFree(db, p);
1.691 + }
1.692 + }else{
1.693 + pNew = sqlite3_realloc(p, n);
1.694 + if( !pNew ){
1.695 + db->mallocFailed = 1;
1.696 + }
1.697 + }
1.698 + }
1.699 + return pNew;
1.700 +}
1.701 +
1.702 +/*
1.703 +** Attempt to reallocate p. If the reallocation fails, then free p
1.704 +** and set the mallocFailed flag in the database connection.
1.705 +*/
1.706 +void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
1.707 + void *pNew;
1.708 + pNew = sqlite3DbRealloc(db, p, n);
1.709 + if( !pNew ){
1.710 + sqlite3DbFree(db, p);
1.711 + }
1.712 + return pNew;
1.713 +}
1.714 +
1.715 +/*
1.716 +** Make a copy of a string in memory obtained from sqliteMalloc(). These
1.717 +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
1.718 +** is because when memory debugging is turned on, these two functions are
1.719 +** called via macros that record the current file and line number in the
1.720 +** ThreadData structure.
1.721 +*/
1.722 +char *sqlite3DbStrDup(sqlite3 *db, const char *z){
1.723 + char *zNew;
1.724 + size_t n;
1.725 + if( z==0 ){
1.726 + return 0;
1.727 + }
1.728 + n = strlen(z)+1;
1.729 + assert( (n&0x7fffffff)==n );
1.730 + zNew = sqlite3DbMallocRaw(db, (int)n);
1.731 + if( zNew ){
1.732 + memcpy(zNew, z, n);
1.733 + }
1.734 + return zNew;
1.735 +}
1.736 +char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
1.737 + char *zNew;
1.738 + if( z==0 ){
1.739 + return 0;
1.740 + }
1.741 + assert( (n&0x7fffffff)==n );
1.742 + zNew = sqlite3DbMallocRaw(db, n+1);
1.743 + if( zNew ){
1.744 + memcpy(zNew, z, n);
1.745 + zNew[n] = 0;
1.746 + }
1.747 + return zNew;
1.748 +}
1.749 +
1.750 +/*
1.751 +** Create a string from the zFromat argument and the va_list that follows.
1.752 +** Store the string in memory obtained from sqliteMalloc() and make *pz
1.753 +** point to that string.
1.754 +*/
1.755 +void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
1.756 + va_list ap;
1.757 + char *z;
1.758 +
1.759 + va_start(ap, zFormat);
1.760 + z = sqlite3VMPrintf(db, zFormat, ap);
1.761 + va_end(ap);
1.762 + sqlite3DbFree(db, *pz);
1.763 + *pz = z;
1.764 +}
1.765 +
1.766 +
1.767 +/*
1.768 +** This function must be called before exiting any API function (i.e.
1.769 +** returning control to the user) that has called sqlite3_malloc or
1.770 +** sqlite3_realloc.
1.771 +**
1.772 +** The returned value is normally a copy of the second argument to this
1.773 +** function. However, if a malloc() failure has occured since the previous
1.774 +** invocation SQLITE_NOMEM is returned instead.
1.775 +**
1.776 +** If the first argument, db, is not NULL and a malloc() error has occured,
1.777 +** then the connection error-code (the value returned by sqlite3_errcode())
1.778 +** is set to SQLITE_NOMEM.
1.779 +*/
1.780 +int sqlite3ApiExit(sqlite3* db, int rc){
1.781 + /* If the db handle is not NULL, then we must hold the connection handle
1.782 + ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
1.783 + ** is unsafe, as is the call to sqlite3Error().
1.784 + */
1.785 + assert( !db || sqlite3_mutex_held(db->mutex) );
1.786 + if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
1.787 + sqlite3Error(db, SQLITE_NOMEM, 0);
1.788 + db->mallocFailed = 0;
1.789 + rc = SQLITE_NOMEM;
1.790 + }
1.791 + return rc & (db ? db->errMask : 0xff);
1.792 +}