环境

ubuntu 20.04 64系统

本文大部分内容翻译mit6.828 Lab1 part3的内容，原地址点击这里
课程主页:MIT6.828-2018 Fall

正文

本篇是MIT6.828 Lab1 的part3的内容。经过了part2对boot loader的深入研究以及知道了如何去加载一个elf文件，现在我们终于可以来看看JOS的kernel了。像boot loader一样，kernel也是由一些汇编代码开始的，并且汇编代码做好了准备工作，这样才使得C语言代码能够正常的工作。
当你观察boot loader的link address(虚拟地址)和loaded address(物理地址)的时候,会发现他们俩匹配的很好
ps:
这里稍微提一下，可能我们会产生疑问为什么有虚拟地址和物理地址这样的东西。首先一个最直观的好处在这样的机制下，每一个程序都有自己的地址空间，我们只需要将不同的虚拟地址映射(mapping)到不同的物理地址，这样当某些恶心程序想修改某些属于内核地址的时候，经过映射的转换，那些地址并不是真正的内存地址，这样就使得每一个程序在运行的时候相互独立，不会影响到其他程序或者是操作系统。我们根据elf文件提供的虚拟地址和实际地址，将程序加载到elf文件中制定的物理地址，然后那些虚拟地址要映射(mapping)到这些物理地址，就可以正常的运行了。
回归正题，我们先来看下boot loader的地址映射,如下图:

boot loader的地址映射

kernel之间的地址映射

Exercise 7

使用QEMU和GDB来最终JOS的内核(主要是调试obj/kern/kernel.asm)，停在movl %eax, %cr0这条语句，查看内存0x0010_0000和0xf010_0000处的内容，接着使用si命令单步调试，查看mov命令执行后的效果。

实验:
执行前

执行前

第一条内和语句

执行后的结果

阅读kern/printf.c,lib/printfmt.c和kern/console.c，弄清楚他们之间的关系。

Exercise 8

我们省略了一小段代码--使用%o来格式化八进制的数，请在代码中找到并且写上代码实现

并且回答下列问题

1. 解释printf.c和console.c它们的interface(这里说的是接口，我没有完全理解，我的理解应该是让我们解释每个函数的作用)。console.c对外提供了什么函数?，这个函数在printf.c当中如何被使用的？
2. 解释下面代码的意思

    if (crt_pos >= CRT_SIZE) {
        int i;
        memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
        for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
            crt_buf[i] = 0x0700 | ' ';
        crt_pos -= CRT_COLS;
    }

3. 接下来的问题要看Lecture2 notes才能彻底理解，这些notes描述了关于x86平台上的C calling convention
   逐步执行以下的代码

    int x = 1, y = 3, z = 4;
    cprintf("x %d, y %x, z %d\n", x, y, z);

回答两个小问题:

• 在调用cprintf()的时候，fmt指向了哪里?
• List (in order of execution) each call to cons_putc, va_arg, and vcprintf. For cons_putc, list its argument as well. For va_arg, list what ap points to before and after the call. For vcprintf list the values of its two arguments.

4. 运行下面的代码

    unsigned int i = 0x00646c72;
    cprintf("H%x Wo%s", 57616, &i);

输出结果是什么？ 逐步调试来解释它的输出结果(这个问题和endian相关)

5. 下面代码的输出结果是什么?

 cprintf("x=%d y=%d", 3);

不得不说part3的题目多多了，而且做起来也不容易，不过学习路上不能偷懒，开始干活吧~

解释下printf.c和console.c当中各个函数是干嘛的？

说在前面，console.c当中不少和硬件相关的，我没有完全理解，比如说串口(serial port)和并口(parallel port)的初始化以及相关数据的写入，我很多都没有了解，我认为，学习操作系统更应该是关注软件层面的东西。遇到相关的，知道的我说一下，不懂的省略，希望有时间来补充这里的空白吧。

