★PART1：32位保护模式下任务的隔离和特权级保护
这一章是全书的重点之一，这一张必须要理解特权级（包括CPL，RPL和DPL的含义）是什么，调用门的使用，还有LDT和TSS的工作原理（15章着重讲TSS如何进行任务切换）。
1. 任务，任务的LDT和TSS
程序是记录在载体上的指令和数据，其正在执行的一个副本，叫做任务（Task）。如果一个程序有多个副本正在内存中运行，那么他对应多个任务，每一个副本都是一个任务。为了有效地在任务之间进行隔离，处理器建议每个任务都应该具有他自己的描述符表，称为局部描述符表LDT（Local Descriptor Table）。LDT和GDT一样也是用来储存描述符的，但是LDT是只属于某个任务的。每个任务是有的段，都应该在LDT中进行描述，和GDT不同的是，LDT的0位也是有效的，也可以使用。
LDT可以有很多个（有多少个任务就有多少个LDT），处理器使用局部描述符寄存器（LDT Register: LDTR）。在一个多任务的系统中，会有很多任务在轮流执行，正在执行中的那个任务，称为当前任务（Current Task）。因为LDTR只有一个，所以他用于指向当前任务的LDT，当发生任务切换（会在15章讲），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）。如图：
任务状态段TSS是具有上图的固定格式的，最小尺寸是104（这就是为什么图上的I/O映射基地址只有16位的原因，其实是可以32位的）。图中标注的偏移量都是10进制的。和LDT一样，处理器用TR（Task Register: TR）寄存器来指向当前的任务TSS。TR也是只有一个。当任务进行切换的时候，处理器将当前任务的现场信息保存到TR指向的TSS中，然后，再使TR寄存器指向新的任务TSS，并从新任务的TSS中恢复现场。
2. 任务的全局空间和局部空间
每个任务都包含两个部分：全局部分和私有部分。全局部分是所有任务共有的，含有操作系统的软件和库程序，以及可以调用的系统服务和数据。私有部分则是每个任务自己的数据和代码，与任务要解决的具体问题有关，彼此各不相同。每个任务的LDT可以登记8192个段，GDT可以登记8191个段（0不能用），这样的话每个用户程序可以有64TB的总空间。在操作系统中，允许程序使用逻辑地址来访问内存，而不是实际地址，所以这64TB内存是虚拟地址空间（要开启页功能，16章讲）（全局地址空间可以有32TB，一个任务的局部空间为32TB，也就是一个任务的总空间可以是64TB，但是操作系统允许程序的编写者使用虚拟地址（逻辑地址）来访问内存。同一块内存，可以让多任务，或者是每个任务的不同段来使用。当执行或者访问一个新的段的时候，如果它不在物理内存中，而且也没有空闲的物理内存来加载它的时候，操作系统会挑出一个暂时不用的段，把它换到磁盘中，并把空间腾出来分配给马上要访问的段。并修改段描述符，使之指向这一段内存空间。当要使用这个段的时候再把段置换回物理内存中。）操作系统本身要进行虚拟内存管理。
3. 任务和特权级保护，调用门
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特权级别，I/O端口的访问权限控制等下再讲。
接下来我们要分清楚DPL，RPL和CPL之间的联系。
每个在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，代码段必须是依从的代码段）
程序还可以通过门来进行代码段的转移，14章讲的是调用门切换，但是总感觉讲的好啰嗦。说白了调用门其实也是一个描述符。如下图：
通常一些内核例程都是特权0级的（特别是那些需要访问硬盘的程序），所以调用门可以给用户程序便捷的调用例程的手段（用户程序在特权3级，用户程序只要知道例程函数名就可以了，不需要知道例程实现细节，而且可以做一些特权3级做不到的东西）。
调用门描述符给出了例程所在的代码段的选择子，通过这个选择子就可以访问到描述符表相应的代码段，然后通过门调用实施代码段描述符的有效性，段界限和特权级的检查。例程开始偏移是直接在调用门描述符中指定的。
描述符的TYPE位用于表示门的类型，‘1100’表示的是调用门（这里注意S位，门的S位固定是0，说明这个是一个系统段，当检查了S为为0后处理器会继续检查TYPE为看是什么系统段（门或者LDT描述符，TSS描述符等））。
描述符P位是有效位，正常来讲应该是‘1’，当它是0的时候，调用这样的门，会导致处理器产生中断。但是P=0这对于处理器来说是属于故障中断，从中断处理过程返回时，处理器还会重新执行引起故障的指令。对于操作系统来说，可以利用这个特性来统计门的调用次数，在中断程序中，每当某个门调用失败，就把该门的调用次数+1。
通过调用门实施特权级之间控制转移时，可以使用jmp far指令，也可以使用call far指令，这两种方式的调用有差别。具体看下表：
如果使用了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寄存器，开始执行调用过程。
注：如果不进行段切换，那么SS不会变，直接压入CS和EIP就好
使用jmp far来通过调用门转移控制，则没有特权级的变化，所以也不会进行栈段的切换，而且不能使用retf来返回控制到调用者。
使用call far来通过调用门转移控制，可以使用retf来将控制返回，retf或者ret指令都是可以带参数的，带参数的返回其实就是高级语言的_stdcall的原型。具体可以看这篇文章：
http://www.cnblogs.com/Philip-Tell-Truth/articles/5294369.html
带参数的返回是用于解决通过栈传递参数的过程最后维持栈平衡的问题，过程编写者知道进入过程前栈中有多少个元素，如果需要把这些元素在结束过程后弹出，则可以使用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域都是静态的，除非软件进行修改，否则处理器不会改变他们。
好了讲了那么多，我们来看下如何创建一个调用门
首先符号表每个项下面要加多一个东西，就是参数个数（教材上没有写这个东西，默认参数个数为0）。
这就是安装门的过程，其实和安装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字段的值和应用程序的特权级相匹配，这个指令也可以在应用程序上用。
比如一个采用压栈传递参数，且通过门调用的读取磁盘函数前一段可以这么写：
★PART2：加载用户程序并创建任务
1. 记录任务数据临时块（TCB）（非处理器要求）
一个合格的操作系统应该有能力跟踪程序的大小，加载的位置，使用内存的多少等，当然在现代流行的操作系统中，这个管理是非常复杂的。教材作者用一个简单的例子来做这个事情（和之前的符号表，内存管理什么的都一样，都是作者自己的私货），能解决问题就好了，暂时不需要考虑太复杂的东西。这个例子就是TCB链（Task Contorl Block，TCB）。
在内和数据段加多一个上面的双字空间。然后创建TCB，也就是简单的分配内存
因为TCB是链表，所以每加一个TCB，就要寻链表一次，简单的遍历过程如下：
2. 创建和加载LDT到GDT中
14章和13章不同的地方在于，因为14章要按照特权级3加载程序，要使用LDT，所以要给程序分配LDT的内存，而且要把一些描述符（包括那些用来切换的栈段）写入LDT，我们先把这些信息写入TCB。
上面的代码的最后是安装LDT到GDT中，其实LDT的描述符和普通的段描述符长得差不多，就是他的S位必须是0，TYPE位必须是0010。
3. 创建和加载TSS到GDT中
要加载TSS，首先就要向TSS填入所需要的信息，再看一下TSS，除了段寄存器和段指针这些我们已经很熟悉了，我们来看一下我们不熟悉的部分，CR3（PDBR）和分页有关，这个将在16章讲述，LDT段选择子就是指的是当前任务的LDT在GDT中的选择子，任务切换时要用到（15章讲述），T位是软件调试位，如果T位是1，那么每次切换到该任务，就会引发一个调试异常中断，可以用来调试，现在只需要把这个清零就可以了。
之前我们说过，EFLAGS中有一个IOPL位，是用来管理端口的读写问题的，而TSS恰好就有一个EFALGS段，那么现在我们就来搞明白这个域是怎么使用的。
一个典型的例子就是硬件端口输入输出指令in和out，他们应该对特权级别位1的程序开放，因为设备驱动程序就工作在这个特权级别，不过，特权级3和特权级2的程序也同样需要快速访问端口，通过调用门来使用内核程序访问的方法太慢，而处理器是可以访问65536个硬件端口的。处理器允许只对应用程序开放那些他们需要的端口，而屏蔽敏感端口，这有利于设备的统一管理。每个任务都有EFLAGS寄存器的副本，其内容在任务创建的时候由内核或者操作系统初始化，在多任务系统中，每当任务恢复运行时，就由处理器固件自动从TSS恢复。
EFLAGS寄存器的IPOL位决定了当前任务的I/O特权级别，如果CPL高于或者和任务的I/O特权级IOPL相同，也就是在数值上
CPL<=IOPL
则虽有的I/O操作都是允许的，针对任何硬件端口的访问都可以通过。
如果CPL低于任务的IOPL，则处理器要检索I/O许可位串，看是否允许这个任务访问这个接口。
如图所示，I/O许可串（I/O Perission Bit String）是一个比特序列，最多允许65536个比特（8KB），每一个比特代表一个端口，如果该比特为1，则这个比特对应的端口禁止访问，如果为0，则允许访问。这里要非常注意的是，I/O端口是按字节编址的，每个端口仅被设计者用来读写一个字节的数据，当以字或者双字访问时，实际上是连续访问2个或者4个端口，比如，从端口n读取一个字时，相当于从端口n和端口n+1各读取一个字节。
TSS还可以包括一个I/O许可串，他所占用的区域称为I/O许可串映射区，处于TSS的偏移地址位102D的那个字单元，从TSS起始位置（0）开始算起，如果这个字单元的内容大于或者等于（教材是小于等于，有误）TSS的段界限（在TSS描述符中），则表明没有I/0许可串（且不能超过DFFFH），在这种情况下，如果CPL低于当前IOPL，执行任何硬件I/O都会引发处理器中断，TSS的界限值应该包括I/O许可映射区在内，I/O许可映射区在以TSS的初始位置（0）位起始点，按照I/O许可映射区的值作为偏移值所对应的内存的首地址，一直到TSS的段界限为止就是I/O映射区，且映射区的最后一个字节必须是0xFF，如果中间有空余，可以留给软件使用（TSS的尺寸最小是104）。
处理器提供pushf和popf来给EFLAGS进行读写，pushf在16位模式下（实模式和16位保护模式），将16位的FLAGS压栈（16位），在32位保护模式下，将EFLAGS压栈（32位），pushf是一个字节的指令。则如果在16位模式下，pushf是压入EFLAGS的低16位，如果要压入32位EFLAGS，则要添加指令前缀66（指令：66 9C，66是前缀）为了区分EFLAGS在16位模式下的两种压栈方式，nasm提供了pushfd指令，它无论在16位模式还是在32位模式下，都会压入32位EFLAGS，而且在16为模式下，会给指令添加66（其实pushfd和pushf的作用是一样的）。popf和popfd同理。
注意能够修改IOPL位和IF位的两个标志位的指令时popf（popfd），iret，cli，sti。注意没有pushf（pushfd），但是这是个指令都不是特权指令。处理器通过IOPL位来控制它们的使用。
当且仅当：CPL<=IOPL（数值上），则允许执行上面4个指令和访问所有硬件端口。否则，当当前特权级低于I/O特权级，则执行iret和popf时，会引发异常中断，执行cli和sti时，不会引发异常中断，但不会改变标志寄存器的IF位，同时，能否安稳特定的I/O端口，要参考TSS中的I/O许可位映射串。
接下来就是填写TSS和把TSS描述符写入GDT了，TSS描述符长得和LDT描述符差不多，只是TYPE位是10B1（B位是忙（Busy）位，一般由处理器填写，操作系统应该写这个位为0，和任务切换有关，15章讲）。
注：因为本章不用任务切换，所以TSS的其他段可以先不用填写。
★PART3：以特权级3加载用户程序
1. 加载任务寄存器TR和局部描述符寄存器LDTR
和段寄存器一样，TR和LDTR寄存器都包括16位选择子部分，以及描述符高速缓存器部分，选择子部分是TR和LDT的描述符选择子，描述符高速缓存器同样是64位的（32位的线性基地址，20位的段界限，12位的段属性）。
加载任务寄存器TR需要用到ltr命令，指令格式为ltr r/m16，这条指令的操作数可以是16位的通用寄存器或者是16位的内存单元，包含16位的TSS选择子。当TSS加载到TR后，处理器自动将TSS的B位置1，但不进行任务切换。该指令不影响EFLAGS的任何标志位，但属于只能在0特权级下执行的特权命令。
加载据不描述符寄存器LDTR要用到lldt命令，指令格式为lldt r/m16，这条指令的操作数可以是16位的通用寄存器或者是16位的内存单元，包含16位的LDT选择子。lldt命令会把在GDT的ldt描述符的段界限和段基地址加载到LDTR的描述符高速缓存器部分，CS，SS，DS，ES，FS和GS寄存器的当前内容不受该指令的影响，包括TSS内的LDT选择子字段。
如果执行这条指令时，代入LDT选择器部分的选择子高14位全部都是0，则LDT寄存器的内容会被标记为无效，而该指令的执行会结束，且不会引发异常中断，但是后面的对LDT内描述符的操作都会引发异常中断。
处理器在加载TR和LDTR时，都要检查描述符的有效性。包括审查是不是TSS或者LDT描述符。
当然这一章没有将任务门，教材用了一个非常奇葩的方法（把切换到特权级3任务看成是从某个调用门的返回），非常别扭，等一下看代码就知道了，用户程序是直接用一个调用门返回的，而且教材给的例程返回后一定会引发常中断，因为其返回时用的是jmp返回，特权级还是3，最后教材那里要切换到内核数据区（DPL=3），肯定是不行的。
2. 显示处理器信息
上一章忘记这茬了，这里补一补，主要是讲如何用cpuid来显示处理器信息
cpuid（CPU Identification）指令是用于返回处理器标识和特性信息的，EAX是用于指定要返回什么样的信息，也就是功能，有时候还要用到ECX寄存器，但是无论如何cpuid指令执行后处理器将返回的信息放在EAX，EBX,ECX或者EDX中，cpuid指令是在（80486以后开始支持的，原则上使用cpuid之前要检测处理器是否支持该指令，再检测是否支持所需功能）。这个问题就出在EFLAGS上，EFLAGS的ID标志位（21位），如果可以被设置和清除，则他不支持cpuid指令，反之则可以支持。
通常情况下不需要检查处理器是否支持cpuid（毕竟80486这款CPU年代太久远了），为了探测处理器能支持的最大的功能号，应该先用0号功能来执行cpuid指令：
指令执行后，EAX寄存器返回最大可以支持的功能号，同时，还在EBX，ECX和ED中返回处理器供应商的信息，对于Intel来说，返回的信息就是“GenuineIntel”。
要返回处理器品牌信息，需要使用0x80000002~0x80000004功能，分三次进行，该功能仅被奔腾4（Pentium4）之后的处理器支持，可以在内核数据区存放之后再显示。
★PART4：14章的相关程序
这里直接课后习题两道题一起做了，感觉都是差不多的，主要是欣赏一下那个别扭的调用方法。
1 ;===============================内核程序=================================
2 ;定义内核所要用到的选择子
3 All_4GB_Segment equ 0x0008 ;4GB的全内存区域
4 Stack_Segement equ 0x0018 ;内核栈区
5 Print_Segement equ 0x0020 ;显存映射区
6 Sys_Routine_Segement equ 0x0028 ;公用例程段
7 Core_Data_Segement equ 0x0030 ;内核数据区
8 Core_Code_Segement equ 0x0038 ;内核代码段
9 ;----------------------------------------------------------------
10 User_Program_Address equ 50 ;用户程序所在逻辑扇区
11 Switch_Stack_Size equ 4096 ;切换栈段的大小
12 ;=============================内核程序头部===============================
13 SECTION header vstart=0
14 Program_Length dd Program_end ;内核总长度
15 Sys_Routine_Seg dd section.Sys_Routine.start ;公用例程段线性地址
16 Core_Data_Seg dd section.Core_Data.start ;内核数据区线性地址
17 Core_Code_Seg dd section.Core_Code.start ;内核代码区线性地址
18 Code_Entry dd start ;注意偏移地址一定是32位的
19 dw Core_Code_Segement
20 ;----------------------------------------------------------------
21 [bits 32]
22 ;=========================================================================
23 ;============================公用例程区===================================
24 ;=========================================================================
25 SECTION Sys_Routine align=16 vstart=0
26 ReadHarddisk: ;push1：28位磁盘号(esi)
27 ;push2：应用程序数据段选择子(ax->ds)
28 ;push3: 偏移地址(ebx)
29 ;push4: 应用程序代码段选择子(dx)
30 pushad
31 push ds
32 push es
33
34 mov ebp,esp
35
36 mov esi,[ebp+15*4]
37 movzx eax,word[ebp+14*4]
38 mov ebx,[ebp+13*4]
39 movzx edx,word[ebp+12*4]
40
41 arpl ax,dx
42 mov ds,ax
43
44 mov dx,0x1f2
45 mov al,0x01 ;读一个扇区
46 out dx,al
47
48 inc edx ;0-7位
49 mov eax,esi
50 out dx,al
51
52 inc edx ;8-15位
53 mov al,ah
54 out dx,al
55
56 inc edx ;16-23位
57 shr eax,16
58 out dx,al
59
60 inc edx ;24-28位，主硬盘，LBA模式
61 mov al,ah
62 and al,0x0f
63 or al,0xe0
64 out dx,al
65
66 inc edx
67 mov al,0x20
68 out dx,al
69
70 _wait:
71 in al,dx
72 and al,0x88
73 cmp al,0x08
74 jne _wait
75
76 mov dx,0x1f0
77 mov ecx,256
78
79 _read:
80 in ax,dx
81 mov [ebx],ax
82 add ebx,2
83 loop _read
84
85 pop es
86 pop ds
87 popad
88 retf 16 ;4个数据
89 ;----------------------------------------------------------------
90 put_string: ;ebx：偏移地址
91 pushad
92 push ds
93 push es
94
95 _print:
96 mov cl,[ebx]
97 cmp cl,0
98 je _exit
99 call put_char
100 inc ebx
101 jmp _print
102 _exit:
103 pop es
104 pop ds
105 popad
106 retf ;段间返回
107 ;--------------------------------------------------------------
108 put_char: ;cl就是要显示的字符
109 push ebx
110 push es
111 push ds
112
113 mov dx,0x3d4
114 mov al,0x0e ;高8位
115 out dx,al
116 mov dx,0x3d5
117 in al,dx
118 mov ah,al ;先把高8位存起来
119 mov dx,0x3d4
120 mov al,0x0f ;低8位
121 out dx,al
122 mov dx,0x3d5
123 in al,dx ;现在ax就是当前光标的位置
124
125 _judge:
126 cmp cl,0x0a
127 je _set_0x0a
128 cmp cl,0x0d
129 je _set_0x0d
130 _print_visible:
131 mov bx,ax
132 mov eax,Print_Segement
133 mov es,eax
134 shl bx,1 ;注意这里一定要把ebx变成原来的两倍，实际位置是光标位置的两倍
135 mov [es:bx],cl ;注意这里是屏幕！
136 mov byte[es:bx+1],0x07
137 add bx,2
138 shr bx,1
139 jmp _roll_screen
140 _set_0x0d: ;回车
141 mov bl,80
142 div bl
143 mul bl
144 mov bx,ax
145 jmp _set_cursor
146 _set_0x0a: ;换行
147 mov bx,ax
148 add bx,80
149 jmp _roll_screen
150 _roll_screen:
151 cmp bx,2000
152 jl _set_cursor
153 mov eax,Print_Segement
154 mov ds,eax
155 mov es,eax
156
157 cld
158 mov edi,0x00
159 mov esi,0xa0
160 mov ecx,1920
161 rep movsw
162 _cls:
163 mov bx,3840
164 mov ecx,80
165 _print_blank:
166 mov word[es:bx],0x0720
167 add bx,2
168 loop _print_blank
169 mov bx,1920 ;别总是忘了光标的位置！
170 _set_cursor: ;改变后的光标位置在bx上
171 mov dx,0x3d4
172 mov al,0x0f ;低8位
173 out dx,al
174
175 mov al,bl
176 mov dx,0x3d5
177 out dx,al
178
179 mov dx,0x3d4
180 mov al,0x0e ;高8位
181 out dx,al
182
183 mov al,bh
184 mov dx,0x3d5
185 out dx,al
186
187 pop ds
188 pop es
189 pop ebx
190 ret
191 ;----------------------------------------------------------------
192 allocate_memory: ;简易内存分配策略
193 ;输入ecx：想要分配的总字节数
194 ;输出ecx：分配的线性基地址
195 push ds
196 push eax
197 push ebx
198 call Cal_User_Mem
199
200 mov eax,Core_Data_Segement
201 mov ds,eax
202 mov eax,[ram_alloc]
203 mov edx,eax ;edx暂存一下eax
204 add eax,ecx
205
206 cmp eax,edx ;发现新分配的现地址比原来的还小，说明已经溢出
207 jge _alloc
208 mov ebx,mem_alloc_fail
209 call Sys_Routine_Segement:put_string
210 mov ecx,0 ;分配为0说明已经分配失败
211 jmp _exit1
212 _alloc:
213
214 mov ebx,eax
215 and ebx,0xfffffffc
216 add ebx,4 ;强行向上取整
217 test eax,0x00000003
218 cmovnz eax,ebx
219 mov ecx,[ram_alloc] ;要返回要分配的初始地址
220 mov [ram_alloc],eax ;下一次分配的线性基地址
221
222 _exit1:
223 pop ebx
224 pop eax
225 pop ds
226
227 retf
228 ;----------------------------------------------------------------
229 recycled_memory_and_gdt:
230 mov eax,[ram_recycled]
231 sub [ram_alloc],eax
232 mov dword[ram_recycled],0 ;因为我们还没学到多任务，先这样简单地清零
233
234 sgdt [pgdt_base_tmp]
235 sub word[pgdt_base_tmp],16 ;应用程序的LDT，TSS
236 lgdt [pgdt_base_tmp] ;重新加载内核
237 retf
238 ;----------------------------------------------------------------
239 Cal_User_Mem: ;输入ecx：应用程序用到的内存（字节）
240 add [ram_recycled],ecx
241 ret
242 ;----------------------------------------------------------------
243 PrintDword: ;显示edx内容的一个调试函数
244 pushad
245 push ds
246
247 mov eax,Core_Data_Segement
248 mov ds,eax
249
250 mov ebx,bin_hex
251 mov ecx,8
252
253 _query:
254 rol edx,4
255 mov eax,edx
256 and eax,0x0000000f
257 xlat
258
259 push ecx
260 mov cl,al
261 call put_char
262 pop ecx
263
264 loop _query
265
266 pop ds
267 popad
268
269 retf
270 ;----------------------------------------------------------------
271 Make_Seg_Descriptor: ;构造段描述符
272 ;输入：
273 ;eax:线性基地址
274 ;ebx:段界限
275 ;ecx:属性
276 ;输出：
277 ;eax:段描述符低32位
278 ;edx:段描述符高32位
279 mov edx,eax
280 and edx,0xffff0000
281 rol edx,8
282 bswap edx
283 or edx,ecx
284
285 shl eax,16
286 or ax,bx
287 and ebx,0x000f0000
288 or edx,ebx
289 retf
290 ;----------------------------------------------------------------
291 Make_Gate_Descriptor: ;构造门描述符
292 ;输入：
293 ;eax:段内偏移地址
294 ;bx: 段的选择子
295 ;cx: 段的属性
296 ;输出：
297 ;eax:门描述符低32位
298 ;edx:门描述符高32位
299 push ebx
300 push ecx
301
302 mov edx,eax
303 and edx,0xffff0000 ;要高16位
304 or dx,cx
305
306 shl ebx,16
307 and eax,0x0000ffff
308 or eax,ebx
309
310 pop ecx
311 pop ebx
312
313 retf
314 ;----------------------------------------------------------------
315 Set_New_GDT: ;装载新的全局描述符
316 ;输入：edx:eax描述符
317 ;输出：cx选择子
318 push ds
319 push es
320
321 mov ebx,Core_Data_Segement
322 mov ds,ebx
323
324 mov ebx,All_4GB_Segment
325 mov es,ebx
326
327 sgdt [pgdt_base_tmp]
328
329 movzx ebx,word[pgdt_base_tmp]
330 inc bx ;注意这里要一定是inc bx而不是inc ebx，因为gdt段界限初始化是0xffff的
331 ;要用到回绕特性
332 add ebx,[pgdt_base_tmp+0x02] ;得到pgdt的线性基地址
333
334 mov [es:ebx],eax
335 mov [es:ebx+0x04],edx ;装载新的gdt符
336 ;装载描述符要装载到实际位置上
337
338 add word[pgdt_base_tmp],8 ;给gdt的段界限加上8（字节）
339
340 lgdt [pgdt_base_tmp] ;加载gdt到gdtr的位置和实际表的位置无关
341
342 mov ax,[pgdt_base_tmp] ;得到段界限
343 xor dx,dx
344 mov bx,8 ;得到gdt大小
345 div bx
346 mov cx,ax
347 shl cx,3 ;得到选择子,ti=0（全局描述符），rpl=0（申请特权0级）
348
349 pop es
350 pop ds
351 retf
352 ;----------------------------------------------------------------
353 Set_New_LDT_To_TCB: ;装载新的局部描述符
354 ;输入：edx:eax描述符
355 ; : ebx:TCB线性基地址
356 ;输出：cx选择子
357
358 push edi
359 push eax
360 push ebx
361 push edx
362 push ds
363
364 mov ecx,All_4GB_Segment
365 mov ds,ecx
366
367 mov edi,[ebx+0x0c] ;LDT的线性基地址
368 movzx ecx,word[ebx+0x0a]
369 inc cx ;得到实际的LDT的大小（界限还要-1）
370
371 mov [edi+ecx+0x00],eax
372 mov [edi+ecx+0x04],edx
373
374 add cx,8
375 dec cx
376
377 mov [ebx+0x0a],cx
378
379 mov ax,cx
380 xor dx,dx
381 mov cx,8
382 div cx
383
384 shl ax,3
385 mov cx,ax
386 or cx,0x0004 ;LDT，第三位TI位一定是1
387
388 pop ds
389 pop edx
390 pop ebx
391 pop eax
392 pop edi
393 retf
394 ;=========================================================================
395 ;===========================内核数据区====================================
396 ;=========================================================================
397 SECTION Core_Data align=16 vstart=0
398 ;-------------------------------------------------------------------------------
399 pgdt_base_tmp: dw 0 ;这一章的用户程序都是从GDT中加载的
400 dd 0
401
402 ram_alloc: dd 0x00100000 ;下次分配内存时的起始地址（直接暴力从0x00100000开始分配了）
403 ram_recycled dd 0 ;这里储存程序实际用的大小
404 salt:
405 salt_1: db '@Printf' ;@Printf函数(公用例程)
406 times 256-($-salt_1) db 0
407 dd put_string
408 dw Sys_Routine_Segement
409 dw 0 ;参数个数
410
411 salt_2: db '@ReadHarddisk' ;@ReadHarddisk函数(公用例程)
412 times 256-($-salt_2) db 0
413 dd ReadHarddisk
414 dw Sys_Routine_Segement
415 dw 4 ;参数个数
416
417 salt_3: db '@PrintDwordAsHexString' ;@PrintDwordAsHexString函数(公用例程)
418 times 256-($-salt_3) db 0
419 dd PrintDword
420 dw Sys_Routine_Segement
421 dw 0 ;参数个数
422
423 salt_4: db '@TerminateProgram' ;@TerminateProgram函数(内核例程)
424 times 256-($-salt_4) db 0
425 dd _return_point
426 dw Core_Code_Segement
427 dw 0 ;参数个数
428
429 salt_length: equ $-salt_4
430 salt_items_sum equ ($-salt)/salt_length ;得到项目总数
431
432 message_1 db ' If you seen this message,that means we '
433 db 'are now in protect mode,and the system '
434 db 'core is loaded,and the video display '
435 db 'routine works perfectly.',0x0d,0x0a,0
436
437 message_2 db ' Loading user program...',0
438
439 do_status db 'Done.',0x0d,0x0a,0
440
441 message_3 db 0x0d,0x0a,0x0d,0x0a,0x0d,0x0a
442 db ' User program terminated,control returned.'
443 db 0x0d,0x0a,0x0d,0x0a,0
444 message_4 db ' We have been backed to kernel.',0x0d,0x0a,0
445 message_5 db ' The GDT and memory have benn recycled.',0
446 message_6 db ' From the system wide gate:',0x0d,0x0a,0
447 message_7 db ' Setting the gate discriptor...',0
448 message_In_Gate db ' Hi!My name is Philip:',0x0d,0x0a,0
449
450 bin_hex db '0123456789ABCDEF'
451 ;put_hex_dword子过程用的查找表
452 core_buf times 2048 db 0 ;内核用的缓冲区（2049个字节（2MB））
453
454 esp_pointer dd 0 ;内核用来临时保存自己的栈指针
455
456 cpu_brnd0 db 0x0d,0x0a,' ',0
457 cpu_brand times 52 db 0
458 cpu_brnd1 db 0x0d,0x0a,0x0d,0x0a,0
459 mem_alloc_fail db 'The Program is too large to load'
460 core_ss dw 0
461 core_sp dd 0
462
463
464 tcb_chain dd 0 ;任务控制块链头指针
465 ;=========================================================================
466 ;===========================内核代码区====================================
467 ;=========================================================================
468 SECTION Core_Code align=16 vstart=0
469 ;---------------------------------------------------------------------
470 append_to_tcb: ;写入新的TCB链
471 ;输入：ecx新的TCB线性基地址
472 pushad
473
474 push ds
475 push es
476
477 mov eax,All_4GB_Segment
478 mov es,eax
479
480 mov eax,Core_Data_Segement
481 mov ds,eax
482
483 mov eax,[tcb_chain]
484 cmp eax,0x00
485 je _notcb
486
487 _search_tcb:
488 mov edx,[tcb_chain+0x00]
489 mov eax,[es:edx]
490 cmp eax,0x00
491 jne _search_tcb
492
493 mov [es:edx+0x00],ecx
494 jmp _out_tcb_search
495
496 _notcb:
497 mov [tcb_chain],ecx
498
499 _out_tcb_search:
500 pop es
501 pop ds
502
503 popad
504 ret
505 ;---------------------------------------------------------------------
506 load_program: ;输入push1：逻辑扇区号
507 ; push2: 线性基地址
508 pushad
509 push ds
510 push es
511
512 mov ebp,esp ;别忘了把参数传给ebp
513
514 mov eax,Core_Data_Segement
515 mov ds,eax ;切换到内核数据段
516
517 mov eax,All_4GB_Segment
518 mov es,eax
519
520 mov edi,[ebp+11*4] ;获取tcb的线性基地址，别忘了调用相对近调用还要有1个push
521
522 mov ecx,160
523 call Sys_Routine_Segement:allocate_memory
524 mov [es:edi+0x0c],ecx
525 mov word[es:edi+0x0a],0xffff ;初始化LDT界限位0xffff
526
527 mov esi,[ebp+12*4] ;esi必须是逻辑扇区号
528 mov ebx,core_buf ;ebx要在内核数据缓冲区（先读取头部在缓冲区,esi已经是有扇区号了）
529
530 push esi
531 push ds
532 push ebx
533 push cs
534 call Sys_Routine_Segement:ReadHarddisk
535
536 mov eax,[core_buf] ;读取用户程序长度
537
538 mov ebx,eax
539 and ebx,0xfffffe00 ;清空低9位（强制对齐512）
540 add ebx,512
541 test eax,0x000001ff
542 cmovnz eax,ebx ;低9位不为0则使用向上取整的结果
543
544 mov ecx,eax ;eax是整个程序的向上取整的大小
545 call Sys_Routine_Segement:allocate_memory
546 ;先分配内存给整个程序，再分配内存给栈区
547 mov ebx,ecx
548 mov [es:edi+0x06],ecx ;tcb 0x06：程序加载基地址
549
550 xor edx,edx
551 mov ecx,512 ;千万不要改掉ebx
552 div ecx
553 mov ecx,eax
554
555 mov eax,All_4GB_Segment ;切换到4GB段区域（平坦模式）
556 mov ds,eax
557
558 _loop_read:
559 push esi
560 push ds
561 push ebx
562 push cs
563 call Sys_Routine_Segement:ReadHarddisk ;esi还是User_Program_Address
564 inc esi
565 add ebx,512
566 loop _loop_read
567
568 mov esi,edi ;esi：把TCB的线性基地址
569 mov edi,[es:esi+0x06] ;程序加载的线性基地址
570
571 ;建立头部描述符
572 mov eax,edi
573 mov ebx,[edi+0x04]
574 dec ebx ;段界限
575 mov ecx,0x0040f200
576 call Sys_Routine_Segement:Make_Seg_Descriptor
577 mov ebx,esi
578 call Sys_Routine_Segement:Set_New_LDT_To_TCB
579 or cx,0x0003 ;特权级3
580 mov [es:esi+0x44],cx ;记得要登记头部的选择子
581 mov [edi+0x04],cx
582
583 ;建立代码段描述符
584 mov eax,edi
585 add eax,[edi+0x14]
586 mov ebx,[edi+0x18]
587 dec ebx
588 mov ecx,0x0040f800
589 call Sys_Routine_Segement:Make_Seg_Descriptor
590 mov ebx,esi
591 call Sys_Routine_Segement:Set_New_LDT_To_TCB
592 or cx,0x0003
593 mov [edi+0x14],cx
594
595 ;建立数据段描述符
596 mov eax,edi
597 add eax,[edi+0x1c]
598 mov ebx,[edi+0x20]
599 dec ebx
600 mov ecx,0x0040f200
601 call Sys_Routine_Segement:Make_Seg_Descriptor
602 mov ebx,esi
603 call Sys_Routine_Segement:Set_New_LDT_To_TCB
604 or cx,0x0003
605 mov [edi+0x1c],cx
606
607 ;建立栈段描述符
608 mov ecx,[edi+0x0c]
609 mov ebx,0x000fffff
610 sub ebx,ecx
611 mov eax,4096 ;4KB粒度
612 mul ecx
613 mov ecx,eax
614 call Sys_Routine_Segement:allocate_memory
615 mov eax,ecx ;eax是栈段的线性基地址
616 mov ecx,0x00c0f600
617 call Sys_Routine_Segement:Make_Seg_Descriptor
618 mov ebx,esi
619 call Sys_Routine_Segement:Set_New_LDT_To_TCB
620 or cx,0x0003
621 mov [edi+0x08],cx
622
623 ;现在开始重定位API符号表
624 ;---------------------------------------------------------------------
625 mov eax,All_4GB_Segment ;因为这个时候用户头部在LDT，而LDT还没有被加载，只能通过4GB空间访问
626 mov es,eax
627 mov eax,Core_Data_Segement
628 mov ds,eax
629
630 cld
631 mov ecx,[es:edi+0x24] ;得到用户程序符号表的条数
632 add edi,0x28 ;用户符号表的偏移地址是0x28
633
634 _loop_U_SALT:
635 push edi
636 push ecx
637
638 mov ecx,salt_items_sum
639 mov esi,salt
640
641 _loop_C_SALT:
642 push edi
643 push esi
644 push ecx
645
646 mov ecx,64 ;比较256个字节
647 repe cmpsd
648 jne _re_match ;如果成功匹配，那么esi和edi刚好会在数据区之后的
649
650 mov eax,[esi] ;偏移地址
651 mov [es:edi-256],eax ;把偏移地址填入用户程序的符号区
652 mov ax,[esi+0x04] ;段的选择子
653
654 or ax,0x0002 ;把RPL改为3，代表（内核）赋予应用程序以特权级3
655 mov [es:edi-252],ax ;把段的选择子填入用户程序的段选择区
656
657 _re_match:
658 pop ecx
659 pop esi
660 add esi,salt_length
661 pop edi
662 loop _loop_C_SALT
663
664 pop ecx
665 pop edi
666 add edi,256
667 loop _loop_U_SALT
668 ;---------------------------------------------------------------------
669
670 mov esi,[ebp+11*4] ;重新获得TCB的线性基地址
671
672 ;现在设置所有的特权级栈段，并且把特权级栈段放到TCB中（为了等一下设置TSS）
673 ;设置TSS特权0级栈段（暂存在TCB中）
674 mov ecx,Switch_Stack_Size
675 mov eax,ecx
676 mov [es:esi+0x1a],ecx
677 shr dword[es:esi+0x1a],12 ;相当于除以4096
678 call Sys_Routine_Segement:allocate_memory
679 add eax,ecx ;得到最高地址
680 mov [es:esi+0x1e],eax ;登记线性基地址
681 mov ebx,0x000fffff
682 sub ebx,[es:esi+0x1a]
683 mov ecx,0x00c09600 ;特权级0
684 call Sys_Routine_Segement:Make_Seg_Descriptor
685 mov ebx,esi
686 call Sys_Routine_Segement:Set_New_LDT_To_TCB
687 or cx,0x0000 ;RPL为0
688 mov [es:esi+0x22],cx
689 mov dword[es:esi+0x24],0
690
691 ;设置TSS特权1级栈段（暂存在TCB中）
692 mov ecx,Switch_Stack_Size
693 mov eax,ecx
694 mov [es:esi+0x28],ecx
695 shr dword[es:esi+0x28],12 ;相当于除以4096
696 call Sys_Routine_Segement:allocate_memory
697 add eax,ecx ;得到最高地址
698 mov [es:esi+0x2c],eax ;登记线性基地址
699 mov ebx,0x000fffff
700 sub ebx,[es:esi+0x28]
701 mov ecx,0x00c0b600 ;特权级1
702 call Sys_Routine_Segement:Make_Seg_Descriptor
703 mov ebx,esi
704 call Sys_Routine_Segement:Set_New_LDT_To_TCB
705 or cx,0x0001 ;RPL为1
706 mov [es:esi+0x30],cx
707 mov dword[es:esi+0x32],0
708
709 ;设置TSS特权2级栈段（暂存在TCB中）
710 mov ecx,Switch_Stack_Size
711 mov eax,ecx
712 mov [es:esi+0x36],ecx
713 shr dword[es:esi+0x36],12 ;相当于除以4096
714 call Sys_Routine_Segement:allocate_memory
715 add eax,ecx ;得到最高地址
716 mov [es:esi+0x3a],eax ;登记线性基地址
717 mov ebx,0x000fffff
718 sub ebx,[es:esi+0x36]
719 mov ecx,0x00c0d600 ;特权级2
720 call Sys_Routine_Segement:Make_Seg_Descriptor
721 mov ebx,esi
722 call Sys_Routine_Segement:Set_New_LDT_To_TCB
723 or cx,0x0002 ;RPL为2
724 mov [es:esi+0x3e],cx
725 mov dword[es:esi+0x40],0
726
727 ;在GDT中存入LDT信息
728 mov eax,[es:esi+0x0c]
729 movzx ebx,word[es:esi+0x0a]
730 mov ecx,0x00408200 ;LDT描述符，特权级0级
731 call Sys_Routine_Segement:Make_Seg_Descriptor
732 call Sys_Routine_Segement:Set_New_GDT
733 mov [es:esi+0x10],cx ;在TCB放入LDT选择子
734
735 ;在TCB中登记TSS的信息
736 mov ecx,104 ;创建一个最小尺寸的TSS
737 mov [es:esi+0x12],cx
738 dec word[es:esi+0x12] ;记得-1，要的是段界限
739 call Sys_Routine_Segement:allocate_memory
740 mov [es:esi+0x14],ecx ;TSS基地址
741
742 ;登记基本的TSS表格内容
743 mov word [es:ecx+0],0 ;反向链=0
744
745 mov edx,[es:esi+0x24] ;登记0特权级堆栈初始ESP
746 mov [es:ecx+4],edx ;到TSS中
747
748 mov dx,[es:esi+0x22] ;登记0特权级堆栈段选择子
749 mov [es:ecx+8],dx ;到TSS中
750
751 mov edx,[es:esi+0x32] ;登记1特权级堆栈初始ESP
752 mov [es:ecx+12],edx ;到TSS中
753
754 mov dx,[es:esi+0x30] ;登记1特权级堆栈段选择子
755 mov [es:ecx+16],dx ;到TSS中
756
757 mov edx,[es:esi+0x40] ;登记2特权级堆栈初始ESP
758 mov [es:ecx+20],edx ;到TSS中
759
760 mov dx,[es:esi+0x3e] ;登记2特权级堆栈段选择子
761 mov [es:ecx+24],dx ;到TSS中
762
763 mov dx,[es:esi+0x10] ;登记任务的LDT选择子
764 mov [es:ecx+96],dx ;到TSS中
765
766 mov dx,[es:esi+0x12] ;登记任务的I/O位图偏移
767 mov [es:ecx+102],dx ;到TSS中
768
769 mov word [es:ecx+100],0 ;T=0
770
771 ;在GDT中存入TSS信息
772 mov eax,[es:esi+0x14]
773 movzx ebx,word[es:esi+0x12]
774 mov ecx,0x00408900
775 call Sys_Routine_Segement:Make_Seg_Descriptor
776 call Sys_Routine_Segement:Set_New_GDT
777 mov [es:esi+0x18],cx
778
779 pop es
780 pop ds
781 popad
782 ret 8 ;相当于是stdcall，过程清栈
783 ;---------------------------------------------------------------------
784 start:
785 mov eax,Core_Data_Segement
786 mov ds,eax
787
788 mov ebx,message_1
789 call Sys_Routine_Segement:put_string
790
791 mov eax,0
792 cpuid
793 cmp eax,0x80000004 ;判断是否有0x80000002-0x80000004功能
794 jl _@load
795
796 ;显示处理器品牌信息，从80486的后期版本开始引入
797 mov eax,0x80000002
798 cpuid
799 mov [cpu_brand+0x00],eax
800 mov [cpu_brand+0x04],ebx
801 mov [cpu_brand+0x08],ecx
802 mov [cpu_brand+0x0c],edx
803
804 mov eax,0x80000003
805 cpuid
806 mov [cpu_brand+0x10],eax
807 mov [cpu_brand+0x14],ebx
808 mov [cpu_brand+0x18],ecx
809 mov [cpu_brand+0x1c],edx
810
811 mov eax,0x80000004
812 cpuid
813 mov [cpu_brand+0x20],eax
814 mov [cpu_brand+0x24],ebx
815 mov [cpu_brand+0x28],ecx
816 mov [cpu_brand+0x2c],edx
817
818 mov ebx,cpu_brnd0
819 call Sys_Routine_Segement:put_string
820 mov ebx,cpu_brand
821 call Sys_Routine_Segement:put_string
822 mov ebx,cpu_brnd1
823 call Sys_Routine_Segement:put_string
824
825 _@load:
826 mov ebx,message_7
827 call Sys_Routine_Segement:put_string
828 ;----------------------------安装门------------------------------------
829 mov edi,salt
830 mov ecx,salt_items_sum
831 _set_gate:
832 push ecx
833 mov eax,[edi+256]
834 mov bx,[edi+260] ;选择子
835 mov cx,0xec00 ;门是特权级是3的门，那么任何程序都能调用
836 or cx,[edi+262] ;加上参数个数
837
838 call Sys_Routine_Segement:Make_Gate_Descriptor
839 call Sys_Routine_Segement:Set_New_GDT
840 mov [edi+260],cx ;回填选择子
841 add edi,salt_length
842 pop ecx
843 loop _set_gate
844 ;----------------------------------------------------------------------
845 mov ebx,do_status
846 call far [salt_1+256]
847 mov ebx,message_6
848 call far [salt_1+256]
849 mov ebx,message_In_Gate
850 call far [salt_1+256] ;调用门显示字符信息(忽略偏移地址(前4字节))
851
852 mov ebx,message_4
853 call far [salt_1+256]
854 mov ebx,message_2
855 call far [salt_1+256]
856
857 ;创建TCB链：TCB不是所有内核的要求，但是必须要有记录任务的机制
858 mov ecx,0x46
859 call Sys_Routine_Segement:allocate_memory
860 call append_to_tcb
861
862 ;用栈去传数据，80386以后支持直接压一个双字，地址自己算
863 push dword User_Program_Address ;用户程序所在的逻辑地址
864 push ecx ;传入TCB线性基地址
865
866 call load_program
867 mov ebx,do_status
868 call Sys_Routine_Segement:put_string
869
870 ;下一章讲任务切换的时候再改下面
871
872 mov [core_ss],ss
873 mov [core_sp],esp
874 mov eax,All_4GB_Segment
875 mov ds,eax
876
877 ltr [ecx+0x18]
878 lldt [ecx+0x10]
879
880 mov eax,[ecx+0x44] ;用户头部选择子
881 mov ds,eax
882
883 push dword[0x08] ;栈段寄存器
884 push dword 0
885
886 push dword[0x14]
887 push dword[0x10] ;切换特权栈段
888
889 retf
890
891 _return_point:
892 pop eax
893 pop eax ;清除残存在栈段CS和EIP
894
895 mov eax,Core_Data_Segement
896 mov ds,eax
897
898 mov ss,[core_ss]
899 mov esp,[core_sp]
900 mov eax,Stack_Segement
901 mov ss,eax ;重新设置数据段和栈段
902 mov esp,[esp_pointer]
903 mov ebx,message_4
904 call Sys_Routine_Segement:put_string
905
906 call Sys_Routine_Segement:recycled_memory_and_gdt
907 mov ecx,[ram_alloc]
908
909 mov ebx,message_5
910 call Sys_Routine_Segement:put_string
911 cli
912 hlt
913 ;=========================================================================
914 SECTION core_trail
915 ;----------------------------------------------------------------
916 Program_end:
;==============================用户程序=======================================
SECTION header vstart=0
program_length dd program_end ;程序总长度#0x00
head_len dd header_end ;程序头部的长度#0x04
stack_seg dd 0 ;用于接收堆栈段选择子#0x08
stack_len dd 1 ;程序建议的堆栈大小#0x0c
;以4KB为单位
prgentry dd start ;程序入口#0x10
code_seg dd section.code.start ;代码段位置#0x14
code_len dd code_end ;代码段长度#0x18
data_seg dd section.data.start ;数据段位置#0x1c
data_len dd data_end ;数据段长度#0x20
;-------------------------------------------------------------------------------
;符号地址检索表
salt_items dd (header_end-salt)/256 ;#0x24
salt: ;#0x28
Printf: db '@Printf'
times 256-($-Printf) db 0
TerminateProgram:db '@TerminateProgram'
times 256-($-TerminateProgram) db 0
ReadHarddisk: db '@ReadHarddisk'
times 256-($-ReadHarddisk) db 0
header_end:
;===============================================================================
SECTION data align=16 vstart=0
buffer times 1024 db 0 ;缓冲区
message_1 db 0x0d,0x0a,0x0d,0x0a
db '**********User program is runing**********'
db 0x0d,0x0a,0
message_2 db ' Disk data:',0x0d,0x0a,0
data_end:
;===============================================================================
[bits 32]
;===============================================================================
SECTION code align=16 vstart=0
start:
User_Data_File equ 100 ;数据文件存放地点
mov eax,ds
mov fs,eax
mov eax,[stack_seg]
mov ss,eax
mov esp,0
mov eax,[data_seg]
mov ds,eax
mov ebx,message_1
call far [fs:Printf]
mov esi,User_Data_File
mov ebx,buffer ;缓冲区偏移地址
push esi
push ds
push ebx
push cs
call far [fs:ReadHarddisk] ;相当于调用函数
mov ebx,message_2
call far [fs:Printf]
mov ebx,buffer
call far [fs:Printf]
call far [fs:TerminateProgram] ;将控制权返回到系统
code_end:
;===============================================================================
SECTION trail
;-------------------------------------------------------------------------------
program_end: