操作系统内核Hack：(四)内核雏形

在本系列的前一篇文章《操作系统内核Hack：(三)BootLoader制作》中，我们制作出了一个两阶段引导BootLoader，并进入了一个内核的空壳main函数。本文我们继续完善引导程序和内核，让内核的内容一点点充实起来。本文的代码可以参考GitHub上的MiniOS分支kernel_prototype。

1.周边代码修改

1.1 常量和宏提取

像各个模块的内存这种常量，会经常被引导，所以就提取出一个单独的文件var.inc。同理，保护模式相关的常量和宏都提取到了pm.inc，这里主要是拷贝了Orange’s的代码和注释。

;   var.inc

; ############################

;   Constants

; ############################

SETUPLEN    equ 4

BOOTSEG     equ 0x07c0

INITSEG     equ 0x9000

SETUPSEG    equ 0x9020

SYSSEG      equ 0x1000

NEWSYSSEG   equ 0x0000

MEMSIZE     equ 0       ; INITSEG:MEMSIZE

;   pm.inc

; ############################

;   Macros

; ############################

; 描述符类型

DA_32       equ 4000h   ; 32 位段

DA_LIMIT_4K equ 8000h   ; 段界限粒度为 4K 字节

; 存储段描述符类型

DA_DR       equ 90h ; 存在的只读数据段类型值

DA_DRW      equ 92h ; 存在的可读写数据段属性值

DA_C        equ 98h ; 存在的只执行代码段属性值

DA_CR       equ 9Ah ; 存在的可执行可读代码段属性值

; Descriptor macro

%macro Descriptor 3

    dw  %2 & 0FFFFh             ; Limit 1

    dw  %1 & 0FFFFh             ; Base addr 1

    db  (%1 >> 16) & 0FFh           ; Base addr 2

    dw  ((%2 >> 8) & 0F00h) | (%3 & 0F0FFh) ; Attr 1 + Limit 2 + Attr 2

    db  (%1 >> 24) & 0FFh           ; Base addr 3

%endmacro

1.2 Makefile修改

因为include/的提取和后面第二阶段引导过程拆分的影响，所以Makefile也要做相应的修改：

新加编译参数ASINC，编译bootsect.asm、setup.asm和head.asm时都要用到
链接参数LDFLAGS中的entry地址改为startup_32，这也是head.asm中的代码起始地址
SYSSIZE不再除以16，而是system的真实大小，后面bootsect.asm中会用到

ASINC   = -I include/

ASFLAGS = -f elf

LD  = ld

# -Ttext org -e entry -s(omit all symbol info)

# -x(discard all local symbols) -M(print memory map)

LDFLAGS = -Ttext 0 -e startup_32 --oformat binary -s -x -M

    ...

# SYSSIZE = system file size

boot1/bootsect: boot1/bootsect.asm include/var.inc system/system

    (echo -n "SYSSIZE equ ";ls -l system/system | grep system \

        | cut -d " " -f 5 | tr '\012' ' ') > tmp.asm

    cat $< >> tmp.asm

    $(AS) $(ASINC) -o $@ tmp.asm

    rm -f tmp.asm

boot2/setup:    boot2/setup.asm include/var.inc include/pm.inc

    $(AS) $(ASINC) -o $@ $<

system/system:  system/init/head.o system/init/main.o

    $(LD) $(LDFLAGS) \

    system/init/head.o \

    system/init/main.o \

    -o $@ > System.map

system/init/head.o:     system/init/head.asm include/var.inc include/pm.inc

    $(AS) $(ASFLAGS) $(ASINC) -o $@ $<

    ...

2.第一阶段引导完善

2.1 system加载

之前为了简化代码，避免被细枝末节干扰，所以从软盘加载system到内存的代码写的非常简单，只读取了一个扇区。随着我们的system模块越来越大，这样是肯定不行的，于是就想参考Linux源码做一下改进。

结果不看不知道，一细研究还真吓一跳每个磁道有18个扇区，每个磁头有80个磁道，根据要加载的数据大小，自己负责切换扇区、磁道、磁头号。就这样还不行，要加载到的内存位置是用[es:bx]表示的，也就是说bx偏移逐渐增加最后要溢出的时候，我们还得修改es重置bx，避免它溢出。原来想写一段通用的从软盘加载数据的代码这么费劲啊！先看看我写的，因为之前已经加载过bootsect和setup了，所以第一个磁道还需读取13个扇区，之后的每个磁道读取18个扇区，最后一个磁道根据还剩余多少扇区没读决定要读取多少，先不考虑磁头和bx溢出问题。结果已经来回调试改进了好几遍了，还是有问题。

; 4) Load system module at 0x10000

;    Assume SYSSIZE < 1 head

;    1 track = 18 sectors * 512b = 9216(b)

;    1 head = 80 tracks * 9216 = 720(kb)

_Sector:        db 0

_Track:         db 0

Sector          equ _Sector-$$

Track           equ _Track-$$

SECT_PER_TRACK  equ 18

LEFT_IN_TRACK1  equ SECT_PER_TRACK - 1 - SETUPLEN

load_system:

        mov     ax, SYSSEG

        mov     es, ax

        mov     bx, 0000h               ; es:bx = target(es=1000h,bx=0)

        mov     dx, 0000h               ; dx    = driver(dh)/head(dl)

        mov     cx, 0006h               ; cx    = track(ch)/sector(cl)

        mov     ax, SYSSIZE

        add     ax, 511

        shr     ax, 9                   ; al    = (SYSSIZE + 511) / 512, sectors to read

        mov     byte [Sector], al

        cmp     al, LEFT_IN_TRACK1

        jbe     .loop

        mov     al, LEFT_IN_TRACK1      ; al    = (al <= 13) ? al : 13

.loop

        mov     ah, 02h                 ; ah    = service id(ah=02 means read)

        int     13h                     ; ignore any error

        sub     byte [Sector], al       ; remainingSector -= al

        cmp     byte [Sector], 0

        je      ok_load_system

        xor     ah, ah

        shl     ax, 9

        add     bx, ax                  ; offset += (al * 512)

        add     byte [Track], 1

        mov     ch, byte [Track]        ; track++

        mov     cl, 1                   ; start at first sector

        xor     ax, ax

        mov     al, byte [Sector]

        cmp     al, SECT_PER_TRACK

        jbe     .loop

        mov     al, SECT_PER_TRACK      ; al    = (al <= 18) ? al : 18

        jmp     .loop

最后发现一次读取跨磁道的扇区也没关系，Bochs的BIOS支持一次最多读取72个扇区。于是就放弃了，先读取最多72个吧，对于现阶段的system的规模是暂时够用了，到时再改吧。此外，要注意的是对要加载的扇区数的计算：这里SYSSIZE是system的实际大小，而不是Linux中所谓的click数（实际size加15后左移了4位）。并且为了避免丢失余数的差一问题，我们要先加上511。

; 4) Load system module at 0x10000

;    Assume SYSSIZE < 72 sectors (36864)

;    1 track = 18 sectors * 512b = 9216(b)

;    1 head = 80 tracks * 9216 = 720(kb)

MAX_ONE_READ    equ 72

load_system:

    mov     ax, SYSSEG

    mov     es, ax

    mov     bx, 0000h       ; es:bx = target(es=1000h,bx=0)

    mov     dx, 0000h       ; dx    = driver(dh)/head(dl)

    mov     cx, 0006h       ; cx    = track(ch)/sector(cl)

    mov     ax, SYSSIZE

    add     ax, 511

    shr     ax, 9           ; al    = (SYSSIZE + 511) / 512 sectors to read

    cmp     al, MAX_ONE_READ

    jbe     .loop

    mov     al, MAX_ONE_READ    ; al    = (al <= 72) ? al : 72

.loop

    mov     ah, 02h         ; ah    = service id(ah=02 means read)

    int     13h         ; ignore any error

2.2 关闭软驱马达

至此所有要加载的数据就都加载完了，所以我们可以关掉软驱的马达了。这样可以关闭软盘控制器FDC、禁止DMA和中断请求。具体细节有待深入研究。

; 5) Kill motor

ok_load_system:

    mov     dx, 0x3f2       ; floppy controller port

    mov     al, 0           ; floppy A

    outb                ; output al to dx port

3.第二阶段引导拆分

在上一篇文章中，在setup.asm中进入了保护模式，并执行了一段32位的代码。我们其实可以将进入保护模式之后的内核初始化工作继续填到setup.asm这段32位代码中，但这样做不如Linux 0.11的方式优雅，即将这部分工作放到system模块的头部去完成。缺点是可能引导过程有些零散，但优点就是因为system会被加载到0x0处，所以后续初始化的页目录表和页表、重放置后的GDT都会在低地址，安全、集中且易于管理，这在我们的上一篇文章中也提到了。

3.1 上半部：setup.asm

setup.asm首先读取BIOS中的有用信息保存到0x9000，即覆盖了bootsect的内存位置，因为它已经没有用了。然后将system拷贝到0x0低地址，进入保护模式后就跳转到system。

%include "var.inc"

%include "pm.inc"

; ############################

;   Booting Process

; ############################

[SECTION .s16]

[BITS   16]

; 1) Read memory info from BIOS

    mov     ax, INITSEG

    mov     ds, ax          ; save to bootsect space

    mov     ah, 0x88

    int     0x15

    mov     [MEMSIZE], ax       ; ax=3c00h (15360kb=15mb)

; 2) Move system to 0x0000

;    round-1: 10000~1ffff => 0000~ffff

;       ...

;    round-5: 80000~8ffff => 70000~7ffff

;

; NOTE: 8000h word = 10000h byte

WordPerMove     equ 8000h

move_system:

    mov     ax, 0h

.loop

    mov     es, ax

    add     ax, 1000h

    mov     ds, ax

    mov     cx, WordPerMove     ; cx    = counter

    xor     si, si          ; ds:si = source

    xor     di, di          ; es:di = target

    rep     movsw           ; move

    cmp     ax, INITSEG

    jne     .loop

; 3) Enter protection mode

    mov     ax, cs

    mov     ds, ax

    mov     es, ax

    mov     ss, ax

    mov     sp, 0100h

    ; 3.1) Load gdt to gdtr

    xor     eax, eax

    mov     ax, ds

    shl     eax, 4

    add     eax, LABEL_GDT      ; eax <- gdt base addr

    mov     dword [GdtPtr + 2], eax ; [GdtPtr + 2] <- gdt base addr

    lgdt    [GdtPtr]

    ; 3.2) Disable interrupt

    cli

    ; 3.3) Enable A20 addr line

    in  al, 92h

    or  al, 00000010b

    out     92h, al

    ; 3.4) Set PE in cr0

    mov     eax, cr0

    or      eax, 1

    mov     cr0, eax

    ; 3.5) Jump to protective mode!

    jmp     dword SelectorSystem:0  ; 0x0000:0x0

[SECTION .gdt]

;                                Base Addr,        Limit,   Attribute

LABEL_GDT:      Descriptor      0h,           0h, 0h

LABEL_DESC_SYSTEM:  Descriptor      0h,       0ffffh, DA_CR | DA_32 | DA_LIMIT_4K

LABEL_DESC_DATA:    Descriptor  0h,       0ffffh, DA_DRW | DA_32 | DA_LIMIT_4K

LABEL_DESC_VIDEO:   Descriptor 0B8000h,       0ffffh, DA_DRW

GdtLen      equ $ - LABEL_GDT

GdtPtr      dw  GdtLen - 1      ; GDT limit

        dd  0           ; GDT base addr

SelectorSystem  equ LABEL_DESC_SYSTEM - LABEL_GDT

SelectorData    equ LABEL_DESC_DATA - LABEL_GDT

SelectorVideo   equ LABEL_DESC_VIDEO - LABEL_GDT

读取BIOS中内存信息的方式有几种，目前setup.s中用的是最简单的一种，也是Linux 0.11中用的方式。代码只有三行，极其简单。获取结果保存在ax中，单位是KB，不是Byte：

    mov     ah, 0x88

    int     0x15

    mov     [MEMSIZE], ax       ; ax=3c00h (15360kb=15mb)

但这种方式的缺点也同样明显，就是最大只支持64MB。因为ax只有16位，最大能表示65536。所以在Orange’s中作者用了另一种更为强大的方式，ax=0xe820的int 0x15中断，除了能获得内存大小外，还能获得到内存分布。当然缺点就是代码比前面这种方式要麻烦多了，所以这里就不细说了，知道有多种获取BIOS中内存信息的方式就可以了。

3.2 下半部：head.asm

这就是我们新拆分出来的head.asm，它将各个段寄存器置为内核的代码段Selector后，就开始内核初始化的工作了：

直接写显存的方式打印一条消息
重置GDT的地址。至于GDT的内容则与setup.asm的一样
将main函数的地址压到栈上，这样setup_paging就会将它当做调用的返回地址，执行ret时就会跳转到main.c中的main函数了
开启分页管理

%include "var.inc"

%include "pm.inc"

extern main

global startup_32

pdt:

[SECTION .text]

ALIGN   32

[BITS   32]

startup_32:

    mov     ax, 16      ; SelectorData

    mov     ds, ax

    mov     es, ax

    mov     ss, ax

    mov     esp, TopOfStack

; 1) Print welcome message

    mov     ax, 24      ; SelectorVideo

    mov     gs, ax

    mov     ah, 0Ch

    mov     ebx, 0

    mov     ecx, len

    mov     edx, Message

.loop:

    mov     edi, ebx

    add     edi, (80 * 20)  ; (80 * row + col) * 2

    imul    edi, 2

    mov     al, byte [edx]

    mov     [gs:edi], ax

    inc     ebx

    dec     ecx

    inc     edx

    cmp     ecx, 0h

    jne     .loop

; 2) Reset GDTR

    lgdt    [GdtPtr]

; 3) Prepare return address

    push    main

    jmp     setup_paging

; Temporary data and stack, will be overriden later

Message:

    db  "Welcome to MiniOS"

len     equ $ - Message

; LinearAddr[31~22] = 10 bits = 1024 entry (* 4B = 4096B)

; So PDT has 1024 entries (1024 page tables, occupy 4096b totally)

; LinearAddr[21~12] = 10 bits = 1024 entry (* 4B = 4096B)

; So PD  has 1024 entries (1024 pages, occupy 4096b totally)

; LinearAddr[11~0]  = 12 bits = 4096 byte

; So offset (page size) is 4096b

PdtSize     equ     1024

PtSize      equ     1024

EntrySize   equ     4

PageSize    equ     4096

times   PdtSize*EntrySize-($-$$) db 0

pg0:

times   PtSize*EntrySize    db 0

pg1:

times   PtSize*EntrySize    db 0

pg2:

times   PtSize*EntrySize    db 0

pg3:

times   PtSize*EntrySize    db 0

; 4) Setup paging

PgRw        equ     111h

ALIGN   32

setup_paging:

    ; 4.1) Clear page space

    mov     ecx, PdtSize + PtSize       ; counter = 5*1024

    xor     eax, eax

    xor     edi, edi

    cld                     ; DF=0: edi move forward

    rep     stosd               ; move eax => [es:edi] by dword

    ; 4.2) Fill page dir

    mov     dword [pdt], pg0 + PgRw     ; 111h(7): read/write page

    mov     dword [pdt+04h], pg1 + PgRw

    mov     dword [pdt+08h], pg2 + PgRw

    mov     dword [pdt+0ch], pg3 + PgRw

    ; 4.3) Fill page table

    ;      pg0~3 can represent 0h ~ fff000h (16MB) memory space

    ; 0x3ffc: start addr of last entry of last PT

    mov     edi, (pg3 + PtSize * EntrySize) - EntrySize     

    ; 0xfff000: start addr of last page represented by last entry

    mov     eax, ((4 * PtSize * PageSize) - PageSize) + PgRw    

    std                     ; DF=1: edi move backward

.loop:

    stosd                   ; move eax => [es:edi] by dword

    sub     eax, PageSize

    jge     .loop

    ; 4.4) Set cr3 (PDBR, Page-Dir Base address Register)

    xor     eax, eax

    mov     cr3, eax

    ; 4.5) Set PG bit of cr0 to enable paging

    mov     eax, cr0

    or  eax, 80000000h

    mov     cr0, eax

    ; 4.6) Transfer control to main()

    ret

; Temporary stack space

times   100h    db  0

TopOfStack  equ $ 

;[SECTION .gdt]

;                                Base Addr,        Limit,   Attribute

LABEL_GDT:      Descriptor      0h,           0h, 0h

LABEL_DESC_SYSTEM:  Descriptor      0h,       0ffffh, DA_CR | DA_32 | DA_LIMIT_4K

LABEL_DESC_DATA:    Descriptor  0h,       0ffffh, DA_DRW | DA_32 | DA_LIMIT_4K

times   253     dd  0x0, 0x0        ; space for LDT and TSS

GdtLen      equ $ - LABEL_GDT

GdtPtr      dw  GdtLen - 1      ; GDT limit

        dd  LABEL_GDT       ; GDT base addr

SelectorSystem  equ LABEL_DESC_SYSTEM - LABEL_GDT

SelectorData    equ LABEL_DESC_DATA - LABEL_GDT

代码有些长，但比较清晰，真正的难点在于我们之前没有接触到的分页管理机制。其实我们此刻不是必须开启分页管理，但为了避免麻烦，我们这次就多做一点，把分页给弄好，这样以后就没有后顾之忧了。

3.2.1 内存位置

可能大家刚才看上面代码时没有注意标签，现在后看一下就会发现精心放置好的标签，包括pdt、pg0~3、以及后面的栈空间和GDT。这些标签和代码在运行时对应的内存空间非常重要，都是内核最重要的数据，所以它们的位置绝对不是随意放置的：

pdt放在最开头，使页目录表覆盖掉head.asm的部分代码
setup_paging位于pg3后，避免自己把自己覆盖掉
栈放在setup_paging，作为临时的内核栈，因为main函数地址需要入栈
GDT放在最后

--------pdt-----------

| 0x0000 | 0000 0000 |

|  ...   |    ...    |

| 0x0FFC | 0000 0000 |

|-------pg0----------|

| 0x1000 | 0000 0000 |

|  ...   |    ...    |

| 0x1FFC | 0000 0000 |

|-------pg1----------|

| 0x2000 | 0000 0000 |

|  ...   |    ...    |

| 0x2FFC | 0000 0000 |

|-------pg2----------|

| 0x3000 | 0000 0000 |

|  ...   |    ...    |

| 0x3FFC | 0000 0000 |

|-------pg3----------|

| 0x4000 | 0000 0000 |

|  ...   |    ...    |

| 0x4FFC | 0000 0000 |

|  ...   |    ...    |

|  ...   |    ...    |

|------stack---------|

|  ...   |    ...    |

|-------gdt----------|

|  ...   |    ...    |

3.2.2 代码解释

《Linux 0.11中的页目录表及页表内容分析》作者对Linux 0.11中setup_paging处的代码进行了详细分析，清晰易懂，非常棒！

首先解释一下cld和std两个命令的用处，其实很简单：“在字符串的比较、赋值、读取等一系列和rep连用的操作中，di或si是可以自动增减的而不需要人来加减它的值，cld即告诉程序si，di向前移动，std指令为设置方向，告诉程序si，di向后移动”。

下面就重点说一下PDT和PT的初始化过程，为了使代码尽可能的清晰，很多“魔数”都提取成了常量。

    ; 4.1) Clear page space

    mov     ecx, PdtSize + PtSize       ; counter = 5*1024

    xor     eax, eax

    xor     edi, edi

    cld                     ; DF=0: edi move forward

    rep     stosd               ; move eax => [es:edi] by dword

    ; 4.2) Fill page dir

    mov     dword [pdt], pg0 + PgRw     ; 111h(7): read/write page

    mov     dword [pdt+04h], pg1 + PgRw

    mov     dword [pdt+08h], pg2 + PgRw

    mov     dword [pdt+0ch], pg3 + PgRw

    ; 4.3) Fill page table

    ;      pg0~3 can represent 0h ~ fff000h (16MB) memory space

    ; 0x3ffc: start addr of last entry of last PT

    mov     edi, (pg3 + PtSize * EntrySize) - EntrySize     

    ; 0xfff000: start addr of last page represented by last entry

    mov     eax, ((4 * PtSize * PageSize) - PageSize) + PgRw    

    std                     ; DF=1: edi move backward

.loop:

    stosd                   ; move eax => [es:edi] by dword

    sub     eax, PageSize

    jge     .loop

3.2.3 PDT和PT的样子

PDT和PT到底是什么样子呢？要是看完前面的代码解释还是觉得很抽象的话，我们就直观的看看初始化成功后，内存从低到高的模样！

--------pdt-----------

| 0x0000 | 0000 1111 | => pg0

| 0x0004 | 0000 2111 | => pg1

| 0x0008 | 0000 3111 | => pg2

| 0x000C | 0000 4111 | => pg3

| 0x0010 | 0000 0000 |

|  ...   |    ...    |

| 0x0FFC | 0000 0000 |

|-------pg0----------|     Physical Address

| 0x1000 | 0000 0111 | => [00000000~00000FFF]

| 0x1004 | 0000 1111 | => [00001000~00001FFF]

| 0x1008 | 0000 2111 | => [00002000~00002FFF]

|  ...   |    ...    |

| 0x1FFC | 003F F111 | => [003FF000~003FFFFF]

|-------pg1----------|

| 0x2000 | 0040 0111 | => [00400000~00400FFF]

| 0x2004 | 0040 1111 | => [00401000~00401FFF]

| 0x2008 | 0040 2111 | => [00402000~00402FFF]

|  ...   |    ...    |

| 0x2FFC | 007F F111 | => [007FF000~007FFFFF]

|-------pg2----------|

| 0x3000 | 0080 0111 | => [00800000~00800FFF]

| 0x3004 | 0080 1111 | => [00801000~00801FFF]

| 0x3008 | 0080 2111 | => [00802000~00802FFF]

|  ...   |    ...    |

| 0x3FFC | 00BF F111 | => [00BFF000~00BFFFFF]

|-------pg3----------|

| 0x4000 | 00C0 0111 | => [00C00000~00C00FFF]

| 0x4004 | 00C0 1111 | => [00C01000~00C01FFF]

| 0x4008 | 00C0 2111 | => [00C02000~00C02FFF]

|  ...   |    ...    |

| 0x4FFC | 00FF F111 | => [00CFF000~00CFFFFF]

下面就运行起来Bochs，验证一下页表是否初始化成功了。我们查看几个关键位置就可以了，比如页目录表(0x0000)，四个页表的开头部分(0x1000, 0x2000, 0x3000, 0x4000)，以及pg4的最末尾部分(0x4ffc)。

(0) Breakpoint 1, 0x00005047 in ?? ()

Next at t=15473080

(0) [0x0000000000005047] 0008:00005047 (unk. ctxt): xor eax, eax              ; 31c0

<bochs:3> xp /32bx 0x00000

[bochs]:

0x00000000 <bogus+       0>:    0x11    0x11    0x00    0x00    0x11    0x21    0x00    0x00

0x00000008 <bogus+       8>:    0x11    0x31    0x00    0x00    0x11    0x41    0x00    0x00

0x00000010 <bogus+      16>:    0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00

0x00000018 <bogus+      24>:    0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00

<bochs:4> xp /32bx 0x01000

[bochs]:

0x00001000 <bogus+       0>:    0x11    0x01    0x00    0x00    0x11    0x11    0x00    0x00

0x00001008 <bogus+       8>:    0x11    0x21    0x00    0x00    0x11    0x31    0x00    0x00

0x00001010 <bogus+      16>:    0x11    0x41    0x00    0x00    0x11    0x51    0x00    0x00

0x00001018 <bogus+      24>:    0x11    0x61    0x00    0x00    0x11    0x71    0x00    0x00

<bochs:5> xp /32bx 0x02000

[bochs]:

0x00002000 <bogus+       0>:    0x11    0x01    0x40    0x00    0x11    0x11    0x40    0x00

0x00002008 <bogus+       8>:    0x11    0x21    0x40    0x00    0x11    0x31    0x40    0x00

0x00002010 <bogus+      16>:    0x11    0x41    0x40    0x00    0x11    0x51    0x40    0x00

0x00002018 <bogus+      24>:    0x11    0x61    0x40    0x00    0x11    0x71    0x40    0x00

<bochs:6> xp /32bx 0x03000

[bochs]:

0x00003000 <bogus+       0>:    0x11    0x01    0x80    0x00    0x11    0x11    0x80    0x00

0x00003008 <bogus+       8>:    0x11    0x21    0x80    0x00    0x11    0x31    0x80    0x00

0x00003010 <bogus+      16>:    0x11    0x41    0x80    0x00    0x11    0x51    0x80    0x00

0x00003018 <bogus+      24>:    0x11    0x61    0x80    0x00    0x11    0x71    0x80    0x00

<bochs:8> xp /4bx 0x04ffc

[bochs]:

0x00004ffc <bogus+       0>:    0x11    0xf1    0xff    0x00

4.宝贵的参考资料

个人感觉底层编程的学习曲线非常陡峭，要积累好多知识，爬过好多的“坑”，才能走到这一步，所以好的学习资料是非常重要的。以下就是我学习过程中常用的资料，它们的用法是：以《Linux内核完全剖析》为主，如果看不懂就去找《Orange’s：一个操作系统实现》中对应的章节对比学习。渐渐熟悉Linux的代码后，就参照Linux实现我们的操作系统。如果碰到NASM语法的相关问题，就去看一下博古以通今的博客，作者用NASM重写的代码还是靠谱的，只不过下不到全部代码了。

4.1 Linux 0.11源码

《完全剖析》中给出的代码包不是很方便，有热心的网友已经做了优化，“一键”就可直接编译运行起来Linux 0.11。

4.2 用NASM重写Linux 0.11

《用nasm语言重新实现linux-0.11 bootsect.s（博古以通今）》

《用nasm语言重新实现linux-0.11 setup.s (博古以通今)》

《nasm重写linux-0.11 head.s (博古以通今)》

4.3 NASM汇编指令

官方文档提供了一份NASM汇编指令列表，令我惊讶的是这份列表貌似并不全，有些查不到的指令如jge也是可用的。

此外，汇编语言没有高级语言那些控制结构，所以jmp对于实现逻辑就非常重要了，这是一份总结的不错的各种跳转指令的列表。

秒客网

操作系统内核Hack：(四)内核雏形

操作系统内核Hack：(四)内核雏形

1.周边代码修改

1.1 常量和宏提取

1.2 Makefile修改

2.第一阶段引导完善

2.1 system加载

2.2 关闭软驱马达

3.第二阶段引导拆分

3.1 上半部：setup.asm

3.2 下半部：head.asm

3.2.1 内存位置

3.2.2 代码解释

3.2.3 PDT和PT的样子

4.宝贵的参考资料

4.1 Linux 0.11源码

4.2 用NASM重写Linux 0.11

4.3 NASM汇编指令

相关文章