当我们使用cprintf()这个函数的时候，调用顺序是如下的:
cprintf () -> vcprintf() -> vprintfmt() -> vprintfmt() (定义在printfmt.c中)->putch()(定义在printf.c中) -> cputchar() (定义在console.c当中) -> ....（console.c还调用了别的函数）。
下面着重讲几个比较重要的函数
cprint

int
cprintf(const char *fmt, ...)
{
    va_list ap;
    int cnt;

    va_start(ap, fmt);
    cnt = vcprintf(fmt, ap);
    va_end(ap);

    return cnt;
}

这里使用了C语言中的可变参数，这里使用的几个va开头的都是GCC compiler builtin的宏(macros)。这里介绍了这几个宏的意思，在lab1中的这几个宏定义在stdarg.h当中，在这里我们只需要记住一点，va_start,va_arg,va_end都是和处理可变参数有关，而cprintf用到了可变参数，所以这里出现了他们的身影。根据文章描述，va_start的第一个参数是va_list类型的并且指向可选参数的第一个参数，va_start的第二个参数是指向必须参数(required parameters)(并且必要参数要在可选参数之前)，可以看到代码确实按照这样的思路来实现的。

After all arguments have been retrieved, va_end resets the pointer to NULL. va_end must be called on each argument list that's initialized with va_start or va_copy before the function returns.

va_end必须要在函数返回前被调用，所以在return cnt前面我们调用了va_end。

vcprintf

int
vcprintf(const char *fmt, va_list ap)
{
    int cnt = 0;

    vprintfmt((void*)putch, &cnt, fmt, ap);
    return cnt;
}

vcprintf是针对格式化符号处理的，putch()是一个函数指针，在vcprintf内调用vprintfmt()格式化字符串结束后，调用putch()来改变屏幕上的光标位置(虽然改变光标位置的真正的函数并不是putch,putch调用了其他函数来实现这个功能)。vprintfmt()中完成了对屏幕内容的输出。
接下来看一下vprintfmt()
原来函数的实现有点长，而且有些代码也不好懂，我选了一点我们最熟悉的。比如说%d打印数字
可以看到case 'd'就是处理打印数字的代码。通过这样就可以知道，vprintfmt()完成了格式化字符串的任务。另外作业也做好了，实现打印八进制的数字，基本思路和十进制的一样，只需要改以下base就行.

        case 'd':
            num = getint(&ap, lflag);
            if ((long long) num < 0) {
                putch('-', putdat);
                num = -(long long) num;
            }
            base = 10;
            goto number;

        // unsigned decimal
        case 'u':
            num = getuint(&ap, lflag);
            base = 10;
            goto number;

        // (unsigned) octal
        case 'o':
            // Replace this with your code.
            //打印8进制数
            num = getuint(&ap, lflag);
            base = 8;
            goto number;

下面解释下一下putch()函数

static void putch(int ch, int *cnt)
{
    cputchar(ch);
    *cnt++;
}

//在console.c中
void cputchar(int c)
{
    cons_putc(c);
}


//这个在console.c当中
static void cons_putc(int c)
{   
    //输出到串口(serial port)
    serial_putc(c);
    //输出到并口(parallel port)
    lpt_putc(c);
    //输出到屏幕
    cga_putc(c);
}

putch每次向屏幕会输出一个字符，cnt用于记录输出的字符个数，putch()调用了cputchar(),虽然参数是一个int类型，实际上每次传入的都是ascii，cputchar()调用cons_putc()，cons_putc（）中的cga_putc（）才是真正的输出内容到屏幕的函数。

好了现在就可以回答第一个问题了，虽然我们没有查看console.c中所有的函数。但是已经大概知道了如何向屏幕输出内容。console.c中向printf.c提供了cputchar()函数，Printf.c中的putch函数来使用cputchar（）完成了输出

第二到问题，解释代码意思

    if (crt_pos >= CRT_SIZE) {
        int i;
        memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
        for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
            crt_buf[i] = 0x0700 | ' ';
        crt_pos -= CRT_COLS;
    }

这段代码的意思是，当屏幕满的时候，滚屏。屏幕可以显示的是25*80字节的内容。所以if (crt_pos >= CRT_SIZE)判断当前光标位置是否超过了屏幕。很自然的下面的代码就是为滚屏服务的，memove()函数就是为了在复制内容。新空出来的一行，以黑底白字，空格填充,最后光标位置减80。这个函数当中的其他部主要处理的都是改变光表位置，比如\n，光标位置+80。

第三问题，逐步调代码

反编译的结果

从上面结果可以看到，可以看到把可变参数都压入到栈了，所以我们可以得到结论，ap肯定是指向栈顶的，这样才可以压入参数。那么fmt自然指向的就是前面的字符串了。

第四道题，调试cprintf语句
这道题目非常有意思.废话少说，先看实验结果:

实验结果

代码

竟然打印出来了Hello world。不过仔细观察以下这里，两个不是字母L，而是数字1。57616=0xe110。
在来看一下World是怎么出现的。这里涉及到little-endian这个问题，在这里我暂时先不仔细的说endian的问题。先记住一点，这个问题会出现在多字节数据或者字(word)存储的时候，上面的无符号数就是一个4字节的数据，当他通过总线写入到内存的时候，是低字节在前，高字节在后，是反着的。然后我们使用了%s来读取，读出来的数据自然也是反着的。在将他转为对应的ascii，r = 114 = 0x72,l = 108 = 0x6c, d = 100 = 0x64。这就产生了He110 World,注意，这个He110是假冒伪劣

第五个问题， In the following code, what is going to be printed after 'y='? (note: the answer is not a specific value.) Why does this happen?
实话说，第五个问题为不知道他的用意是什么，逐步调试到这里也十分麻烦。我说一下为观察到的结果,
在我的电脑上输出结果为:x=3,y=1600，我想当然猜测为什么会出现这样的结果，是因为，y没有压入到栈，所有栈得到的数据是内存中的其他值。

上面一个实验，我们知道了JOS中那些函数完成了向屏幕输出内容，如何格式化输出的内容，并且是如何改变光标位置的，并且草草地知道了几个GCC内置的用于处理可变参数的宏。接下来的内容是和栈相关的，又是比较麻烦的一个part。

栈(Stack)

本个lab最后一个实验就是，我们将会更加详细地探索以下C语言是如何使用x86的栈的，并且我们要写一个非常有用的内核监控函数(kernel monitor function)，它会打印目前所执行函数之前的函数的EIP。

Exercise 9

看一看在哪里初始化了内核的栈，并且内核栈初始化在哪个内存地址？内核是如何为它的内核保留栈的？这块区域的哪一端是esp指向的呢？

这个Exercise相对来说还是比较容易的，一个一个回答。
首先栈的初始化是在./lab/kern/entry.S中初始化的，代码如下:

初始化栈

初始化esp

Exercise 10

为了使得我们对x86 calling convention更加熟悉，找到test_backtrace的地址，并且打一个断点在那里，每次在调用它后发生了什么？栈当中压入了多少数据？ 我们推荐使用qemu pachted，MIT推荐使用这个，但是我好像在lab1 没有发现什么问题。

首先来跟踪以下test_backtrace这个函数，这个函数是递归调用的，初始的参数是5，接着4.3.2.1。在这里我代码就不贴了，我就跟踪了test_backtrace(5)到test_backtrace(4)的情况，下面先给反汇编的代码:

void
test_backtrace(int x)
{
f0100040:   f3 0f 1e fb             endbr32 
f0100044:   55                      push   %ebp     ;将原来的ebp亚入,esp = init-4
f0100045:   89 e5                   mov    %esp,%ebp ; ebp = init-4 
f0100047:   56                      push   %esi  ;esp = init-8
f0100048:   53                      push   %ebx  ;esp = init-12
f0100049:   e8 8f 01 00 00          call   f01001dd <__x86.get_pc_thunk.bx>
f010004e:   81 c3 ba 12 01 00       add    $0x112ba,%ebx    ;dont konw
f0100054:   8b 75 08                mov    0x8(%ebp),%esi   ;ebp+8 = agrs
    cprintf("entering test_backtrace %d\n", x);
f0100057:   83 ec 08                sub    $0x8,%esp    ;空出8字节
f010005a:   56                      push   %esi     ;args压栈
f010005b:   8d 83 18 08 ff ff       lea    -0xf7e8(%ebx),%eax   ;不知道lea命令是干嘛，猜测是获得字符串的地址    
f0100061:   50                      push   %eax     ;字符串地址压栈,总共esp变化了16字节
f0100062:   e8 37 0a 00 00          call   f0100a9e <cprintf>
    if (x > 0)
f0100067:   83 c4 10                add    $0x10,%esp ;esp+16，恢复了上面cprintf的调用
f010006a:   85 f6                   test   %esi,%esi 
f010006c:   7e 29                   jle    f0100097 <test_backtrace+0x57> ;条件不成立，跳转mon_backtrace
        test_backtrace(x-1);
f010006e:   83 ec 0c                sub    $0xc,%esp    ;空出12字节
f0100071:   8d 46 ff                lea    -0x1(%esi),%eax ;猜测,原来args在esi,这里做了esi=esi-1,eax=esi
f0100074:   50                      push   %eax ;eax=4压栈
f0100075:   e8 c6 ff ff ff          call   f0100040 <test_backtrace> ;递归执行
f010007a:   83 c4 10                add    $0x10,%esp   
    else
        mon_backtrace(0, 0, 0);
    cprintf("leaving test_backtrace %d\n", x);
f010007d:   83 ec 08                sub    $0x8,%esp ;空出两个字节
f0100080:   56                      push   %esi     ;压入esi=5
f0100081:   8d 83 34 08 ff ff       lea    -0xf7cc(%ebx),%eax
f0100087:   50                      push   %eax     ;压入字符串
f0100088:   e8 11 0a 00 00          call   f0100a9e <cprintf> ;打印leaving
}
f010008d:   83 c4 10                add    $0x10,%esp   ;总共压入了16字节，恢复栈，所以add0x10
f0100090:   8d 65 f8                lea    -0x8(%ebp),%esp
f0100093:   5b                      pop    %ebx ;test_backtrace执行结束
f0100094:   5e                      pop    %esi ;恢复寄存器内容，这几个寄存器都是callee register
f0100095:   5d                      pop    %ebp ;也是callee register
f0100096:   c3                      ret         ;递归已经结束，从这里返回
        mon_backtrace(0, 0, 0);
f0100097:   83 ec 04                sub    $0x4,%esp
f010009a:   6a 00                   push   $0x0 ;mon_backtrace三个参数压栈
f010009c:   6a 00                   push   $0x0
f010009e:   6a 00                   push   $0x0
f01000a0:   e8 1d 08 00 00          call   f01008c2 <mon_backtrace>
f01000a5:   83 c4 10                add    $0x10,%esp ;因为上面sub 0x04，加上上面三个0x00的亚栈，因此这里add 0x10
f01000a8:   eb d3                   jmp    f010007d <test_backtrace+0x3d> ;跳转到打印leaving那一段函数

我的实验目标，看一下test_backtrace(5)到test_backtrace(4) call之前的栈的情况。下面是上面代码的一部分:

部分代码

栈内信息

实际内存

下面稍微偷懒，我只记录下对栈操作的时候（例如push）的时候栈的截图：
sub $0x8,%esp
这个不赘述，就在上面。，它这里实际上是让栈直接空了8字节的内容，在上图，一个是0xf010_004e，另外一个是0x0。0xf010_004e是怎么产生的，我没有去逐步调试。
push %esi
认真看上面的代码，并且结合自己的编译出来的boot.asm，我们知道esi存放的是agrs,就是0x05，所以此时栈如下所示:

压入0x05

foo

f0100067:   83 c4 10                add    $0x10,%esp ;esp+16，恢复了上面cprintf的调用
f010006a:   85 f6                   test   %esi,%esi 
f010006c:   7e 29                   jle    f0100097 <test_backtrace+0x57> ;条件不成立，跳转mon_backtrace

调用者恢复栈(C calling convention)，此时的栈恢复到了最初情况,如下,仔细对照以下上面点的那个表格：

最初情况

好继续前进，在f0100075停下，查看一下栈

        test_backtrace(x-1);
f010006e:   83 ec 0c                sub    $0xc,%esp    ;空出12字节
f0100071:   8d 46 ff                lea    -0x1(%esi),%eax ;猜测,原来args在esi,这里做了esi=esi-1,eax=esi
f0100074:   50                      push   %eax ;eax=4压栈
f0100075:   e8 c6 ff ff ff          call   f0100040 <test_backtrace> ;递归执行

栈的情况如下所示:

栈

总结

回到正文，下面继续介绍part3的内容（我要开始继续翻译了哈哈哈）。
以上的练习，他应该给了你一些信息，并且你需要根据这些信息实现一个mon_backtrace()。函数的声明已经在kern/monitor.c当中了。
mon_backtrace()打印出来的信息应该如下所示:
Stack backtrace:
ebp f0109e58 eip f0100a62 args 00000001 f0109e80 f0109e98 f0100ed2 00000031
ebp f0109ed8 eip f01000d6 args 00000000 00000000 f0100058 f0109f28 00000061
...
每一行都包括了ebp,eip,和args。ebp应该是在进入后函数后的ebp寄存器的值，就是栈指针的在进入函数以及完成开场白后的位置。eip的值是返回指针的值(也就是被ret所使用的地址)。返回指针通常指向call之后的下一条语句(这个很好理解吧，只有指向下一条指令才可以继续运行)。最后，5个十六进制数就是5个需要传递的参数。如果函数所需要的参数少于5个，当然并不是这5个所有的参数都有用(通过上面的观察，确实好几个参数没用)，遗留问题:为什么不能够从代码中获得到底有多少个参数呢？如何解决这个问题呢？

Exercise 11

根据上面的输出例子实现mon_backtrace()函数。请使用上面的输出格式，否这grade script无法通过，如果你觉得你做好了就用make grade来测试下你是不是作对了。

代码实现:

int mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// 获取寄存器ebp本身的位置
    int regebp = read_ebp();  //获得ebp寄存器的内容
    int* ebp = (int*)regebp;   //将内容转为指针类型，然后就可以获得需要的参数了
    while(*ebp != 0) {
        cprintf("ebp:%08x ",*ebp);
        cprintf("eip:%08x ",*(ebp+1));
        cprintf("args:%08x ",*(ebp+2));
        cprintf("%08x ",*(ebp+3));
        cprintf("%08x ",*(ebp+4));
        cprintf("%08x ",*(ebp+5));
        cprintf("%08x \n",*(ebp+6));
        ebp = (int *)(*ebp);
    }
    return 0;
}

注意看之前的那个寄存器总结图，ebp内的内容就是一个地址,因为我们执行了mov esp,ebp命令。所以思路很简单，先获得ebp的值，就得到了栈单元的地址。然后在根据上面的图，就可以计算处各个参数的值了。效果如下:

实验结果

唉，就这么一点简单的代码，花了我差不多一天的时间在调试，最后把它写出来，属实不容易。在最后，我还有一个Exercise 12没有实现。先暂时这样吧，草草看了一下Exercise 12，Exercise 12是在Exercise 11的基础上增加一点功能，我暂时没做，留到有时间在做吧，我想Exercise 11已经让我们收获很多了，我们知道了C calling convention,并且根据此知道了如何获得之前的eip寄存器内容。