1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/mem2.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,443 @@
1.4 +/*
1.5 +** 2007 August 15
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** This file contains low-level memory allocation drivers for when
1.17 +** SQLite will use the standard C-library malloc/realloc/free interface
1.18 +** to obtain the memory it needs while adding lots of additional debugging
1.19 +** information to each allocation in order to help detect and fix memory
1.20 +** leaks and memory usage errors.
1.21 +**
1.22 +** This file contains implementations of the low-level memory allocation
1.23 +** routines specified in the sqlite3_mem_methods object.
1.24 +**
1.25 +** $Id: mem2.c,v 1.37 2008/07/25 08:49:00 danielk1977 Exp $
1.26 +*/
1.27 +#include "sqliteInt.h"
1.28 +
1.29 +/*
1.30 +** This version of the memory allocator is used only if the
1.31 +** SQLITE_MEMDEBUG macro is defined
1.32 +*/
1.33 +#ifdef SQLITE_MEMDEBUG
1.34 +
1.35 +/*
1.36 +** The backtrace functionality is only available with GLIBC
1.37 +*/
1.38 +#ifdef __GLIBC__
1.39 + extern int backtrace(void**,int);
1.40 + extern void backtrace_symbols_fd(void*const*,int,int);
1.41 +#else
1.42 +# define backtrace(A,B) 0
1.43 +# define backtrace_symbols_fd(A,B,C)
1.44 +#endif
1.45 +#include <stdio.h>
1.46 +
1.47 +/*
1.48 +** Each memory allocation looks like this:
1.49 +**
1.50 +** ------------------------------------------------------------------------
1.51 +** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard |
1.52 +** ------------------------------------------------------------------------
1.53 +**
1.54 +** The application code sees only a pointer to the allocation. We have
1.55 +** to back up from the allocation pointer to find the MemBlockHdr. The
1.56 +** MemBlockHdr tells us the size of the allocation and the number of
1.57 +** backtrace pointers. There is also a guard word at the end of the
1.58 +** MemBlockHdr.
1.59 +*/
1.60 +struct MemBlockHdr {
1.61 + i64 iSize; /* Size of this allocation */
1.62 + struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
1.63 + char nBacktrace; /* Number of backtraces on this alloc */
1.64 + char nBacktraceSlots; /* Available backtrace slots */
1.65 + short nTitle; /* Bytes of title; includes '\0' */
1.66 + int iForeGuard; /* Guard word for sanity */
1.67 +};
1.68 +
1.69 +/*
1.70 +** Guard words
1.71 +*/
1.72 +#define FOREGUARD 0x80F5E153
1.73 +#define REARGUARD 0xE4676B53
1.74 +
1.75 +/*
1.76 +** Number of malloc size increments to track.
1.77 +*/
1.78 +#define NCSIZE 1000
1.79 +
1.80 +/*
1.81 +** All of the static variables used by this module are collected
1.82 +** into a single structure named "mem". This is to keep the
1.83 +** static variables organized and to reduce namespace pollution
1.84 +** when this module is combined with other in the amalgamation.
1.85 +*/
1.86 +static struct {
1.87 +
1.88 + /*
1.89 + ** Mutex to control access to the memory allocation subsystem.
1.90 + */
1.91 + sqlite3_mutex *mutex;
1.92 +
1.93 + /*
1.94 + ** Head and tail of a linked list of all outstanding allocations
1.95 + */
1.96 + struct MemBlockHdr *pFirst;
1.97 + struct MemBlockHdr *pLast;
1.98 +
1.99 + /*
1.100 + ** The number of levels of backtrace to save in new allocations.
1.101 + */
1.102 + int nBacktrace;
1.103 + void (*xBacktrace)(int, int, void **);
1.104 +
1.105 + /*
1.106 + ** Title text to insert in front of each block
1.107 + */
1.108 + int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */
1.109 + char zTitle[100]; /* The title text */
1.110 +
1.111 + /*
1.112 + ** sqlite3MallocDisallow() increments the following counter.
1.113 + ** sqlite3MallocAllow() decrements it.
1.114 + */
1.115 + int disallow; /* Do not allow memory allocation */
1.116 +
1.117 + /*
1.118 + ** Gather statistics on the sizes of memory allocations.
1.119 + ** nAlloc[i] is the number of allocation attempts of i*8
1.120 + ** bytes. i==NCSIZE is the number of allocation attempts for
1.121 + ** sizes more than NCSIZE*8 bytes.
1.122 + */
1.123 + int nAlloc[NCSIZE]; /* Total number of allocations */
1.124 + int nCurrent[NCSIZE]; /* Current number of allocations */
1.125 + int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */
1.126 +
1.127 +} mem;
1.128 +
1.129 +
1.130 +/*
1.131 +** Adjust memory usage statistics
1.132 +*/
1.133 +static void adjustStats(int iSize, int increment){
1.134 + int i = ((iSize+7)&~7)/8;
1.135 + if( i>NCSIZE-1 ){
1.136 + i = NCSIZE - 1;
1.137 + }
1.138 + if( increment>0 ){
1.139 + mem.nAlloc[i]++;
1.140 + mem.nCurrent[i]++;
1.141 + if( mem.nCurrent[i]>mem.mxCurrent[i] ){
1.142 + mem.mxCurrent[i] = mem.nCurrent[i];
1.143 + }
1.144 + }else{
1.145 + mem.nCurrent[i]--;
1.146 + assert( mem.nCurrent[i]>=0 );
1.147 + }
1.148 +}
1.149 +
1.150 +/*
1.151 +** Given an allocation, find the MemBlockHdr for that allocation.
1.152 +**
1.153 +** This routine checks the guards at either end of the allocation and
1.154 +** if they are incorrect it asserts.
1.155 +*/
1.156 +static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
1.157 + struct MemBlockHdr *p;
1.158 + int *pInt;
1.159 + u8 *pU8;
1.160 + int nReserve;
1.161 +
1.162 + p = (struct MemBlockHdr*)pAllocation;
1.163 + p--;
1.164 + assert( p->iForeGuard==FOREGUARD );
1.165 + nReserve = (p->iSize+7)&~7;
1.166 + pInt = (int*)pAllocation;
1.167 + pU8 = (u8*)pAllocation;
1.168 + assert( pInt[nReserve/sizeof(int)]==REARGUARD );
1.169 + assert( (nReserve-0)<=p->iSize || pU8[nReserve-1]==0x65 );
1.170 + assert( (nReserve-1)<=p->iSize || pU8[nReserve-2]==0x65 );
1.171 + assert( (nReserve-2)<=p->iSize || pU8[nReserve-3]==0x65 );
1.172 + return p;
1.173 +}
1.174 +
1.175 +/*
1.176 +** Return the number of bytes currently allocated at address p.
1.177 +*/
1.178 +static int sqlite3MemSize(void *p){
1.179 + struct MemBlockHdr *pHdr;
1.180 + if( !p ){
1.181 + return 0;
1.182 + }
1.183 + pHdr = sqlite3MemsysGetHeader(p);
1.184 + return pHdr->iSize;
1.185 +}
1.186 +
1.187 +/*
1.188 +** Initialize the memory allocation subsystem.
1.189 +*/
1.190 +static int sqlite3MemInit(void *NotUsed){
1.191 + if( !sqlite3Config.bMemstat ){
1.192 + /* If memory status is enabled, then the malloc.c wrapper will already
1.193 + ** hold the STATIC_MEM mutex when the routines here are invoked. */
1.194 + mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
1.195 + }
1.196 + return SQLITE_OK;
1.197 +}
1.198 +
1.199 +/*
1.200 +** Deinitialize the memory allocation subsystem.
1.201 +*/
1.202 +static void sqlite3MemShutdown(void *NotUsed){
1.203 + mem.mutex = 0;
1.204 +}
1.205 +
1.206 +/*
1.207 +** Round up a request size to the next valid allocation size.
1.208 +*/
1.209 +static int sqlite3MemRoundup(int n){
1.210 + return (n+7) & ~7;
1.211 +}
1.212 +
1.213 +/*
1.214 +** Allocate nByte bytes of memory.
1.215 +*/
1.216 +static void *sqlite3MemMalloc(int nByte){
1.217 + struct MemBlockHdr *pHdr;
1.218 + void **pBt;
1.219 + char *z;
1.220 + int *pInt;
1.221 + void *p = 0;
1.222 + int totalSize;
1.223 + int nReserve;
1.224 + sqlite3_mutex_enter(mem.mutex);
1.225 + assert( mem.disallow==0 );
1.226 + nReserve = (nByte+7)&~7;
1.227 + totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
1.228 + mem.nBacktrace*sizeof(void*) + mem.nTitle;
1.229 + p = malloc(totalSize);
1.230 + if( p ){
1.231 + z = p;
1.232 + pBt = (void**)&z[mem.nTitle];
1.233 + pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
1.234 + pHdr->pNext = 0;
1.235 + pHdr->pPrev = mem.pLast;
1.236 + if( mem.pLast ){
1.237 + mem.pLast->pNext = pHdr;
1.238 + }else{
1.239 + mem.pFirst = pHdr;
1.240 + }
1.241 + mem.pLast = pHdr;
1.242 + pHdr->iForeGuard = FOREGUARD;
1.243 + pHdr->nBacktraceSlots = mem.nBacktrace;
1.244 + pHdr->nTitle = mem.nTitle;
1.245 + if( mem.nBacktrace ){
1.246 + void *aAddr[40];
1.247 + pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
1.248 + memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
1.249 + if( mem.xBacktrace ){
1.250 + mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
1.251 + }
1.252 + }else{
1.253 + pHdr->nBacktrace = 0;
1.254 + }
1.255 + if( mem.nTitle ){
1.256 + memcpy(z, mem.zTitle, mem.nTitle);
1.257 + }
1.258 + pHdr->iSize = nByte;
1.259 + adjustStats(nByte, +1);
1.260 + pInt = (int*)&pHdr[1];
1.261 + pInt[nReserve/sizeof(int)] = REARGUARD;
1.262 + memset(pInt, 0x65, nReserve);
1.263 + p = (void*)pInt;
1.264 + }
1.265 + sqlite3_mutex_leave(mem.mutex);
1.266 + return p;
1.267 +}
1.268 +
1.269 +/*
1.270 +** Free memory.
1.271 +*/
1.272 +static void sqlite3MemFree(void *pPrior){
1.273 + struct MemBlockHdr *pHdr;
1.274 + void **pBt;
1.275 + char *z;
1.276 + assert( sqlite3Config.bMemstat || mem.mutex!=0 );
1.277 + pHdr = sqlite3MemsysGetHeader(pPrior);
1.278 + pBt = (void**)pHdr;
1.279 + pBt -= pHdr->nBacktraceSlots;
1.280 + sqlite3_mutex_enter(mem.mutex);
1.281 + if( pHdr->pPrev ){
1.282 + assert( pHdr->pPrev->pNext==pHdr );
1.283 + pHdr->pPrev->pNext = pHdr->pNext;
1.284 + }else{
1.285 + assert( mem.pFirst==pHdr );
1.286 + mem.pFirst = pHdr->pNext;
1.287 + }
1.288 + if( pHdr->pNext ){
1.289 + assert( pHdr->pNext->pPrev==pHdr );
1.290 + pHdr->pNext->pPrev = pHdr->pPrev;
1.291 + }else{
1.292 + assert( mem.pLast==pHdr );
1.293 + mem.pLast = pHdr->pPrev;
1.294 + }
1.295 + z = (char*)pBt;
1.296 + z -= pHdr->nTitle;
1.297 + adjustStats(pHdr->iSize, -1);
1.298 + memset(z, 0x2b, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
1.299 + pHdr->iSize + sizeof(int) + pHdr->nTitle);
1.300 + free(z);
1.301 + sqlite3_mutex_leave(mem.mutex);
1.302 +}
1.303 +
1.304 +/*
1.305 +** Change the size of an existing memory allocation.
1.306 +**
1.307 +** For this debugging implementation, we *always* make a copy of the
1.308 +** allocation into a new place in memory. In this way, if the
1.309 +** higher level code is using pointer to the old allocation, it is
1.310 +** much more likely to break and we are much more liking to find
1.311 +** the error.
1.312 +*/
1.313 +static void *sqlite3MemRealloc(void *pPrior, int nByte){
1.314 + struct MemBlockHdr *pOldHdr;
1.315 + void *pNew;
1.316 + assert( mem.disallow==0 );
1.317 + pOldHdr = sqlite3MemsysGetHeader(pPrior);
1.318 + pNew = sqlite3MemMalloc(nByte);
1.319 + if( pNew ){
1.320 + memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
1.321 + if( nByte>pOldHdr->iSize ){
1.322 + memset(&((char*)pNew)[pOldHdr->iSize], 0x2b, nByte - pOldHdr->iSize);
1.323 + }
1.324 + sqlite3MemFree(pPrior);
1.325 + }
1.326 + return pNew;
1.327 +}
1.328 +
1.329 +
1.330 +const sqlite3_mem_methods *sqlite3MemGetDefault(void){
1.331 + static const sqlite3_mem_methods defaultMethods = {
1.332 + sqlite3MemMalloc,
1.333 + sqlite3MemFree,
1.334 + sqlite3MemRealloc,
1.335 + sqlite3MemSize,
1.336 + sqlite3MemRoundup,
1.337 + sqlite3MemInit,
1.338 + sqlite3MemShutdown,
1.339 + 0
1.340 + };
1.341 + return &defaultMethods;
1.342 +}
1.343 +
1.344 +/*
1.345 +** Populate the low-level memory allocation function pointers in
1.346 +** sqlite3Config.m with pointers to the routines in this file.
1.347 +*/
1.348 +void sqlite3MemSetDefault(void){
1.349 + sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetDefault());
1.350 +}
1.351 +
1.352 +/*
1.353 +** Set the number of backtrace levels kept for each allocation.
1.354 +** A value of zero turns off backtracing. The number is always rounded
1.355 +** up to a multiple of 2.
1.356 +*/
1.357 +void sqlite3MemdebugBacktrace(int depth){
1.358 + if( depth<0 ){ depth = 0; }
1.359 + if( depth>20 ){ depth = 20; }
1.360 + depth = (depth+1)&0xfe;
1.361 + mem.nBacktrace = depth;
1.362 +}
1.363 +
1.364 +void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
1.365 + mem.xBacktrace = xBacktrace;
1.366 +}
1.367 +
1.368 +/*
1.369 +** Set the title string for subsequent allocations.
1.370 +*/
1.371 +void sqlite3MemdebugSettitle(const char *zTitle){
1.372 + int n = strlen(zTitle) + 1;
1.373 + sqlite3_mutex_enter(mem.mutex);
1.374 + if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
1.375 + memcpy(mem.zTitle, zTitle, n);
1.376 + mem.zTitle[n] = 0;
1.377 + mem.nTitle = (n+7)&~7;
1.378 + sqlite3_mutex_leave(mem.mutex);
1.379 +}
1.380 +
1.381 +void sqlite3MemdebugSync(){
1.382 + struct MemBlockHdr *pHdr;
1.383 + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
1.384 + void **pBt = (void**)pHdr;
1.385 + pBt -= pHdr->nBacktraceSlots;
1.386 + mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
1.387 + }
1.388 +}
1.389 +
1.390 +/*
1.391 +** Open the file indicated and write a log of all unfreed memory
1.392 +** allocations into that log.
1.393 +*/
1.394 +void sqlite3MemdebugDump(const char *zFilename){
1.395 + FILE *out;
1.396 + struct MemBlockHdr *pHdr;
1.397 + void **pBt;
1.398 + int i;
1.399 + out = fopen(zFilename, "w");
1.400 + if( out==0 ){
1.401 + fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
1.402 + zFilename);
1.403 + return;
1.404 + }
1.405 + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
1.406 + char *z = (char*)pHdr;
1.407 + z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
1.408 + fprintf(out, "**** %lld bytes at %p from %s ****\n",
1.409 + pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
1.410 + if( pHdr->nBacktrace ){
1.411 + fflush(out);
1.412 + pBt = (void**)pHdr;
1.413 + pBt -= pHdr->nBacktraceSlots;
1.414 + backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
1.415 + fprintf(out, "\n");
1.416 + }
1.417 + }
1.418 + fprintf(out, "COUNTS:\n");
1.419 + for(i=0; i<NCSIZE-1; i++){
1.420 + if( mem.nAlloc[i] ){
1.421 + fprintf(out, " %5d: %10d %10d %10d\n",
1.422 + i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
1.423 + }
1.424 + }
1.425 + if( mem.nAlloc[NCSIZE-1] ){
1.426 + fprintf(out, " %5d: %10d %10d %10d\n",
1.427 + NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
1.428 + mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
1.429 + }
1.430 + fclose(out);
1.431 +}
1.432 +
1.433 +/*
1.434 +** Return the number of times sqlite3MemMalloc() has been called.
1.435 +*/
1.436 +int sqlite3MemdebugMallocCount(){
1.437 + int i;
1.438 + int nTotal = 0;
1.439 + for(i=0; i<NCSIZE; i++){
1.440 + nTotal += mem.nAlloc[i];
1.441 + }
1.442 + return nTotal;
1.443 +}
1.444 +
1.445 +
1.446 +#endif /* SQLITE_MEMDEBUG */