内容


使用 DrMemory 发现内存编程错误

内存调试利器

Comments

Dr Memory 简介

Dr. Memory 是一个开源免费的内存检测工具,它能够及时发现内存相关的编程错误,比如未初始化访问、内存非法访问以及内存泄露等。它不仅能够在 Linux 下面工作,也能在微软的 Windows 操作系统上工作。不过,本文撰写时,DrMemory 仅能支持 32 位程序,这是它的一个巨大缺陷,但相信随着开发的进行,DrMemory 会推出支持 64 位程序的版本。

Dr Memory 与 Valgrind 类似,可以直接检查已经编译好的可执行文件。用户不用改写被检查程序的源代码,也无须重新链接第三方库文件,使用起来非常方便。

Dr. Memory 建立在 DynamoRIO 这个动态二进制插桩平台上。动态监测程序的运行,并对内存访问相关的执行代码进行动态修改,记录其行为,并采用先进的算法进行错误检查。

根据 DrMemory 开发人员发表在 CGO 2011上的论文 Practical Memory Checking with Dr. Memory,DrMemory 对程序的正常执行影响较小,这在同类工具中是比较领先的。其 performance 和 Valgrind 的比较如图 1 所示(图片源自 DrMemory 主页):

图 1. 和 Valgrind 的性能比较

Valgrind 对程序的正常运行影响较大,一般来说如果进行全面内存检测,会使程序的运行速度有 50 到 300 倍的减慢。而 DrMemory 在这个方面则有一定的优势。

易用性和性能是 DrMemory 的主要优点,此外 DrMemory 可以用于调试 Windows 程序,因此它被广泛认为是 Windows 上的 Valgrind 替代工具。在 Linux 平台中,DrMemory 也往往可以作为 Valgrind 之外的另一个选择。

DrMemory 对内存泄露的监测采用了比较独特的算法,大量减少了”false positive”,即虚假错误。如果您使用 Valgrind 等工具后仍无法找到程序中的内存错误,不妨试试 DrMemory 吧。

在 Linux 上,DrMemory 的目前版本尚不能调试 64 位程序,这是它的一个比较大的缺点。

DrMemory 的安装

在 Linux 上,安装 Dr Memory 非常简单,简单地将下载包解压即可,如:

tar –xzvf DrMemory-Linux-1.4.6-2.tar.gz

要想使用 DrMemory,要保证下面这些软件已经正确安装:

perl、objdump、addr2line。

在任何一个当前的 Linux 发行版中,这几个软件应该都已经安装了,因此基本上您只需要下载 DrMemory 的 tar 包,然后解压即可使用了。

Windows 上 DrMemory 提供了可执行安装包,只需点击下一步,即可安装完毕。

Hello DrMemory,第一印象

DrMemory 的使用很简单,可以说它是傻瓜式。正常运行一个程序时,我们在 shell 中敲入命令然后回车。为了用 DrMemory 检查,只需要在正常命令之前加入 drmemory.pl,比如程序检查程序 t,那么就这样:

drmemory.pl  ./t

在计算机领域,Helloworld 总是第一个程序。让我们写一个 HelloDrMemory,来和 DrMemory 简单接触一下吧。

清单 1,Hello DrMem 例子程序
1:   int main()
2:   {
3:     char *ptr;
4:     int i;
5:     for(i=0;i<100;i++)
6:     {
7:       ptr=(char*)malloc(i);
8:       if(i%2) free(ptr);
9:     }
10:    return 0;
11:  }

很明显,有 50 个内存泄露,都在同一行代码中(Line 8)。让我们用 Dr Memory 来检查它。

-bash-3.2$ gcc -m32 -o t t1.c -g
-bash-3.2$ drmemory.pl ./t
-bash-3.2$ ~~Dr.M~~
~~Dr.M~~ ERRORS FOUND:
~~Dr.M~~       0 unique,     0 total unaddressable access(es)
~~Dr.M~~       0 unique,     0 total uninitialized access(es)
~~Dr.M~~       0 unique,     0 total invalid heap argument(s)
~~Dr.M~~       0 unique,     0 total warning(s)
~~Dr.M~~       1 unique,    50 total,      0 byte(s) of leak(s)
~~Dr.M~~       0 unique,     0 total,      0 byte(s) of possible leak(s)
~~Dr.M~~ ERRORS IGNORED:
~~Dr.M~~       0 still-reachable allocation(s)
~~Dr.M~~ Details: /home/…/logs/DrMemory-t.15086.000/results.txt

屏幕上会有如上所示的错误汇总,注意看 ERRORS FOUND 下面的第 5 行:”50 total leaks”。不错吧。根据提示,更多的细节被写入一个 result 文本文件。打开并查看该文件,就可以知道程序在哪里出现了内存错误了。真是太方便了。不过 result 文件是否容易阅读呢?下面我们来详细解释如何阅读 DrMemory 产生的 result 文件。

DrMemory 报告解读细节

内存非法访问

DrMemory 认为任何对未分配内存区域的读写都是非法的。在 Linux 中,应用程序可以用以下几个方式分配内存:

  • 调用 mmap (或者 mremap)
  • 调用 malloc 在堆上分配内存
  • 使用 alloca 在栈上分配内存

非法访问就是对以上三种方法分配的内存区域之外进行的访问。常见的问题包括 buffer overflow、数组越界、读写已经 free 的内存、堆栈溢出等等。让我们测试下面这个问题程序。

清单 2,存在非法访问的例子程序
1:  int main()
2:  {
3:    char *ptr;
4:    int i;
5:    char *x = malloc(8);
6:    char c = *(x+8);   //buffer overlow
7:    free(x);
8:    c = *x;  //read free memory
9:    return 0;
10: }

Buffer overflow

例子程序的第 5 到 6 行存在 buffer overflow。在内存中,buffer 的分布如下图所示:

图 2. Buffer 分布

访问 x+8 将产生一个非法内存访问。对此,Dr Memory 将给出如下的错误信息:

Error #1: UNADDRESSABLE ACCESS: 
reading 0x0804a020-0x0804a021 1 byte(s)
# 0 t!main          [/home/DrMem/t.c:9]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:00.133 in thread 13971
Note: refers to 1 byte(s) beyond last valid byte in prior malloc
Note: prev lower malloc:  0x0804a018-0x0804a020
Note: instruction: movzx  (%eax) -> %eax

首先用大写的单词 UNADDRESSABLE ACCESS 表明这是一个非法访问错误。接着,“reading 0x0804a020-0x0804a021 1 byte(s)”表示这是一个非法读,读取的范围为 0x0804a020 到 0x0804a021,一共读了 1 个 byte。接下来的三行是调用堆栈信息,可以方便地看到错误发生在哪个源文件的哪一行(程序 t 需要在用 gcc 编译的时候给定-g 选项)。此外 DrMemory 还给出了一些辅助的错误信息。比如:

错误发生的时间:Note: elapsed time = 0:00:00.133 in thread 13971。这表明错误是程序开始的第 0.133 秒后发生的,有些情况下,人们可以根据这个时间进行辅助判断。

错误细节:Note: refers to 1 byte(s) beyond last valid byte in prior malloc。这里给出了错误的详细信息,如前所述,造成非法访问的可能很多,在本例中是 buffer overflow,因此这里的详细信息可以帮助我们了解非法访问的具体原因。

Note: prev lower malloc: 0x0804a018-0x0804a020。这里给出了 overflow 之前的合法内存地址,有些情况下对于查错 有一定的帮助。

Note: instruction: movzx (%eax) -> %eax。这里给出的是造成错误的具体指令。

访问已释放内存

例子程序的第 7 行将内存 x 释放,之后再读取该内存即为错误。对于此类错误,错误信息如下所示:

Error #2: UNADDRESSABLE ACCESS: 
reading 0x0804a018-0x0804a019 1 byte(s)
# 0 t!main                         [/home/DrMem/t.c:13]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:01.159 in thread 16384
Note: 0x0804a018-0x0804a019 overlaps 
memory 0x0804a018-0x0804a020 that was freed
Note: instruction: movzx  (%eax) -> %eax

一些运行选项可以让 DrMemory 的报告更加易读,或者给出更有指导性的信息。

-delay_frees_stack 选项的影响

仍然使用前面的例子,在运行 DrMemory 的时候给定-delay_frees_stack 选项:

drmemory.pl –delay_fress_stack -- ./t

现在打开 DrMemory 的 result 文件,将看到关于访问以释放内存的错误信息更加丰富了:

Error #2: UNADDRESSABLE ACCESS: 
reading 0x0804a018-0x0804a019 1 byte(s)
# 0 t!main                                          [/home/DrMem/t.c:13]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:01.176 in thread 24378
Note: 0x0804a018-0x0804a019 overlaps 
memory 0x0804a018-0x0804a020
that was freed here:
Note: # 0 t!main                        [/homeDrMem/t.c:13]
Note: # 1 libc.so.6<nosyms>!?
Note: # 2 t!_start
Note: instruction: movzx  (%eax) -> %eax

多了三行 Note:信息,指明内存释放的代码行。这个特性在很多情况下都十分有用。因为程序可能在释放内存之后很久才对其进行读写,如果不指出释放的地方,查找错误原因还要很费一番工夫。有了这额外信息,我们立即就可以知道程序是在 t.c 的第 13 行将内存释放掉了。

-brief 选项的影响

采用 –delay_fress_stack之后,虽然信息更丰富了,但天下没有免费的午餐,这样也有一个缺点,即最终报告变得不易阅读了。因此您还可以使用-brief 选项来简化输出。

drmemory.pl –delay_fress_stack -- ./t
。。。
Error #3: UNADDRESSABLE ACCESS: reading 1 byte(s)
# 0 t!main                     [/home/DrMem/t.c:14]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: refers to memory that was freed here:
Note: # 0 t!main              [/home/DrMem/t.c:14]
Note: # 1 libc.so.6<nosyms>!?
Note: # 2 t!_start

不再输出类似 elapseTime 等信息,从而简化错误信息,使之更加容易阅读。也许您并不认为上述输出更加容易阅读,嗯,您可以不使用这个选项。

未初始化读

读取未初始化的内存其结果是未知的,使用这样的数据是很危险的。让我们查看下面这个测试程序(并不危险的程序):

清单 3,未初始化错误例子程序
1:       typedef struct T_ {
2:         char a;
3:         char b;
4:       }T;

5:       int main()
6:       {
7:         T a,b;
8:         char x;
9:         a.a = 'a';
10:        a.b = 'b';
11:        b.a = x;
12:        if(b.a ==10)
13:           memcpy(&b,&a, sizeof(T));
14:        return 0;
15:       }

运行 DrMemory 得到如下报告:

Dr. Memory results for pid 24399, …

Error #1: UNINITIALIZED READ: reading register al
# 0 t!main                             [/home/DrMem/uninit.c:16]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:00.111 in thread 24399
Note: instruction: cmp    %al $0x0a

========================================================
FINAL SUMMARY:
Grouping errors that may be the same or related:
Group 1:
Group 2:  1
DUPLICATE ERROR COUNTS:
SUPPRESSIONS USED:
ERRORS FOUND:
      0 unique,     0 total unaddressable access(es)
      1 unique,     1 total uninitialized access(es)
      0 unique,     0 total invalid heap argument(s)
      0 unique,     0 total warning(s)
      0 unique,     0 total,      0 byte(s) of leak(s)
      0 unique,     0 total,      0 byte(s) of possible leak(s)
ERRORS IGNORED:
      0 still-reachable allocation(s)

可以看到 DrMemory 只报告了一个未初始化读错误,在第 12 行。很多其他工具对于 memcpy(&b,&a, sizeof(T))也会报错。

GCC 将自动对齐数据结构(未使用 pack 修饰符的情况下)。因此 struct T 在内存中的实际分布如下:

图 3. 内存拷贝细节

在 memcpy 时,有 3 个未初始化 byte 也被访问了,但这类错误如果也报告的话,对正常程序 DrMemory 会产生很多错误信息。这些其实不是错误,所以被称为 False Positive。类似医学名词“假阳性”。内存调试工具的一个主要目标就是减少 False Positive,否则产生的报告有用性将极大降低。

其它很多工具,遇到上述拷贝会报告 false positive,浪费读报告的人们的时间。因此这是 Dr Memory 的一个重要优点。

Heap 操作参数错误(Invalid Heap Argument)

C 语言用 malloc()、free()等函数处理内存 heap 的使用。如果使用不当,会造成未知后果,比如传入 free()的参数不正确,可能造成 crash,或者用 new 分配,却用 free 来释放内存。这类错误 DrMemory 称之为 Invalid Heap Argument 错误。

比如下面这个 C++程序:

清单 4.非法 Heap 操作参数
//invalidArg.cpp
4:  int main()
5:  {
6:    char * ptr = NULL;
7:    ptr = new char;
8:    free(ptr);
9:    free(ptr);
10:   return 0;
11:  }

运行 DrMemory 检测上述程序,将产生两个错误信息:

Error #1: INVALID HEAP ARGUMENT: 
allocated with operator new, freed with free
# 0 t!main             [/home/DrMem/invalidArg.cpp:8]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:00.165 in thread 27804
Note: memory was allocated here:
Note: # 0 libstdc++.so.6<nosyms>!?
Note: # 1 t!main      [/home/DrMem/invalidArg.cpp:7]
Note: # 2 libc.so.6<nosyms>!?

Error #2: INVALID HEAP ARGUMENT to free() 0x0804a018
# 0 t!main        [/homeDrMem/invalidArg.cpp:9]
# 1 libc.so.6<nosyms>!?
# 2 t!_start
Note: elapsed time = 0:00:00.167 in thread 27804
Note: memory was previously freed

Error#1 表示在程序的第 8 行,用 C 风格的 free 来释放一个用 new 操作符分配的内存。这是一个错误。

在第 9 行,出现了 free 两次的错误,这也是不当使用内存堆分配函数的典型例子。

通过 Dr Memory,我们可以方便地检测到程序中这类不当使用内存函数和操作符的地方。

内存泄露

内存泄露是常见的内存错误,我们可能都曾经遇到过。不过 Dr.Memory 对内存泄露的定义比较独特,在程序退出之前,Dr.Memory 把所有依然被分配的内存分为三类:

Still-reachable allocation

很多程序分配了内存之后,在其整个生命周期内都不释放。虽然这是一种泄露,但实际上多数情况下这是无害的,甚至是特意这样设计的。因此 Dr.Memory 并不认为这是一种内存泄露,而称之为”Still-reachable allocation”。

Leak

有一些内存无法再被释放,因为指向该内存的指针丢失了。比如下面这个代码:

清单 5.内存 Leak 例子代码
 char *ptr = malloc(10);
 char *ptr1 = malloc(100);
 ptr=ptr1; //leak

DrMemory 称这类错误为内存泄露。因为这些内存已经没有办法被释放了。

Possible Leak

如前所述指向内存的指针被修改会被认为是一个 Leak,但并非所有的指针修改都是一个 Leak。DrMemory 利用一些经验规则(Heuristic)将以下几种指针修改列为 Possible Leak。

第一种情况:C++程序利用 new[]分配了一个数组,该数组的每个元素都是 拥有自己的析构函数的复杂数据结构。这种情况下,New 操作符为每个元素加上一个 header 用来保存数组的个数,以便 delete[]操作符知道需要调用多少个析构函数。但 new[]返回 caller 的是 header 之后的地址,这样就变成了一个 mid-allocation 指针。这可能被 Dr memory 认为是一个内存泄露。但可以使用-no_midchunk_new_ok 选项让 DrMemory 将这类错误报告为”possible leak”而非”leak”。

参考下图,理解这种情况。

图 4.mid-chunk new

从堆分配器的角度来看,buffer 的起点在 A 处,但 new 返回 B,给 Object 变量赋值。从某种角度上看,指针 A 丢失了,是一个 leak,但实际上,当调用 delete []操作符时,C++运行时库会自动将 Object 指针减 4,从而指向 A 点,再进行释放。某些编译器不使用这种做法,则没有这个问题。

第二种情况,某些 C++编译器在处理多继承时,会出现 mid-chunk 指针。很抱歉,具体细节本人也不甚了解。Dr Memory 的原文如下:it includes instances of a pointer to a class with multiple inheritance that is cast to one of the parents: it can end up pointing to the subobject representation in the middle of the allocation. 您可以用-no_midchunk_inheritance_ok 选项将这类“错误”报告为”possible leak” 。

还有一种可能:std::string 类把一个 char[]数组放置在分配空间中,并返回一个指针直接指向它,造成了一个 mid-allocation 指针。您可以用-no_midchunk_string_ok 选项让这类错误显示为”possible leak”。

一些有用的选项

现实世界中真正的程序有很多不同于本文中所罗列的那些例子程序,现实程序更复杂,查找错误并不像例子所示的那么容易。DrMemory 设计了一些辅助选项,灵活使用它们才能在真正的工作中得到有用的信息。

监控子程序

缺省情况下 DrMemory 将监控当前进程产生的子进程的内存错误。如果您想禁止检查子进程,可以使用-no_follow_children 选项。

合并检查结果

用-aggregate 选项可以合并 DrMemory 的检查结果,比如下面的命令把 logs 目录下面多个 DrMemory 报告合并为一个总的报告。

Drmemory.pl –aggregate ./logs

这个功能在某些情况下比较有用。比如对同一个程序用多个不同的测试用例测出不同的内存错误,可以把多个报告合并起来,以便程序员一次阅读。

检查不退出程序

一些程序永远或者长时间都不退出,对于某些内存错误,比如未初始化读写,或者非法读写,DrMemory 一旦发现就立即写入 result 文件。但 DrMemory 只有在进程退出时才检查内存泄露。因此对于长期运行的程序,如果我们想在其运行期间得到内存泄露的报告,就需要使用 DrMemory 的 nudge 命令。比如您的进程 pid 为 1000,正在被 DrMemory 检测。那么你可以在 Shell 中运行下面这条命令,强制 DrMemory 进行内存泄露检查,并把结果更新到 result 文件中。

drmemory.pl –nudge 1000

现在打开 result 文件,如果程序有内存泄露,您将在该文件中找到错误信息。

Suppressing Errors

内存错误检查工具的一个重要能力就是能够 suppress errors,即隐藏指定”错误”的能力。因为人们使用内存错误检测工具最希望的是它能给出“真正的”错误,而不是给出大量的不是错误的错误。工具本身可以根据一些经验算法隐藏一些“众所周知”的假错误。但更多的情况下,需要使用者告诉工具如何区分出假错误。

每次运行 DrMemory 时,它会产生一个 suppress 文件,和 result 文件放在一起。该文件的格式如下:

图 5. suppress 文件格式

suppress 文件有多个”One Error”小节组成,每个”One Error”表示一个可以被 suppress 的错误。用调用堆栈来表示,有两种格式来表示堆栈:

format1: module!function 比如: t!foo 表示 t.c 中的 foo 函数
format2: <module+offset>

DrMemory 支持通配符,比如 t!*表示不报告所有模块 t 中的错误。在 Linux 下面,模块 t,就是由 t.c 生成的 t.o 所包含的代码,换句话说就是不检查 t.c 中的错误。

结束语

很高兴也很遗憾我能为大家介绍一款新的内存调试工具。我们恐怕已经面临太多的选择,假如您用 Google 搜索,会找到很多类似的工具,他们中的多数都不易使用,也许您花了很多的精力去学习某款工具的使用,却发现它根本就不适合您的环境。

可惜,不同的工具有不同的优点和缺点,直到今天,尚没有一款工具能够替代所有其它的同类。写程序有时很无奈,尤其是面对内存错误的时候,多一个选择也许会让你摆脱困境。下一次,假如人们告诉您程序有内存泄露,那么不妨用 DrMemory 试一下。


相关主题


评论

添加或订阅评论,请先登录注册

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Linux, AIX and UNIX
ArticleID=945178
ArticleTitle=使用 DrMemory 发现内存编程错误
publish-date=09162013