• 通过调用门尽管进入R0的例程,但是并没有进行任务切换,只是控制转换到了任务的全局区域

任务切换的方法:

1. 中断:未屏蔽情况下,任务切换随时发生,如定时器中断（准确的时间间隔发生）,强制任务实施任务切换(就我现在的理解就是进程能够执行的时间片是相同的,超过了在处理器层面上任务要切换),

实模式在是内存最低端1KB的中断向量表,保护模式不再适用,取而代之的是中断描述符表

类似GDT和LDT来保存描述符,不过保存的是门描述符: 中断门,陷阱门,任务门,

中断和陷阱门本质是控制转移

任务门本质是任务切换

2. 任务门格式:
   

主要成分:任务的TSS选择子

3. 通过中断进行任务切换的大概流程:

   中断取出任务门描述符->通过TSS选择子从GDT中取出TSS描述符->处理器将当前任务(TR指的TSS)状态保存起来->处理器访问新TSS恢复寄存器内容->最终TR指向新任务TSS

• 中断返回使用的都是iret,如何区分控制转移返回和任务切换返回?

EFLAGS

​ NT位(14Nested Task Flag)

NT=1:当前任务嵌套与其他任务中,并且通过TSS任务链接域的指针可返回到前一个任务

iret指令都要检查NT位,NT=0表一般中断过程,

• 任务门都可以安装在中断描述符表,LDT,GDT中

1. call发起的任务切换是嵌套的
2. jmp发起的任务切换不是嵌套的

任务不可重入:

执行任务切换时新任务,B不能等于1,任务不能忙

4种方法:

1. jmp/call控制转移到GDT中的TSS描述符
2. jmp/call控制转移到GDT和LDT的任务门
3. 异常和中断
4. NT=1时,iret

---

任务切换的core

         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  
terminate_current_task:
    
    pushfd 
    mov edx,[esp]
    add esp,4

    mov eax,core_data_seg_sel
    mov ds,eax 

    test dx,0100_0000_0000_0000B
    jnz .b1 
    mov ebx,core_msg1
    call sys_routine_seg_sel:put_string
    jmp far [prgman_tss]

.b1:
    mov ebx,core_msg0
    call sys_routine_seg_sel:put_string
    iretd 

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  terminate_current_task
                    dw  sys_routine_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
    
    bin_hex          db '0123456789ABCDEF'
                                    ;put_hex_dword子过程用的查找表 

    core_buf   times 2048 db 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
    ;程序管理器的任务信息 
    prgman_tss       dd  0             ;程序管理器的TSS基地址
                    dw  0             ;程序管理器的TSS描述符选择子 

    prgman_msg1      db  0x0d,0x0a
                    db  '[PROGRAM MANAGER]: Hello! I am Program Manager,'
                    db  'run at CPL=0.Now,create user task and switch '
                    db  'to it by the CALL instruction...',0x0d,0x0a,0
            
    prgman_msg2      db  0x0d,0x0a
                    db  '[PROGRAM MANAGER]: I am glad to regain control.'
                    db  'Now,create another user task and switch to '
                    db  'it by the JMP instruction...',0x0d,0x0a,0
            
    prgman_msg3      db  0x0d,0x0a
                    db  '[PROGRAM MANAGER]: I am gain control again,'
                    db  'HALT...',0

    core_msg0        db  0x0d,0x0a
                    db  '[SYSTEM CORE]: Uh...This task initiated with '
                    db  'CALL instruction or an exeception/ interrupt,'
                    db  'should use IRETD instruction to switch back...'
                    db  0x0d,0x0a,0

    core_msg1        db  0x0d,0x0a
                    db  '[SYSTEM CORE]: Uh...This task initiated with '
                    db  'JMP instruction,  should switch to Program '
                    db  'Manager directly by the JMP instruction...'
                    db  0x0d,0x0a,0
core_data_end:

SECTION core_code vstart=0

fill_descriptor_in_ldt:
    push eax 
    push edx 
    push edi
    push ds 

    mov ecx,mem_0_4_gb_seg_sel
    mov ds,ecx 

    mov edi,[ebx+0x0c]

    xor ecx,ecx 
    mov cx,[ebx+0x0a]
    inc cx 

    mov [edi+ecx+0x00],eax 
    mov [edi+ecx+0x04],edx 

    add cx,8
    dec cx 

    mov [ebx+0x0a],cx 

    mov ax,cx 
    xor dx,dx 
    mov cx,8
    div cx 

    mov cx,ax 
    shl cx,3
    or cx,0000_0000_0000_0100B

    pop ds 
    pop edi 
    pop edx 
    pop eax 

    ret 

