Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
dbgmem.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 5k
Category:

Windows Kernel

Development Platform:

Visual C++

dbgmem.cpp：Code Content
  2. #ifdef DEBUG
  4. #include <dbgmem.h>
  6. //EXTERN_C BOOL g_bUseNewLeakDetection;
  7. BOOL          g_bRegistered = FALSE;
  9. HINSTANCE g_hinstDBG;
  10. #define   SHELLDBG    "ShellDBG.DLL"
  12. STDAPI_(void) _GetProcFromDLL(HMODULE* phmod, LPCSTR pszDLL, FARPROC* ppfn, LPCSTR pszProc);
  13. // the following are in olestuff.cpp
  14. STDAPI_(void) _DebugMemLeak(UINT flag, LPCTSTR pszFile, UINT iLine);
  15. STDAPI_(void) _add_to_memlist(HMODULE hmod, void *pv, UINT nSize, UINT nType, LPCSTR pszFile, const INT_PTR iLine);
  16. STDAPI_(void) _remove_from_memlist(void *pv);
  17. STDAPI_(void) _remove_from_thread_memlist(DWORD dwThreadId, LPVOID pv);
  18. STDAPI_(void) _transfer_to_thread_memlist(DWORD dwThread, LPVOID pv);
  19. STDAPI_(UINT) _mem_thread_message(void);
  20. STDAPI_(void) _received_for_thread_memlist(DWORD dwFlags, void * pData);
  21. STDAPI_(void) _register_intelli_dump(HMODULE hmod, const INTELLILEAKDUMPCBFUNCTIONS *pfns);
  23. STDAPI_(void) MemLeakInit(UINT wFlags, LPCTSTR pszFile, UINT iLine);
  24. STDAPI_(void) MemLeakTerminate(DWORD dwFlags);
  26. // should be in olestuff.cpp of each dll
  27. STDAPI_(void) DumpLeakedMemory(PLEAKMEMINFO pmeminfo);
  28. STDAPI_(LPWSTR) GetLeakSymbolicName(PLEAKMEMINFO pmeminfo, LPWSTR pwszBuf, int cchBuf);
  30. static const INTELLILEAKDUMPCBFUNCTIONS c_ildcbf = {
  31.     DumpLeakedMemory,
  32.     GetLeakSymbolicName
  33. };
  35. #define DELAY_LOAD_LEAK_VOID(_fn, _ord, _args, _nargs)  
  36. void __stdcall _fn _args                                
  37. {                                                       
  38.     static void (__stdcall *_pfn##_fn) _args = NULL;    
  39.     if (g_bUseNewLeakDetection)                         
  40.     {                                                   
  41.         if (!g_bRegistered)                             
  42.         {                                               
  43.             register_intelli_dump(HINST_THISDLL, &c_ildcbf); 
  44.             g_bRegistered = TRUE;                       
  45.         }                                               
  46.         _GetProcFromDLL(&g_hinstDBG, SHELLDBG, (FARPROC*)&_pfn##_fn, (LPCSTR)_ord); 
  47.     }                           
  48.     else                         
  49.         _pfn##_fn = _##_fn;       
  50.     if (_pfn##_fn)               
  51.         _pfn##_fn _nargs;        
  52.     return;                      
  53. }
  55. #define DELAY_LOAD_LEAK_FN(_ret, _fn, _ord, _args, _nargs, _err) 
  56. _ret __stdcall _fn _args                            
  57. {                                                       
  58.     static _ret (__stdcall *_pfn##_fn) _args = NULL;    
  59.     if (g_bUseNewLeakDetection)                         
  60.     {                                                   
  61.         if (!g_bRegistered)                             
  62.         {                                               
  63.             register_intelli_dump(HINST_THISDLL, &c_ildcbf); 
  64.             g_bRegistered = TRUE;                       
  65.         }                                               
  66.         _GetProcFromDLL(&g_hinstDBG, SHELLDBG, (FARPROC*)&_pfn##_fn, (LPCSTR)_ord); 
  67.     }                            
  68.     else                         
  69.         _pfn##_fn = _##_fn;       
  70.     if (_pfn##_fn)               
  71.         return _pfn##_fn _nargs;        
  72.     return (_ret)_err;                      
  73. }
  75. #define _MemLeakInit _DebugMemLeak // for delay load macro to work
  76. DELAY_LOAD_LEAK_VOID(MemLeakInit, 2, 
  77.                      (UINT wFlags, LPCTSTR pszFile, UINT iLine), 
  78.                      (wFlags, pszFile, iLine))
  80. // does nothing for now because MemLeakInit is called to terminate leak detection as well
  81. STDAPI_(void) MemLeakTerminate(DWORD dwFlags)
  82. {
  83. }
  85. DELAY_LOAD_LEAK_VOID(add_to_memlist, 3, 
  86.                      (HMODULE hmod, void *pv, UINT nSize, UINT nType, LPCSTR pszFile, const INT_PTR iLine),
  87.                      (hmod, pv, nSize, nType, pszFile, iLine))
  88. DELAY_LOAD_LEAK_FN(UINT, mem_thread_message, 4, (void), (), 0)
  89. DELAY_LOAD_LEAK_VOID(received_for_thread_memlist, 5, (DWORD dwFlags, void *pData), (dwFlags, pData))
  90. DELAY_LOAD_LEAK_VOID(remove_from_memlist, 6, (void *pv), (pv))
  91. DELAY_LOAD_LEAK_VOID(remove_from_thread_memlist, 7, (DWORD dwThreadId, LPVOID pv), (dwThreadId, pv))
  92. DELAY_LOAD_LEAK_VOID(transfer_to_thread_memlist, 8, (DWORD dwThreadId, LPVOID pv), (dwThreadId, pv))
  94. //DELAY_LOAD_LEAK_VOID(register_intelli_dump, 9, (HMODULE hmod, const INTELLILEAKDUMPCBFUNCTIONS *pfns), (hmod, pfns))
  95. void register_intelli_dump(HMODULE hmod, const INTELLILEAKDUMPCBFUNCTIONS *pfns)
  96. {
  97.     static void (__stdcall *pfnregister_intelli_dump)(HMODULE hmod, const INTELLILEAKDUMPCBFUNCTIONS *pfns) = NULL;
  99.     if (!pfnregister_intelli_dump)
  100.     {
  101.         if (g_bUseNewLeakDetection)
  102.             _GetProcFromDLL(&g_hinstDBG, SHELLDBG, (FARPROC*)&pfnregister_intelli_dump, (LPCSTR)9);
  103.         else
  104.             pfnregister_intelli_dump = _register_intelli_dump;
  105.     }
  107.     if (pfnregister_intelli_dump)
  108.         pfnregister_intelli_dump(hmod, pfns);
  109. }
  111. #endif //DEBUG