任务，任务的LDT和TSS
程序是记录在载体上的指令和数据，其正在执行的一个副本，叫做任务（Task）。如果一个程序有多个副本正在内存中运行，那么他对应多个任务，每一个副本都是一个任务。为了有效地在任务之间进行隔离，处理器建议每个任务都应该具有他自己的描述符表，称为局部描述符表LDT（Local Descriptor Table）。LDT和GDT一样也是用来储存描述符的，但是LDT是只属于某个任务的。每个任务是有的段，都应该在LDT中进行描述，和GDT不同的是，LDT的0位也是有效的，也可以使用。
LDT可以有很多个（有多少个任务就有多少个LDT），处理器使用局部描述符寄存器（LDT Register: LDTR）。在一个多任务的系统中，会有很多任务在轮流执行，正在执行中的那个任务，称为当前任务（Current Task）。因为LDTR只有一个，所以他用于指向当前任务的LDT，当发生任务切换，LDTR会被自动更新成新的任务的LDT，和GDTR一样，LDTR包含了32位线性基地址字段和16位段界限。以指示当前LDT的位置和大小。如果要访问LDT中的一个描述符，和访问GDT的时候是差不多的，也是要向段寄存器传输一个16位的段选择子，只是和指向GDT的选择子不同，指向LDT的选择子的TI位是1。
因为索引号只能是13位的，所以每个LDT所能容纳的描述符个数为213，也就是8192个。又因为每个描述符是8个字节，所以LDT最大长度是64KB。
同时，为了保存任务的状态，并且在下次重新执行的时候恢复他们，每个任务都应该用一个额外的内存区域保存相关信息，这就叫做任务状态段（Task State Segment: TSS）。
全局空间和局部空间
每个任务都包含两个部分：全局部分和私有部分。全局部分是所有任务共有的，含有操作系统的软件和库程序，以及可以调用的系统服务和数据。私有部分则是每个任务自己的数据和代码，与任务要解决的具体问题有关，彼此各不相同。每个任务的LDT可以登记8192个段，GDT可以登记8191个段（0不能用），这样的话每个用户程序可以有64TB的总空间。在操作系统中，允许程序使用逻辑地址来访问内存，而不是实际地址，所以这64TB内存是虚拟地址空间（全局地址空间可以有32TB，一个任务的局部空间为32TB，也就是一个任务的总空间可以是64TB，但是操作系统允许程序的编写者使用虚拟地址（逻辑地址）来访问内存。同一块内存，可以让多任务，或者是每个任务的不同段来使用。当执行或者访问一个新的段的时候，如果它不在物理内存中，而且也没有空闲的物理内存来加载它的时候，操作系统会挑出一个暂时不用的段，把它换到磁盘中，并把空间腾出来分配给马上要访问的段。并修改段描述符，使之指向这一段内存空间。当要使用这个段的时候再把段置换回物理内存中。）操作系统本身要进行虚拟内存管理。
特权级保护概述
X86架构下，Intel引进了4个特权级，分别是0-3，权限从0到3逐次递减。操作系统处于0特权级，系统服务程序一般在0-2特权级，普通的应用程序一般在3特权级。这里要特别注意的是：特权级不是指的任务的特权级，而是指的组成任务的各个部分的特权级。比如任务的全局部分一般是0,1和2特权级别的，任务的私有部分一般是3特权级的。
处理器给每个可管理的对象都赋予一个特权级，以决定谁能访问他，确保各种操作的相对安全性。比如系统的一些敏感指令（如hlt，对控制寄存器的读写指令，lgdt，ltr等），必须通过具有0特权级的对象来操作。除了敏感指令，I/O端口的读写操作也是通过特权管理来进行的，这里所说的特权管理，通常是指的I/O端口访问许可权。由EFLAGS中的13位和12位决定（I/O Privilege Level: IOPL），它代表着当前任务的I/O特权级别。
-
每个在GDT或者在LDT中的描述符，都有一个DPL位，这就是这个描述符所指的段的特权级又叫做描述符特权级（Descriptor Privilege Level: DPL）。
-
每个段的选择子的0和1位是一个**RPL（Request Privilege Level: RPL）**位，对应着当前操作请求的特权级。
-
当处理器正在一个代码段中取指令和执行指令时，那个代码段的特权级是当前特权级（Current Privilege Level: CPL）。正在执行的这个代码段的选择子位于段寄存器CS中，其最低两位就是当前特权级的值。
对于数据段，如果一个数据段，其描述符的DPL位2，那么只有特权级为0，1和2的程序才能访问他，如果特权级为3的程序访问这个数据段，那么处理器会阻止并引发异常中断。也就是在数值上要有：
- CPL<=DPL（数值上比较，目标数据段DPL）
- RPL<=DPL（数值上比较，目标数据段DPL）
对于代码段，处理器对代码段的检查是非常严格的，一般控制转移只允许发生在两个特权级相同的代码段之间。但是处理器允许通过将权限转移到依从的代码段或者通过调用门将当前权限变高。但是除了通过门切换或者从门返回，处理器不允许从特权级高的代码段转移到特权级低的代码段。
如果当前程序想通过直接转移从特权级低的代码段到依从的特权级高的代码段，则必须满足：
- CPL>=DPL（数值上比较，目标代码段DPL，代码段必须是依从的代码段）
- RPL>=DPL（数值上比较，目标代码段DPL，代码段必须是依从的代码段）
程序还可以通过门来进行代码段的转移，其实也是一个描述符。
通常一些内核例程都是特权0级的（特别是那些需要访问硬盘的程序），所以调用门可以给用户程序便捷的调用例程的手段（用户程序在特权3级，用户程序只要知道例程函数名就可以了，不需要知道例程实现细节，而且可以做一些特权3级做不到的东西）。
调用门描述符给出了例程所在的代码段的选择子，通过这个选择子就可以访问到描述符表相应的代码段，然后通过门调用实施代码段描述符的有效性，段界限和特权级的检查。例程开始偏移是直接在调用门描述符中指定的。
描述符的TYPE位用于表示门的类型，‘1100’表示的是调用门（这里注意S位，门的S位固定是0，说明这个是一个系统段，当检查了S为为0后处理器会继续检查TYPE为看是什么系统段（门或者LDT描述符，TSS描述符等））。
描述符P位是有效位，正常来讲应该是‘1’，当它是0的时候，调用这样的门，会导致处理器产生中断。但是P=0这对于处理器来说是属于故障中断，从中断处理过程返回时，处理器还会重新执行引起故障的指令。对于操作系统来说，可以利用这个特性来统计门的调用次数，在中断程序中，每当某个门调用失败，就把该门的调用次数+1。
如果使用了call执行调用门，则可能会改变CPL，因为栈段的特权级必须同当前的特权级保持一致，因此执行调用门时还需要对栈进行切换。也就是从低特权级的栈转移到高特权级的栈，比如一个特权级为3的程序通过调用门执行特权级为0的代码段，则栈段要从特权级3转移到特权级0。这是为了防止因为栈空间不足而产生不可预料的问题，同时也是为了防止数据的交叉引用。为了切换栈，每个任务除了自己固有的栈，还必须额外定义几个栈，具体数量去决定于当前任务的特权级，要补充比当前特权级高的栈段。这些额外创建的栈段必须放在任务自己的LDT中。同时，还要在TSS中进行登记。
通过调用门使用高级权限的例程时，调用者会传递一些参数给例程。一般的方法是通过栈段来传递，但是因为切换栈段后栈段的指针会被初始化为一个固定的值，也就是如果你不说，处理器其实并不知道你通过栈传递了多少参数给例程，这个时候需要在调用门上说明传递了多少个参数，而参数的复制是通过处理器固件完成的，然后根据参数个数来把调用者栈中的数据复制到切换的栈段中去（程序员不需要管栈究竟切换到哪了，只要知道某个被传递的参数在调用门之前是什么时候压入栈的，用push和pop指令可以像没有经过切换栈一样得到传递那个参数，尽管栈指针和栈段已经改变）。
用call far指令通过调用门转移控制时，如果改变当前特权级，完整的切换栈段的过程：
- S1：使用目标代码段的DPL到当前任务的TSS中选择一个栈，包括栈段的选择子和栈指针。
- S2：从TSS中独缺所选择的段的选择子和栈指针，并用该选择子和栈指针，并用该选择子读取栈段描述符，在此期间，任何违反段界限的行为都会引起处理器引发异常中断（无效TSS）。
- S3：检查栈段描述符的特权级和类型，并可能引发处理器异常中断（无效TSS）。
- S4：临时保存当前栈段寄存器SS和栈指针ESP的内容。
- S5：把新的栈段选择子和栈指针带入SS和ESP寄存器，切换到新栈。
- S6：将刚才临时保存的SS和ESP内容压入当前栈
- S7：依据调用门描述符“参数个数”字段的指示，从旧栈中所有的参数都复制到新栈中，如果参数为0则不复制。
- S8：将当前段寄存器CS和指针寄存器EIP压入新栈（因为是远调用）。
- S9：从调用门描述符中依次将目标代码选择子和段内偏移传送到CS和ESP寄存器，开始执行调用过程。
使用jmp far来通过调用门转移控制，则没有特权级的变化，所以也不会进行栈段的切换，而且不能使用retf来返回控制到调用者。
带参数的返回是用于解决通过栈传递参数的过程最后维持栈平衡的问题，过程编写者知道进入过程前栈中有多少个元素，如果需要把这些元素在结束过程后弹出，则可以使用ret imm16或者retf imm16，这两条指令都带16位立即数为操作数，前者为近返回，后者为远返回，而且数值总是为2的倍数或者4的倍数（使用SP则位2的倍数，使用ESP则为4的倍数），代表将控制返回调用者之前，应当从栈中弹出多少字节的数据。假如弹出的数值为k，则过程结束后会执行ESP<-ESP+k，相当于弹出了k/4个参数。
要求特权级变化的远返回，只能返回到较低特权级别上。控制返回的全部过程如下：
- S1：检查占中保存的CS寄存器的内容，根据其RPL字段决定返回时是否需要改变特权级别。
- S2：从当前栈中读取CS和EIP的内容，并针对代码段描述符和代码段选择子的RPL段进行特权检查。从同一特权级返回时，处理器任然会进行一次特权检查。
- S3：如果远返回指令是带参数的，则将参数和ESP寄存器的当前值相加，以跳过栈中的参数部分。最后的结果是ESP寄存器指向调用者SS和ESP的压栈值。注意，retf指令的字节计数值必须等于调用门的参数个数乘以参数长度。最后恢复调用者调用过程前（包括压入参数）的栈。
- S4：如果返回时需要改变特权级，则从栈中将SS和ESP的压栈值带入段寄存器SS和指令指针寄存器ESP，切换到调用者的栈，在此期间，一旦检测到有任何界限违反情况都会引发处理器异常中断。
- S5：如果返回时需要改变特权级，检查DS，ES，FS和GS寄存器的内容，根据他们找到相应的段描述符，要是有任何一个段描述符的DPL高于调用者的特权级（返回时新的CPL，数值上段描述符DPL<返回后的CPL），处理器将会把数值0传入该段寄存器（因为数据段的特权级检查只会在把段寄存器的选择子传入段寄存器时检查的，在这之后任何访问数据段指向的内存都不会进行特权级检查，如果当前的数据段特权级高于调用者，不在返回的时候把0传给段寄存器而任然不变的话，那么调用者将有权利使用高特权级的数据段，可能会引发不安全的操作）。
特别需要注意的是，TSS中的SS0，EP0，SS1，EP1，SS2和EP2域都是静态的，除非软件进行修改，否则处理器不会改变他们。
其实和安装GDT描述符差不多（调用门一般为公用例程，所以安装在GDT上），注意调用门的过程，我们使用的是call far，再进行门调用时，无论是间接远调用还是绝对远调用，处理器只会用选择子部分，而偏移地址部分会被忽略。在之后的给用户程序填充门描述符时，一定要记得把门描述符的特权级改为应用程序特权级3,，门调用时候处理器要按以下规则检查（数值上）：
- CPL<=调用门描述符的DPL
- RPL<=调用门描述符的DPL
- CPL>=目标代码段的DPL
上述规则都满足，才能成功调用门，否则会引发异常中断。
这里还有一个地方值得注意的是处理器对调用者的请求特权级RPL的问题，RPL事实上是处理器和操作系统的一个协议，处理器本身只会负责检查特权级的RPL，判断其是否有权限访问目标段。并不检查RPL是否是正确的，对RPL的正确性检查是操作系统的事情。换句话说，操作系统总是会把RPL改为真正发起调用的任务的特权级，以防止低特权级任务通过门等越权操作。为了帮助内核或者操作系统检查真正调用者的身份，并提供正确的RPL的值，处理器提供了arpl（Adjust RPL Field of Segment Selector）指令，以方便地调整段选择子的RPL字段，格式为：
arpl r/m16,r16
该指令的目的操作数包含了16位段选择子的通用寄存器，或者指向一个16位的内存单元。源操作数只能是包含了段选择子的16位通用寄存器。
该执行执行时，处理器检查目的操作数的RPL字段，如果它在数值上小于源操作数的RPL字段，则设置ZF标志，并调整目的操作数的RPL字段为源操作数的RPL，否则，清零ZF，且除此之外不进行任何操作。这个指令是典型的操作系统指令，它常用于调整应用程序传递给操作系统的段选择子，使其RPL字段的值和应用程序的特权级相匹配，这个指令也可以在应用程序上用。
代码清单
;代码清单14-1
;文件名：c14_core.asm
;文件说明：保护模式微型核心程序
;以下常量定义部分。内核的大部分内容都应当固定
core_code_seg_sel equ 0x38 ;内核代码段选择子
core_data_seg_sel equ 0x30 ;内核数据段选择子
sys_routine_seg_sel equ 0x28 ;系统公共例程代码段的选择子
video_ram_seg_sel equ 0x20 ;视频显示缓冲区的段选择子
core_stack_seg_sel equ 0x18 ;内核堆栈段选择子
mem_0_4_gb_seg_sel equ 0x08 ;整个0-4GB内存的段的选择子
;-------------------------------------------------------------------------------
;以下是系统核心的头部，用于加载核心程序
core_length dd core_end ;核心程序总长度#00
sys_routine_seg dd section.sys_routine.start
;系统公用例程段位置#04
core_data_seg dd section.core_data.start
;核心数据段位置#08
core_code_seg dd section.core_code.start
;核心代码段位置#0c
core_entry dd start ;核心代码段入口点#10
dw core_code_seg_sel
;===============================================================================
[bits 32]
;===============================================================================
SECTION sys_routine vstart=0 ;系统公共例程代码段
;-------------------------------------------------------------------------------
;字符串显示例程
put_string: ;显示0终止的字符串并移动光标
;输入：DS:EBX=串地址
push ecx
.getc:
mov cl,[ebx]
or cl,cl
jz .exit
call put_char
inc ebx
jmp .getc
.exit:
pop ecx
retf ;段间返回
;-------------------------------------------------------------------------------
put_char: ;在当前光标处显示一个字符,并推进
;光标。仅用于段内调用
;输入：CL=字符ASCII码
pushad
;以下取当前光标位置
mov dx,0x3d4
mov al,0x0e
out dx,al
inc dx ;0x3d5
in al,dx ;高字
mov ah,al
dec dx ;0x3d4
mov al,0x0f
out dx,al
inc dx ;0x3d5
in al,dx ;低字
mov bx,ax ;BX=代表光标位置的16位数
cmp cl,0x0d ;回车符？
jnz .put_0a
mov ax,bx
mov bl,80
div bl
mul bl
mov bx,ax
jmp .set_cursor
.put_0a:
cmp cl,0x0a ;换行符？
jnz .put_other
add bx,80
jmp .roll_screen
.put_other: ;正常显示字符
push es
mov eax,video_ram_seg_sel ;0xb8000段的选择子
mov es,eax
shl bx,1
mov [es:bx],cl
pop es
;以下将光标位置推进一个字符
shr bx,1
inc bx
.roll_screen:
cmp bx,2000 ;光标超出屏幕？滚屏
jl .set_cursor
push ds
push es
mov eax,video_ram_seg_sel
mov ds,eax
mov es,eax
cld
mov esi,0xa0 ;小心！32位模式下movsb/w/d
mov edi,0x00 ;使用的是esi/edi/ecx
mov ecx,1920
rep movsd
mov bx,3840 ;清除屏幕最底一行
mov ecx,80 ;32位程序应该使用ECX
.cls:
mov word[es:bx],0x0720
add bx,2
loop .cls
pop es
pop ds
mov bx,1920
.set_cursor:
mov dx,0x3d4
mov al,0x0e
out dx,al
inc dx ;0x3d5
mov al,bh
out dx,al
dec dx ;0x3d4
mov al,0x0f
out dx,al
inc dx ;0x3d5
mov al,bl
out dx,al
popad
ret
;-------------------------------------------------------------------------------
read_hard_disk_0: ;从硬盘读取一个逻辑扇区
;EAX=逻辑扇区号
;DS:EBX=目标缓冲区地址
;返回：EBX=EBX+512
push eax
push ecx
push edx
push eax
mov dx,0x1f2
mov al,1
out dx,al ;读取的扇区数
inc dx ;0x1f3
pop eax
out dx,al ;LBA地址7~0
inc dx ;0x1f4
mov cl,8
shr eax,cl
out dx,al ;LBA地址15~8
inc dx ;0x1f5
shr eax,cl
out dx,al ;LBA地址23~16
inc dx ;0x1f6
shr eax,cl
or al,0xe0 ;第一硬盘 LBA地址27~24
out dx,al
inc dx ;0x1f7
mov al,0x20 ;读命令
out dx,al
.waits:
in al,dx
and al,0x88
cmp al,0x08
jnz .waits ;不忙，且硬盘已准备好数据传输
mov ecx,256 ;总共要读取的字数
mov dx,0x1f0
.readw:
in ax,dx
mov [ebx],ax
add ebx,2
loop .readw
pop edx
pop ecx
pop eax
retf ;段间返回
;-------------------------------------------------------------------------------
;汇编语言程序是极难一次成功，而且调试非常困难。这个例程可以提供帮助
put_hex_dword: ;在当前光标处以十六进制形式显示
;一个双字并推进光标
;输入：EDX=要转换并显示的数字
;输出：无
pushad
push ds
mov ax,core_data_seg_sel ;切换到核心数据段
mov ds,ax
mov ebx,bin_hex ;指向核心数据段内的转换表
mov ecx,8
.xlt:
rol edx,4
mov eax,edx
and eax,0x0000000f
xlat
push ecx
mov cl,al
call put_char
pop ecx
loop .xlt
pop ds
popad
retf
;-------------------------------------------------------------------------------
allocate_memory: ;分配内存
;输入：ECX=希望分配的字节数
;输出：ECX=起始线性地址
push ds
push eax
push ebx
mov eax,core_data_seg_sel
mov ds,eax
mov eax,[ram_alloc]
add eax,ecx ;下一次分配时的起始地址
;这里应当有检测可用内存数量的指令
mov ecx,[ram_alloc] ;返回分配的起始地址
mov ebx,eax
and ebx,0xfffffffc
add ebx,4 ;强制对齐
test eax,0x00000003 ;下次分配的起始地址最好是4字节对齐
cmovnz eax,ebx ;如果没有对齐，则强制对齐
mov [ram_alloc],eax ;下次从该地址分配内存
;cmovcc指令可以避免控制转移
pop ebx
pop eax
pop ds
retf
;-------------------------------------------------------------------------------
set_up_gdt_descriptor: ;在GDT内安装一个新的描述符
;输入：EDX:EAX=描述符
;输出：CX=描述符的选择子
push eax
push ebx
push edx
push ds
push es
mov ebx,core_data_seg_sel ;切换到核心数据段
mov ds,ebx
sgdt [pgdt] ;以便开始处理GDT
mov ebx,mem_0_4_gb_seg_sel
mov es,ebx
movzx ebx,word [pgdt] ;GDT界限
inc bx ;GDT总字节数，也是下一个描述符偏移
add ebx,[pgdt+2] ;下一个描述符的线性地址
mov [es:ebx],eax
mov [es:ebx+4],edx
add word [pgdt],8 ;增加一个描述符的大小
lgdt [pgdt] ;对GDT的更改生效
mov ax,[pgdt] ;得到GDT界限值
xor dx,dx
mov bx,8
div bx ;除以8，去掉余数
mov cx,ax
shl cx,3 ;将索引号移到正确位置
pop es
pop ds
pop edx
pop ebx
pop eax
retf
;-------------------------------------------------------------------------------
make_seg_descriptor: ;构造存储器和系统的段描述符
;输入：EAX=线性基地址
; EBX=段界限
; ECX=属性。各属性位都在原始
; 位置，无关的位清零
;返回：EDX:EAX=描述符
mov edx,eax
shl eax,16
or ax,bx ;描述符前32位(EAX)构造完毕
and edx,0xffff0000 ;清除基地址中无关的位
rol edx,8
bswap edx ;装配基址的31~24和23~16 (80486+)
xor bx,bx
or edx,ebx ;装配段界限的高4位
or edx,ecx ;装配属性
retf
;-------------------------------------------------------------------------------
make_gate_descriptor: ;构造门的描述符（调用门等）
;输入：EAX=门代码在段内偏移地址
; BX=门代码所在段的选择子
; CX=段类型及属性等（各属
; 性位都在原始位置）
;返回：EDX:EAX=完整的描述符
push ebx
push ecx
mov edx,eax
and edx,0xffff0000 ;得到偏移地址高16位
or dx,cx ;组装属性部分到EDX
and eax,0x0000ffff ;得到偏移地址低16位
shl ebx,16
or eax,ebx ;组装段选择子部分
pop ecx
pop ebx
retf
sys_routine_end:
;===============================================================================
SECTION core_data vstart=0 ;系统核心的数据段
;-------------------------------------------------------------------------------
pgdt dw 0 ;用于设置和修改GDT
dd 0
ram_alloc dd 0x00100000 ;下次分配内存时的起始地址
;符号地址检索表
salt:
salt_1 db '@PrintString'
times 256-($-salt_1) db 0
dd put_string
dw sys_routine_seg_sel
salt_2 db '@ReadDiskData'
times 256-($-salt_2) db 0
dd read_hard_disk_0
dw sys_routine_seg_sel
salt_3 db '@PrintDwordAsHexString'
times 256-($-salt_3) db 0
dd put_hex_dword
dw sys_routine_seg_sel
salt_4 db '@TerminateProgram'
times 256-($-salt_4) db 0
dd return_point
dw core_code_seg_sel
salt_item_len equ $-salt_4
salt_items equ ($-salt)/salt_item_len
message_1 db ' If you seen this message,that means we '
db 'are now in protect mode,and the system '
db 'core is loaded,and the video display '
db 'routine works perfectly.',0x0d,0x0a,0
message_2 db ' System wide CALL-GATE mounted.',0x0d,0x0a,0
message_3 db 0x0d,0x0a,' Loading user program...',0
do_status db 'Done.',0x0d,0x0a,0
message_6 db 0x0d,0x0a,0x0d,0x0a,0x0d,0x0a
db ' User program terminated,control returned.',0
bin_hex db '0123456789ABCDEF'
;put_hex_dword子过程用的查找表
core_buf times 2048 db 0 ;内核用的缓冲区
esp_pointer dd 0 ;内核用来临时保存自己的栈指针
cpu_brnd0 db 0x0d,0x0a,' ',0
cpu_brand times 52 db 0
cpu_brnd1 db 0x0d,0x0a,0x0d,0x0a,0
;任务控制块链
tcb_chain dd 0
core_data_end:
;===============================================================================
SECTION core_code vstart=0
;-------------------------------------------------------------------------------
fill_descriptor_in_ldt: ;在LDT内安装一个新的描述符
;输入：EDX:EAX=描述符
; EBX=TCB基地址
;输出：CX=描述符的选择子
push eax
push edx
push edi
push ds
mov ecx,mem_0_4_gb_seg_sel
mov ds,ecx
mov edi,[ebx+0x0c] ;获得LDT基地址
xor ecx,ecx
mov cx,[ebx+0x0a] ;获得LDT界限
inc cx ;LDT的总字节数，即新描述符偏移地址
mov [edi+ecx+0x00],eax
mov [edi+ecx+0x04],edx ;安装描述符
add cx,8
dec cx ;得到新的LDT界限值
mov [ebx+0x0a],cx ;更新LDT界限值到TCB
mov ax,cx
xor dx,dx
mov cx,8
div cx
mov cx,ax
shl cx,3 ;左移3位，并且
or cx,0000_0000_0000_0100B ;使TI位=1，指向LDT，最后使RPL=00
pop ds
pop edi
pop edx
pop eax
ret
;-------------------------------------------------------------------------------
load_relocate_program: ;加载并重定位用户程序
;输入: PUSH 逻辑扇区号
; PUSH 任务控制块基地址
;输出：无
pushad
push ds
push es
mov ebp,esp ;为访问通过堆栈传递的参数做准备
mov ecx,mem_0_4_gb_seg_sel
mov es,ecx
mov esi,[ebp+11*4] ;从堆栈中取得TCB的基地址
;以下申请创建LDT所需要的内存
mov ecx,160 ;允许安装20个LDT描述符
call sys_routine_seg_sel:allocate_memory
mov [es:esi+0x0c],ecx ;登记LDT基地址到TCB中
mov word [es:esi+0x0a],0xffff ;登记LDT初始的界限到TCB中
;以下开始加载用户程序
mov eax,core_data_seg_sel
mov ds,eax ;切换DS到内核数据段
mov eax,[ebp+12*4] ;从堆栈中取出用户程序起始扇区号
mov ebx,core_buf ;读取程序头部数据
call sys_routine_seg_sel:read_hard_disk_0
;以下判断整个程序有多大
mov eax,[core_buf] ;程序尺寸
mov ebx,eax
and ebx,0xfffffe00 ;使之512字节对齐（能被512整除的数低
add ebx,512 ;9位都为0
test eax,0x000001ff ;程序的大小正好是512的倍数吗?
cmovnz eax,ebx ;不是。使用凑整的结果
mov ecx,eax ;实际需要申请的内存数量
call sys_routine_seg_sel:allocate_memory
mov [es:esi+0x06],ecx ;登记程序加载基地址到TCB中
mov ebx,ecx ;ebx -> 申请到的内存首地址
xor edx,edx
mov ecx,512
div ecx
mov ecx,eax ;总扇区数
mov eax,mem_0_4_gb_seg_sel ;切换DS到0-4GB的段
mov ds,eax
mov eax,[ebp+12*4] ;起始扇区号
.b1:
call sys_routine_seg_sel:read_hard_disk_0
inc eax
loop .b1 ;循环读，直到读完整个用户程序
mov edi,[es:esi+0x06] ;获得程序加载基地址
;建立程序头部段描述符
mov eax,edi ;程序头部起始线性地址
mov ebx,[edi+0x04] ;段长度
dec ebx ;段界限
mov ecx,0x0040f200 ;字节粒度的数据段描述符，特权级3
call sys_routine_seg_sel:make_seg_descriptor
;安装头部段描述符到LDT中
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0011B ;设置选择子的特权级为3
mov [es:esi+0x44],cx ;登记程序头部段选择子到TCB
mov [edi+0x04],cx ;和头部内
;建立程序代码段描述符
mov eax,edi
add eax,[edi+0x14] ;代码起始线性地址
mov ebx,[edi+0x18] ;段长度
dec ebx ;段界限
mov ecx,0x0040f800 ;字节粒度的代码段描述符，特权级3
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0011B ;设置选择子的特权级为3
mov [edi+0x14],cx ;登记代码段选择子到头部
;建立程序数据段描述符
mov eax,edi
add eax,[edi+0x1c] ;数据段起始线性地址
mov ebx,[edi+0x20] ;段长度
dec ebx ;段界限
mov ecx,0x0040f200 ;字节粒度的数据段描述符，特权级3
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0011B ;设置选择子的特权级为3
mov [edi+0x1c],cx ;登记数据段选择子到头部
;建立程序堆栈段描述符
mov ecx,[edi+0x0c] ;4KB的倍率
mov ebx,0x000fffff
sub ebx,ecx ;得到段界限
mov eax,4096
mul ecx
mov ecx,eax ;准备为堆栈分配内存
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;得到堆栈的高端物理地址
mov ecx,0x00c0f600 ;字节粒度的堆栈段描述符，特权级3
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0011B ;设置选择子的特权级为3
mov [edi+0x08],cx ;登记堆栈段选择子到头部
;重定位SALT
mov eax,mem_0_4_gb_seg_sel ;这里和前一章不同，头部段描述符
mov es,eax ;已安装，但还没有生效，故只能通
;过4GB段访问用户程序头部
mov eax,core_data_seg_sel
mov ds,eax
cld
mov ecx,[es:edi+0x24] ;U-SALT条目数(通过访问4GB段取得)
add edi,0x28 ;U-SALT在4GB段内的偏移
.b2:
push ecx
push edi
mov ecx,salt_items
mov esi,salt
.b3:
push edi
push esi
push ecx
mov ecx,64 ;检索表中，每条目的比较次数
repe cmpsd ;每次比较4字节
jnz .b4
mov eax,[esi] ;若匹配，则esi恰好指向其后的地址
mov [es:edi-256],eax ;将字符串改写成偏移地址
mov ax,[esi+4]
or ax,0000000000000011B ;以用户程序自己的特权级使用调用门
;故RPL=3
mov [es:edi-252],ax ;回填调用门选择子
.b4:
pop ecx
pop esi
add esi,salt_item_len
pop edi ;从头比较
loop .b3
pop edi
add edi,256
pop ecx
loop .b2
mov esi,[ebp+11*4] ;从堆栈中取得TCB的基地址
;创建0特权级堆栈
mov ecx,4096
mov eax,ecx ;为生成堆栈高端地址做准备
mov [es:esi+0x1a],ecx
shr dword [es:esi+0x1a],12 ;登记0特权级堆栈尺寸到TCB
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;堆栈必须使用高端地址为基地址
mov [es:esi+0x1e],eax ;登记0特权级堆栈基地址到TCB
mov ebx,0xffffe ;段长度（界限）
mov ecx,0x00c09600 ;4KB粒度，读写，特权级0
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
;or cx,0000_0000_0000_0000 ;设置选择子的特权级为0
mov [es:esi+0x22],cx ;登记0特权级堆栈选择子到TCB
mov dword [es:esi+0x24],0 ;登记0特权级堆栈初始ESP到TCB
;创建1特权级堆栈
mov ecx,4096
mov eax,ecx ;为生成堆栈高端地址做准备
mov [es:esi+0x28],ecx
shr [es:esi+0x28],12 ;登记1特权级堆栈尺寸到TCB
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;堆栈必须使用高端地址为基地址
mov [es:esi+0x2c],eax ;登记1特权级堆栈基地址到TCB
mov ebx,0xffffe ;段长度（界限）
mov ecx,0x00c0b600 ;4KB粒度，读写，特权级1
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0001 ;设置选择子的特权级为1
mov [es:esi+0x30],cx ;登记1特权级堆栈选择子到TCB
mov dword [es:esi+0x32],0 ;登记1特权级堆栈初始ESP到TCB
;创建2特权级堆栈
mov ecx,4096
mov eax,ecx ;为生成堆栈高端地址做准备
mov [es:esi+0x36],ecx
shr [es:esi+0x36],12 ;登记2特权级堆栈尺寸到TCB
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;堆栈必须使用高端地址为基地址
mov [es:esi+0x3a],ecx ;登记2特权级堆栈基地址到TCB
mov ebx,0xffffe ;段长度（界限）
mov ecx,0x00c0d600 ;4KB粒度，读写，特权级2
call sys_routine_seg_sel:make_seg_descriptor
mov ebx,esi ;TCB的基地址
call fill_descriptor_in_ldt
or cx,0000_0000_0000_0010 ;设置选择子的特权级为2
mov [es:esi+0x3e],cx ;登记2特权级堆栈选择子到TCB
mov dword [es:esi+0x40],0 ;登记2特权级堆栈初始ESP到TCB
;在GDT中登记LDT描述符
mov eax,[es:esi+0x0c] ;LDT的起始线性地址
movzx ebx,word [es:esi+0x0a] ;LDT段界限
mov ecx,0x00408200 ;LDT描述符，特权级0
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [es:esi+0x10],cx ;登记LDT选择子到TCB中
;创建用户程序的TSS
mov ecx,104 ;tss的基本尺寸
mov [es:esi+0x12],cx
dec word [es:esi+0x12] ;登记TSS界限值到TCB
call sys_routine_seg_sel:allocate_memory
mov [es:esi+0x14],ecx ;登记TSS基地址到TCB
;登记基本的TSS表格内容
mov word [es:ecx+0],0 ;反向链=0
mov edx,[es:esi+0x24] ;登记0特权级堆栈初始ESP
mov [es:ecx+4],edx ;到TSS中
mov dx,[es:esi+0x22] ;登记0特权级堆栈段选择子
mov [es:ecx+8],dx ;到TSS中
mov edx,[es:esi+0x32] ;登记1特权级堆栈初始ESP
mov [es:ecx+12],edx ;到TSS中
mov dx,[es:esi+0x30] ;登记1特权级堆栈段选择子
mov [es:ecx+16],dx ;到TSS中
mov edx,[es:esi+0x40] ;登记2特权级堆栈初始ESP
mov [es:ecx+20],edx ;到TSS中
mov dx,[es:esi+0x3e] ;登记2特权级堆栈段选择子
mov [es:ecx+24],dx ;到TSS中
mov dx,[es:esi+0x10] ;登记任务的LDT选择子
mov [es:ecx+96],dx ;到TSS中
mov dx,[es:esi+0x12] ;登记任务的I/O位图偏移
mov [es:ecx+102],dx ;到TSS中
mov word [es:ecx+100],0 ;T=0
;在GDT中登记TSS描述符
mov eax,[es:esi+0x14] ;TSS的起始线性地址
movzx ebx,word [es:esi+0x12] ;段长度（界限）
mov ecx,0x00408900 ;TSS描述符，特权级0
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [es:esi+0x18],cx ;登记TSS选择子到TCB
pop es ;恢复到调用此过程前的es段
pop ds ;恢复到调用此过程前的ds段
popad
ret 8 ;丢弃调用本过程前压入的参数
;-------------------------------------------------------------------------------
append_to_tcb_link: ;在TCB链上追加任务控制块
;输入：ECX=TCB线性基地址
push eax
push edx
push ds
push es
mov eax,core_data_seg_sel ;令DS指向内核数据段
mov ds,eax
mov eax,mem_0_4_gb_seg_sel ;令ES指向0..4GB段
mov es,eax
mov dword [es: ecx+0x00],0 ;当前TCB指针域清零，以指示这是最
;后一个TCB
mov eax,[tcb_chain] ;TCB表头指针
or eax,eax ;链表为空？
jz .notcb
.searc:
mov edx,eax
mov eax,[es: edx+0x00]
or eax,eax
jnz .searc
mov [es: edx+0x00],ecx
jmp .retpc
.notcb:
mov [tcb_chain],ecx ;若为空表，直接令表头指针指向TCB
.retpc:
pop es
pop ds
pop edx
pop eax
ret
;-------------------------------------------------------------------------------
start:
mov ecx,core_data_seg_sel ;使ds指向核心数据段
mov ds,ecx
mov ebx,message_1
call sys_routine_seg_sel:put_string
;显示处理器品牌信息
mov eax,0x80000002
cpuid
mov [cpu_brand + 0x00],eax
mov [cpu_brand + 0x04],ebx
mov [cpu_brand + 0x08],ecx
mov [cpu_brand + 0x0c],edx
mov eax,0x80000003
cpuid
mov [cpu_brand + 0x10],eax
mov [cpu_brand + 0x14],ebx
mov [cpu_brand + 0x18],ecx
mov [cpu_brand + 0x1c],edx
mov eax,0x80000004
cpuid
mov [cpu_brand + 0x20],eax
mov [cpu_brand + 0x24],ebx
mov [cpu_brand + 0x28],ecx
mov [cpu_brand + 0x2c],edx
mov ebx,cpu_brnd0 ;显示处理器品牌信息
call sys_routine_seg_sel:put_string
mov ebx,cpu_brand
call sys_routine_seg_sel:put_string
mov ebx,cpu_brnd1
call sys_routine_seg_sel:put_string
;以下开始安装为整个系统服务的调用门。特权级之间的控制转移必须使用门
mov edi,salt ;C-SALT表的起始位置
mov ecx,salt_items ;C-SALT表的条目数量
.b3:
push ecx
mov eax,[edi+256] ;该条目入口点的32位偏移地址
mov bx,[edi+260] ;该条目入口点的段选择子
mov cx,1_11_0_1100_000_00000B ;特权级3的调用门(3以上的特权级才
;允许访问)，0个参数(因为用寄存器
;传递参数，而没有用栈)
call sys_routine_seg_sel:make_gate_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+260],cx ;将返回的门描述符选择子回填
add edi,salt_item_len ;指向下一个C-SALT条目
pop ecx
loop .b3
;对门进行测试
mov ebx,message_2
call far [salt_1+256] ;通过门显示信息(偏移量将被忽略)
mov ebx,message_3
call sys_routine_seg_sel:put_string ;在内核中调用例程不需要通过门
;创建任务控制块。这不是处理器的要求，而是我们自己为了方便而设立的
mov ecx,0x46
call sys_routine_seg_sel:allocate_memory
call append_to_tcb_link ;将任务控制块追加到TCB链表
push dword 50 ;用户程序位于逻辑50扇区
push ecx ;压入任务控制块起始线性地址
call load_relocate_program
mov ebx,do_status
call sys_routine_seg_sel:put_string
mov eax,mem_0_4_gb_seg_sel
mov ds,eax
ltr [ecx+0x18] ;加载任务状态段
lldt [ecx+0x10] ;加载LDT
mov eax,[ecx+0x44]
mov ds,eax ;切换到用户程序头部段
;以下假装是从调用门返回。摹仿处理器压入返回参数
push dword [0x08] ;调用前的堆栈段选择子
push dword 0 ;调用前的esp
push dword [0x14] ;调用前的代码段选择子
push dword [0x10] ;调用前的eip
retf
return_point: ;用户程序返回点
mov eax,core_data_seg_sel ;因为c14.asm是以JMP的方式使用调
mov ds,eax ;用门@TerminateProgram，回到这
;里时，特权级为3，会导致异常。
mov ebx,message_6
call sys_routine_seg_sel:put_string
hlt
core_code_end:
;-------------------------------------------------------------------------------
SECTION core_trail
;-------------------------------------------------------------------------------
core_end:
扫一扫
859
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
