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

最新推荐文章于 2023-03-16 17:04:44 发布
最新推荐文章于 2023-03-16 17:04:44 发布
阅读量794 收藏
点赞数
分类专栏： C/C++

转载自：http://blog.csdn.net/yichigo/article/details/45092265

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

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

 

 

基本原理：
1.利用glibc提供的__malloc_hook, __free_hook系列函数对内存分配是否做监控；（详见glibc的官方文档）
2.利用backtrace函数获取函数调用栈，并记录；
3.利用backtrace_symbols对调用栈对应的函数做解析；
进一步处理：
4.使用abi::__cxa_demangle把函数名解析为源代码风格；
5.使用addr2line解析出函数调用栈对应的代码行；
6.对于动态库（.so）中的地址解析，需要先在/proc/<pid>/maps文件中找到动态库映射的基地址，才能做解析。
注意：
编译连接参数中使用-g -rdynamic
 
以上每步具体实现的代码可能都没有达到最优，甚至可能是笨办法，如果有更好的实现方案请直接替换，也欢迎赐教。

示例代码：
leakmom.cpp

/* Prototypes for __malloc_hook, __free_hook */
#include  <malloc.h>
#include  <map>
#include  <utility>
#include  <execinfo.h>
#include  <errno.h>
#include    <assert.h>
#include  <cxxabi.h>
#include  <sys/types.h>
#include  <unistd.h>
#include  <stdlib.h>
#include  "leakmon.h"

CMutexLock  gLock  ;
std :: map  < void *,  _PtrInfo >  gPtrInfo  ;
std :: map  < const  LmCallStack *,  _AllocInfo  ,   __comp >  gLeakInfo ;


const  int  LmCallStack ::  MAX_STACK_LAYERS  = 32;

/* Prototypes for our hooks. */
static  void  my_init_hook  (  void );
static  void  * my_malloc_hook  (  size_t ,  const  void  *);
static  void  my_free_hook  (  void *,  const  void  *);

void  *(* __MALLOC_HOOK_VOLATILE  old_malloc_hook )(  size_t  __size  ,  const  void  *) ;
void  (* __MALLOC_HOOK_VOLATILE  old_free_hook ) (  void  * __ptr  ,  const  void  *);
/* Override initializing hook from the C library. */
void  (* __MALLOC_HOOK_VOLATILE  __malloc_initialize_hook ) (  void ) =  my_init_hook ;

void  my_init_hook  ( void )
{
     old_malloc_hook  =  __malloc_hook  ;
     old_free_hook  =  __free_hook  ;
     __malloc_hook  =  my_malloc_hook  ;
     __free_hook  =  my_free_hook  ;
}

static  void  * my_malloc_hook  (  size_t  size  ,  const  void  * caller  )
{
     void  * result  ;
        gLock . lock  ();
     /* Restore all old hooks */
     __malloc_hook  =  old_malloc_hook  ;
     __free_hook  =  old_free_hook  ;
     /* Call recursively */
     result  =  malloc  ( size );
     /* Save underlying hooks */
     old_malloc_hook  =  __malloc_hook  ;
     old_free_hook  =  __free_hook  ;
     /* printf might call malloc, so protect it too. */
     //printf ("malloc (%u) returns %p\n", (unsigned int) size, result);
        RecordPtr (  result  ,  size );

     /* Restore our own hooks */
     __malloc_hook  =  my_malloc_hook  ;
     __free_hook  =  my_free_hook  ;
        gLock . unlock  ();
     return  result  ;
}

static  void  my_free_hook  (  void  * ptr  ,  const  void  * caller  )
{
        gLock . lock  ();
     /* Restore all old hooks */
     __malloc_hook  =  old_malloc_hook  ;
     __free_hook  =  old_free_hook  ;
     /* Call recursively */
     free  ( ptr  );
     /* Save underlying hooks */
     old_malloc_hook  =  __malloc_hook  ;
     old_free_hook  =  __free_hook  ;
     /* printf might call free, so protect it too. */
     //printf ("freed pointer %p\n", ptr);

        RemovePtr (  ptr  );

     /* Restore our own hooks */
     __malloc_hook  =  my_malloc_hook  ;
     __free_hook  =  my_free_hook  ;
        gLock . unlock  ();
}

void  RecordPtr  (  void *  ptr ,  size_t  size )
{
        //  获取调用栈
        void  * array  [ LmCallStack ::  MAX_STACK_LAYERS ];
        int  cstSize  =  backtrace (  array ,  LmCallStack  :: MAX_STACK_LAYERS );

        //  保存指针  调用栈
        LmCallStack *  callstack  =  new  LmCallStack ( array  ,  cstSize );

        gLock . lock  ();

        std :: map  < const  LmCallStack *,  _AllocInfo  ,   __comp >::  iterator  it  =  gLeakInfo . find  ( callstack );
        if  ( it  !=  gLeakInfo .  end ())
      {
              it -> second  . size  +=  size ;
              it -> second  . alloc ++;

              _PtrInfo  pi  ( it ->  first ,  size  );
              gPtrInfo [ ptr  ] =  pi ;
      }
        else
      {
              _AllocInfo  aif  ( size , 1, 0);
              std :: pair  < std ::  map < const  LmCallStack *,  _AllocInfo ,   __comp >:: iterator  ,  bool >  ret  =  gLeakInfo  . insert (  std :: pair  < const  LmCallStack *,  _AllocInfo  >( callstack ,  aif ));
            
              if  ( ret  . second )
            {
                    _PtrInfo  pi  ( ret .  first -> first  ,  size );
                    gPtrInfo [ ptr  ] =  pi ;
            }
              else
            {
                    // failed
            }
      }

        gLock . unlock  ();
}

void  RemovePtr  (  void *  ptr  )
{
        gLock . lock  ();

        std :: map  < void *,  _PtrInfo >:: iterator  it  =  gPtrInfo . find  ( ptr );
        if  ( it  !=  gPtrInfo .  end ())
      {
              std :: map  < const  LmCallStack *,  _AllocInfo  ,   __comp >::  iterator  itc  =  gLeakInfo  . find (  it -> second  . csk );
              if  ( itc  !=  gLeakInfo .  end ())
            {
                    itc -> second  . size  -=  it -> second  . size ;
                    itc -> second  . free ++;

                    if  (0 == ( itc  -> second .  alloc  -  itc  -> second .  free ))
                  {
                          assert (0 ==  itc  -> second .  size );
                          delete  itc  -> first ;
                          gLeakInfo . erase  ( itc );
                  }
            }

              gPtrInfo . erase  ( it );
      }

        gLock . unlock  ();
}

void  Report  ()
{
        char  ** strings  =  NULL ;
        gLock . lock  ();

        __malloc_hook  =  old_malloc_hook  ;
     __free_hook  =  old_free_hook  ;

        for  ( std  :: map <  const  LmCallStack  *,  _AllocInfo ,   __comp >:: iterator  it  =  gLeakInfo  . begin ();
              it  !=  gLeakInfo  . end ();
              it ++)
      {
              printf ( "\n"  );
              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  );
              printf ( "====>  stacks back trace:\n"  );
              strings  =  backtrace_symbols  (( void **)  it -> first  -> callstack ,  it -> first  -> size );
              if  ( strings  )
            {
                    for ( int  i  = 2;  i  <  it  -> first ->  size ;  i  ++)
                  {  //printf("     %s\n", strings[i]);
                          char  output  [1024] = {0};
                          memset ( output  , 0, 1024);
                          char  temp  [1024] = {0};
                          memset ( temp  , 0, 1024);
                         
                              get real function name
                         
                          if  (1 ==  sscanf  ( strings [  i ],  "%*[^(]%*[^_]%[^)+]"  ,  temp ))
                        {
                                      int  status  ;
                                      char *  realname  =  abi :: __cxa_demangle  ( temp , 0, 0, &  status );
                                      if  (0 ==  status  )
                                    {
                                            char *  p  =  strchr (  strings [ i  ],  '(' );
                                            memcpy ( output  ,  strings [  i ],  p - strings  [ i ]);
                                            sprintf ( output  +( p -  strings [ i  ]),  "(%s+%p) "  ,  realname , ((  void **) it  -> first ->  callstack )[ i  ]);  //printf("     -%s\n", realname);
                                            free ( realname  );
                                    }
                                      else
                                    {
                                            char *  p  =  strchr (  strings [ i  ],  ')' );
                                            memcpy ( output  ,  strings [  i ],  p - strings  [ i ]+2);
                                    }
                        }
                          else
                        {
                                char *  p  =  strchr (  strings [ i  ],  ')' );
                                memcpy ( output  ,  strings [  i ],  p - strings  [ i ]+2);
                        }

                          FILE  *  fp  ;
                          char  module  [1024] = {0};
                          memset ( module  , 0, 1024);
                          char *  pm  =  strchr (  strings [ i  ],  '(' );
                          memcpy ( module  ,  strings [  i ],  pm  - strings [  i ]);

                          if  ( strstr  ( module ,  ".so" ))
                        {
                                __pid_t  pid  =  getpid ();
                                sprintf ( temp  ,  "grep %s /proc/%d/maps" ,  module ,  pid  );
                                ///
                                ///         get library base-map-address
                                ///
                                fp  =  popen  ( temp ,  "r" );
                                if  ( fp  )
                              {
                                      char  baseaddr  [64];
                                      unsigned  long  long  base ;
                                    
                                      fgets ( temp  ,  sizeof (  temp )-1,  fp  );   //printf("memmap: %s\n", temp);
                                      sscanf ( temp  ,  "%[^-]" ,  baseaddr );
                                      base  =  strtoll  ( baseaddr ,  NULL , 16);  //printf("baseaddr:%s\n", baseaddr); //printf(" base:0x%llx\n", base);

                                      sprintf ( temp  ,  "addr2line -e %s %p" ,  module , ( void  *)(( unsigned  long  long )(( void  **) it ->  first -> callstack  )[ i ]-  base ));
                              }
                        }
                          else
                        {
                                sprintf ( temp  ,  "addr2line -e %s %p" ,  module , (( void  **) it ->  first -> callstack  )[ i ]);
                        }
                         
                              get source file name and line number
                         
                          fp  =  popen  ( temp ,  "r" );   //printf("cmdline: %s\n", temp);
                          if  ( fp  )
                        {
                                fgets ( temp  ,  sizeof (  temp )-1,  fp  );  //printf("     -%s\n", temp);

                                strcat ( output  ,  temp );
                                printf ( "   ->  %s"  ,  output );
                                pclose ( fp  );
                        }
                          else
                        {
                                printf ( "   ->  %s\n"  ,  output );
                        }
                  }

                    free ( strings  );
                    strings  =  NULL  ;
            }
      }

        __malloc_hook  =  my_malloc_hook  ;
     __free_hook  =  my_free_hook  ;

        gLock . unlock  ();
}


//

CMutexLock :: CMutexLock  ()
{
        pthread_mutexattr_t    m_attr  ;
        pthread_mutexattr_init (& m_attr  );
        pthread_mutexattr_settype (& m_attr  ,  PTHREAD_MUTEX_RECURSIVE );

        if  (0 !=  pthread_mutex_init  (& m_mutex  , &  m_attr ))
      {
              printf ( "c_lock::c_lock pthread_mutex_init error<%d>.\n"  ,  errno );
              assert (0);
      }

        pthread_mutexattr_destroy (& m_attr  );
}

CMutexLock ::~ CMutexLock  ()
{
        if (0 !=  pthread_mutex_destroy  (& m_mutex ))
      {
              printf ( "c_lock::~c_lock pthread_mutex_destroy error<%d>.\n"  ,  errno );
              assert (0);
      }
}

void
CMutexLock :: lock  ()
{

        if (0 !=  pthread_mutex_lock  (& m_mutex ))
      {
              assert ( "c_lock::lock pthread_mutex_lock "  && 0);
      }
}

void
CMutexLock :: unlock  ()
{
        int  iRet  = 0;

        if (0 != ( iRet  =  pthread_mutex_unlock (&  m_mutex )))
      {
              printf ( "c_lock::unlock pthread_mutex_unlock ret<%d> error<%d>.\n" ,  iRet ,  errno  );
              assert (0);
      }
}

示例代码：
leakmom.h

//
//    The Executable file MUST be linked with parameter '-rdynamic' !!!
//

#pragma  once
#include  <string.h>
#include  <pthread.h>
                        
//
class  LmCallStack
{
public :
        char *  callstack  ;  // pointer to buffer recording callstack addresses
        int  size  ;  // count of call stacks
        static  const  int  MAX_STACK_LAYERS ;
public :
        LmCallStack ( void  *  csk =  NULL ,  int  s =0)
      {
              if  ( csk  )
            {
                    callstack  =  new  char [  s * sizeof  ( void *)];
                    memcpy ( callstack  ,  csk ,  s * sizeof  ( void *));
            }
              else
            {
                    callstack  = ( char  *) csk ;
            }
              size  =  s  ;
      }

      ~  LmCallStack ()
      {
              if  ( callstack  )
            {
                    delete []  callstack  ;
            }
              callstack  =  NULL  ;
              size  = 0;
      }
};

class  __comp
{
public :
        __comp (){};
        bool  operator  () ( const  LmCallStack *  first  ,  const  LmCallStack *  second )
      {
              return  (( first  -> size  <  second -> size  ) ||
                        (  first -> size  ==  second ->  size  &&
                                      memcmp ( first  -> callstack ,  second -> callstack  ,  sizeof (  void *)* first  -> size ) < 0)
                        );
      }
};

struct  _PtrInfo
{
        _PtrInfo ( const  LmCallStack *  c = NULL  ,  long  s =0)
      {
              csk  =  c  ;
              size  =  s  ;
      }
        const  LmCallStack  *  csk ;
        long  size  ;
};

struct  _AllocInfo
{
        _AllocInfo ( long  s =0,  int  a  =0,  int  f =0)
      {
              size = s  ;
              alloc = a  ;
              free = f  ;
      }
        //
        long  size  ;
        int  alloc  ;
        int  free  ;
};

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

public :
        void  lock  ();
        void  unlock  ();

private :
        pthread_mutex_t  m_mutex  ;
};


//
void  RecordPtr  (  void *  ptr ,  size_t  size );
void  RemovePtr  ( void *  ptr );
void  Report  ();
一枪尽骚丶魂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++实现内存搜索源代码（和CE差不多）
03-09
c++实现内存搜索源代码（和CE差不多）;c++实现内存搜索源代码（和CE差不多）;c++实现内存搜索源代码（和CE差不多）.
内存泄露检测+锁管理
11-23
说明:简明的内存泄露检测和锁管理 环境:windows/linux 工具:makefile,g++
__cxa_demangle
08-27 3102
char*abi::__cxa_demangle(constchar*mangled_name, char*output_buffer, size_t*length, int*status )...
【C++】C++中获得类型名称
C/C++攻城狮
08-04 8062
文章目录0x00 前言0x02 __cxa_demangle简介 0x00 前言 文章中的文字可能存在语法错误以及标点错误，请谅解； 如果在文章中发现代码错误或其它问题请告知，感谢！ 0x02 __cxa_demangle简介 一般情况下，我们可以通过C++中的typeid().name()获得一个类型或者表达式的名称： std::cout << typeid().name() << std::endl; 例： #include <iostream> #include
如何在C++中获得完整的类型名称
最新发布
Turn X7
03-16 2973
char* name = abi::__cxa_demangle(typeid(Foo*[10]).name(), nullptr, nullptr, nullptr); std::cout
【zz】借助backtrace和demangle实现异常类Exception
hintonic的专栏
08-08 227
转载自： http://www.codeweblog.com/%E5%80%9F%E5%8A%A9backtrace%E5%92%8Cdemangle%E5%AE%9E%E7%8E%B0%E5%BC%82%E5%B8%B8%E7%B1%BBexception/   C++的异常类是没有栈痕迹的，如果需要获取栈痕迹，需要使用以下函数： #include &lt;execinfo.h&gt;...
一次解决Linux内核内存泄漏实战全过程
生活需要深度
03-07 586
主要用来跟踪kmalloc()和kfree()函数对应的trace event, 因为他们的trace event被触发之后会打印kmalloc()和kfree()所申请和释放的内存地址,然后进一步只过滤申请4096字节的情况。PSS:按比例报告的物理内存，比如进程A占用20M物理内存，进程B和进程A共享5M物理内存，那么进程A的PSS就是(20 - 5) + 5/2 = 17.5M。发现从上面几个ptr内存中读出的内容都是非常相似，仔细看一下发现都是/proc/schedstat 的输出内容。
C++查看完整变量类型
编程小喵
06-16 1278
C++查看完整变量类型 使用 cout<<typeid(int).name()<<endl; #include<typeinfo> #include<iostream> using namespace std; int main(){ char search; scanf("%c",&search); cout<<typeid(search).name()<<endl; } 输出结果如下： 56 c ----------
Linux 下几款程序内存泄漏检查工具
热门推荐
youbingchen的博客
07-23 3万+
写这篇博客的原因呢是因为自己在编写基于Nginx磁盘缓存管理程序，目前已经进入测试阶段，关于这个程序的测试分为几个主要步骤：1.内存管理是否正确(因为这个程序本身开辟很多内存空间进行缓存管理，同时这个程序程序本身就是基于C/C++开发的，内存管理机制一直是程序员头痛的东西) 2.程序的健硕性如何（服务器任何程序的基本要求就是要满足高并发的要求，也就是说，如果达不到这个基本要求，程序并并不能成为服务器
如何在程序内部获得call back trace
12-22 310
#include #include #include /* Obtain a backtrace and print it to stdout. */ void print_trace (void) { void *array[10]; size_t size; char **strings; size_t i; size = backtrace (array,
OOM问题预防和排查内存泄漏及解决方法
kuodehai的专栏
02-19 7734
理解了这个算法我们就理解了为啥 MySQL 躺着也能中枪了，因为它的体积总是最大（一般来说它在系统上占用内存最多），所以如果 Out of Memeory (OOM) 的话总是不幸第一个被 kill 掉。 一、什么是OOM，为什么会OOM 二、OOM问题排查 三、OOM问题解决方法
Android：检测内存泄漏的自动化测试Python脚本
zjy764219923的专栏
01-05 563
info shell Python adb 内存 command Android os logger
popen函数引发的血案 -- 64位debian 6
Sky_qing的专栏
06-07 2282
在使用popen()函数查看my_test.py进程数的shell命令是：ps -ef | grep '/usr/bin/python /var/test/my_test.py' | grep -v grep | wc -l 返回的结果始终是0！！！但是在终端上执行该命令的结果却又是正确的！ 于是只能一步一步来，先看看命令的前半部分结果是否正确，也就是使用popen()函数执行： ps
每天进步一点点——Linux系统中的异常堆栈跟踪简单实现
Cynric 的博客
05-04 1万+
在Linux中做C/C++开发经常会遇到一些不可预知的问题导致程序崩溃，同时崩溃后也没留下任何代码运行痕迹，因此，堆栈跟踪技术就显得非要重要了。本文将简单介绍Linux中C/C++程序运行时堆栈获取函数及方法，简单实用。
关于进程内存使用的一点学习和实践
编程开发资料库
09-24 485
在测试，特别是性能测试或者系统的稳定性测试中，内存的使用情况是一个很重要的监控点，不管是从资源使用的角度还是从发现内存泄露问题的角度。 如果笼统的来看，大概就是两个指标，系统的内存使用率和进程使用的内存。但是现实世界的事情往往没有那么简单，稍微细一点来看其实有很多的科目。本文不是一个全面的关于内存使用的探讨，甚至也不是一个详细的Linux下面进程内存使用情况的...
mangle和demangle
weixin_34235105的博客
11-24 415
C/C++语言在编译以后，函数的名字会被编译器修改，改成编译器内部的名字，这个名字会在链接的时候用到。 将C++源程序标识符(original C++ source identifier)转换成C++ ABI标识符(C++ ABI identifier)的过程称为mangle；相反的过程称为demangle。 1 ABI A...
掌握Linux下C/C++程序的GDB实战教程
本篇教程详细介绍了Linux C/C++环境下GDB（GNU Debugger）的使用方法和优势。GDB作为一款强大的开源程序调试工具，特别适合在UNIX平台上进行软件开发。相比于图形化的IDE调试器如VC或BCB，GDB以其命令行操作的方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值