KalFitMemLeak.c File Reference

#include "memwatch.h"
#include <limits.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>

Go to the source code of this file.

Classes
struct	mwData_
struct	mwStat_
struct	mwGrabData_
struct	mwMarker_

Macros
#define	__MEMWATCH_C   1
#define	VERSION   "2.71" /* the current version number */
#define	CHKVAL(mw)
#define	FLUSH()
#define	TESTS(f, l)
#define	PRECHK   0x01234567L
#define	POSTCHK   0x76543210L
#define	mwBUFFER_TO_MW(p)
#define	MW_NML   0x0001
#define	COMMIT   "" /* Normal ANSI */
#define	CPPTEXT   ""
#define	mwSTDERR   mwLog
#define	MW_MUTEX_INIT()
#define	MW_MUTEX_TERM()
#define	MW_MUTEX_LOCK()
#define	MW_MUTEX_UNLOCK()
#define	mw16BIT   1
#define	mwROUNDALLOC_DEFAULT   2
#define	mwROUNDALLOC   mwROUNDALLOC_DEFAULT
#define	AIPH()

Typedefs
typedef struct mwData_	mwData
typedef struct mwStat_	mwStat
typedef struct mwGrabData_	mwGrabData
typedef struct mwMarker_	mwMarker

Functions
void	mwInit (void)
void	mwAbort (void)
void	mwTerm (void)
void	mwStatistics (int level)
void	mwAutoCheck (int onoff)
void	mwSetOutFunc (void(*func)(int))
int	mwTest (const char *file, int line, int items)
int	mwTestBuffer (const char *file, int line, void *p)
void	mwBreakOut (const char *cause)
void *	mwMark (void *p, const char *desc, const char *file, unsigned line)
void *	mwUnmark (void *p, const char *file, unsigned line)
int	mwAriHandler (const char *estr)
void	mwSetAriFunc (int(*func)(const char *))
void *	mwMalloc (size_t size, const char *file, int line)
void *	mwRealloc (void *p, size_t size, const char *file, int line)
char *	mwStrdup (const char *str, const char *file, int line)
void	mwFree (void *p, const char *file, int line)
void *	mwCalloc (size_t a, size_t b, const char *file, int line)
void	mwFree_ (void *p)
void *	mwMalloc_ (size_t size)
void *	mwRealloc_ (void *p, size_t size)
void *	mwCalloc_ (size_t a, size_t b)
void	mwFlushNow (void)
void	mwDoFlush (int onoff)
void	mwLimit (long lim)
void	mwSetAriAction (int action)
int	mwAssert (int exp, const char *exps, const char *fn, int ln)
int	mwVerify (int exp, const char *exps, const char *fn, int ln)
void	mwTrace (const char *format,...)
unsigned	mwGrab (unsigned kb)
unsigned	mwDrop (unsigned kb)
void	mwNoMansLand (int level)
int	mwIsReadAddr (const void *p, unsigned len)
int	mwIsSafeAddr (void *p, unsigned len)

Macro Definition Documentation

__MEMWATCH_C

#define __MEMWATCH_C   1

Definition at line 98 of file KalFitMemLeak.c.

AIPH

#define AIPH

(

)

Value:

if ( always_invoked )                                                                       \
{                                                                                           \
  mwWrite( "autocheck: <%ld> %s(%d) ", mwCounter, file, line );                             \
  always_invoked = 0;                                                                       \
}

Definition at line 2267 of file KalFitMemLeak.c.

#define AIPH()                                                                                \
  if ( always_invoked )                                                                       \
  {                                                                                           \
    mwWrite( "autocheck: <%ld> %s(%d) ", mwCounter, file, line );                             \
    always_invoked = 0;                                                                       \
  }

CHKVAL

#define CHKVAL

(

mw

)

Value:

( 0xFE0180L ^ (long)mw->count ^ (long)mw->size ^ (long)mw->line )

Definition at line 141 of file KalFitMemLeak.c.

Referenced by mwMalloc().

COMMIT

#define COMMIT   "" /* Normal ANSI */

Definition at line 156 of file KalFitMemLeak.c.

CPPTEXT

#define CPPTEXT   ""

Definition at line 162 of file KalFitMemLeak.c.

Referenced by mwInit().

FLUSH

#define FLUSH

(

)

Value:

mwFlush()

Definition at line 142 of file KalFitMemLeak.c.

Referenced by mwAbort(), mwAssert(), mwFree(), mwInit(), mwLimit(), mwMalloc(), mwRealloc(), mwStrdup(), mwTrace(), and mwVerify().

mw16BIT

#define mw16BIT   1

Definition at line 203 of file KalFitMemLeak.c.

MW_MUTEX_INIT

#define MW_MUTEX_INIT

(

)

Definition at line 177 of file KalFitMemLeak.c.

Referenced by mwInit().

MW_MUTEX_LOCK

#define MW_MUTEX_LOCK

(

)

Definition at line 179 of file KalFitMemLeak.c.

Referenced by mwAssert(), mwCalloc_(), mwFree(), mwFree_(), mwMalloc(), mwMalloc_(), mwRealloc(), mwRealloc_(), mwSetAriAction(), mwStrdup(), mwTrace(), and mwVerify().

MW_MUTEX_TERM

#define MW_MUTEX_TERM

(

)

Definition at line 178 of file KalFitMemLeak.c.

Referenced by mwAbort().

MW_MUTEX_UNLOCK

