windows-xp/Source/XPSP1/NT/net/config/inc/trace.h

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997.
//
//  File:       T R A C E . H
//
//  Contents:   Class definition for CTracing
//
//  Notes:
//
//  Author:     jeffspr   15 Apr 1997
//
//----------------------------------------------------------------------------

#pragma once

#include "tracetag.h"
#include "stlalgor.h"
#include "stldeque.h"
#include "stlmap.h"

// ISSUE: The customized STL that we have conflicts with the declarations pulled in 
//        from stdexcpt.h which gets included by typeinfo.h. This sucks!
//        Hence we can't include typeinfo.h to get RTTI's type_info structure, 
//        so we have to declare type_info ourselves. This is a well documented 
//        structure inside MSDN though.
class type_info {
public:
    _CRTIMP virtual ~type_info();
    _CRTIMP int operator==(const type_info& rhs) const;
    _CRTIMP int operator!=(const type_info& rhs) const;
    _CRTIMP int before(const type_info& rhs) const;
    _CRTIMP const char* name() const;
    _CRTIMP const char* raw_name() const;
private:
    void *_m_data;
    char _m_d_name[1];
    type_info(const type_info& rhs);
    type_info& operator=(const type_info& rhs);
};

#define TAKEOWNERSHIP

#ifdef ENABLETRACE

// This is needed for TraceHr, since we can't use a macro (vargs), but we
// need to get the file and line from the source.
#define FAL __FILE__,__LINE__,__FUNCTION__

// The Trace Stack functions
#if defined (_IA64_)
#include <ia64reg.h>

extern "C" unsigned __int64 __getReg(int whichReg);
extern "C" void __setReg(int whichReg, __int64 value);
#pragma intrinsic(__getReg)
#pragma intrinsic(__setReg)

#define GetR32 __getReg(CV_IA64_IntR32)
#define GetR33 __getReg(CV_IA64_IntR33)
#define GetR34 __getReg(CV_IA64_IntR34)
#endif // defined(_IA64_)

extern "C" void* _ReturnAddress(void);
#pragma intrinsic(_ReturnAddress)

extern LPCRITICAL_SECTION g_csTracing;

class CTracingIndent;

class CTracingFuncCall
{
public:
#if defined (_X86_) || defined (_AMD64_)
    CTracingFuncCall(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine, const DWORD_PTR ReturnAddress, const DWORD_PTR dwFramePointer);
#elif defined (_IA64_) 
    CTracingFuncCall(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine, const DWORD_PTR ReturnAddress, const __int64 Args1, const __int64 Args2, const __int64 Args3);
#else
    CTracingFuncCall(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine);
#endif
    
    CTracingFuncCall(const CTracingFuncCall& TracingFuncCall);
    ~CTracingFuncCall();

public:
    LPSTR   m_szFunctionName;
    LPSTR   m_szFunctionDName;
    LPSTR   m_szFile;
    DWORD_PTR m_ReturnAddress;

#if defined (_X86_) || defined (_AMD64_)
    DWORD   m_arguments[3];
#elif defined (_IA64_ )
    __int64 m_arguments[3];
#else
    // ... add other processors here
#endif

    DWORD   m_dwFramePointer;
    DWORD   m_dwThreadId;
    DWORD   m_dwLine;
    
    friend CTracingIndent;
};

class CTracingThreadInfo
{
public:
    CTracingThreadInfo();
    ~CTracingThreadInfo();

public:
    LPVOID m_pfnStack;
    DWORD m_dwLevel;
    DWORD m_dwThreadId;
    friend CTracingIndent;
};

class CTracingIndent
{
    LPSTR   m_szFunctionDName;
    DWORD   m_dwFramePointer;
    BOOL    bFirstTrace;
    
public:
#if defined (_X86_) || defined (_AMD64_)
    void AddTrace(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine, LPCVOID pReturnAddress, const DWORD_PTR dwFramePointer);
#elif defined (_IA64_) 
    void AddTrace(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine, LPCVOID pReturnAddress, const __int64 Args1, const __int64 Args2, const __int64 Args3);
#else
    void AddTrace(LPCSTR szFunctionName, LPCSTR szFunctionDName, LPCSTR szFile, const DWORD dwLine);
#endif
    void RemoveTrace(LPCSTR szFunctionDName, const DWORD dwFramePointer);

    CTracingIndent();
    ~CTracingIndent();

    static CTracingThreadInfo* GetThreadInfo();
    static DWORD getspaces();
    static void TraceStackFn(TRACETAGID TraceTagId);
    static void TraceStackFn(IN OUT LPSTR szString, IN OUT LPDWORD pdwSize);
};


#define IDENT_ADD2(x) indent ## x
#define IDENT_ADD(x)  IDENT_ADD2(x)
#define __INDENT__ IDENT_ADD(__LINE__)

#define FP_ADD2(x) FP ## x
#define FP_ADD(x)  FP_ADD2(x)
#define __FP__ FP_ADD(__LINE__)

#if defined (_X86_)
#define AddTraceLevel \
    __if_not_exists(NetCfgFramePointer) \
    { \
        DWORD NetCfgFramePointer;  \
        BOOL fForceC4715Check = TRUE;  \
    } \
    if (fForceC4715Check) \
    { \
        __asm { mov NetCfgFramePointer, ebp }; \
    } \
    __if_not_exists(NetCfgIndent) \
    { \
        CTracingIndent NetCfgIndent; \
    } \
    NetCfgIndent.AddTrace(__FUNCTION__, __FUNCDNAME__, __FILE__, __LINE__, _ReturnAddress(), NetCfgFramePointer);
#elif defined (_IA64_) 
#define AddTraceLevel \
    __if_not_exists(NetCfgIndent) \
    { \
        CTracingIndent NetCfgIndent; \
    } \
    NetCfgIndent.AddTrace(__FUNCTION__, __FUNCDNAME__, __FILE__, __LINE__, _ReturnAddress(), 0, 0, 0);

    // NetCfgIndent.AddTrace(__FUNCTION__, __FUNCDNAME__, __FILE__, __LINE__, _ReturnAddress(), GetR32, GetR33, GetR34);
    // ISSUE: GetR32, GetR33, GetR34 is inherently unsafe and can cause an STATUS_REG_NAT_CONSUMPTION exception
    // if a register is being read that has the NAT bit set. Removing this for now until the compiler
    // team provides a safe version of __getReg
#elif defined (_AMD64_)
#define AddTraceLevel \
    __if_not_exists(NetCfgIndent) \
    { \
        CTracingIndent NetCfgIndent; \
    } \
    NetCfgIndent.AddTrace(__FUNCTION__, __FUNCDNAME__, __FILE__, __LINE__, _ReturnAddress(), 0);
#else
#define AddTraceLevel \
    __if_not_exists(NetCfgIndent) \
    { \
        CTracingIndent NetCfgIndent; \
    } \
    NetCfgIndent.AddTrace(__FUNCTION__, __FUNCDNAME__, __FILE__, __LINE__);
#endif

// Trace error functions. The leaading _ is to establish the real function,
// while adding a new macro so we can add __FILE__ and __LINE__ to the output.
//
VOID    WINAPI   TraceErrorFn           (PCSTR pszaFile, INT nLine, PCSTR psza, HRESULT hr);
VOID    WINAPI   TraceErrorOptionalFn   (PCSTR pszaFile, INT nLine, PCSTR psza, HRESULT hr, BOOL fOpt);
VOID    WINAPI   TraceErrorSkipFn       (PCSTR pszaFile, INT nLine, PCSTR psza, HRESULT hr, UINT c, ...);
VOID    WINAPIV  TraceLastWin32ErrorFn  (PCSTR pszaFile, INT nLine, PCSTR psza);

#define TraceError(sz, hr)                      TraceErrorFn(__FILE__, __LINE__, sz, hr);
#define TraceErrorOptional(sz, hr, _bool)       TraceErrorOptionalFn(__FILE__, __LINE__, sz, hr, _bool);
#define TraceErrorSkip1(sz, hr, hr1)            TraceErrorSkipFn(__FILE__, __LINE__, sz, hr, 1, hr1);
#define TraceErrorSkip2(sz, hr, hr1, hr2)       TraceErrorSkipFn(__FILE__, __LINE__, sz, hr, 2, hr1, hr2);
#define TraceErrorSkip3(sz, hr, hr1, hr2, hr3)  TraceErrorSkipFn(__FILE__, __LINE__, sz, hr, 3, hr1, hr2, hr3);
#define TraceLastWin32Error(sz)                 TraceLastWin32ErrorFn(__FILE__,__LINE__, sz);

VOID
WINAPIV
TraceHrFn (
    TRACETAGID  ttid,
    PCSTR       pszaFile,
    INT         nLine,
    HRESULT     hr,
    BOOL        fIgnore,
    PCSTR       pszaFmt,
    ...);

VOID
WINAPIV
TraceHrFn (
    TRACETAGID  ttid,
    PCSTR       pszaFile,
    INT         nLine,
    PCSTR       pszaFunc,
    HRESULT     hr,
    BOOL        fIgnore,
    PCSTR       pszaFmt,
    ...);

VOID
WINAPIV
TraceTagFn (
    TRACETAGID  ttid,
    PCSTR       pszaFmt,
    ...);

