学习自狄泰软件，仅作个人笔记
我们在保护模式下的编程有一个特点，就是定义众多的段(section)，而这些段的功能是不一样的，比如 有可执行的代码段，数据段，栈段等等，我们通过定义众多这样的段，来进行保护模式下的编程。但是 如果我们的代码量急剧的膨胀，代码中需要定义几百上千个段，而每个段又需要在全局段描述附表GDT中有对应的描项，那这样的话 全局段描述符表会不够用， 全局段描述符表也是有界限的！所以全局段描述附表 是不能够无限制的增加描述项的。所以可以用 局部段描述符表 进行分级管理，每一个局部段描述符表可以放任意多个描述项。所以 局部段描述符表 代码层的意义就是 用于管理段！
loader.asm
%include "inc.asm"
org 0x9000
jmp ENTRY_SEGMENT
[section .gdt]
; GDT definition
; 段基址， 段界限， 段属性
GDT_ENTRY : Descriptor 0, 0, 0
CODE32_DESC : Descriptor 0, Code32SegLen - 1, DA_C + DA_32
VIDEO_DESC : Descriptor 0xB8000, 0x07FFF, DA_DRWA + DA_32
DATA32_DESC : Descriptor 0, Data32SegLen - 1, DA_DR + DA_32
STACK32_DESC : Descriptor 0, TopOfStack32, DA_DRW + DA_32
CODE16_DESC : Descriptor 0, 0xFFFF, DA_C
UPDATE_DESC : Descriptor 0, 0xFFFF, DA_DRW
;为 任务A 的局部段描述符表 添加描述项，段基址暂时设置为0
TASK_A_LDT_DESC : Descriptor 0, TaskALdtLen - 1, DA_LDT
; GDT end
GdtLen equ $ - GDT_ENTRY
GdtPtr:
dw GdtLen - 1
dd 0
; GDT Selector
Code32Selector equ (0x0001 << 3) + SA_TIG + SA_RPL0
VideoSelector equ (0x0002 << 3) + SA_TIG + SA_RPL0
Data32Selector equ (0x0003 << 3) + SA_TIG + SA_RPL0
Stack32Selector equ (0x0004 << 3) + SA_TIG + SA_RPL0
Code16Selector equ (0x0005 << 3) + SA_TIG + SA_RPL0
UpdateSelector equ (0x0006 << 3) + SA_TIG + SA_RPL0
;为 任务A 的局部段描述符表 定义 选择子
TaskALdtSelector equ (0x0007 << 3) + SA_TIG + SA_RPL0
; end of [section .gdt]
TopOfStack16 equ 0x7c00
[section .dat]
[bits 32]
DATA32_SEGMENT:
DTOS db "D.T.OS!", 0
DTOS_OFFSET equ DTOS - $$
HELLO_WORLD db "Hello World!", 0
HELLO_WORLD_OFFSET equ HELLO_WORLD - $$
Data32SegLen equ $ - DATA32_SEGMENT
[section .s16]
[bits 16]
ENTRY_SEGMENT:
mov ax, cs
mov ds, ax
mov es, ax
mov ss, ax
mov sp, TopOfStack16
mov [BACK_TO_REAL_MODE + 3], ax
; initialize GDT for 32 bits code segment
mov esi, CODE32_SEGMENT
mov edi, CODE32_DESC
call InitDescItem
mov esi, DATA32_SEGMENT
mov edi, DATA32_DESC
call InitDescItem
mov esi, STACK32_SEGMENT
mov edi, STACK32_DESC
call InitDescItem
mov esi, CODE16_SEGMENT
mov edi, CODE16_DESC
call InitDescItem
;初始化 任务A的局部段描述符表 的段描述符的段基址信息
mov esi, TASK_A_LDT_ENTRY
mov edi, TASK_A_LDT_DESC
call InitDescItem
;初始化 局部段描述符表中的 可执行代码段 的 段描述符的段基址信息
mov esi, TASK_A_CODE32_SEGMENT
mov edi, TASK_A_CODE32_DESC
call InitDescItem
;初始化 局部段描述符表中的 数据段 的 段描述符的段基址信息
mov esi, TASK_A_DATA32_SEGMENT
mov edi, TASK_A_DATA32_DESC
call InitDescItem
;初始化 局部段描述符表中的 栈段 的 段描述符的段基址信息
mov esi, TASK_A_STACK32_SEGMENT
mov edi, TASK_A_STACK32_DESC
call InitDescItem
; initialize GDT pointer struct
mov eax, 0
mov ax, ds
shl eax, 4
add eax, GDT_ENTRY
mov dword [GdtPtr + 2], eax
; 1. load GDT
lgdt [GdtPtr]
; 2. close interrupt
cli
; 3. open A20
in al, 0x92
or al, 00000010b
out 0x92, al
; 4. enter protect mode
mov eax, cr0
or eax, 0x01
mov cr0, eax
; 5. jump to 32 bits code
jmp dword Code32Selector : 0
BACK_ENTRY_SEGMENT:
mov ax, cs
mov ds, ax
mov es, ax
mov ss, ax
mov sp, TopOfStack16
in al, 0x92
and al, 11111101b
out 0x92, al
sti
mov bp, HELLO_WORLD
mov cx, 12
mov dx, 0
mov ax, 0x1301
mov bx, 0x0007
int 0x10
jmp $
; esi --> code segment label
; edi --> descriptor label
InitDescItem:
push eax
mov eax, 0
mov ax, cs
shl eax, 4
add eax, esi
mov word [edi + 2], ax
shr eax, 16
mov byte [edi + 4], al
mov byte [edi + 7], ah
pop eax
ret
[section .s16]
[bits 16]
CODE16_SEGMENT:
mov ax, UpdateSelector
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov eax, cr0
and al, 11111110b
mov cr0, eax
BACK_TO_REAL_MODE:
jmp 0 : BACK_ENTRY_SEGMENT
Code16SegLen equ $ - CODE16_SEGMENT
[section .s32]
[bits 32]
CODE32_SEGMENT:
mov ax, VideoSelector
mov gs, ax
mov ax, Stack32Selector
mov ss, ax
mov eax, TopOfStack32
mov esp, eax
mov ax, Data32Selector
mov ds, ax
mov ebp, DTOS_OFFSET
mov bx, 0x0C
mov dh, 12
mov dl, 33
call PrintString
mov ebp, HELLO_WORLD_OFFSET
mov bx, 0x0C
mov dh, 13
mov dl, 31
call PrintString
;使用局部段描述符表 跳转到A任务的可执行代码段
;将局部段描述符表选择子 复制到 ax寄存器中
mov ax, TaskALdtSelector
;加载局部段描述符表
lldt ax
;跳转到A任务的可执行代码段
jmp TaskACode32Selector : 0
; jmp Code16Selector : 0
; ds:ebp --> string address
; bx --> attribute
; dx --> dh : row, dl : col
PrintString:
push ebp
push eax
push edi
push cx
push dx
print:
mov cl, [ds:ebp]
cmp cl, 0
je end
mov eax, 80
mul dh
add al, dl
shl eax, 1
mov edi, eax
mov ah, bl
mov al, cl
mov [gs:edi], ax
inc ebp
inc dl
jmp print
end:
pop dx
pop cx
pop edi
pop eax
pop ebp
ret
Code32SegLen equ $ - CODE32_SEGMENT
[section .gs]
[bits 32]
STACK32_SEGMENT:
times 1024 * 4 db 0
Stack32SegLen equ $ - STACK32_SEGMENT
TopOfStack32 equ Stack32SegLen - 1
; ==========================================
;
; Task A Code Segment
; 目标是只是打印一串字符串，必然需要：可执行代码段，数据段，栈段
; ==========================================
[section .task-a-ldt]
; Task A LDT definition 任务A的局部段描述符表
; 段基址, 段界限, 段属性
TASK_A_LDT_ENTRY:
;可执行代码段 段描述符 段基址暂时设置为0
TASK_A_CODE32_DESC : Descriptor 0, TaskACode32SegLen - 1, DA_C + DA_32
;数据段 段描述符， 32位保护模式下的只读数据段 段基址暂时设置为0
TASK_A_DATA32_DESC : Descriptor 0, TaskAData32SegLen - 1, DA_DR + DA_32
;栈段 段描述符 32位保护模式下的可读可写 栈段 段基址暂时设置为0
TASK_A_STACK32_DESC : Descriptor 0, TaskAStack32SegLen - 1, DA_DRW + DA_32
;局部段描述附表的长度
TaskALdtLen equ $ - TASK_A_LDT_ENTRY
; Task A LDT Selector 定义选择子
TaskACode32Selector equ (0x0000 << 3) + SA_TIL + SA_RPL0
TaskAData32Selector equ (0x0001 << 3) + SA_TIL + SA_RPL0
TaskAStack32Selector equ (0x0002 << 3) + SA_TIL + SA_RPL0
;该任务的 数据段
[section .task-a-dat]
[bits 32]
TASK_A_DATA32_SEGMENT:
TASK_A_STRING db "This is Task A!", 0
TASK_A_STRING_OFFSET equ TASK_A_STRING - $$
TaskAData32SegLen equ $ - TASK_A_DATA32_SEGMENT
;该任务的 栈段
[section .task-a-gs]
[bits 32]
TASK_A_STACK32_SEGMENT:
;大小 1K字节
times 1024 db 0
TaskAStack32SegLen equ $ - TASK_A_STACK32_SEGMENT
;初始栈顶指针位置
TaskATopOfStack32 equ TaskAStack32SegLen - 1
;该任务的 可执行代码段
[section .task-a-s32]
[bits 32]
TASK_A_CODE32_SEGMENT:
; 使用VideoSelector选择子 将显存段 复制到 gs寄存器，代表显存段
; 那么怎么区分这个选择子是哪里的选择子，全局段描述符表? 局部段描述附表？ 根据选择子第二位(0 1 )分区到底是 局部段描述附表 还是 全局段描述符表
mov ax, VideoSelector
mov gs, ax
;代码执行到这里的时候，就已经在执行新任务了，当然要有自己的数据段和栈段，所以需要重新指定栈段，并且重新指定栈顶指针
;重新指定栈段
mov ax, TaskAStack32Selector
mov ss, ax
;重新指定栈顶指针
mov eax, TaskATopOfStack32
mov esp, eax
;指定数据段
mov ax, TaskAData32Selector
mov ds, ax
mov ebp, TASK_A_STRING_OFFSET
mov bx, 0x0C
mov dh, 14
mov dl, 29
;这里不能调用 PrintString ，因为不属于本段
;从选择子和段内偏移地址的角度看，此时代码段并不是同一个代码段，选择子是不同的，而函数名所对应的段内偏移地址 即便是一样的， 而目标地址必然不同
;调用自己的段内打印函数
call TaskAPrintString
;跳转回 实模式 间接返回 先跳转到保护模式下的 16位代码段 (通过选择子+偏移地址)
jmp Code16Selector : 0
;定义 段内自己的打印函数
; ds:ebp --> string address
; bx --> attribute
; dx --> dh : row, dl : col
TaskAPrintString:
push ebp
push eax
push edi
push cx
push dx
task_print:
mov cl, [ds:ebp]
cmp cl, 0
je task_end
mov eax, 80
mul dh
add al, dl
shl eax, 1
mov edi, eax
mov ah, bl
mov al, cl
mov [gs:edi], ax
inc ebp
inc dl
jmp task_print
task_end:
pop dx
pop cx
pop edi
pop eax
pop ebp
ret
TaskACode32SegLen equ $ - TASK_A_CODE32_SEGMENT
inc.asm
; Segment Attribute
DA_32 equ 0x4000
DA_DR equ 0x90
DA_DRW equ 0x92
DA_DRWA equ 0x93
DA_C equ 0x98
DA_CR equ 0x9A
DA_CCO equ 0x9C
DA_CCOR equ 0x9E
; Special Attribute，响应的内存段 是局部段描述附表
DA_LDT equ 0x82
; Selector Attribute
SA_RPL0 equ 0
SA_RPL1 equ 1
SA_RPL2 equ 2
SA_RPL3 equ 3
SA_TIG equ 0
SA_TIL equ 4
; 描述符
; usage: Descriptor Base, Limit, Attr
; Base: dd
; Limit: dd (low 20 bits available)
; Attr: dw (lower 4 bits of higher byte are always 0)
%macro Descriptor 3 ; 段基址， 段界限， 段属性
dw %2 & 0xFFFF ; 段界限1
dw %1 & 0xFFFF ; 段基址1
db (%1 >> 16) & 0xFF ; 段基址2
dw ((%2 >> 8) & 0xF00) | (%3 & 0xF0FF) ; 属性1 + 段界限2 + 属性2
db (%1 >> 24) & 0xFF ; 段基址3
%endmacro ; 共 8 字节