1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/SQLite/malloc.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,761 @@
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.42 2008/09/23 16:41:30 danielk1977 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 +SQLITE_EXPORT 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 +SQLITE_EXPORT 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 + sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
1.159 + memset(&mem0, 0, sizeof(mem0));
1.160 +}
1.161 +
1.162 +/*
1.163 +** Return the amount of memory currently checked out.
1.164 +*/
1.165 +SQLITE_EXPORT sqlite3_int64 sqlite3_memory_used(void){
1.166 + int n, mx;
1.167 + sqlite3_int64 res;
1.168 + sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
1.169 + res = (sqlite3_int64)n; /* Work around bug in Borland C. Ticket #3216 */
1.170 + return res;
1.171 +}
1.172 +
1.173 +/*
1.174 +** Return the maximum amount of memory that has ever been
1.175 +** checked out since either the beginning of this process
1.176 +** or since the most recent reset.
1.177 +*/
1.178 +SQLITE_EXPORT sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
1.179 + int n, mx;
1.180 + sqlite3_int64 res;
1.181 + sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
1.182 + res = (sqlite3_int64)mx; /* Work around bug in Borland C. Ticket #3216 */
1.183 + return res;
1.184 +}
1.185 +
1.186 +/*
1.187 +** Change the alarm callback
1.188 +*/
1.189 +int sqlite3MemoryAlarm(
1.190 + void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
1.191 + void *pArg,
1.192 + sqlite3_int64 iThreshold
1.193 +){
1.194 + sqlite3_mutex_enter(mem0.mutex);
1.195 + mem0.alarmCallback = xCallback;
1.196 + mem0.alarmArg = pArg;
1.197 + mem0.alarmThreshold = iThreshold;
1.198 + sqlite3_mutex_leave(mem0.mutex);
1.199 + return SQLITE_OK;
1.200 +}
1.201 +
1.202 +/*
1.203 +** Deprecated external interface. Internal/core SQLite code
1.204 +** should call sqlite3MemoryAlarm.
1.205 +*/
1.206 +SQLITE_EXPORT int sqlite3_memory_alarm(
1.207 + void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
1.208 + void *pArg,
1.209 + sqlite3_int64 iThreshold
1.210 +){
1.211 + return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
1.212 +}
1.213 +
1.214 +/*
1.215 +** Trigger the alarm
1.216 +*/
1.217 +static void sqlite3MallocAlarm(int nByte){
1.218 + void (*xCallback)(void*,sqlite3_int64,int);
1.219 + sqlite3_int64 nowUsed;
1.220 + void *pArg;
1.221 + if( mem0.alarmCallback==0 || mem0.alarmBusy ) return;
1.222 + mem0.alarmBusy = 1;
1.223 + xCallback = mem0.alarmCallback;
1.224 + nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
1.225 + pArg = mem0.alarmArg;
1.226 + sqlite3_mutex_leave(mem0.mutex);
1.227 + xCallback(pArg, nowUsed, nByte);
1.228 + sqlite3_mutex_enter(mem0.mutex);
1.229 + mem0.alarmBusy = 0;
1.230 +}
1.231 +
1.232 +/*
1.233 +** Do a memory allocation with statistics and alarms. Assume the
1.234 +** lock is already held.
1.235 +*/
1.236 +static int mallocWithAlarm(int n, void **pp){
1.237 + int nFull;
1.238 + void *p;
1.239 + assert( sqlite3_mutex_held(mem0.mutex) );
1.240 + nFull = sqlite3GlobalConfig.m.xRoundup(n);
1.241 + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
1.242 + if( mem0.alarmCallback!=0 ){
1.243 + int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
1.244 + if( nUsed+nFull >= mem0.alarmThreshold ){
1.245 + sqlite3MallocAlarm(nFull);
1.246 + }
1.247 + }
1.248 + p = sqlite3GlobalConfig.m.xMalloc(nFull);
1.249 + if( p==0 && mem0.alarmCallback ){
1.250 + sqlite3MallocAlarm(nFull);
1.251 + p = sqlite3GlobalConfig.m.xMalloc(nFull);
1.252 + }
1.253 + if( p ){
1.254 + nFull = sqlite3MallocSize(p);
1.255 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
1.256 + }
1.257 + *pp = p;
1.258 + return nFull;
1.259 +}
1.260 +
1.261 +/*
1.262 +** Allocate memory. This routine is like sqlite3_malloc() except that it
1.263 +** assumes the memory subsystem has already been initialized.
1.264 +*/
1.265 +void *sqlite3Malloc(int n){
1.266 + void *p;
1.267 + if( n<=0 ){
1.268 + p = 0;
1.269 + }else if( sqlite3GlobalConfig.bMemstat ){
1.270 + sqlite3_mutex_enter(mem0.mutex);
1.271 + mallocWithAlarm(n, &p);
1.272 + sqlite3_mutex_leave(mem0.mutex);
1.273 + }else{
1.274 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.275 + }
1.276 + return p;
1.277 +}
1.278 +
1.279 +/*
1.280 +** This version of the memory allocation is for use by the application.
1.281 +** First make sure the memory subsystem is initialized, then do the
1.282 +** allocation.
1.283 +*/
1.284 +SQLITE_EXPORT void *sqlite3_malloc(int n){
1.285 +#ifndef SQLITE_OMIT_AUTOINIT
1.286 + if( sqlite3_initialize() ) return 0;
1.287 +#endif
1.288 + return sqlite3Malloc(n);
1.289 +}
1.290 +
1.291 +/*
1.292 +** Each thread may only have a single outstanding allocation from
1.293 +** xScratchMalloc(). We verify this constraint in the single-threaded
1.294 +** case by setting scratchAllocOut to 1 when an allocation
1.295 +** is outstanding clearing it when the allocation is freed.
1.296 +*/
1.297 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.298 +static int scratchAllocOut = 0;
1.299 +#endif
1.300 +
1.301 +
1.302 +/*
1.303 +** Allocate memory that is to be used and released right away.
1.304 +** This routine is similar to alloca() in that it is not intended
1.305 +** for situations where the memory might be held long-term. This
1.306 +** routine is intended to get memory to old large transient data
1.307 +** structures that would not normally fit on the stack of an
1.308 +** embedded processor.
1.309 +*/
1.310 +void *sqlite3ScratchMalloc(int n){
1.311 + void *p;
1.312 + assert( n>0 );
1.313 +
1.314 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.315 + /* Verify that no more than one scratch allocation per thread
1.316 + ** is outstanding at one time. (This is only checked in the
1.317 + ** single-threaded case since checking in the multi-threaded case
1.318 + ** would be much more complicated.) */
1.319 + assert( scratchAllocOut==0 );
1.320 +#endif
1.321 +
1.322 + if( sqlite3GlobalConfig.szScratch<n ){
1.323 + goto scratch_overflow;
1.324 + }else{
1.325 + sqlite3_mutex_enter(mem0.mutex);
1.326 + if( mem0.nScratchFree==0 ){
1.327 + sqlite3_mutex_leave(mem0.mutex);
1.328 + goto scratch_overflow;
1.329 + }else{
1.330 + int i;
1.331 + i = mem0.aScratchFree[--mem0.nScratchFree];
1.332 + i *= sqlite3GlobalConfig.szScratch;
1.333 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
1.334 + sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
1.335 + sqlite3_mutex_leave(mem0.mutex);
1.336 + p = (void*)&((char*)sqlite3GlobalConfig.pScratch)[i];
1.337 + }
1.338 + }
1.339 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.340 + scratchAllocOut = p!=0;
1.341 +#endif
1.342 +
1.343 + return p;
1.344 +
1.345 +scratch_overflow:
1.346 + if( sqlite3GlobalConfig.bMemstat ){
1.347 + sqlite3_mutex_enter(mem0.mutex);
1.348 + sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
1.349 + n = mallocWithAlarm(n, &p);
1.350 + if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
1.351 + sqlite3_mutex_leave(mem0.mutex);
1.352 + }else{
1.353 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.354 + }
1.355 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.356 + scratchAllocOut = p!=0;
1.357 +#endif
1.358 + return p;
1.359 +}
1.360 +void sqlite3ScratchFree(void *p){
1.361 + if( p ){
1.362 +
1.363 +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
1.364 + /* Verify that no more than one scratch allocation per thread
1.365 + ** is outstanding at one time. (This is only checked in the
1.366 + ** single-threaded case since checking in the multi-threaded case
1.367 + ** would be much more complicated.) */
1.368 + assert( scratchAllocOut==1 );
1.369 + scratchAllocOut = 0;
1.370 +#endif
1.371 +
1.372 + if( sqlite3GlobalConfig.pScratch==0
1.373 + || p<sqlite3GlobalConfig.pScratch
1.374 + || p>=(void*)mem0.aScratchFree ){
1.375 + if( sqlite3GlobalConfig.bMemstat ){
1.376 + int iSize = sqlite3MallocSize(p);
1.377 + sqlite3_mutex_enter(mem0.mutex);
1.378 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
1.379 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
1.380 + sqlite3GlobalConfig.m.xFree(p);
1.381 + sqlite3_mutex_leave(mem0.mutex);
1.382 + }else{
1.383 + sqlite3GlobalConfig.m.xFree(p);
1.384 + }
1.385 + }else{
1.386 + int i;
1.387 + i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pScratch;
1.388 + i /= sqlite3GlobalConfig.szScratch;
1.389 + assert( i>=0 && i<sqlite3GlobalConfig.nScratch );
1.390 + sqlite3_mutex_enter(mem0.mutex);
1.391 + assert( mem0.nScratchFree<sqlite3GlobalConfig.nScratch );
1.392 + mem0.aScratchFree[mem0.nScratchFree++] = i;
1.393 + sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
1.394 + sqlite3_mutex_leave(mem0.mutex);
1.395 + }
1.396 + }
1.397 +}
1.398 +
1.399 +/*
1.400 +** Allocate memory to be used by the page cache. Make use of the
1.401 +** memory buffer provided by SQLITE_CONFIG_PAGECACHE if there is one
1.402 +** and that memory is of the right size and is not completely
1.403 +** consumed. Otherwise, failover to sqlite3Malloc().
1.404 +*/
1.405 +#if 0
1.406 +void *sqlite3PageMalloc(int n){
1.407 + void *p;
1.408 + assert( n>0 );
1.409 + assert( (n & (n-1))==0 );
1.410 + assert( n>=512 && n<=32768 );
1.411 +
1.412 + if( sqlite3GlobalConfig.szPage<n ){
1.413 + goto page_overflow;
1.414 + }else{
1.415 + sqlite3_mutex_enter(mem0.mutex);
1.416 + if( mem0.nPageFree==0 ){
1.417 + sqlite3_mutex_leave(mem0.mutex);
1.418 + goto page_overflow;
1.419 + }else{
1.420 + int i;
1.421 + i = mem0.aPageFree[--mem0.nPageFree];
1.422 + sqlite3_mutex_leave(mem0.mutex);
1.423 + i *= sqlite3GlobalConfig.szPage;
1.424 + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
1.425 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
1.426 + p = (void*)&((char*)sqlite3GlobalConfig.pPage)[i];
1.427 + }
1.428 + }
1.429 + return p;
1.430 +
1.431 +page_overflow:
1.432 + if( sqlite3GlobalConfig.bMemstat ){
1.433 + sqlite3_mutex_enter(mem0.mutex);
1.434 + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);
1.435 + n = mallocWithAlarm(n, &p);
1.436 + if( p ) sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, n);
1.437 + sqlite3_mutex_leave(mem0.mutex);
1.438 + }else{
1.439 + p = sqlite3GlobalConfig.m.xMalloc(n);
1.440 + }
1.441 + return p;
1.442 +}
1.443 +void sqlite3PageFree(void *p){
1.444 + if( p ){
1.445 + if( sqlite3GlobalConfig.pPage==0
1.446 + || p<sqlite3GlobalConfig.pPage
1.447 + || p>=(void*)mem0.aPageFree ){
1.448 + /* In this case, the page allocation was obtained from a regular
1.449 + ** call to sqlite3_mem_methods.xMalloc() (a page-cache-memory
1.450 + ** "overflow"). Free the block with sqlite3_mem_methods.xFree().
1.451 + */
1.452 + if( sqlite3GlobalConfig.bMemstat ){
1.453 + int iSize = sqlite3MallocSize(p);
1.454 + sqlite3_mutex_enter(mem0.mutex);
1.455 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);
1.456 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
1.457 + sqlite3GlobalConfig.m.xFree(p);
1.458 + sqlite3_mutex_leave(mem0.mutex);
1.459 + }else{
1.460 + sqlite3GlobalConfig.m.xFree(p);
1.461 + }
1.462 + }else{
1.463 + /* The page allocation was allocated from the sqlite3GlobalConfig.pPage
1.464 + ** buffer. In this case all that is add the index of the page in
1.465 + ** the sqlite3GlobalConfig.pPage array to the set of free indexes stored
1.466 + ** in the mem0.aPageFree[] array.
1.467 + */
1.468 + int i;
1.469 + i = (u8 *)p - (u8 *)sqlite3GlobalConfig.pPage;
1.470 + i /= sqlite3GlobalConfig.szPage;
1.471 + assert( i>=0 && i<sqlite3GlobalConfig.nPage );
1.472 + sqlite3_mutex_enter(mem0.mutex);
1.473 + assert( mem0.nPageFree<sqlite3GlobalConfig.nPage );
1.474 + mem0.aPageFree[mem0.nPageFree++] = i;
1.475 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
1.476 + sqlite3_mutex_leave(mem0.mutex);
1.477 +#if !defined(NDEBUG) && 0
1.478 + /* Assert that a duplicate was not just inserted into aPageFree[]. */
1.479 + for(i=0; i<mem0.nPageFree-1; i++){
1.480 + assert( mem0.aPageFree[i]!=mem0.aPageFree[mem0.nPageFree-1] );
1.481 + }
1.482 +#endif
1.483 + }
1.484 + }
1.485 +}
1.486 +#endif
1.487 +
1.488 +/*
1.489 +** TRUE if p is a lookaside memory allocation from db
1.490 +*/
1.491 +static int isLookaside(sqlite3 *db, void *p){
1.492 + return db && p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
1.493 +}
1.494 +
1.495 +/*
1.496 +** Return the size of a memory allocation previously obtained from
1.497 +** sqlite3Malloc() or sqlite3_malloc().
1.498 +*/
1.499 +int sqlite3MallocSize(void *p){
1.500 + return sqlite3GlobalConfig.m.xSize(p);
1.501 +}
1.502 +int sqlite3DbMallocSize(sqlite3 *db, void *p){
1.503 + if( isLookaside(db, p) ){
1.504 + return db->lookaside.sz;
1.505 + }else{
1.506 + return sqlite3GlobalConfig.m.xSize(p);
1.507 + }
1.508 +}
1.509 +
1.510 +/*
1.511 +** Free memory previously obtained from sqlite3Malloc().
1.512 +*/
1.513 +SQLITE_EXPORT void sqlite3_free(void *p){
1.514 + if( p==0 ) return;
1.515 + if( sqlite3GlobalConfig.bMemstat ){
1.516 + sqlite3_mutex_enter(mem0.mutex);
1.517 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
1.518 + sqlite3GlobalConfig.m.xFree(p);
1.519 + sqlite3_mutex_leave(mem0.mutex);
1.520 + }else{
1.521 + sqlite3GlobalConfig.m.xFree(p);
1.522 + }
1.523 +}
1.524 +
1.525 +/*
1.526 +** Free memory that might be associated with a particular database
1.527 +** connection.
1.528 +*/
1.529 +void sqlite3DbFree(sqlite3 *db, void *p){
1.530 + if( isLookaside(db, p) ){
1.531 + LookasideSlot *pBuf = (LookasideSlot*)p;
1.532 + pBuf->pNext = db->lookaside.pFree;
1.533 + db->lookaside.pFree = pBuf;
1.534 + db->lookaside.nOut--;
1.535 + }else{
1.536 + sqlite3_free(p);
1.537 + }
1.538 +}
1.539 +
1.540 +/*
1.541 +** Change the size of an existing memory allocation
1.542 +*/
1.543 +void *sqlite3Realloc(void *pOld, int nBytes){
1.544 + int nOld, nNew;
1.545 + void *pNew;
1.546 + if( pOld==0 ){
1.547 + return sqlite3Malloc(nBytes);
1.548 + }
1.549 + if( nBytes<=0 ){
1.550 + sqlite3_free(pOld);
1.551 + return 0;
1.552 + }
1.553 + nOld = sqlite3MallocSize(pOld);
1.554 + if( sqlite3GlobalConfig.bMemstat ){
1.555 + sqlite3_mutex_enter(mem0.mutex);
1.556 + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
1.557 + nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
1.558 + if( nOld==nNew ){
1.559 + pNew = pOld;
1.560 + }else{
1.561 + if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nNew-nOld >=
1.562 + mem0.alarmThreshold ){
1.563 + sqlite3MallocAlarm(nNew-nOld);
1.564 + }
1.565 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
1.566 + if( pNew==0 && mem0.alarmCallback ){
1.567 + sqlite3MallocAlarm(nBytes);
1.568 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
1.569 + }
1.570 + if( pNew ){
1.571 + nNew = sqlite3MallocSize(pNew);
1.572 + sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
1.573 + }
1.574 + }
1.575 + sqlite3_mutex_leave(mem0.mutex);
1.576 + }else{
1.577 + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nBytes);
1.578 + }
1.579 + return pNew;
1.580 +}
1.581 +
1.582 +/*
1.583 +** The public interface to sqlite3Realloc. Make sure that the memory
1.584 +** subsystem is initialized prior to invoking sqliteRealloc.
1.585 +*/
1.586 +SQLITE_EXPORT void *sqlite3_realloc(void *pOld, int n){
1.587 +#ifndef SQLITE_OMIT_AUTOINIT
1.588 + if( sqlite3_initialize() ) return 0;
1.589 +#endif
1.590 + return sqlite3Realloc(pOld, n);
1.591 +}
1.592 +
1.593 +
1.594 +/*
1.595 +** Allocate and zero memory.
1.596 +*/
1.597 +void *sqlite3MallocZero(int n){
1.598 + void *p = sqlite3Malloc(n);
1.599 + if( p ){
1.600 + memset(p, 0, n);
1.601 + }
1.602 + return p;
1.603 +}
1.604 +
1.605 +/*
1.606 +** Allocate and zero memory. If the allocation fails, make
1.607 +** the mallocFailed flag in the connection pointer.
1.608 +*/
1.609 +void *sqlite3DbMallocZero(sqlite3 *db, int n){
1.610 + void *p = sqlite3DbMallocRaw(db, n);
1.611 + if( p ){
1.612 + memset(p, 0, n);
1.613 + }
1.614 + return p;
1.615 +}
1.616 +
1.617 +/*
1.618 +** Allocate and zero memory. If the allocation fails, make
1.619 +** the mallocFailed flag in the connection pointer.
1.620 +*/
1.621 +void *sqlite3DbMallocRaw(sqlite3 *db, int n){
1.622 + void *p;
1.623 + if( db ){
1.624 + LookasideSlot *pBuf;
1.625 + if( db->mallocFailed ){
1.626 + return 0;
1.627 + }
1.628 + if( db->lookaside.bEnabled && n<=db->lookaside.sz
1.629 + && (pBuf = db->lookaside.pFree)!=0 ){
1.630 + db->lookaside.pFree = pBuf->pNext;
1.631 + db->lookaside.nOut++;
1.632 + if( db->lookaside.nOut>db->lookaside.mxOut ){
1.633 + db->lookaside.mxOut = db->lookaside.nOut;
1.634 + }
1.635 + return (void*)pBuf;
1.636 + }
1.637 + }
1.638 + p = sqlite3Malloc(n);
1.639 + if( !p && db ){
1.640 + db->mallocFailed = 1;
1.641 + }
1.642 + return p;
1.643 +}
1.644 +
1.645 +/*
1.646 +** Resize the block of memory pointed to by p to n bytes. If the
1.647 +** resize fails, set the mallocFailed flag in the connection object.
1.648 +*/
1.649 +void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
1.650 + void *pNew = 0;
1.651 + if( db->mallocFailed==0 ){
1.652 + if( p==0 ){
1.653 + return sqlite3DbMallocRaw(db, n);
1.654 + }
1.655 + if( isLookaside(db, p) ){
1.656 + if( n<=db->lookaside.sz ){
1.657 + return p;
1.658 + }
1.659 + pNew = sqlite3DbMallocRaw(db, n);
1.660 + if( pNew ){
1.661 + memcpy(pNew, p, db->lookaside.sz);
1.662 + sqlite3DbFree(db, p);
1.663 + }
1.664 + }else{
1.665 + pNew = sqlite3_realloc(p, n);
1.666 + if( !pNew ){
1.667 + db->mallocFailed = 1;
1.668 + }
1.669 + }
1.670 + }
1.671 + return pNew;
1.672 +}
1.673 +
1.674 +/*
1.675 +** Attempt to reallocate p. If the reallocation fails, then free p
1.676 +** and set the mallocFailed flag in the database connection.
1.677 +*/
1.678 +void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
1.679 + void *pNew;
1.680 + pNew = sqlite3DbRealloc(db, p, n);
1.681 + if( !pNew ){
1.682 + sqlite3DbFree(db, p);
1.683 + }
1.684 + return pNew;
1.685 +}
1.686 +
1.687 +/*
1.688 +** Make a copy of a string in memory obtained from sqliteMalloc(). These
1.689 +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
1.690 +** is because when memory debugging is turned on, these two functions are
1.691 +** called via macros that record the current file and line number in the
1.692 +** ThreadData structure.
1.693 +*/
1.694 +char *sqlite3DbStrDup(sqlite3 *db, const char *z){
1.695 + char *zNew;
1.696 + size_t n;
1.697 + if( z==0 ){
1.698 + return 0;
1.699 + }
1.700 + n = strlen(z)+1;
1.701 + assert( (n&0x7fffffff)==n );
1.702 + zNew = sqlite3DbMallocRaw(db, (int)n);
1.703 + if( zNew ){
1.704 + memcpy(zNew, z, n);
1.705 + }
1.706 + return zNew;
1.707 +}
1.708 +char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
1.709 + char *zNew;
1.710 + if( z==0 ){
1.711 + return 0;
1.712 + }
1.713 + assert( (n&0x7fffffff)==n );
1.714 + zNew = sqlite3DbMallocRaw(db, n+1);
1.715 + if( zNew ){
1.716 + memcpy(zNew, z, n);
1.717 + zNew[n] = 0;
1.718 + }
1.719 + return zNew;
1.720 +}
1.721 +
1.722 +/*
1.723 +** Create a string from the zFromat argument and the va_list that follows.
1.724 +** Store the string in memory obtained from sqliteMalloc() and make *pz
1.725 +** point to that string.
1.726 +*/
1.727 +void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
1.728 + va_list ap;
1.729 + char *z;
1.730 +
1.731 + va_start(ap, zFormat);
1.732 + z = sqlite3VMPrintf(db, zFormat, ap);
1.733 + va_end(ap);
1.734 + sqlite3DbFree(db, *pz);
1.735 + *pz = z;
1.736 +}
1.737 +
1.738 +
1.739 +/*
1.740 +** This function must be called before exiting any API function (i.e.
1.741 +** returning control to the user) that has called sqlite3_malloc or
1.742 +** sqlite3_realloc.
1.743 +**
1.744 +** The returned value is normally a copy of the second argument to this
1.745 +** function. However, if a malloc() failure has occured since the previous
1.746 +** invocation SQLITE_NOMEM is returned instead.
1.747 +**
1.748 +** If the first argument, db, is not NULL and a malloc() error has occured,
1.749 +** then the connection error-code (the value returned by sqlite3_errcode())
1.750 +** is set to SQLITE_NOMEM.
1.751 +*/
1.752 +int sqlite3ApiExit(sqlite3* db, int rc){
1.753 + /* If the db handle is not NULL, then we must hold the connection handle
1.754 + ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
1.755 + ** is unsafe, as is the call to sqlite3Error().
1.756 + */
1.757 + assert( !db || sqlite3_mutex_held(db->mutex) );
1.758 + if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
1.759 + sqlite3Error(db, SQLITE_NOMEM, 0);
1.760 + db->mallocFailed = 0;
1.761 + rc = SQLITE_NOMEM;
1.762 + }
1.763 + return rc & (db ? db->errMask : 0xff);
1.764 +}