VOID
WINAPIV
TraceFileFuncFn (
            TRACETAGID  ttid);

#define TraceFileFunc(ttidWhich) AddTraceLevel; TraceFileFuncFn(ttidWhich);
#define TraceStack(ttidWhich) AddTraceLevel; CTracingIndent::TraceStackFn(ttidWhich);
#define TraceStackToString(szString, nSize) AddTraceLevel; CTracingIndent::TraceStackFn(szString, nSize);
#define TraceHr AddTraceLevel; TraceHrFn
#define TraceTag AddTraceLevel; TraceTagFn
#define TraceException(hr, szExceptionName) TraceHr(ttidError, FAL, hr, FALSE, "A (%s) exception occurred", szExceptionName);

LPCSTR DbgEvents(DWORD Event);
LPCSTR DbgEventManager(DWORD EventManager);
LPCSTR DbgNcm(DWORD ncm);
LPCSTR DbgNcs(DWORD ncs);
LPCSTR DbgNccf(DWORD nccf);
LPCSTR DbgNcsm(DWORD ncsm);

#else   // !ENABLETRACE

#define FAL                                         (void)0
#define TraceError(_sz, _hr)
#define TraceErrorOptional(_sz, _hr, _bool)
#define TraceErrorSkip1(_sz, _hr, _hr1)
#define TraceErrorSkip2(_sz, _hr, _hr1, _hr2)
#define TraceErrorSkip3(_sz, _hr, _hr1, _hr2, _hr3)
#define TraceLastWin32Error(_sz)
#define TraceHr                                       NOP_FUNCTION
#define TraceTag                                      NOP_FUNCTION
#define TraceFileFunc(ttidWhich)                      NOP_FUNCTION
#define TraceException(hr, szExceptionName)           NOP_FUNCTION
#define TraceStack(ttidWhich)                         NOP_FUNCTION
#define TraceStackToString(szString, nSize)           NOP_FUNCTION

#define DbgEvents(Event) ""
#define DbgEventManager(EventManager) ""
#define DbgNcm(ncm) ""
#define DbgNcs(ncs) ""
#define DbgNccf(nccf) ""
#define DbgNcsm(nccf) ""

#endif  // ENABLETRACE

#ifdef ENABLETRACE

//---[ Initialization stuff ]-------------------------------------------------

HRESULT HrInitTracing();
HRESULT HrUnInitTracing();
HRESULT HrOpenTraceUI(HWND  hwndOwner);

#endif // ENABLETRACE

#define ENABLELEAKDETECTION

#if (defined(ENABLETRACE) && defined(ENABLELEAKDETECTION))

template <class T> class CNetCfgDebug; // Fwd template to make this friendly to CObjectLeakTrack

//+---------------------------------------------------------------------------
//
//  class:      CObjectLeakTrack
//
//  Purpose:    Keep a list of all the CNetCfgDebug derived object instances and
//              dump these out on request
//
//  Author:     deonb  7 July 2001
//
//  Notes:      The data types in here are of type LPVOID in order to minimize
//              dependencies when including the trace header.
//  
class CObjectLeakTrack
{
public:
    CObjectLeakTrack();
    ~CObjectLeakTrack();
    void DumpAllocatedObjects(IN TRACETAGID TraceTagId, IN LPCSTR szClassName);
    BOOL AssertIfObjectsStillAllocated(IN LPCSTR szClassName);

protected: 
    // For these, pThis is really of type CNetCfgDebug<T> *. Since this should only ever be called
    // from CNetCfgDebug or ISSUE_knownleak, we are ok with the lack of compile-time type checking.
    void Insert(IN LPCVOID pThis, IN LPCSTR szdbgClassName, IN TAKEOWNERSHIP LPSTR pszConstructionStack);
    void Remove(IN LPCVOID pThis);

    friend class CNetCfgDebug;
    friend void RemoveKnownleakFn(LPCVOID pThis);

protected:
    LPVOID g_mapObjLeak; // This will actually be of type map<LPCVOID, pair<LPSTR, LPSTR> > ;
};

extern CObjectLeakTrack *g_pObjectLeakTrack; // The global list of NetConfig objects in the process.
                                             // Call DumpAllocatedObjects on this to dump out the objects.
void RemoveKnownleakFn(LPCVOID pThis);

