memtest86+4.20流程分析

    公版ubuntu自带memtest86+内存测试工具，出于工作需要，分析了其工作流程记录于此。

    分析一个陌生的程序，当然得先找入口入口函数，很可惜main()/_start之类的都找到，唯一看着像入口点的main.c文件也没找到可能的入口点。看来只能从makefile文件分析了。

OBJS= head.o reloc.o main.o test.o init.o lib.o patn.o screen_buffer.o \
      config.o linuxbios.o memsize.o pci.o controller.o random.o spd.o \
      error.o dmi.o cpuid.o

all: memtest.bin memtest

# Link it statically once so I know I don't have undefined
# symbols and then link it dynamically so I have full
# relocation information
memtest_shared: $(OBJS) memtest_shared.lds Makefile
  $(LD) --warn-constructors --warn-common -static -T memtest_shared.lds \
  -o $@ $(OBJS) && \
  $(LD) -shared -Bsymbolic -T memtest_shared.lds -o $@ $(OBJS)

memtest_shared.bin: memtest_shared
  objcopy -O binary $< memtest_shared.bin

memtest: memtest_shared.bin memtest.lds
  $(LD) -s -T memtest.lds -b binary memtest_shared.bin -o $@

head.s: head.S config.h defs.h test.h
  $(CC) -E -traditional $< -o $@

bootsect.s: bootsect.S config.h defs.h
  $(CC) -E -traditional $< -o $@

setup.s: setup.S config.h defs.h
  $(CC) -E -traditional $< -o $@

memtest.bin: memtest_shared.bin bootsect.o setup.o memtest.bin.lds
  $(LD) -T memtest.bin.lds bootsect.o setup.o -b binary \
  memtest_shared.bin -o memtest.bin

这几个规则指明了源码目录中的obj文件如何链接成memtest86+.bin，而链接过程又由3个lds文件提供：

#memtest_shared.lds链接脚本:规则memtest_shared依赖的lds脚本
OUTPUT_FORMAT("elf32-i386");
OUTPUT_ARCH(i386);

ENTRY(startup_32); 
#指定$(OBJS)的入口点为head.S!startup_32
SECTIONS {
  . = 0;
  .text : 
...
        #重要的节，后面重定位时，会用got表中的信息对memtest_share进行重定向
        .got : {
    *(.got.plt)
    *(.got)
    _edata = . ;
  }
  . = ALIGN(4);
...
    _end = .;
  }
  /DISCARD/ : { *(*) }  
}

memtest_share规则生成memset_share文件，是由源码目录下所有.c文件和head.S链接后生成的，这个文件是标准的linux ELF文件

ubuntu:~/Desktop/memtest86+-4.20$ file memtest_shared
memtest_shared: ELF 32-bit LSB  shared object, Intel 80386, version 1 (SYSV), dynamically linked, not stripped

ubuntu:~/Desktop/memtest86+-4.20$ readelf -a memtest_shared|grep startup
    71: 00000000     0 NOTYPE  GLOBAL DEFAULT    1 startup_32 #这个符号在head.S中
   545: 00000000     0 NOTYPE  GLOBAL DEFAULT    1 startup_32

看下head.S的头几行

.code32
  .globl startup_32
startup_32:
  cld
  cli

代码段开始就申明了标号startup_32，理论上memtest_share的入口点就是这个了

#memtest.lds链接脚本:规则memtest的依赖项
OUTPUT_FORMAT("elf32-i386");
OUTPUT_ARCH(i386);

ENTRY(_start); 
SECTIONS {
  . = 0x5000;
  _start = . ;
  .data : {
    *(.data)
  }
}

规则memtest仅仅把前一个规则生成的memtest_share作为输入链接到.data节

#memtest.bin链接脚本:规则memtest.bin的依赖项
OUTPUT_FORMAT("binary")
OUTPUT_ARCH("i386")

ENTRY(_main);#指明入口点为_main
SECTIONS {
  . = 0;
        #左边是输出:右边是输入
        .bootsect : { *(.bootsect) }
  .setup : { *(.setup) }
  .memtest : { 
    _start = . ;
    *(.data) 
    _end = . ;
  }
  _syssize = (_end - _start + 15) >> 4;
}

这个链接脚本是整个memtest86+中最重要的一个脚本，makefile参考它生成了整个memtest86+二进制文件。同时还规定了源码目录下所有obj文件在bin文件中的布局:bootsect在最前端，紧接着是setup，最后是memtest_share。

    既然知道了整个memtest86+文件分布，也知道了程序入口是bootsect.S!_main，那就可以分析整个程序的流程了，打开bootsect.S

#include "defs.h"
.code16 #告诉汇编器，这里要生成16bit代码
.section ".bootsect", "ax", @progbits
_boot:


# ld86 requires an entry symbol. This may as well be the usual one.
.globl  _main
_main:
  movw  $BOOTSEG, %ax
  movw  %ax, %ds #ds=0x7c00
  movw  $INITSEG, %ax
  movw  %ax, %es
  movw  $256, %cx
  subw  %si, %si
  subw  %di, %di

一堆汇编代码，还有一些奇奇怪怪的立即数，真像直接不干了！查找$BOOTSEG的定义,其值为0x07c0。汇编代码前2句是把0x7c0赋值给段寄存器ds

#define LOW_TEST_ADR  0x00002000    /* Final adrs for test code */

#define BOOTSEG   0x07c0      /* Segment adrs for inital boot */
#define INITSEG   0x9000      /* Segment adrs for relocated boot */
#define SETUPSEG  (INITSEG+0x20)    /* Segment adrs for relocated setup */
#define TSTLOAD   0x1000      /* Segment adrs for load of test */

#define KERNEL_CS 0x10      /* 32 bit segment adrs for code */
#define KERNEL_DS 0x18      /* 32 bit segment adrs for data */
#define REAL_CS   0x20      /* 16 bit segment adrs for code */
#define REAL_DS   0x28      /* 16 bit segment adrs for data */

    如果你做过i386处理器，马上会想到bootsect.S和setup.S是一个启动cpu进入32位保护模式的bootloader，同时从磁盘上加载剩余的程序到内存设置程序运行环境！因为bootloader的功能大同小异，这里略过处理功能这些的代码。

    setup.S最终会调用memtest.share!。前面说过memtest.share是linux elf文件格式，而memtest86+这个程序显然没有运行linux内核，因此为了运行elf文件，它需要自己实现loader的功能，把memtest.share加载到内存并读取got重定位表对其中的重定位信息进行重定位，如下:

#head.S
0:

    /* Load the GOT pointer */
        #call-pop 获得程序运行时，当前指令在内存中的地址，以后ebx就作为重定位的参考地址
        call    0f
0:  popl    %ebx
    addl    $_GLOBAL_OFFSET_TABLE_+[.-0b], %ebx
...
        leal    gdt@GOTOFF(%ebx), %eax
    movl    %eax, 2 + gdt_descr@GOTOFF(%ebx)
    lgdt    gdt_descr@GOTOFF(%ebx) #gdt_descr是一个需要重定位的变量
    leal    flush@GOTOFF(%ebx), %eax

head.S就是通过这个办法对memtest.share中导出的重定位符号进行重定位。可以通过readelf -a查看重定位信息。

    待到重定位结束，head.S通过call do_test进入main.c开始内存测试。

//下面是do_test的伪代码
void do_test(void)
{
    /*如果memtest是由grub启动的，grub会把grub.cfg中的启动参数存放到boot_param中，parse_command_line获得boot_param*/
    parse_command_line();
    switch(tseq[v->test].pat)
    {
    case N://具体的测试项
    break;
    }
    window++; //前面setup.S通过e820获得的内存图,把内存分布存放到数组windows中，而windows是windows中的一项数组元素
    //还有部分e820数组中的内存块没有在这一项test中测试过，通过run_at进行下一次测试
    if (window != 0) {
        run_at(LOW_TEST_ADR); 
    }
    else
    {
        //e820数组中所有内存块都通过了这一项test测试，进入下一项测试
        v->test++;
        run_at(LOW_TEST_ADR);
    }
}

上面的伪代码多次出现run_at，这是整个memtest86+中最奇葩的操作:

static void __run_at(unsigned long addr)
{
  /* Copy memtest86+ code */
  memmove((void *)addr, &_start, _end - _start);
  /* Jump to the start address */
  p = (ulong *)(addr + startup_32 - _start);
  goto *p;
}

static unsigned long run_at_addr = 0xffffffff;
static void run_at(unsigned long addr)
{
  unsigned long start;
  unsigned long len;

  run_at_addr = addr;

  start = (unsigned long) &_start;
  len = _end - _start;
  if (  ((start < addr) && ((start + len) >= addr)) ||
    ((addr < start) &&  ((addr + len) >= start))) {
    /* Handle overlap by doing an extra relocation */
    if (addr + len < high_test_adr) {
      __run_at(high_test_adr);
    }
    else if (start + len < addr) {
      __run_at(LOW_TEST_ADR);
    }
  }
  __run_at(run_at_addr);
}

获得_start标号的位置，然后重新跳到_start去运行。那么，标号_start定义在哪？反汇编看一下

objdump -d memtest_share
00000000 <_start>:
       0: fc                    cld    
       1: fa                    cli    
       2: 85 e4                 test   %esp,%esp
       4: 75 0c                 jne    12 <_start+0x12>
       6: bc 5a c7 02 00        mov    $0x2c75a,%esp
       b: 8d a4 24 20 20 00 00  lea    0x2020(%esp),%esp
      12: e8 00 00 00 00        call   17 <_start+0x17>
      17: 5b                    pop    %ebx
      18: 81 c3 49 a7 02 00     add    $0x2a749,%ebx
      1e: 8d a3 20 20 00 00     lea    0x2020(%ebx),%esp
      24: 8d 83 c8 5e fd ff     lea    -0x2a138(%ebx),%eax
      2a: 89 83 c2 5e fd ff     mov    %eax,-0x2a13e(%ebx)
      30: 0f 01 93 c0 5e fd ff  lgdtl  -0x2a140(%ebx)
      37: 8d 83 e1 58 fd ff     lea    -0x2a71f(%ebx),%eax
      3d: 6a 10                 push   $0x10
      3f: 50                    push   %eax
      40: cb                    lret   

00000041 <flush>:
      41: b8 18 00 00 00        mov    $0x18,%eax

_start定义在head.S中，并且就在head.S的开头。也就是，为了实现跳转，memtest_share跳到程序开头重新再跑一次！！！！尼玛，我都震惊了，好在windows数组和window是全局变量，要不然下次进到do_test都不知道上回测到哪了....