6.828 Lab1 part 1

MIT的6.828課程是關於作業系統實作的有趣課程，我報名參加了相關的讀書會，並開始研讀課程內容，這篇文章主要紀錄Lab1的部份練習(以下描述問題時，我會用比較精簡的方式敘述，想知道完整說明的朋友請直接參考課程嘍~):

Ex1：練習x86 assembly。
Ans：由於該課程使用gas與gcc，所以我簡單練習一下AT&T的語法。

1. .global mmax
3. mmax:
4.         pushl   %ebp
5.         movl    %esp, %ebp
6.         movl    8(%ebp), %eax
7.         cmpl    12(%ebp), %eax
8.         jle     .L2
9.         movl    8(%ebp), %eax
10.         jmp     .L3
11. .L2:
12.         movl    12(%ebp), %eax
13. .L3:
14.         popl    %ebp
15.         ret

inline assembly的版本(由於在C function中嵌入asm，所以省卻prologue & epilogue)：

1. #include <stdio.h>
3. static int mmax(int a, int b)
4. {
5.         asm volatile (
6.         "movl   %0, %%eax \n"
7.         "cmpl   %1, %%eax \n"
8.         "jle    .L2 \n"
9.         "movl   %0, %%eax \n"
10.         "jmp    .L3 \n"
11. ".L2: \n"
12.         "movl   %1, %%eax \n"
13. ".L3: \n"
14.         ::"q"(a), "q"(b));
15. }
17. int main(void)
18. {
19.         printf("max = %d\n", mmax(-10, -2));
20. }

Ex2：使用gdb觀察QEMU的BIOS在開機流程作了哪些事情。
Ans：BIOS基本上將PC的重要硬體週邊初始化並檢測是否有嚴重異常，若無，則讀進first bootable device的bootloader至physical address 0x7c00。課程中的boot device為IDE disk，所以會將sector 0讀進0x7c00，並將控制權移交給bootloader。

Ex3：研讀bootloader的行為。
Ans：主要有兩個檔案：boot/boot.S以及boot/main.c。在課程網站中所提供的文件其實說明的非常深入淺出，連我這個硬體白痴都讀的懂，極力推荐大家參考~


首先，從boot/Makefrag可以知道，bootloader的entry point設在start，並且從0x7c00處開始執行：

1. $(OBJDIR)/boot/boot: $(BOOT_OBJS)
2.     @echo + ld boot/boot
3.     $(V)$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 -o $@.out $^
4.     $(V)$(OBJDUMP) -S $@.out >$@.asm
5.     $(V)$(OBJCOPY) -S -O binary -j .text $@.out $@
6.     $(V)perl boot/sign.pl $(OBJDIR)/boot/boot

所以bootloader的第1行指令要從boot.S的start label開始看起：

1. #include <inc/mmu.h>
3. # Start the CPU: switch to 32-bit protected mode, jump into C.
4. # The BIOS loads this code from the first sector of the hard disk into
5. # memory at physical address 0x7c00 and starts executing in real mode
6. # with %cs=0 %ip=7c00.
8. .set PROT_MODE_CSEG, 0x8         # kernel code segment selector
9. .set PROT_MODE_DSEG, 0x10        # kernel data segment selector
10. .set CR0_PE_ON,      0x1         # protected mode enable flag
12. .globl start
13. start:
14.   .code16                     # Assemble for 16-bit mode
15.   cli                         # Disable interrupts
16.   cld                         # String operations increment
18.   # Set up the important data segment registers (DS, ES, SS).
19.   xorw    %ax,%ax             # Segment number zero
20.   movw    %ax,%ds             # -> Data Segment
21.   movw    %ax,%es             # -> Extra Segment
22.   movw    %ax,%ss             # -> Stack Segment

BIOS移交控制權給loader時，環境為real mode，並且除了CS=0以外，不保證其他segment register的初始值，所以一開始需先將其他的segment registers都先設為0。這樣logical address才不會與loader image中的引用不符(link address設在0x7c00)。

接著，由於歷史因素，需要將A20打開才能順利使用1MB以上的physical address。

1.   # Enable A20:
2.   #   For backwards compatibility with the earliest PCs, physical
3.   #   address line 20 is tied low, so that addresses higher than
4.   #   1MB wrap around to zero by default.  This code undoes this.
5. seta20.1:
6.   inb     $0x64,%al               # Wait for not busy
7.   testb   $0x2,%al
8.   jnz     seta20.1
10.   movb    $0xd1,%al               # 0xd1 -> port 0x64
11.   outb    %al,$0x64
13. seta20.2:
14.   inb     $0x64,%al               # Wait for not busy
15.   testb   $0x2,%al
16.   jnz     seta20.2
18.   movb    $0xdf,%al               # 0xdf -> port 0x60
19.   outb    %al,$0x60

接著，切換到protected mode。

1.   # Switch from real to protected mode, using a bootstrap GDT
2.   # and segment translation that makes virtual addresses
3.   # identical to their physical addresses, so that the
4.   # effective memory map does not change during the switch.
5.   lgdt    gdtdesc
6.   movl    %cr0, %eax
7.   orl     $CR0_PE_ON, %eax
8.   movl    %eax, %cr0
10.   # Jump to next instruction, but in 32-bit code segment.
11.   # Switches processor into 32-bit mode.
12.   ljmp    $PROT_MODE_CSEG, $protcseg

從gdtdesc可以看到，loader所設定的protected mode非常單純，僅先引入32 bit addressing的能力：

1. # Bootstrap GDT
2. .p2align 2                                # force 4 byte alignment
3. gdt:
4.   SEG_NULL              # null seg
5.   SEG(STA_X|STA_R, 0x0, 0xffffffff) # code seg
6.   SEG(STA_W, 0x0, 0xffffffff)           # data seg
8. gdtdesc:
9.   .word   0x17                            # sizeof(gdt) - 1
10.   .long   gdt                             # address gdt

我們可以看到，作者只設定了兩個gdt descriptors，一個作為code segment descriptor，另一個作為data segment descriptor。並且將base都設成0，limit都設成4G。於是，loader從ljmp $PROT_MODE_CEG, $protcseg後，就擁有了32 bit address的能力，並且logical address直接對應physical address。

1.   .code32                     # Assemble for 32-bit mode
2. protcseg:
3.   # Set up the protected-mode data segment registers
4.   movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
5.   movw    %ax, %ds                # -> DS: Data Segment
6.   movw    %ax, %es                # -> ES: Extra Segment
7.   movw    %ax, %fs                # -> FS
8.   movw    %ax, %gs                # -> GS
9.   movw    %ax, %ss                # -> SS: Stack Segment
11.   # Set up the stack pointer and call into C.
12.   movl    $start, %esp
13.   call bootmain

由於進到protected mode後，addressing的方式需使用新方式，所以第一件事就是將gdt中的data segment指定給ds, es, fs, gs, ss，由此可知，gdt中的data segment其實是多個同屬性的segments的集合。接著將start(也就是0x7c00)放進esp以完成stack的初始設定，然後跳進bootmain()這個C function，在閱讀bootmain()之前，我們可以歸納出來，目前的memory使用狀況大致如下：

OK，接著的bootmain()相對單純，基本上就是先讀取sector 1之後一個page，然後依據ELF header將kernel image的每個segment(ELF中的segment往往是多個sections的組合，想知道細節的話可以參考"程式設計師的自我修養")分別載入到指定的load address(program header中的LMA欄位，也就是下列程式的ph->p_pa)：

1. void
2. bootmain(void)
3. {
4.     struct Proghdr *ph, *eph;
6.     // read 1st page off disk
7.     readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
9.     // is this a valid ELF?
10.     if (ELFHDR->e_magic != ELF_MAGIC)
11.         goto bad;
13.     // load each program segment (ignores ph flags)
14.     ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
15.     eph = ph + ELFHDR->e_phnum;
16.     for (; ph < eph; ph++)
17.         // p_pa is the load address of this segment (as well
18.         // as the physical address)
19.         readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
21.     // call the entry point from the ELF header
22.     // note: does not return!
23.     ((void (*)(void)) (ELFHDR->e_entry))();
25. bad:
26.     outw(0x8A00, 0x8A00);
27.     outw(0x8A00, 0x8E00);
28.     while (1)
29.         /* do nothing */;
30. }

然後loader就功成身退啦~接著就將控制權交由kernel嘍~