//+---------------------------------------------------------------------------
//
//  class:      CNetCfgDebug
//
//  Purpose:    In order to debug instance leaks of your class instances, you can
//              derive your class from CNetCfgDebug. This adds no data members nor 
//              a v-table nor virtual functions to your class. It will add 
//              a constructor and destructor that will be called before & after yours
//              respectively, in order to keep track of your class instances.
//  
//              This will only happen on CHK builds. On FRE builds deriving from this
//              class has no effect, and is safe.
//
//  Author:     deonb  7 July 2001
//
//  Notes:      
//              This is s an ATL style parent template derive, e.g.:
//              CNetCfgDbg<parent>
//              e.g.
//              
//              class CConnectionManager : public ClassX, 
//                                         public classY,
//                                         public CNetCfgBase<CConnectionManager>
//
//              No other interaction with your class is needed. This will now automatically 
//              keep a list of all the instances allocated of this class (in debug mode), 
//              with a stack trace where they were allocated from. This is a Tracing
//              stack trace so it's only successful for functions inside the callstack which
//              actually used a TraceXxx statement (any trace statement) before they called
//              the child functions.
//
//              e.g. 
//              void X()
//              {
//                  TraceFileFunc(ttidSomething);
//                  void Y()
//                  {
//                      void Z()
//                      {
//                          TraceTag(ttidSomething, "allocation class");
//                          CConnectionManager *pConnectionManager = new CConnectionManager();
//                      }
//                      TraceTag(ttidSomething, "Z called");
//                  }
//              }
//  
//              This will spew the following when the process terminates (or when TraceAllocatedObjects is called):
//              ASSERT: "An object leak has been detected. Please attach a user or kernel mode debugger and hit 
//                       IGNORE to dump the offending stacks"
//              
//              The object of type 'class CConnectionManager' allocated at 0x7fe2345 has not been freed:
//                  it was constructed from the stack below: 
//              Z [EBP: 0x731d3128] 0x00000001 0x00000000 0x0000000a
//              X [EBP: 0x731d310f] 0x0000000f 0x0000000e 0x0000000a
//
//              (since Y() did not contain a trace statement before the call to Z() )
//
template <class T> 
class CNetCfgDebug
{
public:
    CNetCfgDebug()
    {
        if (FIsDebugFlagSet(dfidTrackObjectLeaks))
        {
            if (g_csTracing && g_pObjectLeakTrack)
            {
                EnterCriticalSection(g_csTracing);

                DWORD dwConstructionStackSize = 16384;
                LPSTR pszConstructionStack = new CHAR[dwConstructionStackSize];
                if (pszConstructionStack)
                {
                    TraceStackToString(pszConstructionStack, &dwConstructionStackSize);

                    if (dwConstructionStackSize < 16384)
                    {
                        // Reduce the amount of memory required
                        LPSTR szTemp = new CHAR[dwConstructionStackSize];
                        if (szTemp)
                        {
                            memcpy(szTemp, pszConstructionStack, dwConstructionStackSize);
                            delete[] pszConstructionStack;

                            pszConstructionStack = szTemp;
                        }
                    }
                    else
                    {
                        
                    }
                }

                TraceTag(ttidAllocations, "An object of type '%s' was allocated at '0x%08x'", typeid(T).name(), this);
                g_pObjectLeakTrack->Insert(this, typeid(T).name(), pszConstructionStack); // ok to insert if pszConstructionStack is NULL.

                LeaveCriticalSection(g_csTracing);
            }
        }
    };

    ~CNetCfgDebug()
    {
        if (FIsDebugFlagSet(dfidTrackObjectLeaks))
        {
            if (g_csTracing && g_pObjectLeakTrack)
            {
                EnterCriticalSection(g_csTracing);

                TraceTag(ttidAllocations, "An object of type '%s' was deleted at '0x%08x'", typeid(T).name(), this);
                g_pObjectLeakTrack->Remove(this);

                LeaveCriticalSection(g_csTracing);
            }
        }
    };
};

#define ISSUE_knownleak(pThis) RemoveKnownleakFn(pThis);

#define TraceAllocatedObjects(ttidWhich, ClassName) g_pObjectLeakTrack->DumpAllocatedObjects(ttidWhich, typeid(ClassName).name());
#define AssertIfAllocatedObjects(ClassName)         g_pObjectLeakTrack->AssertIfObjectsStillAllocated(typeid(ClassName).name());

#define TraceAllAllocatedObjects(ttidWhich) g_pObjectLeakTrack->DumpAllocatedObjects(ttidWhich, NULL);
#define AssertIfAnyAllocatedObjects()       g_pObjectLeakTrack->AssertIfObjectsStillAllocated(NULL);

#else // ENABLETRACE && ENABLELEAKDETECTION

template <class T> 
    class CNetCfgDebug
{
};

#define ISSUE_knownleak(pThis)                        NOP_FUNCTION
#define TraceAllocatedObjects(ttidWhich, szClassName) NOP_FUNCTION
#define AssertNoAllocatedInstances(szClassName)       NOP_FUNCTION

#endif // ENABLETRACE && ENABLELEAKDETECTION