Add a debugging memory allocator. (CVS 4227)

FossilOrigin-Name: 8d2d1c4ff9dca61f75e3048107ee9712d346a28c

src/mem2.c

@@ -0,0 +1,366 @@
+/*
+** 2007 August 15
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** This file contains the C functions that implement a memory
+** allocation subsystem for use by SQLite.  
+**
+** $Id: mem2.c,v 1.1 2007/08/15 17:07:57 drh Exp $
+*/
+
+/*
+** This version of the memory allocator is used only if the
+** SQLITE_MEMDEBUG macro is defined and SQLITE_OMIT_MEMORY_ALLOCATION
+** is not defined.
+*/
+#if defined(SQLITE_MEMDEBUG) && !defined(SQLITE_OMIT_MEMORY_ALLOCATION)
+
+/*
+** We will eventually construct multiple memory allocation subsystems
+** suitable for use in various contexts:
+**
+**    *  Normal multi-threaded builds
+**    *  Normal single-threaded builds
+**    *  Debugging builds
+**
+** This version is suitable for use in debugging builds.
+**
+** Features:
+**
+**    * Every allocate has guards at both ends.
+**    * New allocations are initialized with randomness
+**    * Allocations are overwritten with randomness when freed
+**    * Optional logs of malloc activity generated
+**    * Summary of outstanding allocations with backtraces to the
+**      point of allocation.
+**    * The ability to simulate memory allocation failure
+*/
+#include "sqliteInt.h"
+#include <stdio.h>
+
+/*
+** The backtrace functionality is only available with GLIBC
+*/
+#ifdef __GLIBC__
+  extern int backtrace(void**,int);
+  extern void backtrace_symbols_fd(void*const*,int,int);
+#else
+# define backtrace(A,B) 0
+# define backtrace_symbols_fd(A,B,C)
+#endif
+
+
+/*
+** Mutex to control access to the memory allocation subsystem.
+*/
+static sqlite3_mutex *memMutex = 0;
+
+/*
+** Current allocation and high-water mark.
+*/
+static sqlite3_uint64 nowUsed = 0;
+static sqlite3_uint64 mxUsed = 0;
+
+/*
+** The alarm callback and its arguments.  The memMutex lock will
+** be held while the callback is running.  Recursive calls into
+** the memory subsystem are allowed, but no new callbacks will be
+** issued.  The alarmBusy variable is set to prevent recursive
+** callbacks.
+*/
+static void (*alarmCallback)(void*, sqlite3_uint64, unsigned) = 0;
+static void *alarmArg = 0;
+static sqlite3_uint64 alarmThreshold = (((sqlite3_uint64)1)<<63);
+static int alarmBusy = 0;
+
+
+/*
+** Return the amount of memory currently checked out.
+*/
+sqlite3_uint64 sqlite3_memory_used(void){
+  sqlite3_uint64 n;
+  if( memMutex==0 ){
+    memMutex = sqlite3_mutex_alloc(1);
+  }
+  sqlite3_mutex_enter(memMutex, 1);
+  n = nowUsed;
+  sqlite3_mutex_leave(memMutex);  
+  return n;
+}
+
+/*
+** Return the maximum amount of memory that has ever been
+** checked out since either the beginning of this process
+** or since the most recent reset.
+*/
+sqlite3_uint64 sqlite3_memory_highwater(int resetFlag){
+  sqlite3_uint64 n;
+  if( memMutex==0 ){
+    memMutex = sqlite3_mutex_alloc(1);
+  }
+  sqlite3_mutex_enter(memMutex, 1);
+  n = mxUsed;
+  if( resetFlag ){
+    mxUsed = nowUsed;
+  }
+  sqlite3_mutex_leave(memMutex);  
+  return n;
+}
+
+/*
+** Change the alarm callback
+*/
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_uint64 used, unsigned int N),
+  void *pArg,
+  sqlite3_uint64 iThreshold
+){
+  if( memMutex==0 ){
+    memMutex = sqlite3_mutex_alloc(1);
+  }
+  sqlite3_mutex_enter(memMutex, 1);
+  alarmCallback = xCallback;
+  alarmArg = pArg;
+  alarmThreshold = iThreshold;
+  sqlite3_mutex_leave(memMutex);
+  return SQLITE_OK;
+}
+
+/*
+** Trigger the alarm 
+*/
+static void sqlite3MemsysAlarm(unsigned nByte){
+  if( alarmCallback==0 || alarmBusy  ) return;
+  alarmBusy = 1;
+  alarmCallback(alarmArg, nowUsed, nByte);
+  alarmBusy = 0;
+}
+
+/*
+** Each memory allocation looks like this:
+**
+**    ----------------------------------------------------------------
+**    |  backtrace pointers |  MemBlockHdr |  allocation |  EndGuard |
+**    ----------------------------------------------------------------
+**
+** The application code sees only a pointer to the allocation.  We have
+** to back up from the allocation pointer to find the MemBlockHdr.  The
+** MemBlockHdr tells us the size of the allocation and the number of
+** backtrace pointers.  There is also a guard word at the end of the
+** MemBlockHdr.
+*/
+struct MemBlockHdr {
+  struct MemBlockHdr *pNext, *pPrev;  /* Linked list of all unfreed memory */
+  unsigned int iSize;                 /* Size of this allocation */
+  unsigned short nBacktrace;          /* Number of backtraces on this alloc */
+  unsigned short nBacktraceSlots;     /* Available backtrace slots */
+  unsigned int iForeGuard;            /* Guard word for sanity */
+};
+
+/*
+** Guard words
+*/
+#define FOREGUARD 0x80F5E153
+#define REARGUARD 0xE4676B53
+
+/*
+** Head and tail of a linked list of all outstanding allocations
+*/
+static struct MemBlockHdr *pFirst = 0;
+static struct MemBlockHdr *pLast = 0;
+
+/*
+** The number of levels of backtrace to save in new allocations.
+*/
+static int backtraceLevels = 0;
+
+/*
+** Given an allocation, find the MemBlockHdr for that allocation.
+**
+** This routine checks the guards at either end of the allocation and
+** if they are incorrect it asserts.
+*/
+static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
+  struct MemBlockHdr *p;
+  unsigned int *pInt;
+
+  p = (struct MemBlockHdr*)pAllocation;
+  p--;
+  assert( p->iForeGuard==FOREGUARD );
+  assert( (p->iSize & 3)==0 );
+  pInt = (unsigned int*)pAllocation;
+  assert( pInt[p->iSize/sizeof(unsigned int)]==REARGUARD );
+  return p;
+}
+
+/*
+** Allocate nByte of memory
+*/
+void *sqlite3_malloc(unsigned int nByte){
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  unsigned int *pInt;
+  void *p;
+  unsigned int totalSize;
+
+  if( memMutex==0 ){
+    memMutex = sqlite3_mutex_alloc(1);
+  }
+  sqlite3_mutex_enter(memMutex, 1);
+  if( nowUsed+nByte>=alarmThreshold ){
+    sqlite3MemsysAlarm(nByte);
+  }
+  nByte = (nByte+3)&~3;
+  totalSize = nByte + sizeof(*pHdr) + sizeof(unsigned int) +
+               backtraceLevels*sizeof(void*);
+  p = malloc(totalSize);
+  if( p==0 ){
+    sqlite3MemsysAlarm(nByte);
+    p = malloc(totalSize);
+  }
+  if( p ){
+    pBt = p;
+    pHdr = (struct MemBlockHdr*)&pBt[backtraceLevels];
+    pHdr->pNext = 0;
+    pHdr->pPrev = pLast;
+    if( pLast ){
+      pLast->pNext = pHdr;
+    }else{
+      pFirst = pHdr;
+    }
+    pLast = pHdr;
+    pHdr->iForeGuard = FOREGUARD;
+    pHdr->nBacktraceSlots = backtraceLevels;
+    if( backtraceLevels ){
+      pHdr->nBacktrace = backtrace(pBt, backtraceLevels);
+    }else{
+      pHdr->nBacktrace = 0;
+    }
+    pHdr->iSize = nByte;
+    pInt = (unsigned int *)&pHdr[1];
+    pInt[nByte/sizeof(unsigned int)] = REARGUARD;
+    memset(pInt, 0x65, nByte);
+    nowUsed += nByte;
+    if( nowUsed>mxUsed ){
+      mxUsed = nowUsed;
+    }
+    p = (void*)pInt;
+  }
+  sqlite3_mutex_leave(memMutex);
+  return p; 
+}
+
+/*
+** Free memory.
+*/
+void sqlite3_free(void *pPrior){
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  if( pPrior==0 ){
+    return;
+  }
+  assert( memMutex!=0 );
+  pHdr = sqlite3MemsysGetHeader(pPrior);
+  pBt = (void**)pHdr;
+  pBt -= pHdr->nBacktraceSlots;
+  sqlite3_mutex_enter(memMutex, 1);
+  nowUsed -= pHdr->iSize;
+  if( pHdr->pPrev ){
+    assert( pHdr->pPrev->pNext==pHdr );
+    pHdr->pPrev->pNext = pHdr->pNext;
+  }else{
+    assert( pFirst==pHdr );
+    pFirst = pHdr->pNext;
+  }
+  if( pHdr->pNext ){
+    assert( pHdr->pNext->pPrev==pHdr );
+    pHdr->pNext->pPrev = pHdr->pPrev;
+  }else{
+    assert( pLast==pHdr );
+    pLast = pHdr->pPrev;
+  }
+  memset(pBt, 0x2b, sizeof(void*)*pHdr->nBacktrace + sizeof(*pHdr) +
+                    pHdr->iSize + sizeof(unsigned int));
+  free(pBt);
+  sqlite3_mutex_leave(memMutex);  
+}
+
+/*
+** Change the size of an existing memory allocation.
+**
+** For this debugging implementation, we *always* make a copy of the
+** allocation into a new place in memory.  In this way, if the 
+** higher level code is using pointer to the old allocation, it is 
+** much more likely to break and we are much more liking to find
+** the error.
+*/
+void *sqlite3_realloc(void *pPrior, unsigned int nByte){
+  struct MemBlockHdr *pOldHdr;
+  void *pNew;
+  unsigned nOld;
+  if( pPrior==0 ){
+    return sqlite3_malloc(nByte);
+  }
+  if( nByte==0 ){
+    sqlite3_free(pPrior);
+    return;
+  }
+  pOldHdr = sqlite3MemsysGetHeader(pPrior);
+  pNew = sqlite3_malloc(nByte);
+  if( pNew ){
+    memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
+    if( nByte>pOldHdr->iSize ){
+      memset(&((char*)pNew)[pOldHdr->iSize], 0x2b, nByte - pOldHdr->iSize);
+    }
+    sqlite3_free(pPrior);
+  }
+  return pNew;
+}
+
+/*
+** Set the number of backtrace levels kept for each allocation.
+** A value of zero turns of backtracing.  The number is always rounded
+** up to a multiple of 2.
+*/
+void sqlite3_memdebug_backtrace_depth(int depth){
+  if( depth<0 ){ depth = 0; }
+  if( depth>20 ){ depth = 20; }
+  depth = (depth+1)&~1;
+  backtraceLevels = depth;
+}
+
+/*
+** Open the file indicated and write a log of all unfreed memory 
+** allocations into that log.
+*/
+void sqlite3_memdebug_dump(const char *zFilename){
+  FILE *out;
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  out = fopen(zFilename, "w");
+  if( out==0 ){
+    fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
+                    zFilename);
+    return;
+  }
+  for(pHdr=pFirst; pHdr; pHdr=pHdr->pNext){
+    fprintf(out, "**** %d bytes at %p ****\n", pHdr->iSize, &pHdr[1]);
+    if( pHdr->nBacktrace ){
+      fflush(out);
+      pBt = (void**)pHdr;
+      pBt -= pHdr->nBacktraceSlots;
+      backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
+      fprintf(out, "\n");
+    }
+  }
+  fclose(out);
+}
+
+#endif /* SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */