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 | ** Default value of the hard heap limit. 0 means "no limit". |
37 | */ |
38 | #ifndef SQLITE_MAX_MEMORY |
39 | # define SQLITE_MAX_MEMORY 0 |
40 | #endif |
41 | |
42 | /* |
43 | ** State information local to the memory allocation subsystem. |
44 | */ |
45 | static SQLITE_WSD struct Mem0Global { |
46 | sqlite3_mutex *mutex; /* Mutex to serialize access */ |
47 | sqlite3_int64 alarmThreshold; /* The soft heap limit */ |
48 | sqlite3_int64 hardLimit; /* The hard upper bound on memory */ |
49 | |
50 | /* |
51 | ** True if heap is nearly "full" where "full" is defined by the |
52 | ** sqlite3_soft_heap_limit() setting. |
53 | */ |
54 | int nearlyFull; |
55 | } mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 }; |
56 | |
57 | #define mem0 GLOBAL(struct Mem0Global, mem0) |
58 | |
59 | /* |
60 | ** Return the memory allocator mutex. sqlite3_status() needs it. |
61 | */ |
62 | sqlite3_mutex *sqlite3MallocMutex(void){ |
63 | return mem0.mutex; |
64 | } |
65 | |
66 | #ifndef SQLITE_OMIT_DEPRECATED |
67 | /* |
68 | ** Deprecated external interface. It used to set an alarm callback |
69 | ** that was invoked when memory usage grew too large. Now it is a |
70 | ** no-op. |
71 | */ |
72 | int sqlite3_memory_alarm( |
73 | void(*xCallback)(void *pArg, sqlite3_int64 used,int N), |
74 | void *pArg, |
75 | sqlite3_int64 iThreshold |
76 | ){ |
77 | (void)xCallback; |
78 | (void)pArg; |
79 | (void)iThreshold; |
80 | return SQLITE_OK; |
81 | } |
82 | #endif |
83 | |
84 | /* |
85 | ** Set the soft heap-size limit for the library. An argument of |
86 | ** zero disables the limit. A negative argument is a no-op used to |
87 | ** obtain the return value. |
88 | ** |
89 | ** The return value is the value of the heap limit just before this |
90 | ** interface was called. |
91 | ** |
92 | ** If the hard heap limit is enabled, then the soft heap limit cannot |
93 | ** be disabled nor raised above the hard heap limit. |
94 | */ |
95 | sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){ |
96 | sqlite3_int64 priorLimit; |
97 | sqlite3_int64 excess; |
98 | sqlite3_int64 nUsed; |
99 | #ifndef SQLITE_OMIT_AUTOINIT |
100 | int rc = sqlite3_initialize(); |
101 | if( rc ) return -1; |
102 | #endif |
103 | sqlite3_mutex_enter(mem0.mutex); |
104 | priorLimit = mem0.alarmThreshold; |
105 | if( n<0 ){ |
106 | sqlite3_mutex_leave(mem0.mutex); |
107 | return priorLimit; |
108 | } |
109 | if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){ |
110 | n = mem0.hardLimit; |
111 | } |
112 | mem0.alarmThreshold = n; |
113 | nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); |
114 | AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed); |
115 | sqlite3_mutex_leave(mem0.mutex); |
116 | excess = sqlite3_memory_used() - n; |
117 | if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff)); |
118 | return priorLimit; |
119 | } |
120 | void sqlite3_soft_heap_limit(int n){ |
121 | if( n<0 ) n = 0; |
122 | sqlite3_soft_heap_limit64(n); |
123 | } |
124 | |
125 | /* |
126 | ** Set the hard heap-size limit for the library. An argument of zero |
127 | ** disables the hard heap limit. A negative argument is a no-op used |
128 | ** to obtain the return value without affecting the hard heap limit. |
129 | ** |
130 | ** The return value is the value of the hard heap limit just prior to |
131 | ** calling this interface. |
132 | ** |
133 | ** Setting the hard heap limit will also activate the soft heap limit |
134 | ** and constrain the soft heap limit to be no more than the hard heap |
135 | ** limit. |
136 | */ |
137 | sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){ |
138 | sqlite3_int64 priorLimit; |
139 | #ifndef SQLITE_OMIT_AUTOINIT |
140 | int rc = sqlite3_initialize(); |
141 | if( rc ) return -1; |
142 | #endif |
143 | sqlite3_mutex_enter(mem0.mutex); |
144 | priorLimit = mem0.hardLimit; |
145 | if( n>=0 ){ |
146 | mem0.hardLimit = n; |
147 | if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){ |
148 | mem0.alarmThreshold = n; |
149 | } |
150 | } |
151 | sqlite3_mutex_leave(mem0.mutex); |
152 | return priorLimit; |
153 | } |
154 | |
155 | |
156 | /* |
157 | ** Initialize the memory allocation subsystem. |
158 | */ |
159 | int sqlite3MallocInit(void){ |
160 | int rc; |
161 | if( sqlite3GlobalConfig.m.xMalloc==0 ){ |
162 | sqlite3MemSetDefault(); |
163 | } |
164 | mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); |
165 | if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512 |
166 | || sqlite3GlobalConfig.nPage<=0 ){ |
167 | sqlite3GlobalConfig.pPage = 0; |
168 | sqlite3GlobalConfig.szPage = 0; |
169 | } |
170 | rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData); |
171 | if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0)); |
172 | return rc; |
173 | } |
174 | |
175 | /* |
176 | ** Return true if the heap is currently under memory pressure - in other |
177 | ** words if the amount of heap used is close to the limit set by |
178 | ** sqlite3_soft_heap_limit(). |
179 | */ |
180 | int sqlite3HeapNearlyFull(void){ |
181 | return AtomicLoad(&mem0.nearlyFull); |
182 | } |
183 | |
184 | /* |
185 | ** Deinitialize the memory allocation subsystem. |
186 | */ |
187 | void sqlite3MallocEnd(void){ |
188 | if( sqlite3GlobalConfig.m.xShutdown ){ |
189 | sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData); |
190 | } |
191 | memset(&mem0, 0, sizeof(mem0)); |
192 | } |
193 | |
194 | /* |
195 | ** Return the amount of memory currently checked out. |
196 | */ |
197 | sqlite3_int64 sqlite3_memory_used(void){ |
198 | sqlite3_int64 res, mx; |
199 | sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0); |
200 | return res; |
201 | } |
202 | |
203 | /* |
204 | ** Return the maximum amount of memory that has ever been |
205 | ** checked out since either the beginning of this process |
206 | ** or since the most recent reset. |
207 | */ |
208 | sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ |
209 | sqlite3_int64 res, mx; |
210 | sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag); |
211 | return mx; |
212 | } |
213 | |
214 | /* |
215 | ** Trigger the alarm |
216 | */ |
217 | static void sqlite3MallocAlarm(int nByte){ |
218 | if( mem0.alarmThreshold<=0 ) return; |
219 | sqlite3_mutex_leave(mem0.mutex); |
220 | sqlite3_release_memory(nByte); |
221 | sqlite3_mutex_enter(mem0.mutex); |
222 | } |
223 | |
224 | /* |
225 | ** Do a memory allocation with statistics and alarms. Assume the |
226 | ** lock is already held. |
227 | */ |
228 | static void mallocWithAlarm(int n, void **pp){ |
229 | void *p; |
230 | int nFull; |
231 | assert( sqlite3_mutex_held(mem0.mutex) ); |
232 | assert( n>0 ); |
233 | |
234 | /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal |
235 | ** implementation of malloc_good_size(), which must be called in debug |
236 | ** mode and specifically when the DMD "Dark Matter Detector" is enabled |
237 | ** or else a crash results. Hence, do not attempt to optimize out the |
238 | ** following xRoundup() call. */ |
239 | nFull = sqlite3GlobalConfig.m.xRoundup(n); |
240 | |
241 | sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n); |
242 | if( mem0.alarmThreshold>0 ){ |
243 | sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); |
244 | if( nUsed >= mem0.alarmThreshold - nFull ){ |
245 | AtomicStore(&mem0.nearlyFull, 1); |
246 | sqlite3MallocAlarm(nFull); |
247 | if( mem0.hardLimit ){ |
248 | nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); |
249 | if( nUsed >= mem0.hardLimit - nFull ){ |
250 | *pp = 0; |
251 | return; |
252 | } |
253 | } |
254 | }else{ |
255 | AtomicStore(&mem0.nearlyFull, 0); |
256 | } |
257 | } |
258 | p = sqlite3GlobalConfig.m.xMalloc(nFull); |
259 | #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT |
260 | if( p==0 && mem0.alarmThreshold>0 ){ |
261 | sqlite3MallocAlarm(nFull); |
262 | p = sqlite3GlobalConfig.m.xMalloc(nFull); |
263 | } |
264 | #endif |
265 | if( p ){ |
266 | nFull = sqlite3MallocSize(p); |
267 | sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull); |
268 | sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1); |
269 | } |
270 | *pp = p; |
271 | } |
272 | |
273 | /* |
274 | ** Maximum size of any single memory allocation. |
275 | ** |
276 | ** This is not a limit on the total amount of memory used. This is |
277 | ** a limit on the size parameter to sqlite3_malloc() and sqlite3_realloc(). |
278 | ** |
279 | ** The upper bound is slightly less than 2GiB: 0x7ffffeff == 2,147,483,391 |
280 | ** This provides a 256-byte safety margin for defense against 32-bit |
281 | ** signed integer overflow bugs when computing memory allocation sizes. |
282 | ** Parnoid applications might want to reduce the maximum allocation size |
283 | ** further for an even larger safety margin. 0x3fffffff or 0x0fffffff |
284 | ** or even smaller would be reasonable upper bounds on the size of a memory |
285 | ** allocations for most applications. |
286 | */ |
287 | #ifndef SQLITE_MAX_ALLOCATION_SIZE |
288 | # define SQLITE_MAX_ALLOCATION_SIZE 2147483391 |
289 | #endif |
290 | #if SQLITE_MAX_ALLOCATION_SIZE>2147483391 |
291 | # error Maximum size for SQLITE_MAX_ALLOCATION_SIZE is 2147483391 |
292 | #endif |
293 | |
294 | /* |
295 | ** Allocate memory. This routine is like sqlite3_malloc() except that it |
296 | ** assumes the memory subsystem has already been initialized. |
297 | */ |
298 | void *sqlite3Malloc(u64 n){ |
299 | void *p; |
300 | if( n==0 || n>SQLITE_MAX_ALLOCATION_SIZE ){ |
301 | p = 0; |
302 | }else if( sqlite3GlobalConfig.bMemstat ){ |
303 | sqlite3_mutex_enter(mem0.mutex); |
304 | mallocWithAlarm((int)n, &p); |
305 | sqlite3_mutex_leave(mem0.mutex); |
306 | }else{ |
307 | p = sqlite3GlobalConfig.m.xMalloc((int)n); |
308 | } |
309 | assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */ |
310 | return p; |
311 | } |
312 | |
313 | /* |
314 | ** This version of the memory allocation is for use by the application. |
315 | ** First make sure the memory subsystem is initialized, then do the |
316 | ** allocation. |
317 | */ |
318 | void *sqlite3_malloc(int n){ |
319 | #ifndef SQLITE_OMIT_AUTOINIT |
320 | if( sqlite3_initialize() ) return 0; |
321 | #endif |
322 | return n<=0 ? 0 : sqlite3Malloc(n); |
323 | } |
324 | void *sqlite3_malloc64(sqlite3_uint64 n){ |
325 | #ifndef SQLITE_OMIT_AUTOINIT |
326 | if( sqlite3_initialize() ) return 0; |
327 | #endif |
328 | return sqlite3Malloc(n); |
329 | } |
330 | |
331 | /* |
332 | ** TRUE if p is a lookaside memory allocation from db |
333 | */ |
334 | #ifndef SQLITE_OMIT_LOOKASIDE |
335 | static int isLookaside(sqlite3 *db, const void *p){ |
336 | return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pTrueEnd); |
337 | } |
338 | #else |
339 | #define isLookaside(A,B) 0 |
340 | #endif |
341 | |
342 | /* |
343 | ** Return the size of a memory allocation previously obtained from |
344 | ** sqlite3Malloc() or sqlite3_malloc(). |
345 | */ |
346 | int sqlite3MallocSize(const void *p){ |
347 | assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); |
348 | return sqlite3GlobalConfig.m.xSize((void*)p); |
349 | } |
350 | static int lookasideMallocSize(sqlite3 *db, const void *p){ |
351 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
352 | return p<db->lookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL; |
353 | #else |
354 | return db->lookaside.szTrue; |
355 | #endif |
356 | } |
357 | int sqlite3DbMallocSize(sqlite3 *db, const void *p){ |
358 | assert( p!=0 ); |
359 | #ifdef SQLITE_DEBUG |
360 | if( db==0 ){ |
361 | assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); |
362 | assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); |
363 | }else if( !isLookaside(db,p) ){ |
364 | assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
365 | assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
366 | } |
367 | #endif |
368 | if( db ){ |
369 | if( ((uptr)p)<(uptr)(db->lookaside.pTrueEnd) ){ |
370 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
371 | if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ |
372 | assert( sqlite3_mutex_held(db->mutex) ); |
373 | return LOOKASIDE_SMALL; |
374 | } |
375 | #endif |
376 | if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ |
377 | assert( sqlite3_mutex_held(db->mutex) ); |
378 | return db->lookaside.szTrue; |
379 | } |
380 | } |
381 | } |
382 | return sqlite3GlobalConfig.m.xSize((void*)p); |
383 | } |
384 | sqlite3_uint64 sqlite3_msize(void *p){ |
385 | assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); |
386 | assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); |
387 | return p ? sqlite3GlobalConfig.m.xSize(p) : 0; |
388 | } |
389 | |
390 | /* |
391 | ** Free memory previously obtained from sqlite3Malloc(). |
392 | */ |
393 | void sqlite3_free(void *p){ |
394 | if( p==0 ) return; /* IMP: R-49053-54554 */ |
395 | assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); |
396 | assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); |
397 | if( sqlite3GlobalConfig.bMemstat ){ |
398 | sqlite3_mutex_enter(mem0.mutex); |
399 | sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p)); |
400 | sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); |
401 | sqlite3GlobalConfig.m.xFree(p); |
402 | sqlite3_mutex_leave(mem0.mutex); |
403 | }else{ |
404 | sqlite3GlobalConfig.m.xFree(p); |
405 | } |
406 | } |
407 | |
408 | /* |
409 | ** Add the size of memory allocation "p" to the count in |
410 | ** *db->pnBytesFreed. |
411 | */ |
412 | static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){ |
413 | *db->pnBytesFreed += sqlite3DbMallocSize(db,p); |
414 | } |
415 | |
416 | /* |
417 | ** Free memory that might be associated with a particular database |
418 | ** connection. Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op. |
419 | ** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL. |
420 | */ |
421 | void sqlite3DbFreeNN(sqlite3 *db, void *p){ |
422 | assert( db==0 || sqlite3_mutex_held(db->mutex) ); |
423 | assert( p!=0 ); |
424 | if( db ){ |
425 | if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ |
426 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
427 | if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ |
428 | LookasideSlot *pBuf = (LookasideSlot*)p; |
429 | assert( db->pnBytesFreed==0 ); |
430 | #ifdef SQLITE_DEBUG |
431 | memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */ |
432 | #endif |
433 | pBuf->pNext = db->lookaside.pSmallFree; |
434 | db->lookaside.pSmallFree = pBuf; |
435 | return; |
436 | } |
437 | #endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ |
438 | if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ |
439 | LookasideSlot *pBuf = (LookasideSlot*)p; |
440 | assert( db->pnBytesFreed==0 ); |
441 | #ifdef SQLITE_DEBUG |
442 | memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ |
443 | #endif |
444 | pBuf->pNext = db->lookaside.pFree; |
445 | db->lookaside.pFree = pBuf; |
446 | return; |
447 | } |
448 | } |
449 | if( db->pnBytesFreed ){ |
450 | measureAllocationSize(db, p); |
451 | return; |
452 | } |
453 | } |
454 | assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
455 | assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
456 | assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); |
457 | sqlite3MemdebugSetType(p, MEMTYPE_HEAP); |
458 | sqlite3_free(p); |
459 | } |
460 | void sqlite3DbNNFreeNN(sqlite3 *db, void *p){ |
461 | assert( db!=0 ); |
462 | assert( sqlite3_mutex_held(db->mutex) ); |
463 | assert( p!=0 ); |
464 | if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ |
465 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
466 | if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ |
467 | LookasideSlot *pBuf = (LookasideSlot*)p; |
468 | assert( db->pnBytesFreed==0 ); |
469 | #ifdef SQLITE_DEBUG |
470 | memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */ |
471 | #endif |
472 | pBuf->pNext = db->lookaside.pSmallFree; |
473 | db->lookaside.pSmallFree = pBuf; |
474 | return; |
475 | } |
476 | #endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ |
477 | if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ |
478 | LookasideSlot *pBuf = (LookasideSlot*)p; |
479 | assert( db->pnBytesFreed==0 ); |
480 | #ifdef SQLITE_DEBUG |
481 | memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ |
482 | #endif |
483 | pBuf->pNext = db->lookaside.pFree; |
484 | db->lookaside.pFree = pBuf; |
485 | return; |
486 | } |
487 | } |
488 | if( db->pnBytesFreed ){ |
489 | measureAllocationSize(db, p); |
490 | return; |
491 | } |
492 | assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
493 | assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
494 | sqlite3MemdebugSetType(p, MEMTYPE_HEAP); |
495 | sqlite3_free(p); |
496 | } |
497 | void sqlite3DbFree(sqlite3 *db, void *p){ |
498 | assert( db==0 || sqlite3_mutex_held(db->mutex) ); |
499 | if( p ) sqlite3DbFreeNN(db, p); |
500 | } |
501 | |
502 | /* |
503 | ** Change the size of an existing memory allocation |
504 | */ |
505 | void *sqlite3Realloc(void *pOld, u64 nBytes){ |
506 | int nOld, nNew, nDiff; |
507 | void *pNew; |
508 | assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) ); |
509 | assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) ); |
510 | if( pOld==0 ){ |
511 | return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */ |
512 | } |
513 | if( nBytes==0 ){ |
514 | sqlite3_free(pOld); /* IMP: R-26507-47431 */ |
515 | return 0; |
516 | } |
517 | if( nBytes>=0x7fffff00 ){ |
518 | /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */ |
519 | return 0; |
520 | } |
521 | nOld = sqlite3MallocSize(pOld); |
522 | /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second |
523 | ** argument to xRealloc is always a value returned by a prior call to |
524 | ** xRoundup. */ |
525 | nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes); |
526 | if( nOld==nNew ){ |
527 | pNew = pOld; |
528 | }else if( sqlite3GlobalConfig.bMemstat ){ |
529 | sqlite3_int64 nUsed; |
530 | sqlite3_mutex_enter(mem0.mutex); |
531 | sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes); |
532 | nDiff = nNew - nOld; |
533 | if( nDiff>0 && (nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)) >= |
534 | mem0.alarmThreshold-nDiff ){ |
535 | sqlite3MallocAlarm(nDiff); |
536 | if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){ |
537 | sqlite3_mutex_leave(mem0.mutex); |
538 | return 0; |
539 | } |
540 | } |
541 | pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); |
542 | #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT |
543 | if( pNew==0 && mem0.alarmThreshold>0 ){ |
544 | sqlite3MallocAlarm((int)nBytes); |
545 | pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); |
546 | } |
547 | #endif |
548 | if( pNew ){ |
549 | nNew = sqlite3MallocSize(pNew); |
550 | sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); |
551 | } |
552 | sqlite3_mutex_leave(mem0.mutex); |
553 | }else{ |
554 | pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); |
555 | } |
556 | assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ |
557 | return pNew; |
558 | } |
559 | |
560 | /* |
561 | ** The public interface to sqlite3Realloc. Make sure that the memory |
562 | ** subsystem is initialized prior to invoking sqliteRealloc. |
563 | */ |
564 | void *sqlite3_realloc(void *pOld, int n){ |
565 | #ifndef SQLITE_OMIT_AUTOINIT |
566 | if( sqlite3_initialize() ) return 0; |
567 | #endif |
568 | if( n<0 ) n = 0; /* IMP: R-26507-47431 */ |
569 | return sqlite3Realloc(pOld, n); |
570 | } |
571 | void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){ |
572 | #ifndef SQLITE_OMIT_AUTOINIT |
573 | if( sqlite3_initialize() ) return 0; |
574 | #endif |
575 | return sqlite3Realloc(pOld, n); |
576 | } |
577 | |
578 | |
579 | /* |
580 | ** Allocate and zero memory. |
581 | */ |
582 | void *sqlite3MallocZero(u64 n){ |
583 | void *p = sqlite3Malloc(n); |
584 | if( p ){ |
585 | memset(p, 0, (size_t)n); |
586 | } |
587 | return p; |
588 | } |
589 | |
590 | /* |
591 | ** Allocate and zero memory. If the allocation fails, make |
592 | ** the mallocFailed flag in the connection pointer. |
593 | */ |
594 | void *sqlite3DbMallocZero(sqlite3 *db, u64 n){ |
595 | void *p; |
596 | testcase( db==0 ); |
597 | p = sqlite3DbMallocRaw(db, n); |
598 | if( p ) memset(p, 0, (size_t)n); |
599 | return p; |
600 | } |
601 | |
602 | |
603 | /* Finish the work of sqlite3DbMallocRawNN for the unusual and |
604 | ** slower case when the allocation cannot be fulfilled using lookaside. |
605 | */ |
606 | static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){ |
607 | void *p; |
608 | assert( db!=0 ); |
609 | p = sqlite3Malloc(n); |
610 | if( !p ) sqlite3OomFault(db); |
611 | sqlite3MemdebugSetType(p, |
612 | (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP); |
613 | return p; |
614 | } |
615 | |
616 | /* |
617 | ** Allocate memory, either lookaside (if possible) or heap. |
618 | ** If the allocation fails, set the mallocFailed flag in |
619 | ** the connection pointer. |
620 | ** |
621 | ** If db!=0 and db->mallocFailed is true (indicating a prior malloc |
622 | ** failure on the same database connection) then always return 0. |
623 | ** Hence for a particular database connection, once malloc starts |
624 | ** failing, it fails consistently until mallocFailed is reset. |
625 | ** This is an important assumption. There are many places in the |
626 | ** code that do things like this: |
627 | ** |
628 | ** int *a = (int*)sqlite3DbMallocRaw(db, 100); |
629 | ** int *b = (int*)sqlite3DbMallocRaw(db, 200); |
630 | ** if( b ) a[10] = 9; |
631 | ** |
632 | ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed |
633 | ** that all prior mallocs (ex: "a") worked too. |
634 | ** |
635 | ** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is |
636 | ** not a NULL pointer. |
637 | */ |
638 | void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){ |
639 | void *p; |
640 | if( db ) return sqlite3DbMallocRawNN(db, n); |
641 | p = sqlite3Malloc(n); |
642 | sqlite3MemdebugSetType(p, MEMTYPE_HEAP); |
643 | return p; |
644 | } |
645 | void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){ |
646 | #ifndef SQLITE_OMIT_LOOKASIDE |
647 | LookasideSlot *pBuf; |
648 | assert( db!=0 ); |
649 | assert( sqlite3_mutex_held(db->mutex) ); |
650 | assert( db->pnBytesFreed==0 ); |
651 | if( n>db->lookaside.sz ){ |
652 | if( !db->lookaside.bDisable ){ |
653 | db->lookaside.anStat[1]++; |
654 | }else if( db->mallocFailed ){ |
655 | return 0; |
656 | } |
657 | return dbMallocRawFinish(db, n); |
658 | } |
659 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
660 | if( n<=LOOKASIDE_SMALL ){ |
661 | if( (pBuf = db->lookaside.pSmallFree)!=0 ){ |
662 | db->lookaside.pSmallFree = pBuf->pNext; |
663 | db->lookaside.anStat[0]++; |
664 | return (void*)pBuf; |
665 | }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){ |
666 | db->lookaside.pSmallInit = pBuf->pNext; |
667 | db->lookaside.anStat[0]++; |
668 | return (void*)pBuf; |
669 | } |
670 | } |
671 | #endif |
672 | if( (pBuf = db->lookaside.pFree)!=0 ){ |
673 | db->lookaside.pFree = pBuf->pNext; |
674 | db->lookaside.anStat[0]++; |
675 | return (void*)pBuf; |
676 | }else if( (pBuf = db->lookaside.pInit)!=0 ){ |
677 | db->lookaside.pInit = pBuf->pNext; |
678 | db->lookaside.anStat[0]++; |
679 | return (void*)pBuf; |
680 | }else{ |
681 | db->lookaside.anStat[2]++; |
682 | } |
683 | #else |
684 | assert( db!=0 ); |
685 | assert( sqlite3_mutex_held(db->mutex) ); |
686 | assert( db->pnBytesFreed==0 ); |
687 | if( db->mallocFailed ){ |
688 | return 0; |
689 | } |
690 | #endif |
691 | return dbMallocRawFinish(db, n); |
692 | } |
693 | |
694 | /* Forward declaration */ |
695 | static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n); |
696 | |
697 | /* |
698 | ** Resize the block of memory pointed to by p to n bytes. If the |
699 | ** resize fails, set the mallocFailed flag in the connection object. |
700 | */ |
701 | void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){ |
702 | assert( db!=0 ); |
703 | if( p==0 ) return sqlite3DbMallocRawNN(db, n); |
704 | assert( sqlite3_mutex_held(db->mutex) ); |
705 | if( ((uptr)p)<(uptr)db->lookaside.pEnd ){ |
706 | #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE |
707 | if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){ |
708 | if( n<=LOOKASIDE_SMALL ) return p; |
709 | }else |
710 | #endif |
711 | if( ((uptr)p)>=(uptr)db->lookaside.pStart ){ |
712 | if( n<=db->lookaside.szTrue ) return p; |
713 | } |
714 | } |
715 | return dbReallocFinish(db, p, n); |
716 | } |
717 | static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){ |
718 | void *pNew = 0; |
719 | assert( db!=0 ); |
720 | assert( p!=0 ); |
721 | if( db->mallocFailed==0 ){ |
722 | if( isLookaside(db, p) ){ |
723 | pNew = sqlite3DbMallocRawNN(db, n); |
724 | if( pNew ){ |
725 | memcpy(pNew, p, lookasideMallocSize(db, p)); |
726 | sqlite3DbFree(db, p); |
727 | } |
728 | }else{ |
729 | assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
730 | assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); |
731 | sqlite3MemdebugSetType(p, MEMTYPE_HEAP); |
732 | pNew = sqlite3Realloc(p, n); |
733 | if( !pNew ){ |
734 | sqlite3OomFault(db); |
735 | } |
736 | sqlite3MemdebugSetType(pNew, |
737 | (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP)); |
738 | } |
739 | } |
740 | return pNew; |
741 | } |
742 | |
743 | /* |
744 | ** Attempt to reallocate p. If the reallocation fails, then free p |
745 | ** and set the mallocFailed flag in the database connection. |
746 | */ |
747 | void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){ |
748 | void *pNew; |
749 | pNew = sqlite3DbRealloc(db, p, n); |
750 | if( !pNew ){ |
751 | sqlite3DbFree(db, p); |
752 | } |
753 | return pNew; |
754 | } |
755 | |
756 | /* |
757 | ** Make a copy of a string in memory obtained from sqliteMalloc(). These |
758 | ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This |
759 | ** is because when memory debugging is turned on, these two functions are |
760 | ** called via macros that record the current file and line number in the |
761 | ** ThreadData structure. |
762 | */ |
763 | char *sqlite3DbStrDup(sqlite3 *db, const char *z){ |
764 | char *zNew; |
765 | size_t n; |
766 | if( z==0 ){ |
767 | return 0; |
768 | } |
769 | n = strlen(z) + 1; |
770 | zNew = sqlite3DbMallocRaw(db, n); |
771 | if( zNew ){ |
772 | memcpy(zNew, z, n); |
773 | } |
774 | return zNew; |
775 | } |
776 | char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){ |
777 | char *zNew; |
778 | assert( db!=0 ); |
779 | assert( z!=0 || n==0 ); |
780 | assert( (n&0x7fffffff)==n ); |
781 | zNew = z ? sqlite3DbMallocRawNN(db, n+1) : 0; |
782 | if( zNew ){ |
783 | memcpy(zNew, z, (size_t)n); |
784 | zNew[n] = 0; |
785 | } |
786 | return zNew; |
787 | } |
788 | |
789 | /* |
790 | ** The text between zStart and zEnd represents a phrase within a larger |
791 | ** SQL statement. Make a copy of this phrase in space obtained form |
792 | ** sqlite3DbMalloc(). Omit leading and trailing whitespace. |
793 | */ |
794 | char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ |
795 | int n; |
796 | while( sqlite3Isspace(zStart[0]) ) zStart++; |
797 | n = (int)(zEnd - zStart); |
798 | while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--; |
799 | return sqlite3DbStrNDup(db, zStart, n); |
800 | } |
801 | |
802 | /* |
803 | ** Free any prior content in *pz and replace it with a copy of zNew. |
804 | */ |
805 | void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){ |
806 | char *z = sqlite3DbStrDup(db, zNew); |
807 | sqlite3DbFree(db, *pz); |
808 | *pz = z; |
809 | } |
810 | |
811 | /* |
812 | ** Call this routine to record the fact that an OOM (out-of-memory) error |
813 | ** has happened. This routine will set db->mallocFailed, and also |
814 | ** temporarily disable the lookaside memory allocator and interrupt |
815 | ** any running VDBEs. |
816 | ** |
817 | ** Always return a NULL pointer so that this routine can be invoked using |
818 | ** |
819 | ** return sqlite3OomFault(db); |
820 | ** |
821 | ** and thereby avoid unnecessary stack frame allocations for the overwhelmingly |
822 | ** common case where no OOM occurs. |
823 | */ |
824 | void *sqlite3OomFault(sqlite3 *db){ |
825 | if( db->mallocFailed==0 && db->bBenignMalloc==0 ){ |
826 | db->mallocFailed = 1; |
827 | if( db->nVdbeExec>0 ){ |
828 | AtomicStore(&db->u1.isInterrupted, 1); |
829 | } |
830 | DisableLookaside; |
831 | if( db->pParse ){ |
832 | Parse *pParse; |
833 | sqlite3ErrorMsg(db->pParse, "out of memory" ); |
834 | db->pParse->rc = SQLITE_NOMEM_BKPT; |
835 | for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){ |
836 | pParse->nErr++; |
837 | pParse->rc = SQLITE_NOMEM; |
838 | } |
839 | } |
840 | } |
841 | return 0; |
842 | } |
843 | |
844 | /* |
845 | ** This routine reactivates the memory allocator and clears the |
846 | ** db->mallocFailed flag as necessary. |
847 | ** |
848 | ** The memory allocator is not restarted if there are running |
849 | ** VDBEs. |
850 | */ |
851 | void sqlite3OomClear(sqlite3 *db){ |
852 | if( db->mallocFailed && db->nVdbeExec==0 ){ |
853 | db->mallocFailed = 0; |
854 | AtomicStore(&db->u1.isInterrupted, 0); |
855 | assert( db->lookaside.bDisable>0 ); |
856 | EnableLookaside; |
857 | } |
858 | } |
859 | |
860 | /* |
861 | ** Take actions at the end of an API call to deal with error codes. |
862 | */ |
863 | static SQLITE_NOINLINE int apiHandleError(sqlite3 *db, int rc){ |
864 | if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){ |
865 | sqlite3OomClear(db); |
866 | sqlite3Error(db, SQLITE_NOMEM); |
867 | return SQLITE_NOMEM_BKPT; |
868 | } |
869 | return rc & db->errMask; |
870 | } |
871 | |
872 | /* |
873 | ** This function must be called before exiting any API function (i.e. |
874 | ** returning control to the user) that has called sqlite3_malloc or |
875 | ** sqlite3_realloc. |
876 | ** |
877 | ** The returned value is normally a copy of the second argument to this |
878 | ** function. However, if a malloc() failure has occurred since the previous |
879 | ** invocation SQLITE_NOMEM is returned instead. |
880 | ** |
881 | ** If an OOM as occurred, then the connection error-code (the value |
882 | ** returned by sqlite3_errcode()) is set to SQLITE_NOMEM. |
883 | */ |
884 | int sqlite3ApiExit(sqlite3* db, int rc){ |
885 | /* If the db handle must hold the connection handle mutex here. |
886 | ** Otherwise the read (and possible write) of db->mallocFailed |
887 | ** is unsafe, as is the call to sqlite3Error(). |
888 | */ |
889 | assert( db!=0 ); |
890 | assert( sqlite3_mutex_held(db->mutex) ); |
891 | if( db->mallocFailed || rc ){ |
892 | return apiHandleError(db, rc); |
893 | } |
894 | return rc & db->errMask; |
895 | } |
896 | |