Linux下c++程序内存泄漏检测代码范例-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

Linux下c++程序内存泄漏检测代码范例

简介:
Linux下对于程序内存泄漏检测的方法很多,最常用的的莫过于使用valgrind工具。但是valgrind相当于让程序在虚拟机中运行,会带 来较大的系统资源开销,还会对程序的运行效率产生较大影响,对于那种资源占用大的程序,如果需要长时间运行才能暴露的泄漏问题,它就显得不太好用。

linux下的c++程序中自己实现一个轻量级的泄漏检测代码其实是比较方便的,下面我就给出一个简单的范例,并作简单的说明。当然,我们还是应该提倡使用共享指针,用共享指针自动管理内存可以避免内存泄漏这样的不必要的麻烦。

Linux下c++程序内存泄漏检测代码范例

基本原理:
  • 利用glibc提供的__malloc_hook, __free_hook系列函数对内存分配是否做监控;(详见glibc的官方文档)
  • 利用backtrace函数获取函数调用栈,并记录;
  • 利用backtrace_symbols对调用栈对应的函数做解析;

进一步处理:

  •  使用abi::__cxa_demangle把函数名解析为源代码风格;
  •  使用addr2line解析出函数调用栈对应的代码行;
  •  对于动态库(.so)中的地址解析,需要先在/proc/<pid>/maps文件中找到动态库映射的基地址,才能做解析。

注意:

编译连接参数中使用-g -rdynamic

以上每步具体实现的代码可能都没有达到最优,甚至可能是笨办法,如果有更好的实现方案请直接替换,也欢迎赐教。

示例代码:
leakmom.cpp

  1. /* Prototypes for __malloc_hook, __free_hook */ 
  2. #include <malloc.h> 
  3. #include <map> 
  4. #include <utility> 
  5. #include <execinfo.h> 
  6. #include <errno.h> 
  7. #include  <assert.h> 
  8. #include <cxxabi.h> 
  9. #include <sys/types.h> 
  10. #include <unistd.h> 
  11. #include <stdlib.h> 
  12. #include "leakmon.h" 
  13.  
  14. CMutexLock gLock ; 
  15. std::map <void*, _PtrInfo> gPtrInfo ; 
  16. std::map <const LmCallStack*, _AllocInfo ,  __comp> gLeakInfo; 
  17.  
  18.  
  19. const int LmCallStack:: MAX_STACK_LAYERS = 32; 
  20.  
  21. /* Prototypes for our hooks. */ 
  22. static void my_init_hook ( void); 
  23. static void *my_malloc_hook ( size_tconst void *); 
  24. static void my_free_hook ( void*, const void *); 
  25.  
  26. void *(*__MALLOC_HOOK_VOLATILE old_malloc_hook)( size_t __size , const void *) ; 
  27. void (*__MALLOC_HOOK_VOLATILE old_free_hook) ( void *__ptr , const void *); 
  28. /* Override initializing hook from the C library. */ 
  29. void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook) ( void) = my_init_hook; 
  30.  
  31. void my_init_hook (void
  32.     old_malloc_hook = __malloc_hook ; 
  33.     old_free_hook = __free_hook ; 
  34.     __malloc_hook = my_malloc_hook ; 
  35.     __free_hook = my_free_hook ; 
  36.  
  37. static void *my_malloc_hook ( size_t size , const void *caller ) 
  38.     void *result ; 
  39.        gLock.lock (); 
  40.     /* Restore all old hooks */ 
  41.     __malloc_hook = old_malloc_hook ; 
  42.     __free_hook = old_free_hook ; 
  43.     /* Call recursively */ 
  44.     result = malloc (size); 
  45.     /* Save underlying hooks */ 
  46.     old_malloc_hook = __malloc_hook ; 
  47.     old_free_hook = __free_hook ; 
  48.     /* printf might call malloc, so protect it too. */ 
  49.     //printf ("malloc (%u) returns %p\n", (unsigned int) size, result); 
  50.        RecordPtr( result , size); 
  51.  
  52.     /* Restore our own hooks */ 
  53.     __malloc_hook = my_malloc_hook ; 
  54.     __free_hook = my_free_hook ; 
  55.        gLock.unlock (); 
  56.     return result ; 
  57.  
  58. static void my_free_hook ( void *ptr , const void *caller ) 
  59.        gLock.lock (); 
  60.     /* Restore all old hooks */ 
  61.     __malloc_hook = old_malloc_hook ; 
  62.     __free_hook = old_free_hook ; 
  63.     /* Call recursively */ 
  64.     free (ptr ); 
  65.     /* Save underlying hooks */ 
  66.     old_malloc_hook = __malloc_hook ; 
  67.     old_free_hook = __free_hook ; 
  68.     /* printf might call free, so protect it too. */ 
  69.     //printf ("freed pointer %p\n", ptr); 
  70.  
  71.        RemovePtr( ptr ); 
  72.  
  73.     /* Restore our own hooks */ 
  74.     __malloc_hook = my_malloc_hook ; 
  75.     __free_hook = my_free_hook ; 
  76.        gLock.unlock (); 
  77.  
  78. void RecordPtr ( void* ptr, size_t size) 
  79.        // 获取调用栈 
  80.        void *array [LmCallStack:: MAX_STACK_LAYERS]; 
  81.        int cstSize = backtrace( array, LmCallStack ::MAX_STACK_LAYERS); 
  82.  
  83.        // 保存指针 调用栈 
  84.        LmCallStack* callstack = new LmCallStack(array , cstSize); 
  85.  
  86.        gLock.lock (); 
  87.  
  88.        std::map <const LmCallStack*, _AllocInfo ,  __comp>:: iterator it = gLeakInfo.find (callstack); 
  89.        if (it != gLeakInfo. end()) 
  90.       { 
  91.              it->second .size += size; 
  92.              it->second .alloc++; 
  93.  
  94.              _PtrInfo pi (it-> first, size ); 
  95.              gPtrInfo[ptr ] = pi; 
  96.       } 
  97.        else 
  98.       { 
  99.              _AllocInfo aif (size, 1, 0); 
  100.              std::pair <std:: map<const LmCallStack*, _AllocInfo,  __comp>::iterator , bool> ret = gLeakInfo .insert( std::pair <const LmCallStack*, _AllocInfo >(callstack, aif)); 
  101.              
  102.              if (ret .second) 
  103.             { 
  104.                    _PtrInfo pi (ret. first->first , size); 
  105.                    gPtrInfo[ptr ] = pi; 
  106.             } 
  107.              else 
  108.             { 
  109.                    // failed 
  110.             } 
  111.       } 
  112.  
  113.        gLock.unlock (); 
  114.  
  115. void RemovePtr ( void* ptr ) 
  116.        gLock.lock (); 
  117.  
  118.        std::map <void*, _PtrInfo>::iterator it = gPtrInfo.find (ptr); 
  119.        if (it != gPtrInfo. end()) 
  120.       { 
  121.              std::map <const LmCallStack*, _AllocInfo ,  __comp>:: iterator itc = gLeakInfo .find( it->second .csk); 
  122.              if (itc != gLeakInfo. end()) 
  123.             { 
  124.                    itc->second .size -= it->second .size; 
  125.                    itc->second .free++; 
  126.  
  127.                    if (0 == (itc ->second. alloc - itc ->second. free)) 
  128.                   { 
  129.                          assert(0 == itc ->second. size); 
  130.                          delete itc ->first; 
  131.                          gLeakInfo.erase (itc); 
  132.                   } 
  133.             } 
  134.  
  135.              gPtrInfo.erase (it); 
  136.       } 
  137.  
  138.        gLock.unlock (); 
  139.  
  140. void Report () 
  141.        char **strings = NULL; 
  142.        gLock.lock (); 
  143.  
  144.        __malloc_hook = old_malloc_hook ; 
  145.     __free_hook = old_free_hook ; 
  146.  
  147.        for (std ::map< const LmCallStack *, _AllocInfo,  __comp>::iterator it = gLeakInfo .begin(); 
  148.              it != gLeakInfo .end(); 
  149.              it++) 
  150.       { 
  151.              printf("\n" ); 
  152.              printf("====>  size: %ld,  allocs: %d,  frees: %d, a-f: %d\n", it-> second.size , it-> second.alloc , it-> second.free , it->second .alloc- it->second .free ); 
  153.              printf("====>  stacks back trace:\n" ); 
  154.              strings = backtrace_symbols ((void**) it->first ->callstack, it->first ->size); 
  155.              if (strings ) 
  156.             { 
  157.                    for(int i = 2; i < it ->first-> size; i ++) 
  158.                   { //printf("     %s\n", strings[i]); 
  159.                          char output [1024] = {0}; 
  160.                          memset(output , 0, 1024); 
  161.                          char temp [1024] = {0}; 
  162.                          memset(temp , 0, 1024); 
  163.                          //// 
  164.                          ////    get real function name 
  165.                          //// 
  166.                          if (1 == sscanf (strings[ i], "%*[^(]%*[^_]%[^)+]" , temp)) 
  167.                         { 
  168.                                      int status ; 
  169.                                      char* realname = abi::__cxa_demangle (temp, 0, 0, & status); 
  170.                                      if (0 == status ) 
  171.                                     { 
  172.                                            char* p = strchr( strings[i ], '('); 
  173.                                            memcpy(output , strings[ i], p-strings [i]); 
  174.                                            sprintf(output +(p- strings[i ]), "(%s+%p) " , realname, (( void**)it ->first-> callstack)[i ]); //printf("     -%s\n", realname); 
  175.                                            free(realname ); 
  176.                                     } 
  177.                                      else 
  178.                                     { 
  179.                                            char* p = strchr( strings[i ], ')'); 
  180.                                            memcpy(output , strings[ i], p-strings [i]+2); 
  181.                                     } 
  182.                         } 
  183.                          else 
  184.                         { 
  185.                                char* p = strchr( strings[i ], ')'); 
  186.                                memcpy(output , strings[ i], p-strings [i]+2); 
  187.                         } 
  188.  
  189.                          FILE * fp ; 
  190.                          char module [1024] = {0}; 
  191.                          memset(module , 0, 1024); 
  192.                          char* pm = strchr( strings[i ], '('); 
  193.                          memcpy(module , strings[ i], pm -strings[ i]); 
  194.  
  195.                          if (strstr (module, ".so")) 
  196.                         { 
  197.                                __pid_t pid = getpid(); 
  198.                                sprintf(temp , "grep %s /proc/%d/maps", module, pid ); 
  199.                                /// 
  200.                                ///         get library base-map-address 
  201.                                /// 
  202.                                fp = popen (temp, "r"); 
  203.                                if (fp ) 
  204.                               { 
  205.                                      char baseaddr [64]; 
  206.                                      unsigned long long base; 
  207.                                      
  208.                                      fgets(temp , sizeof( temp)-1, fp );  //printf("memmap: %s\n", temp); 
  209.                                      sscanf(temp , "%[^-]", baseaddr); 
  210.                                      base = strtoll (baseaddr, NULL, 16); //printf("baseaddr:%s\n", baseaddr); //printf(" base:0x%llx\n", base); 
  211.  
  212.                                      sprintf(temp , "addr2line -e %s %p", module, (void *)((unsigned long long)((void **)it-> first->callstack )[i]- base)); 
  213.                               } 
  214.                         } 
  215.                          else 
  216.                         { 
  217.                                sprintf(temp , "addr2line -e %s %p", module, ((void **)it-> first->callstack )[i]); 
  218.                         } 
  219.                          //// 
  220.                          ////    get source file name and line number 
  221.                          //// 
  222.                          fp = popen (temp, "r");  //printf("cmdline: %s\n", temp); 
  223.                          if (fp ) 
  224.                         { 
  225.                                fgets(temp , sizeof( temp)-1, fp ); //printf("     -%s\n", temp); 
  226.  
  227.                                strcat(output , temp); 
  228.                                printf("   ->  %s" , output); 
  229.                                pclose(fp ); 
  230.                         } 
  231.                          else 
  232.                         { 
  233.                                printf("   ->  %s\n" , output); 
  234.                         } 
  235.                   } 
  236.  
  237.                    free(strings ); 
  238.                    strings = NULL ; 
  239.             } 
  240.       } 
  241.  
  242.        __malloc_hook = my_malloc_hook ; 
  243.     __free_hook = my_free_hook ; 
  244.  
  245.        gLock.unlock (); 
  246.  
  247.  
  248. ////////////////////////////////////////////////////////////////////////// 
  249.  
  250. CMutexLock::CMutexLock () 
  251.        pthread_mutexattr_t  m_attr ; 
  252.        pthread_mutexattr_init(&m_attr ); 
  253.        pthread_mutexattr_settype(&m_attr , PTHREAD_MUTEX_RECURSIVE); 
  254.  
  255.        if (0 != pthread_mutex_init (&m_mutex , & m_attr)) 
  256.       { 
  257.              printf("c_lock::c_lock pthread_mutex_init error<%d>.\n" , errno); 
  258.              assert(0); 
  259.       } 
  260.  
  261.        pthread_mutexattr_destroy(&m_attr ); 
  262.  
  263. CMutexLock::~CMutexLock () 
  264.        if(0 != pthread_mutex_destroy (&m_mutex)) 
  265.       { 
  266.              printf("c_lock::~c_lock pthread_mutex_destroy error<%d>.\n" , errno); 
  267.              assert(0); 
  268.       } 
  269.  
  270. void 
  271. CMutexLock::lock () 
  272.  
  273.        if(0 != pthread_mutex_lock (&m_mutex)) 
  274.       { 
  275.              assert("c_lock::lock pthread_mutex_lock " && 0); 
  276.       } 
  277.  
  278. void 
  279. CMutexLock::unlock () 
  280.        int iRet = 0; 
  281.  
  282.        if(0 != (iRet = pthread_mutex_unlock(& m_mutex))) 
  283.       { 
  284.              printf("c_lock::unlock pthread_mutex_unlock ret<%d> error<%d>.\n", iRet, errno ); 
  285.              assert(0); 
  286.       } 
  287.  
  288. 示例代码: 
  289. leakmom.h 
  290.  
  291. //////////////////////////////////////////////////////////////////////// 
  292. // 
  293. //    The Executable file MUST be linked with parameter '-rdynamic' !!! 
  294. // 
  295. //////////////////////////////////////////////////////////////////////// 
  296.  
  297. #pragma once 
  298. #include <string.h> 
  299. #include <pthread.h> 
  300.                          
  301. // 
  302. class LmCallStack 
  303. public
  304.        char* callstack ; // pointer to buffer recording callstack addresses 
  305.        int size ; // count of call stacks 
  306.        static const int MAX_STACK_LAYERS; 
  307. public
  308.        LmCallStack(void * csk= NULL, int s=0) 
  309.       { 
  310.              if (csk ) 
  311.             { 
  312.                    callstack = new char[ s*sizeof (void*)]; 
  313.                    memcpy(callstack , csk, s*sizeof (void*)); 
  314.             } 
  315.              else 
  316.             { 
  317.                    callstack = (char *)csk; 
  318.             } 
  319.              size = s ; 
  320.       } 
  321.  
  322.       ~ LmCallStack() 
  323.       { 
  324.              if (callstack ) 
  325.             { 
  326.                    delete[] callstack ; 
  327.             } 
  328.              callstack = NULL ; 
  329.              size = 0; 
  330.       } 
  331. }; 
  332.  
  333. class __comp 
  334. public
  335.        __comp(){}; 
  336.        bool operator () (const LmCallStack* first , const LmCallStack* second) 
  337.       { 
  338.              return ((first ->size < second->size ) || 
  339.                         ( first->size == second-> size && 
  340.                                      memcmp(first ->callstack, second->callstack , sizeofvoid*)*first ->size) < 0) 
  341.                         ); 
  342.       } 
  343. }; 
  344.  
  345. struct _PtrInfo 
  346.        _PtrInfo(const LmCallStack* c=NULL , long s=0) 
  347.       { 
  348.              csk = c ; 
  349.              size = s ; 
  350.       } 
  351.        const LmCallStack * csk; 
  352.        long size ; 
  353. }; 
  354.  
  355. struct _AllocInfo 
  356.        _AllocInfo(long s=0, int a =0, int f=0) 
  357.       { 
  358.              size=s ; 
  359.              alloc=a ; 
  360.              free=f ; 
  361.       } 
  362.        // 
  363.        long size ; 
  364.        int alloc ; 
  365.        int free ; 
  366. }; 
  367.  
  368. class CMutexLock 
  369. public
  370.        CMutexLock(); 
  371.       ~ CMutexLock(); 
  372.  
  373. public
  374.        void lock (); 
  375.        void unlock (); 
  376.  
  377. private
  378.        pthread_mutex_t m_mutex ; 
  379. }; 
  380.  
  381.  
  382. // 
  383. void RecordPtr ( void* ptr, size_t size); 
  384. void RemovePtr (void* ptr); 
  385. void Report (); 
 
 
 



来源:51CTO

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享: