#include <stdlib.h>

Macros
#define	MW_ARI_NULLREAD 0x10 /* Null read (to start debugger) */

#define	MW_ARI_ABORT 0x04 /* ARI handler says: abort program! */

#define	MW_ARI_RETRY 0x02 /* ARI handler says: retry action! */

#define	MW_ARI_IGNORE 0x01 /* ARI handler says: ignore error! */

#define	MW_VAL_NEW 0xFE /* value in newly allocated memory */

#define	MW_VAL_DEL 0xFD /* value in newly deleted memory */

#define	MW_VAL_NML 0xFC /* value in no-mans-land */

#define	MW_VAL_GRB 0xFB /* value in grabbed memory */

#define	MW_TEST_ALL 0xFFFF /* perform all tests */

#define	MW_TEST_CHAIN 0x0001 /* walk the heap chain */

#define	MW_TEST_ALLOC 0x0002 /* test allocations & NML guards */

#define	MW_TEST_NML 0x0004 /* test all-NML areas for modifications */

#define	MW_NML_NONE 0 /* no NML */

#define	MW_NML_FREE 1 /* turn FREE'd memory into NML */

#define	MW_NML_ALL 2 /* all unused memory is NML */

#define	MW_NML_DEFAULT 0 /* the default NML setting */

#define	MW_STAT_GLOBAL 0 /* only global statistics collected */

#define	MW_STAT_MODULE 1 /* collect statistics on a module basis */

#define	MW_STAT_LINE 2 /* collect statistics on a line basis */

#define	MW_STAT_DEFAULT 0 /* the default statistics setting */

#define	MW_TRACE_BUFFER 2048 /* (min 160) size of TRACE()'s output buffer */

#define	MW_FREE_LIST 64 /* (min 4) number of free()'s to track */

#define	mwASSERT(exp)

#define	ASSERT mwASSERT

#define	mwVERIFY(exp)

#define	VERIFY mwVERIFY

#define	mwTRACE /lint -save -e506 / 1?(void)0:mwDummyTraceFunction /lint -restore /

#define	TRACE mwTRACE

#define	mwDoFlush(n)

#define	mwPuts(s)

#define	mwInit()

#define	mwGrab(n)

#define	mwDrop(n)

#define	mwLimit(n)

#define	mwTest(f, l)

#define	mwSetOutFunc(f)

#define	mwSetAriFunc(f)

#define	mwDefaultAri()

#define	mwNomansland()

#define	mwStatistics(f)

#define	mwMark(p, t, f, n)

#define	mwUnmark(p, f, n)

#define	mwMalloc(n, f, l)

#define	mwStrdup(p, f, l)

#define	mwRealloc(p, n, f, l)

#define	mwCalloc(n, m, f, l)

#define	mwFree(p)

#define	mwMalloc_(n)

#define	mwRealloc_(p, n)

#define	mwCalloc_(n, m)

#define	mwFree_(p)

#define	mwAssert(e, es, f, l)

#define	mwVerify(e, es, f, l)

#define	mwTrace mwDummyTrace

#define	mwTestBuffer(f, l, b)

#define	CHECK()

#define	CHECK_THIS(n)

#define	CHECK_BUFFER(b)

#define	MARK(p)

#define	UNMARK(p)

Functions
void	mwTerm (void)

void	mwAbort (void)

void	mwFlushNow (void)

void	mwDoFlush (int onoff)

void	mwLimit (long bytes)

unsigned	mwGrab (unsigned kilobytes)

unsigned	mwDrop (unsigned kilobytes)

void	mwNoMansLand (int mw_nml_level)

void	mwStatistics (int level)

void	mwFreeBufferInfo (int onoff)

void	mwAutoCheck (int onoff)

void	mwCalcCheck (void)

void	mwDumpCheck (void)

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

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

int	mwIsReadAddr (const void *p, unsigned len)

int	mwIsSafeAddr (void *p, unsigned len)

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

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

int	mwAssert (int, const char , const char , int)

int	mwVerify (int, const char , const char , int)

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

void	mwPuts (const char *text)

void	mwSetOutFunc (void(*func)(int))

void	mwSetAriFunc (int(func)(const char ))

void	mwSetAriAction (int mw_ari_value)

int	mwAriHandler (const char *cause)

void	mwBreakOut (const char *cause)

void *	mwMalloc (size_t, const char *, int)

void *	mwMalloc_ (size_t)

void *	mwRealloc (void , size_t, const char , int)

void *	mwRealloc_ (void *, size_t)

void *	mwCalloc (size_t, size_t, const char *, int)

void *	mwCalloc_ (size_t, size_t)

void	mwFree (void , const char , int)

void	mwFree_ (void *)

char *	mwStrdup (const char , const char , int)

void	mwDummyTraceFunction (const char *,...)

Variables
const unsigned long	mwCounter

Macro Definition Documentation

◆ ASSERT

#define ASSERT mwASSERT

Definition at line 594 of file KalFitMemLeak.h.

◆ CHECK

#define CHECK ( )

Definition at line 643 of file KalFitMemLeak.h.

◆ CHECK_BUFFER

#define CHECK_BUFFER ( b )

Definition at line 645 of file KalFitMemLeak.h.

◆ CHECK_THIS

#define CHECK_THIS ( n )

Definition at line 644 of file KalFitMemLeak.h.

◆ MARK

#define MARK ( p )

Value:

(p)

Definition at line 646 of file KalFitMemLeak.h.

◆ MW_ARI_ABORT

#define MW_ARI_ABORT 0x04 /* ARI handler says: abort program! */

Definition at line 349 of file KalFitMemLeak.h.

◆ MW_ARI_IGNORE

#define MW_ARI_IGNORE 0x01 /* ARI handler says: ignore error! */

Definition at line 351 of file KalFitMemLeak.h.

Referenced by mwAssert(), and mwVerify().

◆ MW_ARI_NULLREAD

#define MW_ARI_NULLREAD 0x10 /* Null read (to start debugger) */

Definition at line 348 of file KalFitMemLeak.h.

Referenced by mwAssert(), and mwVerify().

◆ MW_ARI_RETRY

#define MW_ARI_RETRY 0x02 /* ARI handler says: retry action! */

Definition at line 350 of file KalFitMemLeak.h.

Referenced by mwAssert().

◆ MW_FREE_LIST

#define MW_FREE_LIST 64 /* (min 4) number of free()'s to track */

Definition at line 379 of file KalFitMemLeak.h.

Referenced by mwFree(), and mwRealloc().

◆ MW_NML_ALL

#define MW_NML_ALL 2 /* all unused memory is NML */

Definition at line 365 of file KalFitMemLeak.h.

Referenced by mwNoMansLand().

◆ MW_NML_DEFAULT

#define MW_NML_DEFAULT 0 /* the default NML setting */

Definition at line 366 of file KalFitMemLeak.h.

◆ MW_NML_FREE

#define MW_NML_FREE 1 /* turn FREE'd memory into NML */

Definition at line 364 of file KalFitMemLeak.h.

Referenced by mwNoMansLand().

◆ MW_NML_NONE

#define MW_NML_NONE 0 /* no NML */

Definition at line 363 of file KalFitMemLeak.h.

Referenced by mwNoMansLand().

◆ MW_STAT_DEFAULT

#define MW_STAT_DEFAULT 0 /* the default statistics setting */

Definition at line 371 of file KalFitMemLeak.h.

◆ MW_STAT_GLOBAL

#define MW_STAT_GLOBAL 0 /* only global statistics collected */

Definition at line 368 of file KalFitMemLeak.h.

◆ MW_STAT_LINE

#define MW_STAT_LINE 2 /* collect statistics on a line basis */

Definition at line 370 of file KalFitMemLeak.h.

◆ MW_STAT_MODULE

#define MW_STAT_MODULE 1 /* collect statistics on a module basis */

Definition at line 369 of file KalFitMemLeak.h.

