Chinaunix首页 | 论坛 | 博客
  • 博客访问: 216649
  • 博文数量: 44
  • 博客积分: 10
  • 博客等级: 民兵
  • 技术积分: 1354
  • 用 户 组: 普通用户
  • 注册时间: 2012-04-08 15:38
个人简介

人生像是在跑马拉松,能够完赛的都是不断地坚持向前迈进;人生就是像在跑马拉松,不断调整步伐,把握好分分秒秒;人生还是像在跑马拉松,能力决定了能跑短程、半程还是全程。人生其实就是一场马拉松,坚持不懈,珍惜时间。

文章分类

分类: LINUX

2016-12-23 14:03:59

kmemcheck和kmemleaklinux2.6.31版本开始对外提供的内核内存管理方面的两个检测工具,最初仅支持x86环境,时至今日已经能够支持arm环境了。其中kmemcheck主要是用于内核内存破坏检测,而kmemleak则是用于内核内存泄露检测。本文主要分析kmemcheck的实现,至于kmemleak下一篇文章再详细介绍。

为什么要有kmemcheck?古人云:人非圣贤孰能无过,程序员也会犯错,但是这不能作为犯错的辩解。也是由于C语言的强大,几乎可以访问所有内存,加上程序开发时的考虑不周或者疏忽等情况,极有可能操作越界或者访问了未初始化的内存空间等,导致了内存破坏或者改写,这时则需要一个能够记录导致错误的日志信息。对此,kmemcheck应运而生。

kmemcheck的设计思路是分配内存页面的同时分配等量的影子内存,所有对分配出来的内存的操作,都将被影子内存所“替代”,也就是该操作都会先通过影子内存,经检测内存操作的“合法性”后,最终才会落入到实际的内存页面中,对于所有检测出来的“非法”操作,都将会被记录下来。

其具体工作原理可以通过分配内存、访问内存、释放内存以及错误处理四个方面进行了解:(注:该描述来自于IBM工程师的一篇文章:http://www.ibm.com/developerworks/cn/linux/l-cn-kmemcheck/,鉴于确实写得好,此处就照抄过来了)

1、分配内存

对分配到的内存数据页面(分配标志中不包含 __GFP_NOTRACK__GFP_HIGHMEM,对于 slab cache 的内存,cache 创建时标志中不包含 SLAB_NOTRACK)kmemcheck 会为其分配相同数量的影子页面(在分配影子页面时,置位了 __GFP_NOTRACK 标志位,所以它自己不会被 kmemcheck 跟踪),数据页面通过其 page 结构体中的 shadow 指针和影子页面联系起来。然后影子页面中的每个字节会标志为未初始化状态,同时将数据页面对应的页表项中 _PAGE_PRESENT 标志位清零(这样访问该数据页面时会引发页面异常),并置位 _PAGE_HIDDEN 标志位来表明该页面是被 kmemcheck 跟踪的。

2、访问内存

由于在分配过程中将数据页面对应的页表项中的 _PAGE_PRESENT 清零了,因此对该数据页面的访问会引发一次页面异常,在 do_page_fault 函数处理过程中,如果它发现页表项属性中的 _PAGE_HIDDEN 置位了,那么说明该页面是被 Kmemcheck 跟踪的,接下来就会进入 kmemcheck 的处理流程,其中会根据该次内存访问地址所对应的影子页面中的内容来检查这次访问是否是合法的,如果是非法的那么它就会将预先设置好的一个 tasklet(该 tasklet 负责错误处理)插入到当前 CPU tasklet 队列中,然后去触发一个软中断,这样在中断的下半部分就会执行这个 tasklet。接下来 kmemcheck 会将影子页面中对应本次内存访问地址的内存区域标识为初始化状态(防止同一个地址警告两次),同时将数据页面页表项中的 _PAGE_PRESENT 置位,并将 CPU 标志寄存器 TF 置位开启单步调试功能,这样当页面异常处理返回后,CPU 会重新执行触发异常的指令,而这次是可以正确执行的。但是执行该指令完毕后,由于 TF 标志位置位了,所以在执行下一条指令之前,系统会进入调试陷阱(debug trap),在其处理函数 do_trap 中,kmemcheck 又会清零该数据页面页表项中的 _PAGE_PRESENT 属性标志位(并且清零标志寄存器中的 TF 位),从而当下次再访问到这个页面时,又会引发一次页面异常。

3、释放内存

影子页面会随着数据页面的释放而被释放,因此当数据页面被释放之后,如果再去访问该页面,不会出现 kmemcheck 报警。

4、错误处理

kmemcheck 用了一个循环缓冲区(包含了 CONFIG_KMEMCHECK_QUEUE_SIZE 个元素)来记录每次的警告信息,包括警告类型,引发警告的内存地址及其访问长度,各寄存器的值和 stack trace,同时还将访问地址附近(起始地址:以 2 CONFIG_KMEMCHECK_SHADOW_COPY_SHIFT 次幂大小对该地址进行圆整后的值;大小:2 CONFIG_KMEMCHECK_SHADOW_COPY_SHIFT 次幂)的数据页面和其对应影子页面中的内容保存在记录中(由同一指令地址引发的相邻的两次警告不会被重复记录)。当前文中注册的 tasklet 被调度执行时,会将循环缓冲区中所有的记录都打印出来。

    了解过kmemcheck实现原理后,下面分析一下其代码显示,其中kmemcheck模块的函数入口为kmemcheck_init()

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. int __init kmemcheck_init(void)
  3. {
  4. #ifdef CONFIG_SMP
  5.     /*
  6.      * Limit SMP to use a single CPU. We rely on the fact that this code
  7.      * runs before SMP is set up.
  8.      */
  9.     if (setup_max_cpus > 1) {
  10.         printk(KERN_INFO
  11.             "kmemcheck: Limiting number of CPUs to 1.\n");
  12.         setup_max_cpus = 1;
  13.     }
  14. #endif
  15.  
  16.     if (!kmemcheck_selftest()) {
  17.         printk(KERN_INFO "kmemcheck: self-tests failed; disabling\n");
  18.         kmemcheck_enabled = 0;
  19.         return -EINVAL;
  20.     }
  21.  
  22.     printk(KERN_INFO "kmemcheck: Initialized\n");
  23.     return 0;
  24. }
  25.  
  26. early_initcall(kmemcheck_init)

该函数通过early_initcall()的方式注册到linux内核初始化中,其将在kernel_init()内核线程中被调用初始化,调用路径kernel_init()->kernel_init_freeable()->do_pre_smp_initcalls()->do_one_initcall()->kmemcheck_init(),至于其注册和被调用的方式实现将在后面的kswapd内核守护线程中进行分析,这里就不赘述了。

进一步分析kmemcheck_selftest()函数实现。

  1. 【file:/arch/x86/mm/kmemcheck/selftest.c】
  2. bool kmemcheck_selftest(void)
  3. {
  4.     bool pass = true;
  5.  
  6.     pass = pass && selftest_opcodes_all();
  7.  
  8.     return pass;
  9. }

    该函数主要封装selftest_opcodes_all()函数; 

  1. 【file:/arch/x86/mm/kmemcheck/selftest.c】
  2. static bool selftest_opcodes_all(void)
  3. {
  4.     bool pass = true;
  5.     unsigned int i;
  6.  
  7.     for (i = 0; i < ARRAY_SIZE(selftest_opcodes); ++i)
  8.         pass = pass && selftest_opcode_one(&selftest_opcodes[i]);
  9.  
  10.     return pass;
  11. }

    至于selftest_opcodes_all()则主要是通过遍历selftest_opcodes[]数组列表,对CPU的操作码进行解码操作。具体的selftest_opcodes定义如下。

  1. 【file:/arch/x86/mm/kmemcheck/selftest.c】
  2. static const struct selftest_opcode selftest_opcodes[] = {
  3.     /* REP MOVS */
  4.     {1, "\xf3\xa4", "rep movsb , "},
  5.     {4, "\xf3\xa5", "rep movsl , "},
  6.  
  7.     /* MOVZX / MOVZXD */
  8.     {1, "\x66\x0f\xb6\x51\xf8", "movzwq , "},
  9.     {1, "\x0f\xb6\x51\xf8", "movzwq , "},
  10.  
  11.     /* MOVSX / MOVSXD */
  12.     {1, "\x66\x0f\xbe\x51\xf8", "movswq , "},
  13.     {1, "\x0f\xbe\x51\xf8", "movswq , "},
  14.  
  15. #ifdef CONFIG_X86_64
  16.     /* MOVZX / MOVZXD */
  17.     {1, "\x49\x0f\xb6\x51\xf8", "movzbq , "},
  18.     {2, "\x49\x0f\xb7\x51\xf8", "movzbq , "},
  19.  
  20.     /* MOVSX / MOVSXD */
  21.     {1, "\x49\x0f\xbe\x51\xf8", "movsbq , "},
  22.     {2, "\x49\x0f\xbf\x51\xf8", "movsbq , "},
  23.     {4, "\x49\x63\x51\xf8", "movslq , "},
  24. #endif
  25. };

    selftest_opcode_one()将会对selftest_opcodes[]的每项操作码信息进行解析。

  1. 【file:/arch/x86/mm/kmemcheck/selftest.c】
  2. static bool selftest_opcode_one(const struct selftest_opcode *op)
  3. {
  4.     unsigned size;
  5.  
  6.     kmemcheck_opcode_decode(op->insn, &size);
  7.  
  8.     if (size == op->expected_size)
  9.         return true;
  10.  
  11.     printk(KERN_WARNING "kmemcheck: opcode %s: expected size %d, got %d\n",
  12.         op->desc, op->expected_size, size);
  13.     return false;
  14. }

    该函数会调用kmemcheck_opcode_decode()对操作码解码操作,这是一个非常粗暴的解码函数实现,主要是从其他指令中区别出读写指令及其大小,返回实际指令长度以及前缀操作码。最终实际上是对读写指令做操作码检验,至于为什么在初始化函数中调用,只是做一下检验?有待考究。

  1. 【file:/arch/x86/mm/kmemcheck/opcode.c】
  2. /*
  3.  * This is a VERY crude opcode decoder. We only need to find the size of the
  4.  * load/store that caused our #PF and this should work for all the opcodes
  5.  * that we care about. Moreover, the ones who invented this instruction set
  6.  * should be shot.
  7.  */
  8. void kmemcheck_opcode_decode(const uint8_t *op, unsigned int *size)
  9. {
  10.     /* Default operand size */
  11.     int operand_size_override = 4;
  12.  
  13.     /* prefixes */
  14.     for (; opcode_is_prefix(*op); ++op) {
  15.         if (*op == 0x66)
  16.             operand_size_override = 2;
  17.     }
  18.  
  19.     /* REX prefix */
  20.     if (opcode_is_rex_prefix(*op)) {
  21.         uint8_t rex = *op;
  22.  
  23.         ++op;
  24.         if (rex & REX_W) {
  25.             switch (*op) {
  26.             case 0x63:
  27.                 *size = 4;
  28.                 return;
  29.             case 0x0f:
  30.                 ++op;
  31.  
  32.                 switch (*op) {
  33.                 case 0xb6:
  34.                 case 0xbe:
  35.                     *size = 1;
  36.                     return;
  37.                 case 0xb7:
  38.                 case 0xbf:
  39.                     *size = 2;
  40.                     return;
  41.                 }
  42.  
  43.                 break;
  44.             }
  45.  
  46.             *size = 8;
  47.             return;
  48.         }
  49.     }
  50.  
  51.     /* escape opcode */
  52.     if (*op == 0x0f) {
  53.         ++op;
  54.  
  55.         /*
  56.          * This is move with zero-extend and sign-extend, respectively;
  57.          * we don't have to think about 0xb6/0xbe, because this is
  58.          * already handled in the conditional below.
  59.          */
  60.         if (*op == 0xb7 || *op == 0xbf)
  61.             operand_size_override = 2;
  62.     }
  63.  
  64.     *size = (*op & 1) ? operand_size_override : 1;
  65. }

    kmemcheck模块初始化,实际上是没做什么事情的,只是检验一下处理器的操作码,至少从代码实现中是如此的。个人感觉是为了检验代码的有效性,直接写在初始化中,以便系统启动后就可以观察到该解析函数是否有效(以上为个人愚见)。

    而实际上的kmemcheck如何实现内存检查的,接下来进行分析一下。首先是分配影子内存,该函数入口为kmemcheck_alloc_shadow(),具体实现:

  1. 【file:/mm/kmemcheck.c】
  2. void kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node)
  3. {
  4.     struct page *shadow;
  5.     int pages;
  6.     int i;
  7.  
  8.     pages = 1 << order;
  9.  
  10.     /*
  11.      * With kmemcheck enabled, we need to allocate a memory area for the
  12.      * shadow bits as well.
  13.      */
  14.     shadow = alloc_pages_node(node, flags | __GFP_NOTRACK, order);
  15.     if (!shadow) {
  16.         if (printk_ratelimit())
  17.             printk(KERN_ERR "kmemcheck: failed to allocate "
  18.                 "shadow bitmap\n");
  19.         return;
  20.     }
  21.  
  22.     for(i = 0; i < pages; ++i)
  23.         page[i].shadow = page_address(&shadow[i]);
  24.  
  25.     /*
  26.      * Mark it as non-present for the MMU so that our accesses to
  27.      * this memory will trigger a page fault and let us analyze
  28.      * the memory accesses.
  29.      */
  30.     kmemcheck_hide_pages(page, pages);
  31. }

该函数主要在__alloc_pages_slowpath()kmem_getpages()allocate_slab()中被直接或者间接被调用,其针对的是内存页面的分配使用影子内存。其实现主要是通过alloc_pages_node()分配等大小的内存页面空间,然后将入参传入分配出去的page页面进行影子内存关联,最后通过kmemcheck_hide_pages()来对分配出去的页面进行隐藏。

具体的页面隐藏实现:

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. void kmemcheck_hide_pages(struct page *p, unsigned int n)
  3. {
  4.     unsigned int i;

  5.     for (i = 0; i < n; ++i) {
  6.         unsigned long address;
  7.         pte_t *pte;
  8.         unsigned int level;

  9.         address = (unsigned long) page_address(&p[i]);
  10.         pte = lookup_address(address, &level);
  11.         BUG_ON(!pte);
  12.         BUG_ON(level != PG_LEVEL_4K);

  13.         set_pte(pte, __pte(pte_val(*pte) & ~_PAGE_PRESENT));
  14.         set_pte(pte, __pte(pte_val(*pte) | _PAGE_HIDDEN));
  15.         __flush_tlb_one(address);
  16.     }
  17. }

该函数主要是通过查找页面对应的PTE页表项,通过设置页表项的PRESENT标志位对页面进行隐藏。至此,分配影子页面的动作已经完成,但是实际上还有一个动作,在__alloc_pages_slowpath()kmem_getpages()allocate_slab()等函数调用之后,会根据是否存在内存页面的构造函数而分别调用kmemcheck_mark_uninitialized_pages()kmemcheck_mark_unallocated_pages ()kmemcheck_mark_initialized_pages()函数。

这三个函数都主要是通过对kmemcheck_mark_uninitialized()kmemcheck_mark_unallocated()kmemcheck_mark_initialized()函数的封装,最后调用了mark_shadow()。以kmemcheck_mark_uninitialized_pages()函数实现为例:

  1. 【file:/arch/x86/mm/kmemcheck/shadow.c】
  2. void kmemcheck_mark_uninitialized_pages(struct page *p, unsigned int n)
  3. {
  4.     unsigned int i;
  5.  
  6.     for (i = 0; i < n; ++i)
  7.         kmemcheck_mark_uninitialized(page_address(&p[i]), PAGE_SIZE);
  8. }

其通过循环调用kmemcheck_mark_uninitialized()函数,以实现对影子内存的标识,而kmemcheck_mark_uninitialized()的实现则是:

  1. 【file:/arch/x86/mm/kmemcheck/shadow.c】
  2. void kmemcheck_mark_uninitialized(void *address, unsigned int n)
  3. {
  4.     mark_shadow(address, n, KMEMCHECK_SHADOW_UNINITIALIZED);
  5. }

最终调用到了mark_shadow()函数来对影子内存进行标记,其中对于未初始化的内存使用的标识为KMEMCHECK_SHADOW_UNINITIALIZED

kmemcheck检测内存就是通过这种对影子内存的标识来识别程序对内存访问的问题,标识类型共有四种,分别是未分配、未初始化、已初始化以及已释放。类型的具体定义为:

  1. 【file:/arch/x86/mm/kmemcheck/shadow.c】
  2. enum kmemcheck_shadow {
  3.     KMEMCHECK_SHADOW_UNALLOCATED,
  4.     KMEMCHECK_SHADOW_UNINITIALIZED,
  5.     KMEMCHECK_SHADOW_INITIALIZED,
  6.     KMEMCHECK_SHADOW_FREED,
  7. };

常规的情况下,如果内存存在构造函数的情况,影子内存将被设置为未初始状态,主要是由于构造函数会对内存进行设置但未是全面性的,所以需要设置为未初始化;而对于内存不存在构造函数的情况,将会被设置为未分配;至于标识为初始化的的情况则是基于内存请求时携带的标志位,如果标志位指明内存需要置0的情况,则会设置为初始化;最后的内存为已释放状态,则是在内存释放的时候会被设置上去的。

回到正文,接下来分析mark_shadow()的具体实现:

  1. 【file:/arch/x86/mm/kmemcheck/shadow.c】
  2. static void mark_shadow(void *address, unsigned int n,
  3.     enum kmemcheck_shadow status)
  4. {
  5.     unsigned long addr = (unsigned long) address;
  6.     unsigned long last_addr = addr + n - 1;
  7.     unsigned long page = addr & PAGE_MASK;
  8.     unsigned long last_page = last_addr & PAGE_MASK;
  9.     unsigned int first_n;
  10.     void *shadow;
  11.  
  12.     /* If the memory range crosses a page boundary, stop there. */
  13.     if (page == last_page)
  14.         first_n = n;
  15.     else
  16.         first_n = page + PAGE_SIZE - addr;
  17.  
  18.     shadow = kmemcheck_shadow_lookup(addr);
  19.     if (shadow)
  20.         memset(shadow, status, first_n);
  21.  
  22.     addr += first_n;
  23.     n -= first_n;
  24.  
  25.     /* Do full-page memset()s. */
  26.     while (n >= PAGE_SIZE) {
  27.         shadow = kmemcheck_shadow_lookup(addr);
  28.         if (shadow)
  29.             memset(shadow, status, PAGE_SIZE);
  30.  
  31.         addr += PAGE_SIZE;
  32.         n -= PAGE_SIZE;
  33.     }
  34.  
  35.     /* Do the remaining page, if any. */
  36.     if (n > 0) {
  37.         shadow = kmemcheck_shadow_lookup(addr);
  38.         if (shadow)
  39.             memset(shadow, status, n);
  40.     }
  41. }

该函数主要是通过kmemcheck_shadow_lookup()查找到分配的内存空间对应的影子内存,而后将影子内存相应的空间大小根据内存的目标状态进行memset标记。至此,对分配的内存页面的kmemcheck准备已经完成。

前面分析的是内存页面的kmemcheck设置,而对于小块的slab内存设置的实现则在kmemcheck_slab_alloc()中,该函数主要是在slab内存分配的时候,slab_alloc_node()slab_alloc()slab_post_alloc_hook()函数内被调用。具体实现如下:

  1. 【file:/mm/kmemcheck.c】
  2. void kmemcheck_slab_alloc(struct kmem_cache *s, gfp_t gfpflags, void *object,
  3.               size_t size)
  4. {
  5.     /*
  6.      * Has already been memset(), which initializes the shadow for us
  7.      * as well.
  8.      */
  9.     if (gfpflags & __GFP_ZERO)
  10.         return;
  11.  
  12.     /* No need to initialize the shadow of a non-tracked slab. */
  13.     if (s->flags & SLAB_NOTRACK)
  14.         return;
  15.  
  16.     if (!kmemcheck_enabled || gfpflags & __GFP_NOTRACK) {
  17.         /*
  18.          * Allow notracked objects to be allocated from
  19.          * tracked caches. Note however that these objects
  20.          * will still get page faults on access, they just
  21.          * won't ever be flagged as uninitialized. If page
  22.          * faults are not acceptable, the slab cache itself
  23.          * should be marked NOTRACK.
  24.          */
  25.         kmemcheck_mark_initialized(object, size);
  26.     } else if (!s->ctor) {
  27.         /*
  28.          * New objects should be marked uninitialized before
  29.          * they're returned to the called.
  30.          */
  31.         kmemcheck_mark_uninitialized(object, size);
  32.     }
  33. }

    此函数类似于内存页面分配时的影子内存设置一样,先行经过标志判断后,继而根据内存的情况进行影子内存设置为已初始化或者未初始化的状态。。

    最后,继而分析如何触发kmemcheck检测的。kmemcheck的检测主要是借助于缺页异常处理,由于内存页面设置为不在位,所以访问内存时必将导致缺页异常,继而在异常处理中对内存的访问操作进行解析,根据影子内存的标志记录信息。该解析函数为kmemcheck_fault(),具体实现:

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. bool kmemcheck_fault(struct pt_regs *regs, unsigned long address,
  3.     unsigned long error_code)
  4. {
  5.     pte_t *pte;
  6.  
  7.     /*
  8.      * XXX: Is it safe to assume that memory accesses from virtual 86
  9.      * mode or non-kernel code segments will _never_ access kernel
  10.      * memory (e.g. tracked pages)? For now, we need this to avoid
  11.      * invoking kmemcheck for PnP BIOS calls.
  12.      */
  13.     if (regs->flags & X86_VM_MASK)
  14.         return false;
  15.     if (regs->cs != __KERNEL_CS)
  16.         return false;
  17.  
  18.     pte = kmemcheck_pte_lookup(address);
  19.     if (!pte)
  20.         return false;
  21.  
  22.     WARN_ON_ONCE(in_nmi());
  23.  
  24.     if (error_code & 2)
  25.         kmemcheck_access(regs, address, KMEMCHECK_WRITE);
  26.     else
  27.         kmemcheck_access(regs, address, KMEMCHECK_READ);
  28.  
  29.     kmemcheck_show(regs);
  30.     return true;
  31. }

该函数在缺页处理函数中被调用do_page_fault()->__do_page_fault()->kmemcheck_fault()。其首先对flags寄存器及cs段寄存器进行检验,避免被PnP BIOS调用到kmemcheck的函数;继而通过kmemcheck_pte_lookup()查找具有隐藏属性的页表项,如果找不到页表项,表示这是正常的缺页异常;最后通过入参中的error_code进行判断当前引发缺页异常的是程序对内存进行何种操作,使用相应的传参调用kmemcheck_access();函数末了,将调用kmemcheck_show()进行日志记录。

具体分析一下kmemcheck_access()的实现:

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. static void kmemcheck_access(struct pt_regs *regs,
  3.     unsigned long fallback_address, enum kmemcheck_method fallback_method)
  4. {
  5.     const uint8_t *insn;
  6.     const uint8_t *insn_primary;
  7.     unsigned int size;
  8.  
  9.     struct kmemcheck_context *data = &__get_cpu_var(kmemcheck_context);
  10.  
  11.     /* Recursive fault -- ouch. */
  12.     if (data->busy) {
  13.         kmemcheck_show_addr(fallback_address);
  14.         kmemcheck_error_save_bug(regs);
  15.         return;
  16.     }
  17.  
  18.     data->busy = true;
  19.  
  20.     insn = (const uint8_t *) regs->ip;
  21.     insn_primary = kmemcheck_opcode_get_primary(insn);
  22.  
  23.     kmemcheck_opcode_decode(insn, &size);
  24.  
  25.     switch (insn_primary[0]) {
  26. #ifdef CONFIG_KMEMCHECK_BITOPS_OK
  27.         /* AND, OR, XOR */
  28.         /*
  29.          * Unfortunately, these instructions have to be excluded from
  30.          * our regular checking since they access only some (and not
  31.          * all) bits. This clears out "bogus" bitfield-access warnings.
  32.          */
  33.     case 0x80:
  34.     case 0x81:
  35.     case 0x82:
  36.     case 0x83:
  37.         switch ((insn_primary[1] >> 3) & 7) {
  38.             /* OR */
  39.         case 1:
  40.             /* AND */
  41.         case 4:
  42.             /* XOR */
  43.         case 6:
  44.             kmemcheck_write(regs, fallback_address, size);
  45.             goto out;
  46.  
  47.             /* ADD */
  48.         case 0:
  49.             /* ADC */
  50.         case 2:
  51.             /* SBB */
  52.         case 3:
  53.             /* SUB */
  54.         case 5:
  55.             /* CMP */
  56.         case 7:
  57.             break;
  58.         }
  59.         break;
  60. #endif
  61.  
  62.         /* MOVS, MOVSB, MOVSW, MOVSD */
  63.     case 0xa4:
  64.     case 0xa5:
  65.         /*
  66.          * These instructions are special because they take two
  67.          * addresses, but we only get one page fault.
  68.          */
  69.         kmemcheck_copy(regs, regs->si, regs->di, size);
  70.         goto out;
  71.  
  72.         /* CMPS, CMPSB, CMPSW, CMPSD */
  73.     case 0xa6:
  74.     case 0xa7:
  75.         kmemcheck_read(regs, regs->si, size);
  76.         kmemcheck_read(regs, regs->di, size);
  77.         goto out;
  78.     }
  79.  
  80.     /*
  81.      * If the opcode isn't special in any way, we use the data from the
  82.      * page fault handler to determine the address and type of memory
  83.      * access.
  84.      */
  85.     switch (fallback_method) {
  86.     case KMEMCHECK_READ:
  87.         kmemcheck_read(regs, fallback_address, size);
  88.         goto out;
  89.     case KMEMCHECK_WRITE:
  90.         kmemcheck_write(regs, fallback_address, size);
  91.         goto out;
  92.     }
  93.  
  94. out:
  95.     data->busy = false;
  96. }

该函数通过data->busy的判断,确认是否发生了kmemcheck嵌套错误,如果是的话,kmemcheck_show_addr()先将已隐藏的内存页面设置为可见,然后通过kmemcheck_error_save_bug()记录日志信息;如果没有发生嵌套错误,接下来将设置data->busy防止嵌套,通过kmemcheck_opcode_get_primary()识别并跳过指令前缀,再是kmemcheck_opcode_decode()识别处理器的操作码;继而是两个switch-case,第一个是通过识别kmemcheck_opcode_get_primary()返回的指令操作码,进行相应的处理,而第二个则是鉴于指令无法正确识别,那么将通过使用缺页异常的数据去判断该地址及其的访问方式。最终调用 kmemcheck_read()处理内存读操作、kmemcheck_write()处理内存写操作、kmemcheck_copy()则处理内存拷贝触发的kmemcheck。这三个处理函数的实现都是大同小异,仅kmemcheck_copy()处理稍微特殊,需要分别识别处理两个地址。

接下来以kmemcheck_read()为例进行分析:

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. /* Access may cross page boundary */
  3. static void kmemcheck_read(struct pt_regs *regs,
  4.     unsigned long addr, unsigned int size)
  5. {
  6.     unsigned long page = addr & PAGE_MASK;
  7.     unsigned long next_addr = addr + size - 1;
  8.     unsigned long next_page = next_addr & PAGE_MASK;
  9.  
  10.     if (likely(page == next_page)) {
  11.         kmemcheck_read_strict(regs, addr, size);
  12.         return;
  13.     }
  14.  
  15.     /*
  16.      * What we do is basically to split the access across the
  17.      * two pages and handle each part separately. Yes, this means
  18.      * that we may now see reads that are 3 + 5 bytes, for
  19.      * example (and if both are uninitialized, there will be two
  20.      * reports), but it makes the code a lot simpler.
  21.      */
  22.     kmemcheck_read_strict(regs, addr, next_page - addr);
  23.     kmemcheck_read_strict(regs, next_page, next_addr - next_page);
  24. }

该函数主要通过给定的addr以及size进行校验判断,识别当前要检测的内存空间是否存在跨内存页面的情况,如果存在,则将空间按照页面进行划分后再行通过kmemcheck_read_strict()进行检查。

至于kmemcheck_read_strict()

  1. 【file:/arch/x86/mm/kmemcheck/kmemcheck.c】
  2. /* Access may NOT cross page boundary */
  3. static void kmemcheck_read_strict(struct pt_regs *regs,
  4.     unsigned long addr, unsigned int size)
  5. {
  6.     void *shadow;
  7.     enum kmemcheck_shadow status;
  8.  
  9.     shadow = kmemcheck_shadow_lookup(addr);
  10.     if (!shadow)
  11.         return;
  12.  
  13.     kmemcheck_save_addr(addr);
  14.     status = kmemcheck_shadow_test(shadow, size);
  15.     if (status == KMEMCHECK_SHADOW_INITIALIZED)
  16.         return;
  17.  
  18.     if (kmemcheck_enabled)
  19.         kmemcheck_error_save(status, addr, size, regs);
  20.  
  21.     if (kmemcheck_enabled == 2)
  22.         kmemcheck_enabled = 0;
  23.  
  24.     /* Don't warn about it again. */
  25.     kmemcheck_shadow_set(shadow, size);
  26. }

此函数先是kmemcheck_shadow_lookup()查找该地址的影子内存,继而如果确认是kmemcheck检查的内存,则会kmemcheck_save_addr()将地址信息保存到当前CPUkmemcheck_context结构信息中;接着kmemcheck_shadow_test()检查不超过页边界的读操作,主要检查对应影子中记录的内存状态是否合法,如有错,则kmemcheck_error_save()记录错误信息、出错上下文等;最后kmemcheck_shadow_set()标记本次检查过的内存影子为“初始化”,避免二次报错。

至此,kmemcheck的内存检查代码实现分析完毕。

阅读(1888) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~