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