Annotation of embedaddon/sqlite3/src/malloc.c, revision 1.1.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