load_relocate_program:

    pushad 

    push ds 
    push es 

    mov ebp,esp 

    mov ecx,mem_0_4_gb_seg_sel
    mov es,ecx 

    mov esi,[ebp+11*4]

    mov ecx,160
    call sys_routine_seg_sel:allocate_memory
    mov [es:esi+0x0c],ecx 
    mov word [es:esi+0x0a],0xffff

    ;加载用户程序
    mov eax,core_data_seg_sel
    mov ds,eax 

    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 word [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 word [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

    mov dword [es:ecx+28],0            ;登记CR3(PDBR)

    ;访问用户程序头部，获取数据填充TSS 
    mov ebx,[ebp+11*4]                 ;从堆栈中取得TCB的基地址
    mov edi,[es:ebx+0x06]              ;用户程序加载的基地址 

    mov edx,[es:edi+0x10]              ;登记程序入口点（EIP） 
    mov [es:ecx+32],edx                ;到TSS

    mov dx,[es:edi+0x14]               ;登记程序代码段（CS）选择子
    mov [es:ecx+76],dx                 ;到TSS中

    mov dx,[es:edi+0x08]               ;登记程序堆栈段（SS）选择子
    mov [es:ecx+80],dx                 ;到TSS中

    mov dx,[es:edi+0x04]               ;登记程序数据段（DS）选择子
    mov word [es:ecx+84],dx            ;到TSS中。注意，它指向程序头部段

    mov word [es:ecx+72],0             ;TSS中的ES=0

    mov word [es:ecx+88],0             ;TSS中的FS=0

    mov word [es:ecx+92],0             ;TSS中的GS=0

    pushfd 
    pop edx 

    mov dword [es:ecx+36],edx           ;EFLAGs

;在GDT中登记TSS描述符
    mov eax,[es:esi+0x14]
    movzx ebx,word [es:esi+0x12]
    mov ecx,0x00408900
    call sys_routine_seg_sel:make_seg_descriptor
    call sys_routine_seg_sel:set_up_gdt_descriptor
    mov [es:esi+0x18],cx 

    pop es 
    pop 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 ecx,mem_0_4_gb_seg_sel         ;令ES指向4GB数据段 
    mov es,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 
    mov ecx,salt_items

.b3:
    push ecx 
    mov eax,[edi+256]
    mov bx,[edi+260]
    mov cx,1_11_0_1100_000_00000B

    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
    pop ecx 
    loop .b3 

    mov ebx,message_2
    call far [salt_1+256]

    mov ecx,104 
    call sys_routine_seg_sel:allocate_memory
    mov [prgman_tss+0x00],ecx 

;当前任务(程序管理)的TSS中设置必要的项目
    mov word [es:ecx+96],0
    mov word [es:ecx+102],103 
    mov word [es:ecx+0],0
    mov dword [es:ecx+28],0
    mov word [es:ecx+100],0

;创建TSS描述符
    mov eax,ecx 
    mov ebx,103 
    mov ecx,0x00408900
    call sys_routine_seg_sel:make_seg_descriptor
    call sys_routine_seg_sel:set_up_gdt_descriptor
    mov [prgman_tss+0x04],cx 

    ltr cx                      ;TR指向当前任务TSS

    mov ebx,prgman_msg1
    call sys_routine_seg_sel:put_string

    mov ecx,0x46
    call sys_routine_seg_sel:allocate_memory
    call append_to_tcb_link

    push dword 50
    push ecx 

    call load_relocate_program

    call far [es:ecx+0x14]

;重新加载并且切换任务
    mov ebx,prgman_msg2
    call sys_routine_seg_sel:put_string

    mov ecx,0x46
    call sys_routine_seg_sel:allocate_memory
    call append_to_tcb_link

    push dword 50
    push ecx 

    call load_relocate_program

    jmp far [es:ecx+0x14]

    mov ebx,prgman_msg3
    call sys_routine_seg_sel:put_string

    hlt 

core_code_end:
SECTION code_trail
core_end:

用户程序:

SECTION header vstart=0
    program_length      dd program_end 

    head_len            dd header_end 

    stack_seg           dd 0
    stack_len           dd 1 
    
    prgentry            dd start 
    
    code_seg            dd section.code.start 

    code_len            dd code_end 

    data_seg            dd section.data.start 

    data_len            dd data_end 

    salt_items          dd (header_end-salt)/256
;符号地址表
    salt:
    PrintString      db  '@PrintString'
                     times 256-($-PrintString) db 0
                     
    TerminateProgram db  '@TerminateProgram'
                times 256-($-TerminateProgram) db 0
                
    ReadDiskData     db  '@ReadDiskData'
                times 256-($-ReadDiskData) db 0

header_end:

SECTION data vstart=0
    message_1        db  0x0d,0x0a
                    db  '[USER TASK]: Hi! nice to meet you,'
                    db  'I am run at CPL=',0
                    
    message_2        db  0
                    db  '.Now,I must exit...',0x0d,0x0a,0
data_end:
    [bits 32]

SECTION code vstart=0
start:
    mov eax,ds 
    mov fs,eax 

    mov eax,[data_seg]
    mov ds,eax 

    mov ebx,message_1
    call far [fs:PrintString]       ;调用门
;计算CPL
    mov ax,cs 
    and al,0000_0011B
    or al,0x0030 
    mov [message_2],al 

    mov ebx,message_2
    call far [fs:PrintString]

    call far [fs:TerminateProgram]
    
code_end:

SECTION trail 
program_end:

来源:
《X86汇编语言实模式到保护模式》