Annotation of embedaddon/sqlite3/src/malloc.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2001 September 15
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: **
! 13: ** Memory allocation functions used throughout sqlite.
! 14: */
! 15: #include "sqliteInt.h"
! 16: #include <stdarg.h>
! 17:
! 18: /*
! 19: ** Attempt to release up to n bytes of non-essential memory currently
! 20: ** held by SQLite. An example of non-essential memory is memory used to
! 21: ** cache database pages that are not currently in use.
! 22: */
! 23: int sqlite3_release_memory(int n){
! 24: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
! 25: return sqlite3PcacheReleaseMemory(n);
! 26: #else
! 27: /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
! 28: ** is a no-op returning zero if SQLite is not compiled with
! 29: ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
! 30: UNUSED_PARAMETER(n);
! 31: return 0;
! 32: #endif
! 33: }
! 34:
! 35: /*
! 36: ** An instance of the following object records the location of
! 37: ** each unused scratch buffer.
! 38: */
! 39: typedef struct ScratchFreeslot {
! 40: struct ScratchFreeslot *pNext; /* Next unused scratch buffer */
! 41: } ScratchFreeslot;
! 42:
! 43: /*
! 44: ** State information local to the memory allocation subsystem.
! 45: */
! 46: static SQLITE_WSD struct Mem0Global {
! 47: sqlite3_mutex *mutex; /* Mutex to serialize access */
! 48:
! 49: /*
! 50: ** The alarm callback and its arguments. The mem0.mutex lock will
! 51: ** be held while the callback is running. Recursive calls into
! 52: ** the memory subsystem are allowed, but no new callbacks will be
! 53: ** issued.
! 54: */
! 55: sqlite3_int64 alarmThreshold;
! 56: void (*alarmCallback)(void*, sqlite3_int64,int);
! 57: void *alarmArg;
! 58:
! 59: /*
! 60: ** Pointers to the end of sqlite3GlobalConfig.pScratch memory
! 61: ** (so that a range test can be used to determine if an allocation
! 62: ** being freed came from pScratch) and a pointer to the list of
! 63: ** unused scratch allocations.
! 64: */
! 65: void *pScratchEnd;
! 66: ScratchFreeslot *pScratchFree;
! 67: u32 nScratchFree;
! 68:
! 69: /*
! 70: ** True if heap is nearly "full" where "full" is defined by the
! 71: ** sqlite3_soft_heap_limit() setting.
! 72: */
! 73: int nearlyFull;
! 74: } mem0 = { 0, 0, 0, 0, 0, 0, 0, 0 };
! 75:
! 76: #define mem0 GLOBAL(struct Mem0Global, mem0)
! 77:
! 78: /*
! 79: ** This routine runs when the memory allocator sees that the
! 80: ** total memory allocation is about to exceed the soft heap
! 81: ** limit.
! 82: */
! 83: static void softHeapLimitEnforcer(
! 84: void *NotUsed,
! 85: sqlite3_int64 NotUsed2,
! 86: int allocSize
! 87: ){
! 88: UNUSED_PARAMETER2(NotUsed, NotUsed2);
! 89: sqlite3_release_memory(allocSize);
! 90: }
! 91:
! 92: /*
! 93: ** Change the alarm callback
! 94: */
! 95: static int sqlite3MemoryAlarm(
! 96: void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
! 97: void *pArg,
! 98: sqlite3_int64 iThreshold
! 99: ){
! 100: int nUsed;
! 101: sqlite3_mutex_enter(mem0.mutex);
! 102: mem0.alarmCallback = xCallback;
! 103: mem0.alarmArg = pArg;
! 104: mem0.alarmThreshold = iThreshold;
! 105: nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
! 106: mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
! 107: sqlite3_mutex_leave(mem0.mutex);
! 108: return SQLITE_OK;
! 109: }
! 110:
! 111: #ifndef SQLITE_OMIT_DEPRECATED
! 112: /*
! 113: ** Deprecated external interface. Internal/core SQLite code
! 114: ** should call sqlite3MemoryAlarm.
! 115: */
! 116: int sqlite3_memory_alarm(
! 117: void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
! 118: void *pArg,
! 119: sqlite3_int64 iThreshold
! 120: ){
! 121: return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
! 122: }
! 123: #endif
! 124:
! 125: /*
! 126: ** Set the soft heap-size limit for the library. Passing a zero or
! 127: ** negative value indicates no limit.
! 128: */
! 129: sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
! 130: sqlite3_int64 priorLimit;
! 131: sqlite3_int64 excess;
! 132: #ifndef SQLITE_OMIT_AUTOINIT
! 133: int rc = sqlite3_initialize();
! 134: if( rc ) return -1;
! 135: #endif
! 136: sqlite3_mutex_enter(mem0.mutex);
! 137: priorLimit = mem0.alarmThreshold;
! 138: sqlite3_mutex_leave(mem0.mutex);
! 139: if( n<0 ) return priorLimit;
! 140: if( n>0 ){
! 141: sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
! 142: }else{
! 143: sqlite3MemoryAlarm(0, 0, 0);
! 144: }
! 145: excess = sqlite3_memory_used() - n;
! 146: if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
! 147: return priorLimit;
! 148: }
! 149: void sqlite3_soft_heap_limit(int n){
! 150: if( n<0 ) n = 0;
! 151: sqlite3_soft_heap_limit64(n);
! 152: }
! 153:
! 154: /*
! 155: ** Initialize the memory allocation subsystem.
! 156: */
! 157: int sqlite3MallocInit(void){
! 158: if( sqlite3GlobalConfig.m.xMalloc==0 ){
! 159: sqlite3MemSetDefault();
! 160: }
! 161: memset(&mem0, 0, sizeof(mem0));
! 162: if( sqlite3GlobalConfig.bCoreMutex ){
! 163: mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
! 164: }
! 165: if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
! 166: && sqlite3GlobalConfig.nScratch>0 ){
! 167: int i, n, sz;
! 168: ScratchFreeslot *pSlot;
! 169: sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch);
! 170: sqlite3GlobalConfig.szScratch = sz;
! 171: pSlot = (ScratchFreeslot*)sqlite3GlobalConfig.pScratch;
! 172: n = sqlite3GlobalConfig.nScratch;
! 173: mem0.pScratchFree = pSlot;
! 174: mem0.nScratchFree = n;
! 175: for(i=0; i<n-1; i++){
! 176: pSlot->pNext = (ScratchFreeslot*)(sz+(char*)pSlot);
! 177: pSlot = pSlot->pNext;
! 178: }
! 179: pSlot->pNext = 0;
! 180: mem0.pScratchEnd = (void*)&pSlot[1];
! 181: }else{
! 182: mem0.pScratchEnd = 0;
! 183: sqlite3GlobalConfig.pScratch = 0;
! 184: sqlite3GlobalConfig.szScratch = 0;
! 185: sqlite3GlobalConfig.nScratch = 0;
! 186: }
! 187: if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
! 188: || sqlite3GlobalConfig.nPage<1 ){
! 189: sqlite3GlobalConfig.pPage = 0;
! 190: sqlite3GlobalConfig.szPage = 0;
! 191: sqlite3GlobalConfig.nPage = 0;
! 192: }
! 193: return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
! 194: }
! 195:
! 196: /*
! 197: ** Return true if the heap is currently under memory pressure - in other
! 198: ** words if the amount of heap used is close to the limit set by
! 199: ** sqlite3_soft_heap_limit().
! 200: */
! 201: int sqlite3HeapNearlyFull(void){
! 202: return mem0.nearlyFull;
! 203: }
! 204:
! 205: /*
! 206: ** Deinitialize the memory allocation subsystem.
! 207: */
! 208: void sqlite3MallocEnd(void){
! 209: if( sqlite3GlobalConfig.m.xShutdown ){
! 210: sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
! 211: }
! 212: memset(&mem0, 0, sizeof(mem0));
! 213: }
! 214:
! 215: /*
! 216: ** Return the amount of memory currently checked out.
! 217: */
! 218: sqlite3_int64 sqlite3_memory_used(void){
! 219: int n, mx;
! 220: sqlite3_int64 res;
! 221: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
! 222: res = (sqlite3_int64)n; /* Work around bug in Borland C. Ticket #3216 */
! 223: return res;
! 224: }
! 225:
! 226: /*
! 227: ** Return the maximum amount of memory that has ever been
! 228: ** checked out since either the beginning of this process
! 229: ** or since the most recent reset.
! 230: */
! 231: sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
! 232: int n, mx;
! 233: sqlite3_int64 res;
! 234: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
! 235: res = (sqlite3_int64)mx; /* Work around bug in Borland C. Ticket #3216 */
! 236: return res;
! 237: }
! 238:
! 239: /*
! 240: ** Trigger the alarm
! 241: */
! 242: static void sqlite3MallocAlarm(int nByte){
! 243: void (*xCallback)(void*,sqlite3_int64,int);
! 244: sqlite3_int64 nowUsed;
! 245: void *pArg;
! 246: if( mem0.alarmCallback==0 ) return;
! 247: xCallback = mem0.alarmCallback;
! 248: nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
! 249: pArg = mem0.alarmArg;
! 250: mem0.alarmCallback = 0;
! 251: sqlite3_mutex_leave(mem0.mutex);
! 252: xCallback(pArg, nowUsed, nByte);
! 253: sqlite3_mutex_enter(mem0.mutex);
! 254: mem0.alarmCallback = xCallback;
! 255: mem0.alarmArg = pArg;
! 256: }
! 257:
! 258: /*
! 259: ** Do a memory allocation with statistics and alarms. Assume the
! 260: ** lock is already held.
! 261: */
! 262: static int mallocWithAlarm(int n, void **pp){
! 263: int nFull;
! 264: void *p;
! 265: assert( sqlite3_mutex_held(mem0.mutex) );
! 266: nFull = sqlite3GlobalConfig.m.xRoundup(n);
! 267: sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
! 268: if( mem0.alarmCallback!=0 ){
! 269: int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
! 270: if( nUsed >= mem0.alarmThreshold - nFull ){
! 271: mem0.nearlyFull = 1;
! 272: sqlite3MallocAlarm(nFull);
! 273: }else{
! 274: mem0.nearlyFull = 0;
! 275: }
! 276: }
! 277: p = sqlite3GlobalConfig.m.xMalloc(nFull);
! 278: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
! 279: if( p==0 && mem0.alarmCallback ){
! 280: sqlite3MallocAlarm(nFull);
! 281: p = sqlite3GlobalConfig.m.xMalloc(nFull);
! 282: }
! 283: #endif
! 284: if( p ){
! 285: nFull = sqlite3MallocSize(p);
! 286: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
! 287: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, 1);
! 288: }
! 289: *pp = p;
! 290: return nFull;
! 291: }
! 292:
! 293: /*
! 294: ** Allocate memory. This routine is like sqlite3_malloc() except that it
! 295: ** assumes the memory subsystem has already been initialized.
! 296: */
! 297: void *sqlite3Malloc(int n){
! 298: void *p;
! 299: if( n<=0 /* IMP: R-65312-04917 */
! 300: || n>=0x7fffff00
! 301: ){
! 302: /* A memory allocation of a number of bytes which is near the maximum
! 303: ** signed integer value might cause an integer overflow inside of the
! 304: ** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving
! 305: ** 255 bytes of overhead. SQLite itself will never use anything near
! 306: ** this amount. The only way to reach the limit is with sqlite3_malloc() */
! 307: p = 0;
! 308: }else if( sqlite3GlobalConfig.bMemstat ){
! 309: sqlite3_mutex_enter(mem0.mutex);
! 310: mallocWithAlarm(n, &p);
! 311: sqlite3_mutex_leave(mem0.mutex);
! 312: }else{
! 313: p = sqlite3GlobalConfig.m.xMalloc(n);
! 314: }
! 315: assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-04675-44850 */
! 316: return p;
! 317: }
! 318:
! 319: /*
! 320: ** This version of the memory allocation is for use by the application.
! 321: ** First make sure the memory subsystem is initialized, then do the
! 322: ** allocation.
! 323: */
! 324: void *sqlite3_malloc(int n){
! 325: #ifndef SQLITE_OMIT_AUTOINIT
! 326: if( sqlite3_initialize() ) return 0;
! 327: #endif
! 328: return sqlite3Malloc(n);
! 329: }
! 330:
! 331: /*
! 332: ** Each thread may only have a single outstanding allocation from
! 333: ** xScratchMalloc(). We verify this constraint in the single-threaded
! 334: ** case by setting scratchAllocOut to 1 when an allocation
! 335: ** is outstanding clearing it when the allocation is freed.
! 336: */
! 337: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
! 338: static int scratchAllocOut = 0;
! 339: #endif
! 340:
! 341:
! 342: /*
! 343: ** Allocate memory that is to be used and released right away.
! 344: ** This routine is similar to alloca() in that it is not intended
! 345: ** for situations where the memory might be held long-term. This
! 346: ** routine is intended to get memory to old large transient data
! 347: ** structures that would not normally fit on the stack of an
! 348: ** embedded processor.
! 349: */
! 350: void *sqlite3ScratchMalloc(int n){
! 351: void *p;
! 352: assert( n>0 );
! 353:
! 354: sqlite3_mutex_enter(mem0.mutex);
! 355: if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){
! 356: p = mem0.pScratchFree;
! 357: mem0.pScratchFree = mem0.pScratchFree->pNext;
! 358: mem0.nScratchFree--;
! 359: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
! 360: sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
! 361: sqlite3_mutex_leave(mem0.mutex);
! 362: }else{
! 363: if( sqlite3GlobalConfig.bMemstat ){
! 364: sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
! 365: n = mallocWithAlarm(n, &p);
! 366: if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
! 367: sqlite3_mutex_leave(mem0.mutex);
! 368: }else{
! 369: sqlite3_mutex_leave(mem0.mutex);
! 370: p = sqlite3GlobalConfig.m.xMalloc(n);
! 371: }
! 372: sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
! 373: }
! 374: assert( sqlite3_mutex_notheld(mem0.mutex) );
! 375:
! 376:
! 377: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
! 378: /* Verify that no more than two scratch allocations per thread
! 379: ** are outstanding at one time. (This is only checked in the
! 380: ** single-threaded case since checking in the multi-threaded case
! 381: ** would be much more complicated.) */
! 382: assert( scratchAllocOut<=1 );
! 383: if( p ) scratchAllocOut++;
! 384: #endif
! 385:
! 386: return p;
! 387: }
! 388: void sqlite3ScratchFree(void *p){
! 389: if( p ){
! 390:
! 391: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
! 392: /* Verify that no more than two scratch allocation per thread
! 393: ** is outstanding at one time. (This is only checked in the
! 394: ** single-threaded case since checking in the multi-threaded case
! 395: ** would be much more complicated.) */
! 396: assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
! 397: scratchAllocOut--;
! 398: #endif
! 399:
! 400: if( p>=sqlite3GlobalConfig.pScratch && p<mem0.pScratchEnd ){
! 401: /* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
! 402: ScratchFreeslot *pSlot;
! 403: pSlot = (ScratchFreeslot*)p;
! 404: sqlite3_mutex_enter(mem0.mutex);
! 405: pSlot->pNext = mem0.pScratchFree;
! 406: mem0.pScratchFree = pSlot;
! 407: mem0.nScratchFree++;
! 408: assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
! 409: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
! 410: sqlite3_mutex_leave(mem0.mutex);
! 411: }else{
! 412: /* Release memory back to the heap */
! 413: assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
! 414: assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
! 415: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
! 416: if( sqlite3GlobalConfig.bMemstat ){
! 417: int iSize = sqlite3MallocSize(p);
! 418: sqlite3_mutex_enter(mem0.mutex);
! 419: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
! 420: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
! 421: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
! 422: sqlite3GlobalConfig.m.xFree(p);
! 423: sqlite3_mutex_leave(mem0.mutex);
! 424: }else{
! 425: sqlite3GlobalConfig.m.xFree(p);
! 426: }
! 427: }
! 428: }
! 429: }
! 430:
! 431: /*
! 432: ** TRUE if p is a lookaside memory allocation from db
! 433: */
! 434: #ifndef SQLITE_OMIT_LOOKASIDE
! 435: static int isLookaside(sqlite3 *db, void *p){
! 436: return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
! 437: }
! 438: #else
! 439: #define isLookaside(A,B) 0
! 440: #endif
! 441:
! 442: /*
! 443: ** Return the size of a memory allocation previously obtained from
! 444: ** sqlite3Malloc() or sqlite3_malloc().
! 445: */
! 446: int sqlite3MallocSize(void *p){
! 447: assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
! 448: assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
! 449: return sqlite3GlobalConfig.m.xSize(p);
! 450: }
! 451: int sqlite3DbMallocSize(sqlite3 *db, void *p){
! 452: assert( db==0 || sqlite3_mutex_held(db->mutex) );
! 453: if( db && isLookaside(db, p) ){
! 454: return db->lookaside.sz;
! 455: }else{
! 456: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
! 457: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
! 458: assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
! 459: return sqlite3GlobalConfig.m.xSize(p);
! 460: }
! 461: }
! 462:
! 463: /*
! 464: ** Free memory previously obtained from sqlite3Malloc().
! 465: */
! 466: void sqlite3_free(void *p){
! 467: if( p==0 ) return; /* IMP: R-49053-54554 */
! 468: assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
! 469: assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
! 470: if( sqlite3GlobalConfig.bMemstat ){
! 471: sqlite3_mutex_enter(mem0.mutex);
! 472: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
! 473: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
! 474: sqlite3GlobalConfig.m.xFree(p);
! 475: sqlite3_mutex_leave(mem0.mutex);
! 476: }else{
! 477: sqlite3GlobalConfig.m.xFree(p);
! 478: }
! 479: }
! 480:
! 481: /*
! 482: ** Free memory that might be associated with a particular database
! 483: ** connection.
! 484: */
! 485: void sqlite3DbFree(sqlite3 *db, void *p){
! 486: assert( db==0 || sqlite3_mutex_held(db->mutex) );
! 487: if( db ){
! 488: if( db->pnBytesFreed ){
! 489: *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
! 490: return;
! 491: }
! 492: if( isLookaside(db, p) ){
! 493: LookasideSlot *pBuf = (LookasideSlot*)p;
! 494: pBuf->pNext = db->lookaside.pFree;
! 495: db->lookaside.pFree = pBuf;
! 496: db->lookaside.nOut--;
! 497: return;
! 498: }
! 499: }
! 500: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
! 501: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
! 502: assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
! 503: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
! 504: sqlite3_free(p);
! 505: }
! 506:
! 507: /*
! 508: ** Change the size of an existing memory allocation
! 509: */
! 510: void *sqlite3Realloc(void *pOld, int nBytes){
! 511: int nOld, nNew, nDiff;
! 512: void *pNew;
! 513: if( pOld==0 ){
! 514: return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
! 515: }
! 516: if( nBytes<=0 ){
! 517: sqlite3_free(pOld); /* IMP: R-31593-10574 */
! 518: return 0;
! 519: }
! 520: if( nBytes>=0x7fffff00 ){
! 521: /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
! 522: return 0;
! 523: }
! 524: nOld = sqlite3MallocSize(pOld);
! 525: /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
! 526: ** argument to xRealloc is always a value returned by a prior call to
! 527: ** xRoundup. */
! 528: nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
! 529: if( nOld==nNew ){
! 530: pNew = pOld;
! 531: }else if( sqlite3GlobalConfig.bMemstat ){
! 532: sqlite3_mutex_enter(mem0.mutex);
! 533: sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
! 534: nDiff = nNew - nOld;
! 535: if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
! 536: mem0.alarmThreshold-nDiff ){
! 537: sqlite3MallocAlarm(nDiff);
! 538: }
! 539: assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
! 540: assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
! 541: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
! 542: if( pNew==0 && mem0.alarmCallback ){
! 543: sqlite3MallocAlarm(nBytes);
! 544: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
! 545: }
! 546: if( pNew ){
! 547: nNew = sqlite3MallocSize(pNew);
! 548: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
! 549: }
! 550: sqlite3_mutex_leave(mem0.mutex);
! 551: }else{
! 552: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
! 553: }
! 554: assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
! 555: return pNew;
! 556: }
! 557:
! 558: /*
! 559: ** The public interface to sqlite3Realloc. Make sure that the memory
! 560: ** subsystem is initialized prior to invoking sqliteRealloc.
! 561: */
! 562: void *sqlite3_realloc(void *pOld, int n){
! 563: #ifndef SQLITE_OMIT_AUTOINIT
! 564: if( sqlite3_initialize() ) return 0;
! 565: #endif
! 566: return sqlite3Realloc(pOld, n);
! 567: }
! 568:
! 569:
! 570: /*
! 571: ** Allocate and zero memory.
! 572: */
! 573: void *sqlite3MallocZero(int n){
! 574: void *p = sqlite3Malloc(n);
! 575: if( p ){
! 576: memset(p, 0, n);
! 577: }
! 578: return p;
! 579: }
! 580:
! 581: /*
! 582: ** Allocate and zero memory. If the allocation fails, make
! 583: ** the mallocFailed flag in the connection pointer.
! 584: */
! 585: void *sqlite3DbMallocZero(sqlite3 *db, int n){
! 586: void *p = sqlite3DbMallocRaw(db, n);
! 587: if( p ){
! 588: memset(p, 0, n);
! 589: }
! 590: return p;
! 591: }
! 592:
! 593: /*
! 594: ** Allocate and zero memory. If the allocation fails, make
! 595: ** the mallocFailed flag in the connection pointer.
! 596: **
! 597: ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
! 598: ** failure on the same database connection) then always return 0.
! 599: ** Hence for a particular database connection, once malloc starts
! 600: ** failing, it fails consistently until mallocFailed is reset.
! 601: ** This is an important assumption. There are many places in the
! 602: ** code that do things like this:
! 603: **
! 604: ** int *a = (int*)sqlite3DbMallocRaw(db, 100);
! 605: ** int *b = (int*)sqlite3DbMallocRaw(db, 200);
! 606: ** if( b ) a[10] = 9;
! 607: **
! 608: ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
! 609: ** that all prior mallocs (ex: "a") worked too.
! 610: */
! 611: void *sqlite3DbMallocRaw(sqlite3 *db, int n){
! 612: void *p;
! 613: assert( db==0 || sqlite3_mutex_held(db->mutex) );
! 614: assert( db==0 || db->pnBytesFreed==0 );
! 615: #ifndef SQLITE_OMIT_LOOKASIDE
! 616: if( db ){
! 617: LookasideSlot *pBuf;
! 618: if( db->mallocFailed ){
! 619: return 0;
! 620: }
! 621: if( db->lookaside.bEnabled ){
! 622: if( n>db->lookaside.sz ){
! 623: db->lookaside.anStat[1]++;
! 624: }else if( (pBuf = db->lookaside.pFree)==0 ){
! 625: db->lookaside.anStat[2]++;
! 626: }else{
! 627: db->lookaside.pFree = pBuf->pNext;
! 628: db->lookaside.nOut++;
! 629: db->lookaside.anStat[0]++;
! 630: if( db->lookaside.nOut>db->lookaside.mxOut ){
! 631: db->lookaside.mxOut = db->lookaside.nOut;
! 632: }
! 633: return (void*)pBuf;
! 634: }
! 635: }
! 636: }
! 637: #else
! 638: if( db && db->mallocFailed ){
! 639: return 0;
! 640: }
! 641: #endif
! 642: p = sqlite3Malloc(n);
! 643: if( !p && db ){
! 644: db->mallocFailed = 1;
! 645: }
! 646: sqlite3MemdebugSetType(p, MEMTYPE_DB |
! 647: ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
! 648: return p;
! 649: }
! 650:
! 651: /*
! 652: ** Resize the block of memory pointed to by p to n bytes. If the
! 653: ** resize fails, set the mallocFailed flag in the connection object.
! 654: */
! 655: void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
! 656: void *pNew = 0;
! 657: assert( db!=0 );
! 658: assert( sqlite3_mutex_held(db->mutex) );
! 659: if( db->mallocFailed==0 ){
! 660: if( p==0 ){
! 661: return sqlite3DbMallocRaw(db, n);
! 662: }
! 663: if( isLookaside(db, p) ){
! 664: if( n<=db->lookaside.sz ){
! 665: return p;
! 666: }
! 667: pNew = sqlite3DbMallocRaw(db, n);
! 668: if( pNew ){
! 669: memcpy(pNew, p, db->lookaside.sz);
! 670: sqlite3DbFree(db, p);
! 671: }
! 672: }else{
! 673: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
! 674: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
! 675: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
! 676: pNew = sqlite3_realloc(p, n);
! 677: if( !pNew ){
! 678: sqlite3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);
! 679: db->mallocFailed = 1;
! 680: }
! 681: sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
! 682: (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
! 683: }
! 684: }
! 685: return pNew;
! 686: }
! 687:
! 688: /*
! 689: ** Attempt to reallocate p. If the reallocation fails, then free p
! 690: ** and set the mallocFailed flag in the database connection.
! 691: */
! 692: void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
! 693: void *pNew;
! 694: pNew = sqlite3DbRealloc(db, p, n);
! 695: if( !pNew ){
! 696: sqlite3DbFree(db, p);
! 697: }
! 698: return pNew;
! 699: }
! 700:
! 701: /*
! 702: ** Make a copy of a string in memory obtained from sqliteMalloc(). These
! 703: ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
! 704: ** is because when memory debugging is turned on, these two functions are
! 705: ** called via macros that record the current file and line number in the
! 706: ** ThreadData structure.
! 707: */
! 708: char *sqlite3DbStrDup(sqlite3 *db, const char *z){
! 709: char *zNew;
! 710: size_t n;
! 711: if( z==0 ){
! 712: return 0;
! 713: }
! 714: n = sqlite3Strlen30(z) + 1;
! 715: assert( (n&0x7fffffff)==n );
! 716: zNew = sqlite3DbMallocRaw(db, (int)n);
! 717: if( zNew ){
! 718: memcpy(zNew, z, n);
! 719: }
! 720: return zNew;
! 721: }
! 722: char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
! 723: char *zNew;
! 724: if( z==0 ){
! 725: return 0;
! 726: }
! 727: assert( (n&0x7fffffff)==n );
! 728: zNew = sqlite3DbMallocRaw(db, n+1);
! 729: if( zNew ){
! 730: memcpy(zNew, z, n);
! 731: zNew[n] = 0;
! 732: }
! 733: return zNew;
! 734: }
! 735:
! 736: /*
! 737: ** Create a string from the zFromat argument and the va_list that follows.
! 738: ** Store the string in memory obtained from sqliteMalloc() and make *pz
! 739: ** point to that string.
! 740: */
! 741: void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
! 742: va_list ap;
! 743: char *z;
! 744:
! 745: va_start(ap, zFormat);
! 746: z = sqlite3VMPrintf(db, zFormat, ap);
! 747: va_end(ap);
! 748: sqlite3DbFree(db, *pz);
! 749: *pz = z;
! 750: }
! 751:
! 752:
! 753: /*
! 754: ** This function must be called before exiting any API function (i.e.
! 755: ** returning control to the user) that has called sqlite3_malloc or
! 756: ** sqlite3_realloc.
! 757: **
! 758: ** The returned value is normally a copy of the second argument to this
! 759: ** function. However, if a malloc() failure has occurred since the previous
! 760: ** invocation SQLITE_NOMEM is returned instead.
! 761: **
! 762: ** If the first argument, db, is not NULL and a malloc() error has occurred,
! 763: ** then the connection error-code (the value returned by sqlite3_errcode())
! 764: ** is set to SQLITE_NOMEM.
! 765: */
! 766: int sqlite3ApiExit(sqlite3* db, int rc){
! 767: /* If the db handle is not NULL, then we must hold the connection handle
! 768: ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
! 769: ** is unsafe, as is the call to sqlite3Error().
! 770: */
! 771: assert( !db || sqlite3_mutex_held(db->mutex) );
! 772: if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
! 773: sqlite3Error(db, SQLITE_NOMEM, 0);
! 774: db->mallocFailed = 0;
! 775: rc = SQLITE_NOMEM;
! 776: }
! 777: return rc & (db ? db->errMask : 0xff);
! 778: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to malloc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src