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