kmemleak的使用---内存泄露检测工具【转】

时间 2019-11-20

标签 kmemleak 使用内存泄露检测工具繁體版

原文原文链接

转自：http://blog.csdn.net/lishenglong666/article/details/8287783node

目录(?)[-]算法

内核泄露检测kmemleak

内核泄露检测（kmemleak）

介绍：

Kmemleak 提供了一种可选的内核泄漏检测，其方法相似于跟踪内存收集器。(http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29#Tracing_garbage_collectors)当独立的对象没有被释放时，其报告记录在 /sys/kernel/debug/kmemleak中。数组

用法：

CONFIG_DEBUG_KMEMLEAK 在Kernel hacking中被使能，一个内核线程每10分钟（默认值）扫描内存，并打印发现新的未引用的对象的数量。数据结构

查看内核打印信息详细过程以下：函数

一、挂载debugfs文件系统工具

mount -t debugfs nodev /sys/kernel/debug/性能

二、开启内核自动检测线程测试

echo scan > /sys/kernel/debug/kmemleakthis

三、查看打印信息

cat /sys/kernel/debug/kmemleak

四、清除内核检测报告，新的内存泄露报告将从新写入/sys/kernel/debug/kmemleak

echo clear > /sys/kernel/debug/kmemleak

内存扫描参数能够进行修改经过向/sys/kernel/debug/kmemleak 文件写入。参数使用以下：

off 禁用kmemleak（不可逆）

stack=on 启用任务堆栈扫描(default)

stack=off 禁用任务堆栈扫描

scan=on 启动自动记忆扫描线程(default)

scan=off 中止自动记忆扫描线程

scan=<secs> 设置n秒内自动记忆扫描，默认600s

scan 开启内核扫描

clear 清除内存泄露报告

dump=<addr> 转存信息对象在<addr>

经过“kmemleak = OFF”，也能够在启动时禁用Kmemleak在内核命令行。在初始化kmemleak以前，内存的分配或释放这些动做被存储在一个前期日志缓冲区。这个缓冲区的大小经过配CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE设置。

功能实现的基本方法原理

经过的kmalloc、vmalloc、kmem_cache_alloc等内存分配会跟踪其指针，连同其余

的分配大小和堆栈跟踪信息，存储在PRIO搜索树。

相应的释放函数调用跟踪和指针就会从kmemleak数据结构中移除。

分配的内存块，被认为是独立的，若是没有指针指向它起始地址或块的内部的任何位置，能够发现扫描内存（包括已保存的寄存器）。这意味着，有可能没有办法为内核经过所分配的地址传递块到一个释放函数，所以，该块被认为是一个内存泄漏。

扫描算法步骤：

1。标记的全部分配对象为白色（稍后将剩余的白色物体

考虑独立的）

2。扫描存储器与所述数据片断和栈开始，检查对地址的值存储在PRIO搜索树。若是

一个白色的对象的指针被发现，该对象将被添加到黑名单

3。扫描的灰色对象匹配的地址（一些白色物体能够变成黑色，并添加结束时的黑名单），直到黑色集结束

4。剩下的白色物体被认为是独立儿，并报告写入/sys/kernel/debug/kmemleak。

一些分配的内存块的指针在内核的内部数据结构和它们不能被检测为孤儿。对

避免这种状况，kmemleak也能够存储的数量的值，指向一个

内的块的地址范围内的地址，须要找到使

块不被认为是泄漏。其中一个例子是使用vmalloc（）函数。

Kmemleak API

------------

见include / linux / kmemleak.h中的函数原型的头。

kmemleak_init - 初始化kmemleak

kmemleak_alloc - 一个内存块分配的通知

kmemleak_alloc_percpu - 通知的一个percpu的内存块分配

kmemleak_free - 通知的内存块释放

kmemleak_free_part - 通知释放部份内存块

kmemleak_free_percpu - 一个percpu内存块释放的通知

kmemleak_not_leak - 当不是泄露时，标记对象

kmemleak_ignore - 当泄漏时不扫描或报告对象

kmemleak_scan_area - 添加扫描区域内的内存块

kmemleak_no_scan - 不扫描的内存块

kmemleak_erase - 删除一个指针变量的旧值

kmemleak_alloc_recursive - 为kmemleak_alloc，只检查递归

kmemleak_free_recursive - 为kmemleak_free，只检查递归

处理假阳性/阴性

--------------------------------------

对于假性的内存泄漏，但不须要报告的，因为值的内存扫描过程当中发现kmemleak是指向这样的对象。为了减小假性报告的数目，kmemleak提供kmemleak_

ignore，kmemleak_scan_area，kmemleak_no_scan，kmemleak_erase的功能，能够指定指针扫描方式，他们的扫描默认状况下不启用。

对于不能肯定是不是内存泄露的，kmemleak提供kmemleak_not_leak。kmemleak_ignore的功能能够指定固定类型的数据是否须要扫描或打印，以上具体函数分析详见3.3详细处理处理过程及功能函数分析。

有的泄露只是瞬间的，尤为是在SMP系统，由于指针暂时存储在CPU的寄存器或栈。当内存泄漏时Kmemleak定义MSECS_MIN_AGE（默认为1000）一个对象的最低时间。

限制和缺点

-------------------------

主要缺点是减小了内存分配和性能释放。为了不其余开销，只进行内存扫描，当在/ sys /kernel/debug/ kmemleak文件被读取。无论怎样，这个工具是用于调试目的，其表现的性能不是重要的。为了保持算法简单，kmemleak的值指向任何扫描一个块的地址范围内的地址。这可能会致使增长假阴性的报告。然而，它包括真正的内存泄漏，最终内存泄露将变得可见。

假阴性的另外一个来源是数据存储在非指针值。

在将来的版本中，kmemleak只能扫描指针成员中分配的结构。此功能解决了许多上述假阴性的状况下。

该工具可能存在误报。这些个案的分配块可能不须要被释放（如一些在init_call功能的状况下），这样的指针经过其余方法计算，与一般的container_of宏或指针被存储在一个位置相比不会被kmemleak扫描。页分配和ioremap不被跟踪

测试的特定部分kmemleak

---------------------------------------

在初始启动时，/sys/kernel/debug/kmemleak输出页面比较多。这样的状况下，当检测指定已经开发的代码错误时，能够经过清除/sys/kerner/debug/kmemleak的输出。经过启动kmemleak的扫描后，你能够找到新的未引用的对象，这应该与测试特定的代码段。

详细步骤以下：

要测试的关键部分以前须要清除kmemleak报告：

echo clear > /sys/kernel/debug/kmemleak

测试你的内核或模块...

echo scan =5> /sys/kernel/debug/kmemleak

而后像往常同样查看报告：

cat /sys/kernel/debug/kmemleak

已经测试的实例详见内核文档kmenleak_test.txt文档

1：检测内核内存泄漏的功能

2：Documentation/kmemleak.txt

3：内核demo:mm/kmemleak-test.c

对于kmemleak，须要理解下面三点就能够了

1：咱们须要知道它能检测哪几种内存泄漏（即用什么方法分配的内存能够检测）

2：内核存在特殊状况，即分配内存但没有引用。使用什么方法能够防止kmemleak report

3：检测的机理是什么，如何知道分配的内存被引用，或者没有引用。

关注点1

kmalloc/kzalloc

vmalloc

kmem_cache_alloc

per_cpu

[Page allocations and ioremap are not tracked]

关注点2

kmemleak_not_leak、kmemleak_ignore、kmemleak_no_scan

这几个函数在内核中被使用，是为了避免被kmemleak 打印出来。可是深层次的区别是什么？

kmemleak_not_leak

/**
* kmemleak_not_leak - mark an allocated object as false positive
* @ptr: pointer to beginning of the object
*
* Calling this function on an object will cause the memory block to no longer
* be reported as leak and always be scanned.
*/

不打印；可是要扫描这个指针所分配的内存的内容。分配数据结构那么该结构自己不打印，可是会扫描结构内部的成员变量，是否引用其余指针。

这个函数每每用在：分配内存的内存永远不会被释放（与内核是一体，vmlinux或者不可移除的模块一类）。

kmemleak_ignore

/**
* kmemleak_ignore - ignore an allocated object
* @ptr: pointer to beginning of the object
*
* Calling this function on an object will cause the memory block to be
* ignored (not scanned and not reported as a leak). This is usually done when
* it is known that the corresponding block is not a leak and does not contain
* any references to other allocated memory blocks.
*/

既不打印，也不扫描指针所指的数据结构的成员变量。若是知道分配的数据结构内部不包含其余引用（不含指针）。

kmemleak_no_scan

/**
* kmemleak_no_scan - do not scan an allocated object
* @ptr: pointer to beginning of the object
*
* This function notifies kmemleak not to scan the given memory block. Useful
* in situations where it is known that the given object does not contain any
* references to other objects. Kmemleak will not scan such objects reducing
* the number of false negatives.
*/

该指针自己被扫描，可是内容不会扫描。

关注点3

所谓reference即所分配的内存有指针引用。若是没有任何指针引用那么确定就是memleak。

因此要查找全部的指针的内容，来寻找其内容是否包含咱们已经记录的分配内存的地址（包括在其实地址+size之间）。

那么这些指针变量的

1：函数的局部变量

这些变量自己在栈中，因此须要检测进程的内核栈

2：全局变量（整个系统/模块内）静态变量

这些变量是存在：ELF的bss/data

这些变量能够经过查看vmlinux或者*.ko查看这类指针变量的区段。

能够经过objdump -x file

---指针是静态分配

3：指针自己是动态分配的，即动态分配内存块（struct).成员变量是指针

因此必需要搜索这类动态分配的内存块的内容。

经过objdump -x vmlinux

.data

where global tables, variables, etc. stand. objdump -s -j .data .process.o will hexdump it.

.bss

don't look for bits of .bss in your file: there's none. That's where your uninitialized arrays and variable are, and the loader 'knows' they should be filled with zeroes ... there's no point storing more zeroes on your disk than there already are, is it ?

.rodata

that's where your strings go, usually the things you forgot when linking and that cause your kernel not to work. objdump -s -j .rodata .process.o will hexdump it. Note that depending on the compiler, you may have more sections like this.

.data..percpu

kmemleak_scan（）

data/bss 段扫描

/* data/bss scanning */

scan_block(_sdata, _edata, NULL, 1);
scan_block(__bss_start, __bss_stop, NULL, 1);

data..percpu

#ifdef CONFIG_SMP
     /* per-cpu sections scanning */
     for_each_possible_cpu(i)
          scan_block(__per_cpu_start + per_cpu_offset(i),
                  __per_cpu_end + per_cpu_offset(i), NULL, 1);
#endif

-->>>>以上都是全局指针变量、per_cpu变量

struct pagep[]数组

/*
         * Struct page scanning for each node.
         */
        lock_memory_hotplug();
        for_each_online_node(i) {
                pg_data_t *pgdat = NODE_DATA(i);
                unsigned long start_pfn = pgdat->node_start_pfn;
                unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
                unsigned long pfn;

                for (pfn = start_pfn; pfn < end_pfn; pfn++) {
                        struct page *page;

                        if (!pfn_valid(pfn))
                                continue;
                        page = pfn_to_page(pfn);
                        /* only scan if page is in use */
                        if (page_count(page) == 0)
                                continue;
                        scan_block(page, page + 1, NULL, 1);
                }
        }
        unlock_memory_hotplug();

内核struct page数组是动态分配的，因此也要单独的进行检测。

内核进程栈

if (kmemleak_stack_scan) {
          struct task_struct *p, *g;

          read_lock(&tasklist_lock);
          do_each_thread(g, p) {
               scan_block(task_stack_page(p), task_stack_page(p) +
                       THREAD_SIZE, NULL, 0);
          } while_each_thread(g, p);
          read_unlock(&tasklist_lock);

通常遍历内核全部的进程用的是：for_each_process();

可是这里却使用：do_each_thread(){};while_each_thread()

>>>for_each_process:只打印进程；而不打印进程内的线程

>>>do_each_thread(){};while_each_thread():打印进程以及进程内的线程信息。这是由于线程有本身单独的内核栈信息。

分配的内存块的内部

分配一块内存（通常是分配数据结构），内部的成员变量是指针，因此这部分也须要检测。

>>> scan_gray_list();---->scan_object():

扫描分配内存的所有内容或者部份内容,是否引用其余指针。

pointer+size

问题

1：读代码理解下面的扫描

struct A*a ---> struct A {

struct B * b------>struct B {

struct C *c ------->struct C

若是struct A *a = NULL