跳到主要內容

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嘍~
標籤：

留言

張貼留言

這個網誌中的熱門文章

淺讀Linux root file system初始化流程

在Unix的世界中，file system佔據一個極重要的抽象化地位。其中，/ 所代表的rootfs更是所有後續新增file system所必須依賴前提條件。以Linux為例，黑客 Jserv 就曾經詳細說明過 initramfs的背後設計考量 。本篇文章不再重複背景知識，主要將追蹤rootfs初始化的流程作點整理，免得自己日後忘記。 :-) file system與特定CPU架構無關，所以我觀察的起點從init/main.c的start_kernel()開始，這是Linux作完基本CPU初始化後首先跳進的C function(我閱讀的版本為 3.12 )。跟root file system有關的流程羅列如下： start_kernel()         -> vfs_caches_init_early()         -> vfs_caches_init()                 -> mnt_init()                         -> init_rootfs()                         -> init_mount_tree()         -> rest_init()                 -> kernel_thread(kernel_init,...) 其中比較重要的是mnt_int()中的init_rootfs()與init_mout_tree()。init_rootfs()實作如下： int __init init_root...
張貼留言
閱讀完整內容

誰在呼叫我？不同的backtrace實作說明好文章

今天下班前一個同事問到：如何在Linux kernel的function中主動印出backtrace以方便除錯？ 寫過kernel module的人都知道，基本上就是用dump_stack()之類的function就可以作到了。但是dump_stack()的功能是如何作到的呢？概念上其實並不難，慣用手法就是先觀察stack在function call時的變化(一般OS或計組教科書都有很好的說明，如果不想翻書，可以參考 這篇 )，然後將對應的return address一層一層找出來後，再將對應的function名稱印出即可(透過執行檔中的section去讀取函式名稱即可，所以要將KALLSYM選項打開)。在userspace的實作可參考Jserv介紹過的 whocallme 或對岸好手實作過的 backtrace() ，都是針對x86架構的很好說明文章。 不過從前面兩篇文章可以知道，只要知道編譯器的calling convention，就可以實作出backtrace，所以是否GCC有提供現成的機制呢？Yes, that is what __builtin_return_address() for!! 可以參考這篇 文章 。該篇文章還提到了其他可以拿來實作功能更齊全的backtrace的 程式庫 ，在了解了運作原理後，用那些東西還蠻方便的。 OK，那Linux kernel是怎麼做的呢？就是用頭兩篇文章的方式啦~ 每個不同的CPU架構各自手工實作一份dump_stack()。 為啥不用GCC的機制？畢竟...嗯，我猜想，除了backtrace以外，開發者還會想看其他register的值，還有一些有的沒的，所以光是GCC提供的介面是很難印出全部所要的資訊，與其用半套GCC的機制，不如全都自己來~ arm的實作 大致上長這樣，可以看到基本上就只是透過迭代fp, lr, pc來完成： 352 void unwind_backtrace (struct pt_regs * regs , struct task_struct *tsk) 353 { 354 struct stackframe frame ; 355 register unsigned long current_sp asm ( "...
13 則留言
閱讀完整內容

中文試譯：Writing a game in Python with Pygame. Part I

原文作者： Eli Bendersky 原文連結： http://eli.thegreenplace.net/2008/12/13/writing-a-game-in-python-with-pygame-part-i/ 簡介 遊戲是最能應用程式設計技巧的領域之一。為了寫出最簡單的遊戲，你必須跟圖像、數學、物理甚至是人工智慧打交道。寫遊戲非常酷，而且也是練習程式設計的有趣方式。 如果你是Python的粉絲（就算你不是也無妨），並且對遊戲有興趣，那麼 Pygame 就是很屌的遊戲程式設計庫，你一定要注意它。它可以在所有主要的平台執行，並提供簡單的工具去管理複雜的、充滿變動與音效的世界。 在網路上有很多Pygame的教學，但大都太過簡單了。甚至是 Pygame book 都停留在入門的程度。為了達到更高的水準，我決定自己寫一套教學文件，希望可以為那些使用Pygame的朋友提供進階的學習。 這份教學鼓勵讀者去把玩程式碼，也非常建議對最後的練習題作些功課。這樣作可以讓你對這些教學有更好的瞭解。 預備知識 因為我在前面提過的理由，這份教學並不是給完全的初學者閱讀的。如果你才開始接觸 Pygame，先到這個 網頁 裡看一些基本的教學。這份 教學 也很適合初學Pygame。 在這篇文章，我假設你有下列知識：     >>Python(你不必是進階使用者，但也不能是完全的菜鳥)     >>基本的數學與物理（向量、矩形、運動定律、機率等等）。我會解釋所有不那麼明顯的部份，但我不會教你如何對向量作加法。     >>對Pygame有一些瞭解。你至少必須有瀏覽過在上面提到的教學裡的例子。 喔，還有一件事...這份教學主要考慮2D遊戲。3D有著另一層的困難度，我以後會提出一個自行開發一部份、簡單、不過足夠完整的3D demo。 我們開始吧！ 在這個部份，我們最後會完成一個模擬 - 有著在地上爬的小生物，會蠕動，然後碰到牆壁也會反彈，並偶而改變它們的行進方向： 這當然不是一個遊戲，不過卻是一個很有用的開頭，讓我們可以實作不同的想法。我延遲給出這個遊戲最終會變成的模樣，當作給我自己的奢侈享受。 程式碼 part 1的完整程式碼...
張貼留言
閱讀完整內容