◆ MW_TEST_ALL

#define MW_TEST_ALL 0xFFFF /* perform all tests */

Definition at line 358 of file KalFitMemLeak.h.

Referenced by mwAutoCheck().

◆ MW_TEST_ALLOC

#define MW_TEST_ALLOC 0x0002 /* test allocations & NML guards */

Definition at line 360 of file KalFitMemLeak.h.

◆ MW_TEST_CHAIN

#define MW_TEST_CHAIN 0x0001 /* walk the heap chain */

Definition at line 359 of file KalFitMemLeak.h.

◆ MW_TEST_NML

#define MW_TEST_NML 0x0004 /* test all-NML areas for modifications */

Definition at line 361 of file KalFitMemLeak.h.

◆ MW_TRACE_BUFFER

#define MW_TRACE_BUFFER 2048 /* (min 160) size of TRACE()'s output buffer */

Definition at line 378 of file KalFitMemLeak.h.

Referenced by mwAssert(), mwTrace(), and mwVerify().

◆ MW_VAL_DEL

#define MW_VAL_DEL 0xFD /* value in newly deleted memory */

Definition at line 354 of file KalFitMemLeak.h.

Referenced by mwFree().

◆ MW_VAL_GRB

#define MW_VAL_GRB 0xFB /* value in grabbed memory */

Definition at line 356 of file KalFitMemLeak.h.

Referenced by mwDrop(), and mwGrab().

◆ MW_VAL_NEW

#define MW_VAL_NEW 0xFE /* value in newly allocated memory */

Definition at line 353 of file KalFitMemLeak.h.

Referenced by mwMalloc().

◆ MW_VAL_NML

#define MW_VAL_NML 0xFC /* value in no-mans-land */

Definition at line 355 of file KalFitMemLeak.h.

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

◆ mwASSERT

#define mwASSERT ( exp )

Definition at line 591 of file KalFitMemLeak.h.

◆ mwAssert

#define mwAssert	(	e,
		es,
		f,
		l )

Definition at line 639 of file KalFitMemLeak.h.

◆ mwCalloc

#define mwCalloc	(	n,
		m,
		f,
		l )

Value:

calloc(n,m)

n

const Int_t n

Definition DataBase/tau_mode.c:65

Definition at line 633 of file KalFitMemLeak.h.

◆ mwCalloc_

#define mwCalloc_	(		n,
			m )

Value:

calloc(n,m)

Definition at line 637 of file KalFitMemLeak.h.

◆ mwDefaultAri

#define mwDefaultAri ( )

Definition at line 625 of file KalFitMemLeak.h.

◆ mwDoFlush

#define mwDoFlush ( n )

Definition at line 616 of file KalFitMemLeak.h.

◆ mwDrop

#define mwDrop ( n )

Definition at line 620 of file KalFitMemLeak.h.

◆ mwFree

#define mwFree ( p )

Value:

free(p)

Definition at line 634 of file KalFitMemLeak.h.

Referenced by mwRealloc().

◆ mwFree_

#define mwFree_ ( p )

Value:

free(p)

Definition at line 638 of file KalFitMemLeak.h.

Referenced by mwFree().

◆ mwGrab

#define mwGrab ( n )

Definition at line 619 of file KalFitMemLeak.h.

◆ mwInit

void mwInit ( )

Definition at line 618 of file KalFitMemLeak.h.

◆ mwLimit

#define mwLimit ( n )

Definition at line 621 of file KalFitMemLeak.h.

◆ mwMalloc

#define mwMalloc	(	n,
		f,
		l )

Value:

malloc(n)

Definition at line 630 of file KalFitMemLeak.h.

Referenced by mwCalloc(), mwRealloc(), and mwStrdup().

◆ mwMalloc_

#define mwMalloc_ ( n )

Value:

malloc(n)

Definition at line 635 of file KalFitMemLeak.h.

◆ mwMark

#define mwMark	(	p,
		t,
		f,
		n )

Value:

(p)

Definition at line 628 of file KalFitMemLeak.h.

◆ mwNomansland

#define mwNomansland ( )

Definition at line 626 of file KalFitMemLeak.h.

◆ mwPuts

#define mwPuts ( s )

Definition at line 617 of file KalFitMemLeak.h.

◆ mwRealloc

#define mwRealloc	(	p,
		n,
		f,
		l )

Value:

realloc(p,n)

Definition at line 632 of file KalFitMemLeak.h.

◆ mwRealloc_

#define mwRealloc_	(		p,
			n )

Value:

realloc(p,n)

Definition at line 636 of file KalFitMemLeak.h.

◆ mwSetAriFunc

#define mwSetAriFunc ( f )

Definition at line 624 of file KalFitMemLeak.h.

◆ mwSetOutFunc

#define mwSetOutFunc ( f )

Definition at line 623 of file KalFitMemLeak.h.

◆ mwStatistics

#define mwStatistics ( f )

Definition at line 627 of file KalFitMemLeak.h.

◆ mwStrdup

#define mwStrdup	(	p,
		f,
		l )

Value:

strdup(p)

Definition at line 631 of file KalFitMemLeak.h.

◆ mwTest

#define mwTest	(		f,
			l )

Definition at line 622 of file KalFitMemLeak.h.

◆ mwTestBuffer

#define mwTestBuffer	(	f,
		l,
		b )

Value:

(0)

Definition at line 642 of file KalFitMemLeak.h.

◆ mwTRACE

#define mwTRACE /*lint -save -e506 */ 1?(void)0:mwDummyTraceFunction /*lint -restore */

Definition at line 606 of file KalFitMemLeak.h.

◆ mwTrace

#define mwTrace mwDummyTrace

Definition at line 641 of file KalFitMemLeak.h.

Referenced by mwMark(), and mwTrace().

◆ mwUnmark

#define mwUnmark	(	p,
		f,
		n )

Value:

(p)

Definition at line 629 of file KalFitMemLeak.h.

◆ mwVERIFY

#define mwVERIFY ( exp )

Value:

exp

EvtComplex exp(const EvtComplex &c)

Definition EvtComplex.hh:252

Definition at line 598 of file KalFitMemLeak.h.

◆ mwVerify

#define mwVerify	(	e,
		es,
		f,
		l )

Value:

(e)

Definition at line 640 of file KalFitMemLeak.h.

◆ TRACE

#define TRACE mwTRACE

Definition at line 610 of file KalFitMemLeak.h.

◆ UNMARK

#define UNMARK ( p )

Value:

(p)

Definition at line 647 of file KalFitMemLeak.h.

◆ VERIFY

#define VERIFY mwVERIFY

Definition at line 601 of file KalFitMemLeak.h.

Function Documentation

◆ mwAbort()

void mwAbort ( void )

Definition at line 517 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 * cause )

Definition at line 848 of file KalFitMemLeak.c.

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

◆ mwAssert()

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

Definition at line 1228 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 649 of file KalFitMemLeak.c.

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

◆ mwBreakOut()

void mwBreakOut ( const char * cause )

Definition at line 709 of file KalFitMemLeak.c.

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

◆ mwCalcCheck()

void mwCalcCheck ( void )

◆ mwCalloc()

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

Definition at line 1154 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 1184 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 1196 of file KalFitMemLeak.c.

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

◆ mwDrop()

unsigned mwDrop ( unsigned kilobytes )

Definition at line 1377 of file KalFitMemLeak.c.

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

◆ mwDummyTraceFunction()

void mwDummyTraceFunction	(	const char *	,
			... )

extern

◆ mwDumpCheck()

void mwDumpCheck ( void )

◆ mwFlushNow()

void mwFlushNow ( void )

Definition at line 1191 of file KalFitMemLeak.c.

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

◆ mwFree()

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

Definition at line 1051 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 1163 of file KalFitMemLeak.c.

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

◆ mwFreeBufferInfo()

void mwFreeBufferInfo ( int onoff )

◆ mwGrab()

unsigned mwGrab ( unsigned kilobytes )

Definition at line 1372 of file KalFitMemLeak.c.

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

◆ mwIsReadAddr()

int mwIsReadAddr	(	const void *	p,
		unsigned	len )

Definition at line 2491 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 2497 of file KalFitMemLeak.c.

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

◆ mwLimit()

void mwLimit ( long bytes )

Definition at line 1202 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 863 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 1170 of file KalFitMemLeak.c.

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

◆ mwMark()

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

Definition at line 718 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 mw_nml_level )

Definition at line 1489 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;
    }

◆ mwPuts()

void mwPuts ( const char * text )

◆ mwRealloc()

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

Definition at line 947 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 1177 of file KalFitMemLeak.c.

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

◆ mwSetAriAction()

void mwSetAriAction ( int mw_ari_value )

Definition at line 1220 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 854 of file KalFitMemLeak.c.

                                               {
    mwAutoInit();
    mwAriFunction = func;
    }

◆ mwSetOutFunc()

void mwSetOutFunc ( void(* func )(int) )

Definition at line 655 of file KalFitMemLeak.c.

                                       {
    mwAutoInit();
    mwOutFunction = func;
    }

◆ mwStatistics()

void mwStatistics ( int level )

Definition at line 637 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 1029 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 625 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	mw_test_flags )

Definition at line 685 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 695 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_string,
			... )

Definition at line 1343 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 804 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 1287 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 */
    }

Variable Documentation

◆ mwCounter

const unsigned long mwCounter

extern

Referenced by mwAssert(), mwFree(), mwMalloc(), mwRealloc(), mwStrdup(), and mwVerify().

Macros

Functions

Variables

Macro Definition Documentation

◆ ASSERT

◆ CHECK

◆ CHECK_BUFFER

◆ CHECK_THIS

◆ MARK

◆ MW_ARI_ABORT

◆ MW_ARI_IGNORE

◆ MW_ARI_NULLREAD

◆ MW_ARI_RETRY

◆ MW_FREE_LIST

◆ MW_NML_ALL

◆ MW_NML_DEFAULT

◆ MW_NML_FREE

◆ MW_NML_NONE

◆ MW_STAT_DEFAULT

◆ MW_STAT_GLOBAL

◆ MW_STAT_LINE

◆ MW_STAT_MODULE

◆ MW_TEST_ALL

◆ MW_TEST_ALLOC

◆ MW_TEST_CHAIN

◆ MW_TEST_NML

◆ MW_TRACE_BUFFER

◆ MW_VAL_DEL

◆ MW_VAL_GRB

◆ MW_VAL_NEW

◆ MW_VAL_NML

◆ mwASSERT

◆ mwAssert

◆ mwCalloc

◆ mwCalloc_

◆ mwDefaultAri

◆ mwDoFlush

◆ mwDrop

◆ mwFree

◆ mwFree_

◆ mwGrab

◆ mwInit

◆ mwLimit

◆ mwMalloc

◆ mwMalloc_

◆ mwMark

◆ mwNomansland

◆ mwPuts

◆ mwRealloc

◆ mwRealloc_

◆ mwSetAriFunc

◆ mwSetOutFunc

◆ mwStatistics

◆ mwStrdup

◆ mwTest

◆ mwTestBuffer

◆ mwTRACE

◆ mwTrace

◆ mwUnmark

◆ mwVERIFY

◆ mwVerify

◆ TRACE

◆ UNMARK

◆ VERIFY

Function Documentation

◆ mwAbort()

◆ mwAriHandler()

◆ mwAssert()

◆ mwAutoCheck()

◆ mwBreakOut()

◆ mwCalcCheck()

◆ mwCalloc()

◆ mwCalloc_()

◆ mwDoFlush()

◆ mwDrop()

◆ mwDummyTraceFunction()

◆ mwDumpCheck()

◆ mwFlushNow()

◆ mwFree()

◆ mwFree_()