x86架构：保护模式下利用中断实现抢占式多任务运行
站在用户角度考虑，一个合格的操作系统即使在单核下也能 "同时" 执行多个任务，这就要求CPU以非常快的频率在不同任务之间切换，让普通人根本感觉不到任务的切换。windwos和linux都有线程切换的方法，今天介绍cpu硬件自带的任务切换方案： 时钟中断 + TSS；
1、关于时钟中断，这里 https://www.cnblogs.com/theseventhson/p/13068709.html 有详细的说明。简单理解：cpu外部有专门负责根据时间间隔产生中断的芯片，每隔一定的时间就会向8259发送中断请求的信号（间隔的时间俗称时间片）。中断号是0x70，用户可以根据业务需求自定义这个中断例程要干哪些事；本实验的中断处理例程：先遍历TCB链表，找到空闲的任务，通过任务切换的方式jmp过去执行；
2、做任务切换，本质是跳转到新的代码执行，常见的跳转方式也就jmp和call；使用jmp far或者call far时，如果给出的段选择子指向的是普通的代码段，那么CPU认为是普通的跳转或是过程调用，依然是同一个任务，不会发生不同任务上下文的切换；想要触发CPU自带的任务切换机制，有下面几种方式：
（1）如果使用jmp far或者call far给出的段选择子指向的是一个TSS系统段/任务门时，CPU将进行任务切换；
（2）中断号对应的是任务门，CPU将进行任务切换；
这里扩展一下：切换任务时，CPU会将当前正在执行任务的上下文（主要是寄存器的值）保存到TSS内。待其他任务执行完，切回来时会先从TSS读取上下文的数据，这样就可以接着上次被打断的地方继续执行；而普通的函数调用是不会保存这些上下文（寄存器）数据的，在执行被调用函数的过程中可能会改变寄存器的值；所以任务切换和普通函数调用的本质区别：任务切换保存了当前上下文，普通函数调用没有。所以windos和linux都自行设计了任务切换的方案，并未采用TSS（耗时较长，intel自己在64位下已经废弃该方式）
整个过程的核心步骤和思路如下：
（1）构造平坦的段描述符，写入GDT；同时关闭中断，利用jmp刷新段寄存器的缓存
（2）加载内核代码到0x40000处；接着构造页目录表和页表，开启分页模式
（3）初始化异常和中断处理例程，单独设置0x70号时钟中断例程（遍历TCB链表，找出空闲的任务并jmp执行）
（4）针对内核API构造调用门，然后加载用户程序到内存，接入TCB链表
- load_relocate_program，加载用户程序到内存核心思路：
（1）清空页目录表低512项，刷新TLB；
（2）申请物理页，在页表中登记，加载用户程序
（3）填充TSS相关域，并写入TCB
（4）用户程序导入表需要的函数重定位
（5）重新申请物理内存，复制页目录表（windows下每个进程有4GB虚拟空间就是这么来的），刷新TLB，并将页目录线性地址写入TSS的CR3段；
- TCB任务链条构造
多任务系统中，既然要在不同的任务之间切换，那么必须记录所有任务的状态，这里模仿windows下的EPROCESS自创一个简单的结构体，详细记录任务的主要属性，结构体如下：
为方便管理多个任务，需要把这些任务首位串联起来形成链条。这里多说一句：windows下的进程结构体之间、驱动对象之间也是通过链表互相串联的，通过遍历链表可以查找每个进程、驱动对象。做外挂、病毒木马之类的想要隐藏，可以先把链表断开，在一定程度上增加了被找到的难度（当然无法完全隐藏，还是能从其他地方找到）；TCB链表示意图如下：
3、部分核心代码介绍
从0x7c00处加载，构造平坦的code、data、ss段描述符，同时关闭8259输入的硬件中断（马上就要进入保护模式了，但IDT表没建立，中断处理例程也没有，暂时无法接受外部硬件中断）：
SECTION mbr vstart=0x00007c00 mov ax,cs mov ss,ax mov sp,0x7c00 ;计算GDT所在的逻辑段地址 mov eax,[cs:pgdt+0x02] ;GDT的32位物理地址 xor edx,edx mov ebx,16 div ebx ;分解成16位逻辑地址 mov ds,eax ;令DS指向该段以进行操作 mov ebx,edx ;段内起始偏移地址 ;跳过0#号描述符的槽位 ;创建1#描述符，保护模式下的代码段描述符 mov dword [ebx+0x08],0x0000ffff ;基地址为0，界限0xFFFFF，DPL=00 mov dword [ebx+0x0c],0x00cf9800 ;4KB粒度，代码段描述符，向上扩展 ;创建2#描述符，保护模式下的数据段和堆栈段描述符 mov dword [ebx+0x10],0x0000ffff ;基地址为0，界限0xFFFFF，DPL=00 mov dword [ebx+0x14],0x00cf9200 ;4KB粒度，数据段描述符，向上扩展 ;初始化描述符表寄存器GDTR mov word [cs: pgdt],23 ;描述符表的界限 lgdt [cs: pgdt] in al,0x92 ;南桥芯片内的端口 or al,0000_0010B out 0x92,al ;打开A20 cli ;中断机制尚未工作；马上要进入保护模式了，但此时IDT还未建立，中断处理例程也没有，所以先关闭外部的8259传过来的硬件中断 mov eax,cr0 or eax,1 mov cr0,eax ;设置PE位 ;以下进入保护模式... ... jmp dword 0x0008:flush ;16位的描述符选择子：32位偏移
初始化页目录表和页表，关键代码如下：
pge: ;准备打开分页机制。从此，再也不用在段之间转来转去，实在晕乎~ ;创建系统内核的页目录表PDT mov ebx,0x00020000 ;页目录表PDT的物理地址 ;在页目录内创建指向页目录表自己的目录项 mov dword [ebx+4092],0x00020003 mov edx,0x00021003 ;MBR空间有限，后面尽量不使用立即数 ;在页目录内创建与线性地址0x00000000对应的目录项 mov [ebx+0x000],edx ;写入目录项（页表的物理地址和属性） ;此目录项仅用于过渡。 ;在页目录内创建与线性地址0x80000000对应的目录项 mov [ebx+0x800],edx ;写入目录项（页表的物理地址和属性） ;创建与上面那个目录项相对应的页表，初始化页表项 mov ebx,0x00021000 ;页表的物理地址 xor eax,eax ;起始页的物理地址 xor esi,esi .b1: mov edx,eax or edx,0x00000003 mov [ebx+esi*4],edx ;登记页的物理地址 add eax,0x1000 ;下一个相邻页的物理地址 inc esi cmp esi,256 ;仅低端1MB内存对应的页才是有效的 jl .b1
页目录表和页表初始化后展示如下：
未开启分页前，GDT表的物理基址是0x8000；开启分页后，需要找个线性地址映射到该物理地址；由于GDT在操作系统内核，那么线性地址理应从0x80000000开始。为了让低1MB地址在分页前后保持一致，可直接在物理地址加上0x80000000，如下：
;将GDT的线性地址映射到从0x80000000开始的相同位置 sgdt [pgdt] mov ebx,[pgdt+2] ;取出GDT的线性地址 add dword [pgdt+2],0x80000000 ;GDTR也用的是线性地址。物理地址初始化是0x8000，这里线性地址变成了0x80008000，按照10-10-12拆分后分别的偏移为0x800、0x20和000，在现有的分页基址下映射的物理地址是0x8000,和分页前的物理地址一样，这就体现了页目录表和页表设计的巧妙性； lgdt [pgdt]
GDT的物理地址是0x8000，加上0x80000000后新的线性地址是：0x80008000，经过分页转换后的物理地址还是0x8000，这就体现了页目录表和页表设计的巧妙：页目录表0x20800项是0x21003，可以直接将0x80000000的线性地址映射到页表；0x008刚好是页表内偏移，每个偏移单元依次新增0x1000的物理地址，那么0x008的物理地址就是0x8000，刚好等于原GDT物理地址；总结一下，以上页目录表和页表设计的巧妙用途：
- 0x80000000~0x800FFFFF线性地址转换成的物理地址还是0~0xFFFFF;
- 0xFFFFF???会被映射到页目录表的???项，可以方便的修改页目录表。比如0xFFFFF100的线性地址，会映射到0x20100的物理地址，这刚好是页目录表的某一项。如果要修改这一项的对应的页表项，比如改成0x2100C，直接mov [0xFFFFF100], 0x2100C
- alloc_inst_a_page函数分配物理页，并挂载到页表：需要挂载物理页的线性地址，（1）高10位（22~31位）右移10位到12~21位，然后把高10位置1. 此时中间这10位会被用来作为页目录表的偏移 （2）原中间10位（12~21）右移10位到低2~11位，这10位经过转换后会被作为页表内的偏移；
时钟中断设置，本实验的核心之一：
- 这里设置边沿触发，只要电平变化达到一定的幅度立即触发中断；
- 禁止周期性中断，开放更新结束后中断：RTC芯片每次跟新CMOS芯片后会发出该中断；感兴趣的读者可以重新设置中断类型，对比看看实验的效果
;设置8259A中断控制器 mov al,0x11 out 0x20,al ;ICW1：边沿触发/级联方式 mov al,0x20 out 0x21,al ;ICW2:起始中断向量 mov al,0x04 out 0x21,al ;ICW3:从片级联到IR2 mov al,0x01 out 0x21,al ;ICW4:非总线缓冲，全嵌套，正常EOI mov al,0x11 out 0xa0,al ;ICW1：边沿触发/级联方式 mov al,0x70 out 0xa1,al ;ICW2:起始中断向量 mov al,0x04 out 0xa1,al ;ICW3:从片级联到IR2 mov al,0x01 out 0xa1,al ;ICW4:非总线缓冲，全嵌套，正常EOI ;设置和时钟中断相关的硬件 mov al,0x0b ;RTC寄存器B or al,0x80 ;阻断NMI out 0x70,al mov al,0x12 ;设置寄存器B，禁止周期性中断，开放更新结束后中断 out 0x71,al ;BCD码，24小时制 in al,0xa1 ;读8259从片的IMR寄存器 and al,0xfe ;清除bit 0(此位连接RTC) out 0xa1,al ;写回此寄存器 ;mov al,0xfe ;只留从片IR0，只保留时钟中断 ;out 0xa1,al ;mov ax,0xfb ;out 0x21,al mov al,0x0c out 0x70,al in al,0x71 ;读RTC寄存器C，复位未决的中断状态 sti ;开放硬件中断
4、整个物理内存分布如下：
最终的运行效果，可以看出任务在A、B、系统3者之间互相切换：
附上需要用的命令如下：
nasm -f bin c17_mbr.asm -o c17_mbr.bin
nasm c17_mbr.asm -l c17_mbr.lst
nasm -f bin c17_core.asm -o c17_core.bin
nasm c17_core.asm -l c17_core.lst
nasm -f bin c17-1.asm -o c17-1.bin
nasm c17-1.asm -l c17-1.lst
nasm -f bin c17-2.asm -o c17-2.bin
nasm c17-2.asm -l c17-2.lst
dd.exe if=c17_mbr.bin of=a.img bs=512
dd.exe if=c17_core.bin of=a.img seek=1
dd.exe if=c17-1.bin of=a.img seek=50
dd.exe if=c17-2.bin of=a.img seek=100
建议做成一个bat文件，双击运行就能把bin写入img对应的区域，不用手动在cmd下逐条执行了，方便快捷；
5、中断和时钟的一些要点总结：
MBR引导程序：
core_base_address equ 0x00040000 ;常数，内核加载的起始内存地址 core_start_sector equ 0x00000001 ;常数，内核的起始逻辑扇区号 ;=============================================================================== SECTION mbr vstart=0x00007c00 mov ax,cs mov ss,ax mov sp,0x7c00 ;计算GDT所在的逻辑段地址 mov eax,[cs:pgdt+0x02] ;GDT的32位物理地址 xor edx,edx mov ebx,16 div ebx ;分解成16位逻辑地址 mov ds,eax ;令DS指向该段以进行操作 mov ebx,edx ;段内起始偏移地址 ;跳过0#号描述符的槽位 ;创建1#描述符，保护模式下的代码段描述符 mov dword [ebx+0x08],0x0000ffff ;基地址为0，界限0xFFFFF，DPL=00 mov dword [ebx+0x0c],0x00cf9800 ;4KB粒度，代码段描述符，向上扩展 ;创建2#描述符，保护模式下的数据段和堆栈段描述符 mov dword [ebx+0x10],0x0000ffff ;基地址为0，界限0xFFFFF，DPL=00 mov dword [ebx+0x14],0x00cf9200 ;4KB粒度，数据段描述符，向上扩展 ;初始化描述符表寄存器GDTR mov word [cs: pgdt],23 ;描述符表的界限 lgdt [cs: pgdt] in al,0x92 ;南桥芯片内的端口 or al,0000_0010B out 0x92,al ;打开A20 cli ;中断机制尚未工作；马上要进入保护模式了，但此时IDT还未建立，中断处理例程也没有，所以先关闭外部的8259传过来的硬件中断 mov eax,cr0 or eax,1 mov cr0,eax ;设置PE位 ;以下进入保护模式... ... jmp dword 0x0008:flush ;16位的描述符选择子：32位偏移 ;清流水线并串行化处理器 [bits 32] flush: mov eax,0x00010 ;加载数据段(4GB)选择子 mov ds,eax mov es,eax mov fs,eax mov gs,eax mov ss,eax ;加载堆栈段(4GB)选择子 mov esp,0x7000 ;堆栈指针 ;以下加载系统核心程序 mov edi,core_base_address mov eax,core_start_sector mov ebx,edi ;起始地址 call read_hard_disk_0 ;以下读取程序的起始部分（一个扇区） ;以下判断整个程序有多大 mov eax,[edi] ;核心程序尺寸 xor edx,edx mov ecx,512 ;512字节每扇区 div ecx or edx,edx jnz @1 ;未除尽，因此结果比实际扇区数少1 dec eax ;已经读了一个扇区，扇区总数减1 @1: or eax,eax ;考虑实际长度≤512个字节的情况 jz pge ;EAX=0 ? ;读取剩余的扇区 mov ecx,eax ;32位模式下的LOOP使用ECX mov eax,core_start_sector inc eax ;从下一个逻辑扇区接着读 @2: call read_hard_disk_0 inc eax loop @2 ;循环读，直到读完整个内核; 内核加载到内存后才开始分页； pge: ;准备打开分页机制。从此，再也不用在段之间转来转去，实在晕乎~ ;创建系统内核的页目录表PDT mov ebx,0x00020000 ;页目录表PDT的物理地址 ;在页目录内创建指向页目录表自己的目录项 mov dword [ebx+4092],0x00020003 mov edx,0x00021003 ;MBR空间有限，后面尽量不使用立即数 ;在页目录内创建与线性地址0x00000000对应的目录项 mov [ebx+0x000],edx ;写入目录项（页表的物理地址和属性） ;此目录项仅用于过渡。 ;在页目录内创建与线性地址0x80000000对应的目录项 mov [ebx+0x800],edx ;写入目录项（页表的物理地址和属性） ;创建与上面那个目录项相对应的页表，初始化页表项 mov ebx,0x00021000 ;页表的物理地址 xor eax,eax ;起始页的物理地址 xor esi,esi .b1: mov edx,eax or edx,0x00000003 mov [ebx+esi*4],edx ;登记页的物理地址 add eax,0x1000 ;下一个相邻页的物理地址 inc esi cmp esi,256 ;仅低端1MB内存对应的页才是有效的 jl .b1 ;令CR3寄存器指向页目录，并正式开启页功能 mov eax,0x00020000 ;PCD=PWT=0 mov cr3,eax ;将GDT的线性地址映射到从0x80000000开始的相同位置 sgdt [pgdt] mov ebx,[pgdt+2] ;取出GDT的线性地址 add dword [pgdt+2],0x80000000 ;GDTR也用的是线性地址。物理地址初始化是0x8000，这里线性地址变成了0x80008000，按照10-10-12拆分后分别的偏移为0x800、0x20和000，在现有的分页基址下映射的物理地址是0x8000,和分页前的物理地址一样，这就体现了页目录表和页表设计的巧妙性； lgdt [pgdt] mov eax,cr0 or eax,0x80000000 mov cr0,eax ;开启分页机制 ;将堆栈映射到高端，这是非常容易被忽略的一件事。应当把内核的所有东西 ;都移到高端，否则，一定会和正在加载的用户任务局部空间里的内容冲突， ;而且很难想到问题会出在这里。 add esp,0x80000000 jmp [0x80040004] ;（1）这里是jmp，不是jmp far，所以只取[0x80040004]处4个字节作为偏移，不会再读2个字节作为选择子；现在都平坦模式了，不用跨段转移，不需要far；（2）处理器执行转移到虚拟内存高端运行 ;------------------------------------------------------------------------------- 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 ret ;------------------------------------------------------------------------------- pgdt dw 0 ;GTD的limit dd 0x00008000 ;GDT的物理/线性地址 ;------------------------------------------------------------------------------- times 510-($-$$) db 0 db 0x55,0xaa
内核程序
;以下定义常量 flat_4gb_code_seg_sel equ 0x0008 ;平坦模型下的4GB代码段选择子 flat_4gb_data_seg_sel equ 0x0018 ;平坦模型下的4GB数据段选择子 idt_linear_address equ 0x8001f000 ;中断描述符表的线性基地址,映射的物理地址是0x1f000 ;------------------------------------------------------------------------------- ;以下定义宏 %macro alloc_core_linear 0 ;在内核空间中分配虚拟内存 mov ebx,[core_tcb+0x06] add dword [core_tcb+0x06],0x1000 ;分配空间后记得加上0x1000,由于是宏，可以被自动替换，避免人为忘记增加导致逻辑错误 call flat_4gb_code_seg_sel:alloc_inst_a_page %endmacro ;------------------------------------------------------------------------------- %macro alloc_user_linear 0 ;在任务空间中分配虚拟内存 mov ebx,[esi+0x06] add dword [esi+0x06],0x1000 call flat_4gb_code_seg_sel:alloc_inst_a_page %endmacro ;=============================================================================== SECTION core vstart=0x80040000 ;以下是系统核心的头部，用于加载核心程序 core_length dd core_end ;核心程序总长度#00 core_entry dd start ;核心代码段入口点#04 ;------------------------------------------------------------------------------- [bits 32] ;------------------------------------------------------------------------------- ;字符串显示例程（适用于平坦内存模型） put_string: ;显示0终止的字符串并移动光标 ;输入：EBX=字符串的线性地址 push ebx push ecx cli ;硬件操作期间，关中断，避免打印被切换，导致打印内容混乱 .getc: mov cl,[ebx] or cl,cl ;检测串结束标志（0） jz .exit ;显示完毕，返回 call put_char inc ebx jmp .getc .exit: sti ;硬件操作完毕，开放中断 pop ecx pop ebx ;整个方法被包装成调用门，方便在用户任务内调用；属于远过程调用，用retf返回 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位数 and ebx,0x0000ffff ;准备使用32位寻址方式访问显存 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: ;正常显示字符 shl bx,1 mov [0x800b8000+ebx],cl ;在光标位置处显示字符 ;以下将光标位置推进一个字符 shr bx,1 inc bx .roll_screen: cmp bx,2000 ;光标超出屏幕？滚屏 jl .set_cursor cld mov esi,0x800b80a0 ;小心！32位模式下movsb/w/d mov edi,0x800b8000 ;使用的是esi/edi/ecx mov ecx,1920 rep movsd mov bx,3840 ;清除屏幕最底一行 mov ecx,80 ;32位程序应该使用ECX .cls: mov word [0x800b8000+ebx],0x0720 add bx,2 loop .cls 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=逻辑扇区号 ;EBX=目标缓冲区线性地址 ;返回：EBX=EBX+512 cli ;也关闭中断，防止读硬盘数据的时候被打断，甚至被改读数据的参数 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 sti retf ;远返回 ;------------------------------------------------------------------------------- ;汇编语言程序是极难一次成功，而且调试非常困难。这个例程可以提供帮助 put_hex_dword: ;在当前光标处以十六进制形式显示 ;一个双字并推进光标 ;输入：EDX=要转换并显示的数字 ;输出：无 pushad 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 popad retf ;------------------------------------------------------------------------------- set_up_gdt_descriptor: ;在GDT内安装一个新的描述符 ;输入：EDX:EAX=描述符 ;输出：CX=描述符的选择子 push eax push ebx push edx sgdt [pgdt] ;取得GDTR的界限和线性地址 movzx ebx,word [pgdt] ;GDT界限 inc bx ;GDT总字节数，也是下一个描述符偏移 add ebx,[pgdt+2] ;下一个描述符的线性地址 mov [ebx],eax mov [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 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 ;------------------------------------------------------------------------------- allocate_a_4k_page: ;分配一个4KB的页 ;输入：无 ;输出：EAX=页的物理地址 push ebx push ecx push edx xor eax,eax .b1: bts [page_bit_map],eax jnc .b2 inc eax cmp eax,page_map_len*8 jl .b1 mov ebx,message_3 call flat_4gb_code_seg_sel:put_string hlt ;没有可以分配的页，停机 .b2: shl eax,12 ;乘以4096（0x1000） pop edx pop ecx pop ebx ret ;------------------------------------------------------------------------------- alloc_inst_a_page: ;分配一个页，并安装在当前活动的 ;层级分页结构中 ;输入：EBX=页的线性地址 push eax push ebx push esi ;检查该线性地址所对应的页表是否存在 mov esi,ebx and esi,0xffc00000 shr esi,20 ;得到页目录索引，并乘以4 or esi,0xfffff000 ;页目录自身的线性地址+表内偏移 test dword [esi],0x00000001 ;P位是否为“1”。检查该线性地址是 jnz .b1 ;否已经有对应的页表 ;创建该线性地址所对应的页表 call allocate_a_4k_page ;分配一个页做为页表 or eax,0x00000007 mov [esi],eax ;在页目录中登记该页表 .b1: ;开始访问该线性地址所对应的页表 mov esi,ebx shr esi,10 and esi,0x003ff000 ;或者0xfffff000，因高10位是零 or esi,0xffc00000 ;得到该页表的线性地址 ;得到该线性地址在页表内的对应条目（页表项） and ebx,0x003ff000 shr ebx,10 ;相当于右移12位，再乘以4 or esi,ebx ;页表项的线性地址 call allocate_a_4k_page ;分配一个页，这才是要安装的页 or eax,0x00000007 mov [esi],eax pop esi pop ebx pop eax retf ;------------------------------------------------------------------------------- create_copy_cur_pdir: ;创建新页目录，并复制当前页目录内容 ;输入：无 ;输出：EAX=新页目录的物理地址 push esi push edi push ebx push ecx call allocate_a_4k_page mov ebx,eax or ebx,0x00000007 mov [0xfffffff8],ebx ;新找到的物理页放在页目录表的FF8偏移处，也就是倒数第二项 invlpg [0xfffffff8] ;刷新TLB，否则页目录表的FF8还是0，不会是刚才申请的物理页地址 mov esi,0xfffff000 ;ESI->当前页目录的线性地址 mov edi,0xffffe000 ;EDI->新页目录的线性地址 mov ecx,1024 ;ECX=要复制的目录项数 cld repe movsd pop ecx pop ebx pop edi pop esi retf ;------------------------------------------------------------------------------- general_interrupt_handler: ;通用的中断处理过程 push eax mov al,0x20 ;中断结束命令EOI out 0xa0,al ;向从片发送 out 0x20,al ;向主片发送 pop eax iretd ;------------------------------------------------------------------------------- general_exception_handler: ;通用的异常处理过程 mov ebx,excep_msg ;就打印一句话，然后停机，等待中断唤醒 call flat_4gb_code_seg_sel:put_string hlt ;连返回都没有，因为无法判断是否有errorcode；如果确认没有，可以直接iretd； ;------------------------------------------------------------------------------- rtm_0x70_interrupt_handle: ;实时时钟中断处理过程 pushad mov al,0x20 ;CPU告诉8259中断已结束,否则8259不会继续向CPU发送中断请求 out 0xa0,al ;向8259A从片发送 out 0x20,al ;向8259A主片发送 mov al,0x0c ;寄存器C的索引。且开放NMI out 0x70,al in al,0x71 ;读一下RTC的寄存器C，否则只发生一次中断 ;此处不考虑闹钟和周期性中断的情况 ;找当前任务（状态为忙的任务）在链表中的位置 mov eax,tcb_chain .b0: ;EAX=链表头或当前TCB线性地址 mov ebx,[eax] ;EBX=下一个TCB线性地址 or ebx,ebx jz .irtn ;链表为空，或已到末尾，从中断返回 cmp word [ebx+0x04],0xffff ;是忙任务（当前任务）？ je .b1 mov eax,ebx ;定位到下一个TCB（的线性地址） jmp .b0 ;将当前为忙的任务移到链尾 .b1: mov ecx,[ebx] ;下游TCB的线性地址 mov [eax],ecx ;将当前任务从链中拆除 .b2: ;此时，EBX=当前任务的线性地址 mov edx,[eax] or edx,edx ;已到链表尾端？ jz .b3 mov eax,edx jmp .b2 .b3: mov [eax],ebx ;将忙任务的TCB挂在链表尾端 mov dword [ebx],0x00000000 ;将忙任务的TCB标记为链尾 ;从链首搜索第一个空闲任务 mov eax,tcb_chain .b4: mov eax,[eax] or eax,eax ;已到链尾（未发现空闲任务） jz .irtn ;未发现空闲任务，从中断返回 cmp word [eax+0x04],0x0000 ;是空闲任务？ jnz .b4 ;将空闲任务和当前任务的状态都取反 not word [eax+0x04] ;设置空闲任务的状态为忙 not word [ebx+0x04] ;设置当前任务（忙）的状态为空闲 jmp far [eax+0x14] ;任务转换 .irtn: popad iretd ;------------------------------------------------------------------------------- terminate_current_task: ;终止当前任务 ;注意，执行此例程时，当前任务仍在 ;运行中。此例程其实也是当前任务的 ;一部分 ;找当前任务（状态为忙的任务）在链表中的位置 mov eax,tcb_chain .b0: ;EAX=链表头或当前TCB线性地址 mov ebx,[eax] ;EBX=下一个TCB线性地址 cmp word [ebx+0x04],0xffff ;是忙任务（当前任务）？ je .b1 mov eax,ebx ;定位到下一个TCB（的线性地址） jmp .b0 .b1: mov word [ebx+0x04],0x3333 ;修改当前任务的状态为“退出” .b2: hlt ;停机，等待程序管理器恢复运行时， ;将其回收 jmp .b2 ;------------------------------------------------------------------------------- pgdt dw 0 ;用于设置和修改GDT dd 0 pidt dw 0 dd 0 ;任务控制块链 tcb_chain dd 0 core_tcb times 32 db 0 ;内核（程序管理器）的TCB page_bit_map db 0xff,0xff,0xff,0xff,0xff,0xff,0x55,0x55 db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff db 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55 db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 page_map_len equ $-page_bit_map ;符号地址检索表 salt: salt_1 db '@PrintString' times 256-($-salt_1) db 0 dd put_string dw flat_4gb_code_seg_sel ;mov [edi+260],cx 将新生成的门描述符选择子回填 salt_2 db '@ReadDiskData' times 256-($-salt_2) db 0 dd read_hard_disk_0 dw flat_4gb_code_seg_sel salt_3 db '@PrintDwordAsHexString' times 256-($-salt_3) db 0 dd put_hex_dword dw flat_4gb_code_seg_sel salt_4 db '@TerminateProgram' times 256-($-salt_4) db 0 dd terminate_current_task dw flat_4gb_code_seg_sel salt_item_len equ $-salt_4 salt_items equ ($-salt)/salt_item_len excep_msg db '********Exception encounted********',0 message_0 db ' Working in system core with protection ' db 'and paging are all enabled.System core is mapped ' db 'to address 0x80000000.',0x0d,0x0a,0 message_1 db ' System wide CALL-GATE mounted.',0x0d,0x0a,0 message_3 db '********No more pages********',0 core_msg0 db ' System core task running!',0x0d,0x0a,0 bin_hex db '0123456789ABCDEF' ;put_hex_dword子过程用的查找表 core_buf times 512 db 0 ;内核用的缓冲区 cpu_brnd0 db 0x0d,0x0a,' ',0 cpu_brand times 52 db 0 cpu_brnd1 db 0x0d,0x0a,0x0d,0x0a,0 ;------------------------------------------------------------------------------- fill_descriptor_in_ldt: ;在LDT内安装一个新的描述符 ;输入：EDX:EAX=描述符 ; EBX=TCB基地址 ;输出：CX=描述符的选择子 push eax push edx push edi 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 edi pop edx pop eax ret ;------------------------------------------------------------------------------- load_relocate_program: ;加载并重定位用户程序 ;输入: PUSH 逻辑扇区号 ; PUSH 任务控制块基地址 ;输出：无 pushad mov ebp,esp ;为访问通过堆栈传递的参数做准备 ;清空当前页目录的前半部分（对应低2GB的局部地址空间） mov ebx,0xfffff000 xor esi,esi .b1: mov dword [ebx+esi*4],0x00000000 inc esi cmp esi,512 jl .b1 mov eax,cr3 mov cr3,eax ;清空缓存，刷新TLB ;以下开始分配内存并加载用户程序 mov eax,[ebp+40] ;从堆栈中取出用户程序起始扇区号 mov ebx,core_buf ;读取程序头部数据 call flat_4gb_code_seg_sel:read_hard_disk_0 ;以下判断整个程序有多大 mov eax,[core_buf] ;程序尺寸 mov ebx,eax and ebx,0xfffff000 ;使之4KB对齐 add ebx,0x1000 test eax,0x00000fff ;程序的大小正好是4KB的倍数吗? cmovnz eax,ebx ;不是。使用凑整的结果 mov ecx,eax shr ecx,12 ;程序占用的总4KB页数 mov eax,[ebp+40] ;起始扇区号 mov esi,[ebp+36] ;从堆栈中取得TCB的基地址 .b2: alloc_user_linear ;宏：在用户任务地址空间上分配内存 push ecx mov ecx,8 .b3: call flat_4gb_code_seg_sel:read_hard_disk_0 inc eax loop .b3 pop ecx loop .b2 ;在内核地址空间内创建用户任务的TSS alloc_core_linear ;宏：在内核的地址空间上分配内存 ;用户任务的TSS必须在全局空间上分配 mov [esi+0x14],ebx ;在TCB中填写TSS的线性地址 mov word [esi+0x12],103 ;在TCB中填写TSS的界限值 ;在用户任务的局部地址空间内创建LDT alloc_user_linear ;宏：在用户任务地址空间上分配内存 mov [esi+0x0c],ebx ;填写LDT线性地址到TCB中 ;建立程序代码段描述符 mov eax,0x00000000 mov ebx,0x000fffff mov ecx,0x00c0f800 ;4KB粒度的代码段描述符，特权级3 call flat_4gb_code_seg_sel:make_seg_descriptor mov ebx,esi ;TCB的基地址 call fill_descriptor_in_ldt or cx,0000_0000_0000_0011B ;设置选择子的特权级为3 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+76],cx ;填写TSS的CS域 ;建立程序数据段描述符 mov eax,0x00000000 mov ebx,0x000fffff mov ecx,0x00c0f200 ;4KB粒度的数据段描述符，特权级3 call flat_4gb_code_seg_sel:make_seg_descriptor mov ebx,esi ;TCB的基地址 call fill_descriptor_in_ldt or cx,0000_0000_0000_0011B ;设置选择子的特权级为3 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+84],cx ;填写TSS的DS域 mov [ebx+72],cx ;填写TSS的ES域 mov [ebx+88],cx ;填写TSS的FS域 mov [ebx+92],cx ;填写TSS的GS域 ;将数据段作为用户任务的3特权级固有堆栈 alloc_user_linear ;宏：在用户任务地址空间上分配内存 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+80],cx ;填写TSS的SS域 mov edx,[esi+0x06] ;堆栈的高端线性地址 mov [ebx+56],edx ;填写TSS的ESP域 ;在用户任务的局部地址空间内创建0特权级堆栈 alloc_user_linear ;宏：在用户任务地址空间上分配内存 mov eax,0x00000000 mov ebx,0x000fffff mov ecx,0x00c09200 ;4KB粒度的堆栈段描述符，特权级0 call flat_4gb_code_seg_sel:make_seg_descriptor mov ebx,esi ;TCB的基地址 call fill_descriptor_in_ldt or cx,0000_0000_0000_0000B ;设置选择子的特权级为0 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+8],cx ;填写TSS的SS0域 mov edx,[esi+0x06] ;堆栈的高端线性地址 mov [ebx+4],edx ;填写TSS的ESP0域 ;在用户任务的局部地址空间内创建1特权级堆栈 alloc_user_linear ;宏：在用户任务地址空间上分配内存 mov eax,0x00000000 mov ebx,0x000fffff mov ecx,0x00c0b200 ;4KB粒度的堆栈段描述符，特权级1 call flat_4gb_code_seg_sel:make_seg_descriptor mov ebx,esi ;TCB的基地址 call fill_descriptor_in_ldt or cx,0000_0000_0000_0001B ;设置选择子的特权级为1 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+16],cx ;填写TSS的SS1域 mov edx,[esi+0x06] ;堆栈的高端线性地址 mov [ebx+12],edx ;填写TSS的ESP1域 ;在用户任务的局部地址空间内创建2特权级堆栈 alloc_user_linear ;宏：在用户任务地址空间上分配内存 mov eax,0x00000000 mov ebx,0x000fffff mov ecx,0x00c0d200 ;4KB粒度的堆栈段描述符，特权级2 call flat_4gb_code_seg_sel:make_seg_descriptor mov ebx,esi ;TCB的基地址 call fill_descriptor_in_ldt or cx,0000_0000_0000_0010B ;设置选择子的特权级为2 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+24],cx ;填写TSS的SS2域 mov edx,[esi+0x06] ;堆栈的高端线性地址 mov [ebx+20],edx ;填写TSS的ESP2域 ;重定位U-SALT cld mov ecx,[0x0c] ;U-SALT条目数 mov edi,[0x08] ;U-SALT在4GB空间内的偏移 .b4: push ecx push edi mov ecx,salt_items mov esi,salt .b5: push edi push esi push ecx mov ecx,64 ;检索表中，每条目的比较次数 repe cmpsd ;每次比较4字节 jnz .b6 mov eax,[esi] ;若匹配，则esi恰好指向其后的地址 mov [edi-256],eax ;将字符串改写成偏移地址 mov ax,[esi+4] or ax,0000000000000011B ;以用户程序自己的特权级使用调用门 ;故RPL=3 mov [edi-252],ax ;回填调用门选择子 .b6: pop ecx pop esi add esi,salt_item_len pop edi ;从头比较 loop .b5 pop edi add edi,256 pop ecx loop .b4 ;在GDT中登记LDT描述符 mov esi,[ebp+36] ;从堆栈中取得TCB的基地址 mov eax,[esi+0x0c] ;LDT的起始线性地址 movzx ebx,word [esi+0x0a] ;LDT段界限 mov ecx,0x00408200 ;LDT描述符，特权级0 call flat_4gb_code_seg_sel:make_seg_descriptor call flat_4gb_code_seg_sel:set_up_gdt_descriptor mov [esi+0x10],cx ;登记LDT选择子到TCB中 mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov [ebx+96],cx ;填写TSS的LDT域 mov word [ebx+0],0 ;反向链=0 mov dx,[esi+0x12] ;段长度（界限） mov [ebx+102],dx ;填写TSS的I/O位图偏移域 mov word [ebx+100],0 ;T=0 mov eax,[0x04] ;从任务的4GB地址空间获取入口点 mov [ebx+32],eax ;填写TSS的EIP域 pushfd pop edx mov [ebx+36],edx ;填写TSS的EFLAGS域 ;在GDT中登记TSS描述符 mov eax,[esi+0x14] ;从TCB中获取TSS的起始线性地址 movzx ebx,word [esi+0x12] ;段长度（界限） mov ecx,0x00408900 ;TSS描述符，特权级0 call flat_4gb_code_seg_sel:make_seg_descriptor call flat_4gb_code_seg_sel:set_up_gdt_descriptor mov [esi+0x18],cx ;登记TSS选择子到TCB ;创建用户任务的页目录 ;注意！页的分配和使用是由页位图决定的，可以不占用线性地址空间 call flat_4gb_code_seg_sel:create_copy_cur_pdir mov ebx,[esi+0x14] ;从TCB中获取TSS的线性地址 mov dword [ebx+28],eax ;填写TSS的CR3(PDBR)域 popad ret 8 ;丢弃调用本过程前压入的参数 ;------------------------------------------------------------------------------- append_to_tcb_link: ;在TCB链上追加任务控制块；TCB块详细记录了任务的属性，相当于简化版的进程结构体 ;输入：ECX=TCB线性基地址 cli ;先关闭中断，避免在尾部追加时发生0x70中断（中断例程会遍历链表，导致任务不同步） push eax push ebx mov eax,tcb_chain .b0: ;EAX=链表头或当前TCB线性地址 mov ebx,[eax] ;EBX=下一个TCB线性地址 or ebx,ebx jz .b1 ;链表为空，或已到末尾 mov eax,ebx ;定位到下一个TCB（的线性地址） jmp .b0 .b1: mov [eax],ecx mov dword [ecx],0x00000000 ;当前TCB指针域清零，以指示这是最 ;后一个TCB pop ebx pop eax sti ret ;------------------------------------------------------------------------------- start: ;创建中断描述符表IDT ;在此之前，禁止调用put_string过程，以及任何含有sti指令的过程。 ;前20个向量是处理器异常使用的，一般情况共用一个处理例程，特殊情况再酌情单独构造 mov eax,general_exception_handler ;门代码在段内偏移地址；例程仅仅打印一句话，然后hlt停机，返回都没有； mov bx,flat_4gb_code_seg_sel ;门代码所在段的选择子 mov cx,0x8e00 ;32位中断门，0特权级 call flat_4gb_code_seg_sel:make_gate_descriptor mov ebx,idt_linear_address ;中断描述符表的线性地址 xor esi,esi .idt0: ;前20个中断处理历程都是一样的 mov [ebx+esi*8],eax mov [ebx+esi*8+4],edx inc esi cmp esi,19 ;安装前20个异常中断处理过程 jle .idt0 ;其余为保留或硬件使用的中断向量，一般情况共用一个处理例程，特殊情况再酌情单独构造 mov eax,general_interrupt_handler ;门代码在段内偏移地址；例程只是通知8259芯片中断结束，然后retf mov bx,flat_4gb_code_seg_sel ;门代码所在段的选择子 mov cx,0x8e00 ;32位中断门，0特权级 call flat_4gb_code_seg_sel:make_gate_descriptor mov ebx,idt_linear_address ;中断描述符表的线性地址 .idt1: mov [ebx+esi*8],eax ;第20~255个中断处理例程，这里都是一样的 mov [ebx+esi*8+4],edx inc esi cmp esi,255 ;安装普通的中断处理过程 jle .idt1 ;设置实时时钟中断处理过程 mov eax,rtm_0x70_interrupt_handle ;门代码在段内偏移地址 mov bx,flat_4gb_code_seg_sel ;门代码所在段的选择子 mov cx,0x8e00 ;32位中断门，0特权级 call flat_4gb_code_seg_sel:make_gate_descriptor mov ebx,idt_linear_address ;中断描述符表的线性地址 mov [ebx+0x70*8],eax ;单独设置0x70号中断例程 mov [ebx+0x70*8+4],edx ;准备开放中断 mov word [pidt],256*8-1 ;IDT的界限 mov dword [pidt+2],idt_linear_address lidt [pidt] ;加载中断描述符表寄存器IDTR ;设置8259A中断控制器 mov al,0x11 out 0x20,al ;ICW1：边沿触发/级联方式 mov al,0x20 out 0x21,al ;ICW2:起始中断向量 mov al,0x04 out 0x21,al ;ICW3:从片级联到IR2 mov al,0x01 out 0x21,al ;ICW4:非总线缓冲，全嵌套，正常EOI mov al,0x11 out 0xa0,al ;ICW1：边沿触发/级联方式 mov al,0x70 out 0xa1,al ;ICW2:起始中断向量 mov al,0x04 out 0xa1,al ;ICW3:从片级联到IR2 mov al,0x01 out 0xa1,al ;ICW4:非总线缓冲，全嵌套，正常EOI ;设置和时钟中断相关的硬件 mov al,0x0b ;RTC寄存器B or al,0x80 ;阻断NMI out 0x70,al mov al,0x12 ;设置寄存器B，禁止周期性中断，开放更 out 0x71,al ;新结束后中断，BCD码，24小时制 in al,0xa1 ;读8259从片的IMR寄存器 and al,0xfe ;清除bit 0(此位连接RTC) out 0xa1,al ;写回此寄存器 mov al,0x0c out 0x70,al in al,0x71 ;读RTC寄存器C，复位未决的中断状态 sti ;开放硬件中断 mov ebx,message_0 call flat_4gb_code_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 flat_4gb_code_seg_sel:put_string mov ebx,cpu_brand call flat_4gb_code_seg_sel:put_string mov ebx,cpu_brnd1 call flat_4gb_code_seg_sel:put_string ;以下开始安装为整个系统服务的调用门。特权级之间的控制转移必须使用门 mov edi,salt ;C-SALT表的起始位置 mov ecx,salt_items ;C-SALT表的条目数量 .b4: push ecx mov eax,[edi+256] ;该条目入口点的32位偏移地址 mov bx,[edi+260] ;该条目入口点的段选择子 mov cx,1_11_0_1100_000_00000B ;特权级3的调用门(3以上的特权级才 ;允许访问)，0个参数(因为用寄存器 ;传递参数，而没有用栈) call flat_4gb_code_seg_sel:make_gate_descriptor call flat_4gb_code_seg_sel:set_up_gdt_descriptor mov [edi+260],cx ;将返回的门描述符选择子回填 add edi,salt_item_len ;指向下一个C-SALT条目 pop ecx loop .b4 ;对门进行测试 mov ebx,message_1 call far [salt_1+256] ;通过门显示信息(偏移量将被忽略) ;初始化创建程序管理器任务的任务控制块TCB mov word [core_tcb+0x04],0xffff ;任务状态：忙碌 mov dword [core_tcb+0x06],0x80100000;0~FFFFF的物理地址已经被用完，只能从0x100000继续 ;内核虚拟空间的分配从这里开始。 mov word [core_tcb+0x0a],0xffff ;登记LDT初始的界限到TCB中（未使用） mov ecx,core_tcb call append_to_tcb_link ;将此TCB添加到TCB链中;当前只有一个任务，就算遇到0x70中断也不会切换任务 ;为程序管理器的TSS分配内存空间 alloc_core_linear ;宏：在内核的虚拟地址空间分配内存 ;在程序管理器的TSS中设置必要的项目 mov word [ebx+0],0 ;反向链=0 mov eax,cr3 mov dword [ebx+28],eax ;登记CR3(PDBR) mov word [ebx+96],0 ;没有LDT。处理器允许没有LDT的任务。 mov word [ebx+100],0 ;T=0 mov word [ebx+102],103 ;没有I/O位图。0特权级事实上不需要。 ;创建程序管理器的TSS描述符，并安装到GDT中 mov eax,ebx ;TSS的起始线性地址 mov ebx,103 ;段长度（界限） mov ecx,0x00408900 ;TSS描述符，特权级0 call flat_4gb_code_seg_sel:make_seg_descriptor call flat_4gb_code_seg_sel:set_up_gdt_descriptor mov [core_tcb+0x18],cx ;登记内核任务的TSS选择子到其TCB ;任务寄存器TR中的内容是任务存在的标志，该内容也决定了当前任务是谁。 ;下面的指令为当前正在执行的0特权级任务“程序管理器”后补手续（TSS）。 ltr cx ;现在可认为“程序管理器”任务正执行中 ;创建用户任务的任务控制块 alloc_core_linear ;宏：在内核的虚拟地址空间分配内存 mov word [ebx+0x04],0 ;任务状态：空闲 mov dword [ebx+0x06],0 ;用户任务局部空间的分配从0开始。 mov word [ebx+0x0a],0xffff ;登记LDT初始的界限到TCB中 push dword 50 ;用户程序位于逻辑50扇区 push ebx ;压入任务控制块起始线性地址 call load_relocate_program mov ecx,ebx call append_to_tcb_link ;将此TCB添加到TCB链中;任务数>=2个后会真正开始不同任务之间切换 ;创建用户任务的任务控制块 alloc_core_linear ;宏：在内核的虚拟地址空间分配内存 mov word [ebx+0x04],0 ;任务状态：空闲 mov dword [ebx+0x06],0 ;用户任务局部空间的分配从0开始。 mov word [ebx+0x0a],0xffff ;登记LDT初始的界限到TCB中 push dword 100 ;用户程序位于逻辑100扇区 push ebx ;压入任务控制块起始线性地址 call load_relocate_program mov ecx,ebx call append_to_tcb_link ;将此TCB添加到TCB链中;任务数>=2个后会真正开始不同任务之间切换 .core: mov ebx,core_msg0 ;CPU的执行重新回到内核 call flat_4gb_code_seg_sel:put_string ;这里可以编写回收已终止任务内存的代码 jmp .core core_code_end: ;------------------------------------------------------------------------------- SECTION core_trail ;------------------------------------------------------------------------------- core_end:
用户程序1：
program_length dd program_end ;程序总长度#0x00 entry_point dd start ;程序入口点#0x04 salt_position dd salt_begin ;SALT表起始偏移量#0x08 salt_items dd (salt_end-salt_begin)/256 ;SALT条目数#0x0C ;------------------------------------------------------------------------------- ;符号地址检索表 salt_begin: PrintString db '@PrintString' times 256-($-PrintString) db 0 TerminateProgram db '@TerminateProgram' times 256-($-TerminateProgram) db 0 ReadDiskData db '@ReadDiskData' times 256-($-ReadDiskData) db 0 PrintDwordAsHex db '@PrintDwordAsHexString' times 256-($-PrintDwordAsHex) db 0 salt_end: message_0 db ' User task A->;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;' db 0x0d,0x0a,0 ;------------------------------------------------------------------------------- [bits 32] ;------------------------------------------------------------------------------- start: mov ebx,message_0 call far [PrintString] jmp start call far [TerminateProgram] ;退出，并将控制权返回到核心 ;------------------------------------------------------------------------------- program_end:
用户程序2：
program_length dd program_end ;程序总长度#0x00 entry_point dd start ;程序入口点#0x04 salt_position dd salt_begin ;SALT表起始偏移量#0x08 salt_items dd (salt_end-salt_begin)/256 ;SALT条目数#0x0C ;------------------------------------------------------------------------------- ;符号地址检索表 salt_begin: PrintString db '@PrintString' times 256-($-PrintString) db 0 TerminateProgram db '@TerminateProgram' times 256-($-TerminateProgram) db 0 ReadDiskData db '@ReadDiskData' times 256-($-ReadDiskData) db 0 PrintDwordAsHex db '@PrintDwordAsHexString' times 256-($-PrintDwordAsHex) db 0 salt_end: message_0 db ' User task B->$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$' db 0x0d,0x0a,0 ;------------------------------------------------------------------------------- [bits 32] ;------------------------------------------------------------------------------- start: mov ebx,message_0 call far [PrintString] jmp start call far [TerminateProgram] ;退出，并将控制权返回到核心 ;------------------------------------------------------------------------------- program_end:
最后补充：
1、任务切换是操作系统最基本的和核心的功能之一；操作系统为了快捷、高效地管理任务切换，抽象出了进程、线程等概念！但是因为CPU硬件功能的确定性，不管操作系统怎么抽象或包装这些概念，任务切换的本质还是没变的了（操作系统层面的系统调用syscall/sysenter、软中断int切换的原理都是这样的），如下：
- 进程切换：本质就是CR3切换；CR3一旦切换，虚拟地址对应的物理地址就切换了；此时用同样的虚拟地址读取的数据已经完全不同了（可以参考：https://www.cnblogs.com/theseventhson/p/13186678.html 这里）；所以此时CPU的通用寄存器、段寄存器、EIP、ESP等需要使用新进程的值替代了（映射到内存的物理地址都不一样了）；
- 线程切换：线程是执行代码的最小单元，本质上是很多函数调用构成的；切换的时候要保存3种数据：
- 通用寄存器：不同执行单元寄存器的初始值或状态都不同，切换走了当然要保存context
- ESP：执行不同的函数调用，需要保存的传参、返回地址、局部变量也不同，所以ESP的值也不同；不同的线程需要不同的栈空间，原来的栈空间千万不能破坏！
- EIP：执行的代码都不同了，这个肯定也要指向新的代码； 注意：x86不能直接改eip的值，线程切换通常通过jmp、call、push+return等方式实现的（和hook实现的方式一样）；