#define MW_MUTEX_UNLOCK

(

)

Definition at line 180 of file KalFitMemLeak.c.

Referenced by mwAssert(), mwCalloc_(), mwFree(), mwFree_(), mwMalloc(), mwMalloc_(), mwRealloc(), mwRealloc_(), mwSetAriAction(), mwStrdup(), mwTrace(), and mwVerify().

MW_NML

#define MW_NML   0x0001

Definition at line 151 of file KalFitMemLeak.c.

Referenced by mwAbort(), mwFree(), and mwRealloc().

mwBUFFER_TO_MW

#define mwBUFFER_TO_MW

(

p

)

Value:

( (mwData*)(void*)( ( (char*)p ) - mwDataSize - mwOverflowZoneSize ) )

Definition at line 147 of file KalFitMemLeak.c.

#define mwBUFFER_TO_MW( p )                                                                   \
  ( (mwData*)(void*)( ( (char*)p ) - mwDataSize - mwOverflowZoneSize ) )

Referenced by mwFree(), mwRealloc(), and mwTestBuffer().

mwROUNDALLOC

#define mwROUNDALLOC   mwROUNDALLOC_DEFAULT

Definition at line 221 of file KalFitMemLeak.c.

Referenced by mwFree(), and mwInit().

mwROUNDALLOC_DEFAULT

#define mwROUNDALLOC_DEFAULT   2

Definition at line 204 of file KalFitMemLeak.c.

mwSTDERR

#define mwSTDERR   mwLog

Definition at line 168 of file KalFitMemLeak.c.

Referenced by mwAbort(), mwAssert(), mwBreakOut(), and mwVerify().

POSTCHK

#define POSTCHK   0x76543210L

Definition at line 146 of file KalFitMemLeak.c.

PRECHK

#define PRECHK   0x01234567L

Definition at line 145 of file KalFitMemLeak.c.

TESTS

#define TESTS	(		f,
			l )

Value:

if ( mwTestAlways ) (void)mwTestNow( f, l, 1 )

Definition at line 143 of file KalFitMemLeak.c.

#define TESTS( f, l )                                                                         \
  if ( mwTestAlways ) (void)mwTestNow( f, l, 1 )

Referenced by mwAssert(), mwCalloc_(), mwDrop(), mwFree(), mwFree_(), mwGrab(), mwLimit(), mwMalloc(), mwMalloc_(), mwMark(), mwNoMansLand(), mwRealloc(), mwRealloc_(), mwSetAriAction(), mwTrace(), and mwVerify().

VERSION

#define VERSION   "2.71" /* the current version number */

Definition at line 140 of file KalFitMemLeak.c.

Referenced by mwInit().

Typedef Documentation

mwData

typedef struct mwData_ mwData

Definition at line 258 of file KalFitMemLeak.c.

mwGrabData

typedef struct mwGrabData_ mwGrabData

Definition at line 286 of file KalFitMemLeak.c.

mwMarker

typedef struct mwMarker_ mwMarker

Definition at line 293 of file KalFitMemLeak.c.

mwStat

typedef struct mwStat_ mwStat

Definition at line 274 of file KalFitMemLeak.c.

Function Documentation

mwAbort()

void mwAbort

(

void

)

Definition at line 524 of file KalFitMemLeak.c.

                     {
  mwData*   mw;
  mwMarker* mrk;
  char*     data;
  time_t    tid;
  int       c, i, j;
  int       errors;
 
  tid = time( NULL );
  mwWrite( "\nStopped at %s\n", ctime( &tid ) );
 
  if ( !mwInited ) mwWrite( "internal: mwAbort(): MEMWATCH not initialized!\n" );
 
  /* release the grab list */
  mwDropAll();
 
  /* report mwMarked items */
  while ( mwFirstMark )
  {
    mrk = mwFirstMark->next;
    mwWrite( "mark: %p: %s\n", mwFirstMark->host, mwFirstMark->text );
    free( mwFirstMark->text );
    free( mwFirstMark );
    mwFirstMark = mrk;
    mwErrors++;
  }
 
  /* release all still allocated memory */
  errors = 0;
  while ( mwHead != NULL && errors < 3 )
  {
    if ( !mwIsOwned( mwHead, __FILE__, __LINE__ ) )
    {
      if ( errors < 3 )
      {
        errors++;
        mwWrite( "internal: NML/unfreed scan restarting\n" );
        FLUSH();
        mwHead = mwHead;
        continue;
      }
      mwWrite( "internal: NML/unfreed scan aborted, heap too damaged\n" );
      FLUSH();
      break;
    }
    mwFlushW( 0 );
    if ( !( mwHead->flag & MW_NML ) )
    {
      mwErrors++;
      data = ( (char*)mwHead ) + mwDataSize;
      mwWrite( "unfreed: <%ld> %s(%d), %ld bytes at %p ", mwHead->count, mwHead->file,
               mwHead->line, (long)mwHead->size, data + mwOverflowZoneSize );
      if ( mwCheckOF( data ) )
      {
        mwWrite( "[underflowed] " );
        FLUSH();
      }
      if ( mwCheckOF( ( data + mwOverflowZoneSize + mwHead->size ) ) )
      {
        mwWrite( "[overflowed] " );
        FLUSH();
      }
      mwWrite( " \t{" );
      j = 16;
      if ( mwHead->size < 16 ) j = (int)mwHead->size;
      for ( i = 0; i < 16; i++ )
      {
        if ( i < j ) mwWrite( "%02X ", (unsigned char)*( data + mwOverflowZoneSize + i ) );
        else mwWrite( ".. " );
      }
      for ( i = 0; i < j; i++ )
      {
        c = *( data + mwOverflowZoneSize + i );
        if ( c < 32 || c > 126 ) c = '.';
        mwWrite( "%c", c );
      }
      mwWrite( "}\n" );
      mw = mwHead;
      mwUnlink( mw, __FILE__, __LINE__ );
      free( mw );
    }
    else
    {
      data = ( (char*)mwHead ) + mwDataSize + mwOverflowZoneSize;
      if ( mwTestMem( data, mwHead->size, MW_VAL_NML ) )
      {
        mwErrors++;
        mwWrite( "wild pointer: <%ld> NoMansLand %p alloc'd at %s(%d)\n", mwHead->count,
                 data + mwOverflowZoneSize, mwHead->file, mwHead->line );
        FLUSH();
      }
      mwNmlNumAlloc--;
      mwNmlCurAlloc -= mwHead->size;
      mw = mwHead;
      mwUnlink( mw, __FILE__, __LINE__ );
      free( mw );
    }
  }
 
  if ( mwNmlNumAlloc )
    mwWrite( "internal: NoMansLand block counter %ld, not zero\n", mwNmlNumAlloc );
  if ( mwNmlCurAlloc )
    mwWrite( "internal: NoMansLand byte counter %ld, not zero\n", mwNmlCurAlloc );
 
  /* report statistics */
  mwStatReport();
  FLUSH();
 
  mwInited = 0;
  mwHead = mwTail = NULL;
  if ( mwErrors ) fprintf( mwSTDERR, "MEMWATCH detected %ld anomalies\n", mwErrors );
  mwLogFile( NULL );
  mwErrors = 0;
 
  MW_MUTEX_TERM();
}

Referenced by mwInit(), and mwTerm().

mwAriHandler()

int mwAriHandler

(

const char *

estr

)

Definition at line 869 of file KalFitMemLeak.c.

                                     {
  mwAutoInit();
  return mwARI( estr );
}

mwAssert()

int mwAssert	(	int	exp,
		const char *	exps,
		const char *	fn,
		int	ln )

Definition at line 1266 of file KalFitMemLeak.c.

                                                                  {
  int  i;
  char buffer[MW_TRACE_BUFFER + 8];
  if ( exp ) { return 0; }
  mwAutoInit();
  MW_MUTEX_LOCK();
  TESTS( fn, ln );
  mwIncErr();
  mwCounter++;
  mwWrite( "assert trap: <%ld> %s(%d), %s\n", mwCounter, fn, ln, exps );
  if ( mwAriFunction != NULL )
  {
    sprintf( buffer, "MEMWATCH: assert trap: %s(%d), %s", fn, ln, exps );
    i = ( *mwAriFunction )( buffer );
    switch ( i )
    {
    case MW_ARI_IGNORE:
      mwWrite( "assert trap: <%ld> IGNORED - execution continues\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 0;
    case MW_ARI_RETRY:
      mwWrite( "assert trap: <%ld> RETRY - executing again\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 1;
    }
  }
  else
  {
    if ( mwAriAction & MW_ARI_IGNORE )
    {
      mwWrite( "assert trap: <%ld> AUTO IGNORED - execution continues\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 0;
    }
    fprintf( mwSTDERR, "\nMEMWATCH: assert trap: %s(%d), %s\n", fn, ln, exps );
  }
 
  FLUSH();
  (void)mwTestNow( fn, ln, 1 );
  FLUSH();
 
  if ( mwAriAction & MW_ARI_NULLREAD )
  {
    /* This is made in an attempt to kick in */
    /* any debuggers or OS stack traces */
    FLUSH();
    /*lint -save -e413 */
    i = *( (int*)NULL );
    mwDummy( (char)i );
    /*lint -restore */
  }
 
  MW_MUTEX_UNLOCK();
  exit( 255 );
  /* NOT REACHED - the return statement is in to keep */
  /* stupid compilers from squeaking about differing return modes. */
  /* Smart compilers instead say 'code unreachable...' */
  /*lint -save -e527 */
  return 0;
  /*lint -restore */
}

mwAutoCheck()

void mwAutoCheck

(

int

onoff

)

Definition at line 662 of file KalFitMemLeak.c.

                              {
  mwAutoInit();
  mwTestAlways = onoff;
  if ( onoff ) mwTestFlags = MW_TEST_ALL;
}

mwBreakOut()

void mwBreakOut

(

const char *

cause

)

Definition at line 714 of file KalFitMemLeak.c.

                                     {
  fprintf( mwSTDERR, "breakout: %s\n", cause );
  mwWrite( "breakout: %s\n", cause );
  return;
}

mwCalloc()

void * mwCalloc	(	size_t	a,
		size_t	b,
		const char *	file,
		int	line )

Definition at line 1189 of file KalFitMemLeak.c.

                                                                 {
  void*  p;
  size_t size = a * b;
  p           = mwMalloc( size, file, line );
  if ( p == NULL ) return NULL;
  memset( p, 0, size );
  return p;
}

mwCalloc_()

void * mwCalloc_	(	size_t	a,
		size_t	b )

Definition at line 1219 of file KalFitMemLeak.c.

                                      {
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  MW_MUTEX_UNLOCK();
  return calloc( a, b );
}

mwDoFlush()

void mwDoFlush

(

int

onoff

)

Definition at line 1231 of file KalFitMemLeak.c.

                            {
  mwFlushW( onoff < 1 ? 0 : onoff );
  if ( onoff )
    if ( mwLogR() ) fflush( mwLogR() );
  return;
}

mwDrop()

unsigned mwDrop

(

unsigned

kb

)

Definition at line 1425 of file KalFitMemLeak.c.

                               {
  TESTS( NULL, 0 );
  return mwDrop_( kb, MW_VAL_GRB, 0 );
}

mwFlushNow()

void mwFlushNow

(

void

)

Definition at line 1226 of file KalFitMemLeak.c.

                        {
  if ( mwLogR() ) fflush( mwLogR() );
  return;
}

mwFree()

void mwFree	(	void *	p,
		const char *	file,
		int	line )

Definition at line 1081 of file KalFitMemLeak.c.

                                                   {
  int     i;
  mwData* mw;
  char    buffer[sizeof( mwData ) + ( mwROUNDALLOC * 3 ) + 64];
 
  /* this code is in support of C++ delete */
  if ( file == NULL )
  {
    mwFree_( p );
    MW_MUTEX_UNLOCK();
    return;
  }
 
  mwAutoInit();
 
  MW_MUTEX_LOCK();
  TESTS( file, line );
  mwCounter++;
 
  /* on NULL free, write a warning and return */
  if ( p == NULL )
  {
    mwWrite( "NULL free: <%ld> %s(%d), NULL pointer free'd\n", mwCounter, file, line );
    FLUSH();
    MW_MUTEX_UNLOCK();
    return;
  }
 
  /* do the quick ownership test */
  mw = (mwData*)mwBUFFER_TO_MW( p );
 
  if ( mwIsOwned( mw, file, line ) )
  {
    (void)mwTestBuf( mw, file, line );
 
    /* if the buffer is an NML, treat this as a double-free */
    if ( mw->flag & MW_NML )
    {
      if ( *( ( (unsigned char*)mw ) + mwDataSize + mwOverflowZoneSize ) != MW_VAL_NML )
      {
        mwWrite( "internal: <%ld> %s(%d), no-mans-land MW-%p is corrupted\n", mwCounter, file,
                 line, mw );
      }
      goto check_dbl_free;
    }
 
    /* update the statistics */
    mwNumCurAlloc--;
    mwStatCurAlloc -= (long)mw->size;
    if ( mwStatLevel ) mwStatFree( mw->size, mw->file, mw->line );
 
    /* we should either free the allocation or keep it as NML */
    if ( mwNML )
    {
      mw->flag |= MW_NML;
      mwNmlNumAlloc++;
      mwNmlCurAlloc += (long)mw->size;
      memset( ( (char*)mw ) + mwDataSize + mwOverflowZoneSize, MW_VAL_NML, mw->size );
    }
    else
    {
      /* unlink the allocation, and enter the post-free data */
      mwUnlink( mw, file, line );
      memset( mw, MW_VAL_DEL,
              mw->size + mwDataSize + mwOverflowZoneSize + mwOverflowZoneSize );
      if ( mwFBI )
      {
        memset( mw, '.', mwDataSize + mwOverflowZoneSize );
        sprintf( buffer, "FBI<%ld>%s(%d)", mwCounter, file, line );
        strncpy( (char*)(void*)mw, buffer, mwDataSize + mwOverflowZoneSize );
      }
      free( mw );
    }
 
    /* add the pointer to the last-free track */
    mwLFfile[mwLFcur]     = file;
    mwLFline[mwLFcur]     = line;
    mwLastFree[mwLFcur++] = p;
    if ( mwLFcur == MW_FREE_LIST ) mwLFcur = 0;
 
    MW_MUTEX_UNLOCK();
    return;
  }
 
  /* check for double-freeing */
check_dbl_free:
  for ( i = 0; i < MW_FREE_LIST; i++ )
  {
    if ( mwLastFree[i] == p )
    {
      mwIncErr();
      mwWrite( "double-free: <%ld> %s(%d), %p was"
               " freed from %s(%d)\n",
               mwCounter, file, line, p, mwLFfile[i], mwLFline[i] );
      FLUSH();
      MW_MUTEX_UNLOCK();
      return;
    }
  }
 
  /* some weird pointer... block the free */
  mwIncErr();
  mwWrite( "WILD free: <%ld> %s(%d), unknown pointer %p\n", mwCounter, file, line, p );
  FLUSH();
  MW_MUTEX_UNLOCK();
  return;
}

mwFree_()

void mwFree_

(

void *

p

)

Definition at line 1198 of file KalFitMemLeak.c.

                        {
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  MW_MUTEX_UNLOCK();
  free( p );
}

mwGrab()

unsigned mwGrab

(

unsigned

kb

)

Definition at line 1420 of file KalFitMemLeak.c.

                               {
  TESTS( NULL, 0 );
  return mwGrab_( kb, MW_VAL_GRB, 0 );
}

mwInit()

void mwInit

(

void

)

Definition at line 417 of file KalFitMemLeak.c.

                    {
  time_t tid;
 
  if ( mwInited++ > 0 ) return;
 
  MW_MUTEX_INIT();
 
  /* start a log if none is running */
  if ( mwLogR() == NULL ) mwLogFile( "memwatch.log" );
  if ( mwLogR() == NULL )
  {
    int  i;
    char buf[32];
    /* oops, could not open it! */
    /* probably because it's already open */
    /* so we try some other names */
    for ( i = 1; i < 100; i++ )
    {
      sprintf( buf, "memwat%02d.log", i );
      mwLogFile( buf );
      if ( mwLogR() != NULL ) break;
    }
  }
 
  /* initialize the statistics */
  mwStatList     = NULL;
  mwStatTotAlloc = 0L;
  mwStatCurAlloc = 0L;
  mwStatMaxAlloc = 0L;
  mwStatNumAlloc = 0L;
  mwNmlCurAlloc  = 0L;
  mwNmlNumAlloc  = 0L;
 
  /* calculate the buffer size to use for a mwData */
  mwDataSize = sizeof( mwData );
  while ( mwDataSize % mwROUNDALLOC ) mwDataSize++;
 
  /* write informational header if needed */
  if ( !mwInfoWritten )
  {
    mwInfoWritten = 1;
    (void)time( &tid );
    mwWrite( "\n============="
             " MEMWATCH " VERSION " Copyright (C) 1992-1999 Johan Lindh "
             "=============\n" );
    mwWrite( "\nStarted at %s\n", ctime( &tid ) );
 
    /**************************************************************** Generic */
    mwWrite( "Modes: " );
#ifdef mwNew
    mwWrite( "C++ " );
#endif /* mwNew */
#ifdef __STDC__
    mwWrite( "__STDC__ " );
#endif /* __STDC__ */
#ifdef mw16BIT
    mwWrite( "16-bit " );
#endif
#ifdef mw32BIT
    mwWrite( "32-bit " );
#endif
#ifdef mw64BIT
    mwWrite( "64-bit " );
#endif
    mwWrite( "mwDWORD==(" mwDWORD_DEFINED ")\n" );
    mwWrite( "mwROUNDALLOC==%d sizeof(mwData)==%d mwDataSize==%d\n", mwROUNDALLOC,
             sizeof( mwData ), mwDataSize );
/**************************************************************** Generic */
 
/************************************************************ Microsoft C */
#ifdef _MSC_VER
    mwWrite( "Compiled using Microsoft C" CPPTEXT " %d.%02d\n", _MSC_VER / 100,
             _MSC_VER % 100 );
#endif /* _MSC_VER */
/************************************************************ Microsoft C */
 
/************************************************************** Borland C */
#ifdef __BORLANDC__
    mwWrite( "Compiled using Borland C"
#  ifdef __cplusplus
             "++ %d.%01d\n",
             __BCPLUSPLUS__ / 0x100, ( __BCPLUSPLUS__ % 0x100 ) / 0x10 );
#  else
             " %d.%01d\n",
             __BORLANDC__ / 0x100, ( __BORLANDC__ % 0x100 ) / 0x10 );
#  endif /* __cplusplus */
#endif   /* __BORLANDC__ */
/************************************************************** Borland C */
 
/************************************************************** Watcom C */
#ifdef __WATCOMC__
    mwWrite( "Compiled using Watcom C %d.%02d ", __WATCOMC__ / 100, __WATCOMC__ % 100 );
#  ifdef __FLAT__
    mwWrite( "(32-bit flat model)" );
#  endif /* __FLAT__ */
    mwWrite( "\n" );
#endif /* __WATCOMC__ */
       /************************************************************** Watcom C */
 
    mwWrite( "\n" );
    FLUSH();
  }
 
  if ( mwUseAtexit ) (void)atexit( mwAbort );
  return;
}

mwIsReadAddr()

int mwIsReadAddr	(	const void *	p,
		unsigned	len )

Definition at line 2617 of file KalFitMemLeak.c.

                                                {
  if ( p == NULL ) return 0;
  if ( len == 0 ) return 1;
  return 1;
}

Referenced by mwMark().

mwIsSafeAddr()

int mwIsSafeAddr	(	void *	p,
		unsigned	len )

Definition at line 2622 of file KalFitMemLeak.c.

                                          {
  if ( p == NULL ) return 0;
  if ( len == 0 ) return 1;
  return 1;
}

mwLimit()

void mwLimit

(

long

lim

)

Definition at line 1238 of file KalFitMemLeak.c.

                         {
  TESTS( NULL, 0 );
  mwWrite( "limit: old limit = " );
  if ( !mwAllocLimit ) mwWrite( "none" );
  else mwWrite( "%ld bytes", mwAllocLimit );
  mwWrite( ", new limit = " );
  if ( !lim )
  {
    mwWrite( "none\n" );
    mwUseLimit = 0;
  }
  else
  {
    mwWrite( "%ld bytes\n", lim );
    mwUseLimit = 1;
  }
  mwAllocLimit = lim;
  FLUSH();
}

mwMalloc()

void * mwMalloc	(	size_t	size,
		const char *	file,
		int	line )

Definition at line 884 of file KalFitMemLeak.c.

                                                          {
  size_t  needed;
  mwData* mw;
  char*   ptr;
  void*   p;
 
  mwAutoInit();
 
  MW_MUTEX_LOCK();
 
  TESTS( file, line );
 
  mwCounter++;
  needed = mwDataSize + mwOverflowZoneSize * 2 + size;
  if ( needed < size )
  {
    /* theoretical case: req size + mw overhead exceeded size_t limits */
    return NULL;
  }
 
  /* if this allocation would violate the limit, fail it */
  if ( mwUseLimit && ( (long)size + mwStatCurAlloc > mwAllocLimit ) )
  {
    mwWrite( "limit fail: <%ld> %s(%d), %ld wanted %ld available\n", mwCounter, file, line,
             (long)size, mwAllocLimit - mwStatCurAlloc );
    mwIncErr();
    FLUSH();
    MW_MUTEX_UNLOCK();
    return NULL;
  }
 
  mw = (mwData*)malloc( needed );
  if ( mw == NULL )
  {
    if ( mwFreeUp( needed, 0 ) >= needed )
    {
      mw = (mwData*)malloc( needed );
      if ( mw == NULL )
      {
        mwWrite( "internal: mwFreeUp(%u) reported success, but malloc() fails\n", needed );
        mwIncErr();
        FLUSH();
      }
    }
    if ( mw == NULL )
    {
      mwWrite( "fail: <%ld> %s(%d), %ld wanted %ld allocated\n", mwCounter, file, line,
               (long)size, mwStatCurAlloc );
      mwIncErr();
      FLUSH();
      MW_MUTEX_UNLOCK();
      return NULL;
    }
  }
 
  mw->count = mwCounter;
  mw->prev  = NULL;
  mw->next  = mwHead;
  mw->file  = file;
  mw->size  = size;
  mw->line  = line;
  mw->flag  = 0;
  mw->check = CHKVAL( mw );
 
  if ( mwHead ) mwHead->prev = mw;
  mwHead = mw;
  if ( mwTail == NULL ) mwTail = mw;
 
  ptr = ( (char*)mw ) + mwDataSize;
  mwWriteOF( ptr ); /* '*(long*)ptr = PRECHK;' */
  ptr += mwOverflowZoneSize;
  p = ptr;
  memset( ptr, MW_VAL_NEW, size );
  ptr += size;
  mwWriteOF( ptr ); /* '*(long*)ptr = POSTCHK;' */
 
  mwNumCurAlloc++;
  mwStatCurAlloc += (long)size;
  mwStatTotAlloc += (long)size;
  if ( mwStatCurAlloc > mwStatMaxAlloc ) mwStatMaxAlloc = mwStatCurAlloc;
  mwStatNumAlloc++;
 
  if ( mwStatLevel ) mwStatAlloc( size, file, line );
 
  MW_MUTEX_UNLOCK();
  return p;
}

mwMalloc_()

void * mwMalloc_

(

size_t

size

)

Definition at line 1205 of file KalFitMemLeak.c.

                               {
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  MW_MUTEX_UNLOCK();
  return malloc( size );
}

mwMark()

void * mwMark	(	void *	p,
		const char *	desc,
		const char *	file,
		unsigned	line )

Definition at line 723 of file KalFitMemLeak.c.

                                                                           {
  mwMarker* mrk;
  unsigned  n, isnew;
  char*     buf;
  int       tot, oflow = 0;
  char      wherebuf[128];
 
  mwAutoInit();
  TESTS( NULL, 0 );
 
  if ( desc == NULL ) desc = "unknown";
  if ( file == NULL ) file = "unknown";
 
  tot = sprintf( wherebuf, "%.48s called from %s(%d)", desc, file, line );
  if ( tot >= (int)sizeof( wherebuf ) )
  {
    wherebuf[sizeof( wherebuf ) - 1] = 0;
    oflow                            = 1;
  }
 
  if ( p == NULL )
  {
    mwWrite( "mark: %s(%d), no mark for NULL:'%s' may be set\n", file, line, desc );
    return p;
  }
 
  if ( mwFirstMark != NULL && !mwIsReadAddr( mwFirstMark, sizeof( mwMarker ) ) )
  {
    mwWrite( "mark: %s(%d), mwFirstMark (%p) is trashed, can't mark for %s\n", file, line,
             mwFirstMark, desc );
    return p;
  }
 
  for ( mrk = mwFirstMark; mrk; mrk = mrk->next )
  {
    if ( mrk->next != NULL && !mwIsReadAddr( mrk->next, sizeof( mwMarker ) ) )
    {
      mwWrite( "mark: %s(%d), mark(%p)->next(%p) is trashed, can't mark for %s\n", file, line,
               mrk, mrk->next, desc );
      return p;
    }
    if ( mrk->host == p ) break;
  }
 
  if ( mrk == NULL )
  {
    isnew = 1;
    mrk   = (mwMarker*)malloc( sizeof( mwMarker ) );
    if ( mrk == NULL )
    {
      mwWrite( "mark: %s(%d), no mark for %p:'%s', out of memory\n", file, line, p, desc );
      return p;
    }
    mrk->next = NULL;
    n         = 0;
  }
  else
  {
    isnew = 0;
    n     = strlen( mrk->text );
  }
 
  n += strlen( wherebuf );
  buf = (char*)malloc( n + 3 );
  if ( buf == NULL )
  {
    if ( isnew ) free( mrk );
    mwWrite( "mark: %s(%d), no mark for %p:'%s', out of memory\n", file, line, p, desc );
    return p;
  }
 
  if ( isnew )
  {
    memcpy( buf, wherebuf, n + 1 );
    mrk->next   = mwFirstMark;
    mrk->host   = p;
    mrk->text   = buf;
    mrk->level  = 1;
    mwFirstMark = mrk;
  }
  else
  {
    strcpy( buf, mrk->text );
    strcat( buf, ", " );
    strcat( buf, wherebuf );
    free( mrk->text );
    mrk->text = buf;
    mrk->level++;
  }
 
  if ( oflow )
  {
    mwIncErr();
    mwTrace( " [WARNING: OUTPUT BUFFER OVERFLOW - SYSTEM UNSTABLE]\n" );
  }
  return p;
}

mwNoMansLand()

void mwNoMansLand

(

int

level

)

Definition at line 1547 of file KalFitMemLeak.c.

                               {
  mwAutoInit();
  TESTS( NULL, 0 );
  switch ( level )
  {
  case MW_NML_NONE: (void)mwDrop_( 0, MW_VAL_NML, 0 ); break;
  case MW_NML_FREE: break;
  case MW_NML_ALL: (void)mwGrab_( 0, MW_VAL_NML, 0 ); break;
  default: return;
  }
  mwNML = level;
}

mwRealloc()

void * mwRealloc	(	void *	p,
		size_t	size,
		const char *	file,
		int	line )

Definition at line 972 of file KalFitMemLeak.c.

                                                                    {
  int     oldUseLimit, i;
  mwData* mw;
  char*   ptr;
 
  mwAutoInit();
 
  if ( p == NULL ) return mwMalloc( size, file, line );
  if ( size == 0 )
  {
    mwFree( p, file, line );
    return NULL;
  }
 
  MW_MUTEX_LOCK();
 
  /* do the quick ownership test */
  mw = (mwData*)mwBUFFER_TO_MW( p );
  if ( mwIsOwned( mw, file, line ) )
  {
 
    /* if the buffer is an NML, treat this as a double-free */
    if ( mw->flag & MW_NML )
    {
      mwIncErr();
      if ( *( (unsigned char*)( mw ) + mwDataSize + mwOverflowZoneSize ) != MW_VAL_NML )
      {
        mwWrite( "internal: <%ld> %s(%d), no-mans-land MW-%p is corrupted\n", mwCounter, file,
                 line, mw );
      }
      goto check_dbl_free;
    }
 
    /* if this allocation would violate the limit, fail it */
    if ( mwUseLimit && ( (long)size + mwStatCurAlloc - (long)mw->size > mwAllocLimit ) )
    {
      TESTS( file, line );
      mwCounter++;
      mwWrite( "limit fail: <%ld> %s(%d), %ld wanted %ld available\n", mwCounter, file, line,
               (unsigned long)size - mw->size, mwAllocLimit - mwStatCurAlloc );
      mwIncErr();
      FLUSH();
      MW_MUTEX_UNLOCK();
      return NULL;
    }
 
    /* fake realloc operation */
    oldUseLimit = mwUseLimit;
    mwUseLimit  = 0;
    ptr         = (char*)mwMalloc( size, file, line );
    if ( ptr != NULL )
    {
      if ( size < mw->size ) memcpy( ptr, p, size );
      else memcpy( ptr, p, mw->size );
      mwFree( p, file, line );
    }
    mwUseLimit = oldUseLimit;
    MW_MUTEX_UNLOCK();
    return (void*)ptr;
  }
 
  /* Unknown pointer! */
 
  /* using free'd pointer? */
check_dbl_free:
  for ( i = 0; i < MW_FREE_LIST; i++ )
  {
    if ( mwLastFree[i] == p )
    {
      mwIncErr();
      mwWrite( "realloc: <%ld> %s(%d), %p was"
               " freed from %s(%d)\n",
               mwCounter, file, line, p, mwLFfile[i], mwLFline[i] );
      FLUSH();
      MW_MUTEX_UNLOCK();
      return NULL;
    }
  }
 
  /* some weird pointer */
  mwIncErr();
  mwWrite( "realloc: <%ld> %s(%d), unknown pointer %p\n", mwCounter, file, line, p );
  FLUSH();
  MW_MUTEX_UNLOCK();
  return NULL;
}

mwRealloc_()

void * mwRealloc_	(	void *	p,
		size_t	size )

Definition at line 1212 of file KalFitMemLeak.c.

                                         {
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  MW_MUTEX_UNLOCK();
  return realloc( p, size );
}

mwSetAriAction()

void mwSetAriAction

(

int

action

)

Definition at line 1258 of file KalFitMemLeak.c.

                                  {
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  mwAriAction = action;
  MW_MUTEX_UNLOCK();
  return;
}

mwSetAriFunc()

void mwSetAriFunc

(

int(*

func )(const char *)

)

Definition at line 875 of file KalFitMemLeak.c.

                                                  {
  mwAutoInit();
  mwAriFunction = func;
}

mwSetOutFunc()

void mwSetOutFunc

(

void(*

func )(int)

)

Definition at line 668 of file KalFitMemLeak.c.

                                           {
  mwAutoInit();
  mwOutFunction = func;
}

mwStatistics()

void mwStatistics

(

int

level

)

Definition at line 651 of file KalFitMemLeak.c.

                               {
  mwAutoInit();
  if ( level < 0 ) level = 0;
  if ( mwStatLevel != level )
  {
    mwWrite( "statistics: now collecting on a %s basis\n",
             level < 1 ? "global" : ( level < 2 ? "module" : "line" ) );
    mwStatLevel = level;
  }
}

mwStrdup()

char * mwStrdup	(	const char *	str,
		const char *	file,
		int	line )

Definition at line 1059 of file KalFitMemLeak.c.

                                                              {
  size_t len;
  char*  newstring;
 
  MW_MUTEX_LOCK();
 
  if ( str == NULL )
  {
    mwIncErr();
    mwWrite( "strdup: <%ld> %s(%d), strdup(NULL) called\n", mwCounter, file, line );
    FLUSH();
    MW_MUTEX_UNLOCK();
    return NULL;
  }
 
  len       = strlen( str ) + 1;
  newstring = (char*)mwMalloc( len, file, line );
  if ( newstring != NULL ) memcpy( newstring, str, len );
  MW_MUTEX_UNLOCK();
  return newstring;
}

mwTerm()

void mwTerm

(

void

)

Definition at line 641 of file KalFitMemLeak.c.

                    {
  if ( mwInited == 1 )
  {
    mwAbort();
    return;
  }
  if ( !mwInited ) mwWrite( "internal: mwTerm(): MEMWATCH has not been started!\n" );
  else mwInited--;
}

mwTest()

int mwTest	(	const char *	file,
		int	line,
		int	items )

Definition at line 692 of file KalFitMemLeak.c.

                                                    {
  mwAutoInit();
  mwTestFlags = items;
  return mwTestNow( file, line, 0 );
}

mwTestBuffer()

int mwTestBuffer	(	const char *	file,
		int	line,
		void *	p )

Definition at line 702 of file KalFitMemLeak.c.

                                                        {
  mwData* mw;
 
  mwAutoInit();
 
  /* do the quick ownership test */
  mw = (mwData*)mwBUFFER_TO_MW( p );
 
  if ( mwIsOwned( mw, file, line ) ) { return mwTestBuf( mw, file, line ); }
  return 1;
}

mwTrace()

void mwTrace	(	const char *	format,
			... )

Definition at line 1388 of file KalFitMemLeak.c.

                                        {
  int     tot, oflow = 0;
  va_list mark;
 
  mwAutoInit();
  MW_MUTEX_LOCK();
  TESTS( NULL, 0 );
  if ( mwOutFunction == NULL ) mwOutFunction = mwDefaultOutFunc;
 
  va_start( mark, format );
  tot = vsprintf( mwPrintBuf, format, mark );
  va_end( mark );
  if ( tot >= MW_TRACE_BUFFER )
  {
    mwPrintBuf[MW_TRACE_BUFFER] = 0;
    oflow                       = 1;
  }
  for ( tot = 0; mwPrintBuf[tot]; tot++ ) ( *mwOutFunction )( mwPrintBuf[tot] );
  if ( oflow )
  {
    mwIncErr();
    mwTrace( " [WARNING: OUTPUT BUFFER OVERFLOW - SYSTEM UNSTABLE]\n" );
  }
 
  FLUSH();
  MW_MUTEX_UNLOCK();
}

mwUnmark()

void * mwUnmark	(	void *	p,
		const char *	file,
		unsigned	line )

Definition at line 821 of file KalFitMemLeak.c.

                                                           {
  mwMarker *mrk, *prv;
  mrk = mwFirstMark;
  prv = NULL;
  while ( mrk )
  {
    if ( mrk->host == p )
    {
      if ( mrk->level < 2 )
      {
        if ( prv ) prv->next = mrk->next;
        else mwFirstMark = mrk->next;
        free( mrk->text );
        free( mrk );
        return p;
      }
      mrk->level--;
      return p;
    }
    prv = mrk;
    mrk = mrk->next;
  }
  mwWrite( "mark: %s(%d), no mark found for %p\n", file, line, p );
  return p;
}

mwVerify()

int mwVerify	(	int	exp,
		const char *	exps,
		const char *	fn,
		int	ln )

Definition at line 1328 of file KalFitMemLeak.c.

                                                                  {
  int  i;
  char buffer[MW_TRACE_BUFFER + 8];
  if ( exp ) { return 0; }
  mwAutoInit();
  MW_MUTEX_LOCK();
  TESTS( fn, ln );
  mwIncErr();
  mwCounter++;
  mwWrite( "verify trap: <%ld> %s(%d), %s\n", mwCounter, fn, ln, exps );
  if ( mwAriFunction != NULL )
  {
    sprintf( buffer, "MEMWATCH: verify trap: %s(%d), %s", fn, ln, exps );
    i = ( *mwAriFunction )( buffer );
    if ( i == 0 )
    {
      mwWrite( "verify trap: <%ld> IGNORED - execution continues\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 0;
    }
    if ( i == 1 )
    {
      mwWrite( "verify trap: <%ld> RETRY - executing again\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 1;
    }
  }
  else
  {
    if ( mwAriAction & MW_ARI_NULLREAD )
    {
      /* This is made in an attempt to kick in */
      /* any debuggers or OS stack traces */
      FLUSH();
      /*lint -save -e413 */
      i = *( (int*)NULL );
      mwDummy( (char)i );
      /*lint -restore */
    }
    if ( mwAriAction & MW_ARI_IGNORE )
    {
      mwWrite( "verify trap: <%ld> AUTO IGNORED - execution continues\n", mwCounter );
      MW_MUTEX_UNLOCK();
      return 0;
    }
    fprintf( mwSTDERR, "\nMEMWATCH: verify trap: %s(%d), %s\n", fn, ln, exps );
  }
  FLUSH();
  (void)mwTestNow( fn, ln, 1 );
  FLUSH();
  MW_MUTEX_UNLOCK();
  exit( 255 );
  /* NOT REACHED - the return statement is in to keep */
  /* stupid compilers from squeaking about differing return modes. */
  /* Smart compilers instead say 'code unreachable...' */
  /*lint -save -e527 */
  return 0;
  /*lint -restore */
}