操作系统-深入特权级转移上

一、深入特权级转移上

A-初识任务状态栏(Task State Segment)

1.处理器所提供的硬件数据结构，用于实现多任务解决方案
2.TSS中保存了关键寄存器的值以及不同特权级使用的栈
TSS有三种不同的数据如下图所示

需要用到段寄存器与通用寄存器的值主要是因为多任务，任务之间需要切换，在切换时需要保存任务上下文，这里的任务上下文具体指的是段寄存器与通用寄存器的值。
3.TSS不同特权级的栈信息-在TSS中只保存了3个栈的信息
特权级0:ss0,esp0
特权级1:ss1,esp1
特权级2:ss2,esp2
4.特权级转移时栈的变化
a.低特权级-高特权级:从TSS获取高特权级目标栈段，将低特权级栈信息压入高特权级栈中(ss和esp)
b.高特权级-低特权级(retf):将低特权级栈信息从高特权级栈中取出并恢复到ss和esp
Q：TSS中为只保存3个特权级(0,1,2)的栈信息?
Intel x86架构的cpu一共有0～4四个特权级，0级最高，3级最低，硬件上在执行每条指令时都会对指令所具有的特权级做相应的检查。硬件已经提供了一套特权级使用的相关机制，软件自然要好好利用，这属于操作系统要做的事情，对于UNIX/LINUX来说，只使用了0级特权级别和3级特权级。也就是说在UNIX/LINUX系统中，一条工作在0级特权级的指令具有了CPU能提供的最高权力，而一条工作在3级特权的指令具有CPU提供的最低或者说最基本权力。
在TSS中，由高特权返回到低特权级的情况，处理器是不需要在TSS中去寻找低特权级目标栈的。其中一个原因我想您已经猜到了：TSS中只记录2、1、0特权级的栈，假如是从2特权级返回到3特权级，没有3特权级的栈进行查找。
实验
低特权级<>高特权级
1.定义32位核心代码段和数据段
2.定义32位任务代码段和数据段
3.由核心代码段跳转到任务代码段执行(高-低)
4.在任务代码段中调用高特权级代码段打印字符串

实现过程:当系统开始执行，从实模式到保护模式，特权级为0对应的时核心代码段，当此处执行完毕，返回任务代码段，此处特权级降低，当其运行到某处，需要调用系统函数，在这里特权级转移，提供调用门转移到系统函数(内核态），系统执行完毕，返回任务段。
在这里需要注意的是
1.特权级转移时发生栈的变化
2.栈的变化需要在TSS结构体中预先定义
3.TSS结构体作为一个独立段定义-描述符与选择子
4.在核心代码段加载具体的TSS结构体

实验，先从高特权级转换到低特权级(下图所示转换部分)，然后通过调用门call FuncPrintStringSelector : 0来升特权级

代码部分

%include "inc.asm"

org 0x9000

jmp ENTRY_SEGMENT

[section .gdt]
; GDT definition
GDT_ENTRY       :     Descriptor    0,            0,           0
CODE32_DESC     :     Descriptor    0,    Code32SegLen - 1,    DA_C + DA_32 + DA_DPL0
VIDEO_DESC      :     Descriptor 0xB8000,     0x07FFF,         DA_DRWA + DA_32 + DA_DPL3
DATA32_DESC     :     Descriptor    0,    Data32SegLen - 1,    DA_DR + DA_32 + DA_DPL0
STACK32_DESC    :     Descriptor    0,     TopOfStack32,       DA_DRW + DA_32 + DA_DPL0
FUNCTION_DESC   :     Descriptor    0,   FunctionSegLen - 1,   DA_C + DA_32 + DA_DPL0;操作系统所提供的函数，应用程序调用陷入内核状态执行，发生特权级转移
TASK_A_LDT_DESC :     Descriptor    0,     TaskALdtLen - 1,    DA_LDT + DA_DPL0
TSS_DESC        :     Descriptor    0,       TSSLen - 1,       DA_386TSS + DA_DPL0
; Call Gate

FUNC_PRINTSTRING_DESC    :    Gate      FunctionSelector,   PrintString,       0,         DA_386CGate + DA_DPL3

; GDT end

GdtLen    equ   $ - GDT_ENTRY

GdtPtr:
          dw   GdtLen - 1
          dd   0

; GDT Selector
Code32Selector     equ (0x0001 << 3) + SA_TIG + SA_RPL0
VideoSelector      equ (0x0002 << 3) + SA_TIG + SA_RPL3
Data32Selector     equ (0x0003 << 3) + SA_TIG + SA_RPL0
Stack32Selector    equ (0x0004 << 3) + SA_TIG + SA_RPL0
FunctionSelector   equ (0x0005 << 3) + SA_TIG + SA_RPL0
TaskALdtSelector   equ (0x0006 << 3) + SA_TIG + SA_RPL0
TSSSelector        equ (0x0007 << 3) + SA_TIG + SA_RPL0
; Gate Selector
FuncPrintStringSelector    equ   (0x0008 << 3) + SA_TIG + SA_RPL3

ion .gdt]

[section .tss];定义任务状态段tss，32位
[bits 32]
TSS_SEGMENT:
        dd    0
        dd    TopOfStack32            ; 0
        dd    Stack32Selector         ;
        dd    0                       ; 1
        dd    0                       ;
        dd    0                       ; 2
        dd    0                       ;
        times 4 * 18 dd 0
        dw    0
        dw    $ - TSS_SEGMENT + 2
        db    0xFF

TSSLen    equ    $ - TSS_SEGMENT

TopOfStack16    equ 0x7c00

[section .s16]
[bits 16]
ENTRY_SEGMENT:
    mov ax, cs
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, TopOfStack16

    ; initialize GDT for 32 bits code segment
    mov esi, CODE32_SEGMENT
    mov edi, CODE32_DESC

    call InitDescItem

    mov esi, DATA32_SEGMENT
    mov edi, DATA32_DESC

    call InitDescItem

    mov esi, STACK32_SEGMENT
    mov edi, STACK32_DESC

    call InitDescItem

    mov esi, FUNCTION_SEGMENT
    mov edi, FUNCTION_DESC

    call InitDescItem

    mov esi, TASK_A_LDT_ENTRY
    mov edi, TASK_A_LDT_DESC

    call InitDescItem

    mov esi, TASK_A_DATA32_SEGMENT
    mov edi, TASK_A_DATA32_DESC

    call InitDescItem

    mov esi, TASK_A_CODE32_SEGMENT
    mov edi, TASK_A_CODE32_DESC

    call InitDescItem

    mov esi, TASK_A_STACK32_SEGMENT
    mov edi, TASK_A_STACK32_DESC

    call InitDescItem

    mov esi, TSS_SEGMENT
    mov edi, TSS_DESC

    call InitDescItem

    ; initialize GDT pointer struct
    mov eax, 0
    mov ax, ds
    shl eax, 4
    add eax, GDT_ENTRY
    mov dword [GdtPtr + 2], eax

    ; 1. load GDT
    lgdt [GdtPtr]

    ; 2. close interrupt
    cli 

    ; 3. open A20
    in al, 0x92
    or al, 00000010b
    out 0x92, al

    ; 4. enter protect mode
    mov eax, cr0
    or eax, 0x01
    mov cr0, eax

    ; 5. jump to 32 bits code
    jmp dword Code32Selector : 0

; esi    --> code segment label
; edi    --> descriptor label
InitDescItem:
    push eax

    mov eax, 0
    mov ax, cs

    shl eax, 4
    add eax, esi
    mov word [edi + 2], ax

    shr eax, 16

    mov byte [edi + 4], al
    mov byte [edi + 7], ah

    pop eax

    ret

[section .dat]
[bits 32]
DATA32_SEGMENT:
    DTOS               db  "D.T.OS!", 0
    DTOS_OFFSET        equ DTOS - $$

Data32SegLen equ $ - DATA32_SEGMENT

[section .s32]
[bits 32]
CODE32_SEGMENT:
    mov ax, VideoSelector
    mov gs, ax

    mov ax, Data32Selector
    mov ds, ax

    mov ax, Stack32Selector
    mov ss, ax

    mov eax, TopOfStack32
    mov esp, eax
    ;在这里进行跳转，核心代码段跳转到任务代码段，高特权级到低特权级
    打印字符串，用于说明核心代码段启动
    mov ebp, DTOS_OFFSET
    mov bx, 0x0c
    mov dh, 12
    mov dl, 33

    call FunctionSelector : PrintString

    mov ax, TSSSelector

    ltr ax
 ;执行跳转，加载应用程序，应用程序的入口地址为任务代码段
 ;[section.task-a-s32]
    mov ax, TaskALdtSelector

    lldt ax
         ;使用retf进行跳转，首先将任务代码段使用栈信息压入到当前核心代码段高特权级栈中
    push TaskAStack32Selector
    push TaskATopOfStack32
    push TaskACode32Selector
    push 0
    retf

Code32SegLen    equ    $ - CODE32_SEGMENT

[section .gs]
[bits 32]
STACK32_SEGMENT:
    times 1024 * 4 db 0

Stack32SegLen equ $ - STACK32_SEGMENT
TopOfStack32  equ Stack32SegLen - 1

; ==========================================
;
;          Global Function Segment 
;
; ==========================================

[section .func]
[bits 32]
FUNCTION_SEGMENT:
; ds:ebp    --> string address
; bx        --> attribute
; dx        --> dh : row, dl : col

PrintStringFunc:
    push ebp
    push eax
    push edi
    push cx
    push dx

print:
    mov cl, [ds:ebp]
    cmp cl, 0
    je end
    mov eax, 80
    mul dh
    add al, dl
    shl eax, 1
    mov edi, eax
    mov ah, bl
    mov al, cl
    mov [gs:edi], ax
    inc ebp
    inc dl
    jmp print

end:
    pop dx
    pop cx
    pop edi
    pop eax
    pop ebp

    retf

PrintString    equ   PrintStringFunc - $$

FunctionSegLen    equ   $ - FUNCTION_SEGMENT

; ==========================================
;
;            Task A Code Segment 
;
; ==========================================

[section .task-a-ldt]
; Task A LDT definition

TASK_A_LDT_ENTRY:
TASK_A_CODE32_DESC    :    Descriptor          0,           TaskACode32SegLen - 1,        DA_C + DA_32 + DA_DPL3
TASK_A_DATA32_DESC    :    Descriptor          0,           TaskAData32SegLen - 1,        DA_DR + DA_32 + DA_DPL3
TASK_A_STACK32_DESC   :    Descriptor          0,           TaskAStack32SegLen - 1,       DA_DRW + DA_32 + DA_DPL3

TaskALdtLen  equ   $ - TASK_A_LDT_ENTRY

; Task A LDT Selector
TaskACode32Selector  equ   (0x0000 << 3) + SA_TIL + SA_RPL3
TaskAData32Selector  equ   (0x0001 << 3) + SA_TIL + SA_RPL3
TaskAStack32Selector equ   (0x0002 << 3) + SA_TIL + SA_RPL3

[section .task-a-dat]
[bits 32]
TASK_A_DATA32_SEGMENT:

    TASK_A_STRING        db   "This is Task A!", 0
    TASK_A_STRING_OFFSET equ  TASK_A_STRING - $$

TaskAData32SegLen  equ  $ - TASK_A_DATA32_SEGMENT

[section .task-a-gs]
[bits 32]
TASK_A_STACK32_SEGMENT:
    times 1024 db 0

TaskAStack32SegLen  equ  $ - TASK_A_STACK32_SEGMENT

TaskATopOfStack32   equ  TaskAStack32SegLen - 1

[section .task-a-s32];任务代码段
[bits 32]
TASK_A_CODE32_SEGMENT:  

    mov ax, TaskAData32Selector
    mov ds, ax

    mov ebp, TASK_A_STRING_OFFSET
    mov bx, 0x0c
    mov dh, 14
    mov dl, 29

    call FuncPrintStringSelector : 0

    jmp $

TaskACode32SegLen   equ  $ - TASK_A_CODE32_SEGMENT

运行结果

分析过程

1.首先通过反编译将其换成32位的代码，找到关键的跳转命令retf，并在bochs下设置断点
2.在设置好断电之后进行单步调试，在跳转之前查看寄存器值，此时cx寄存器值为0x0007，在跳转之后，代码进入到PrintStringFunc，此时cx寄存器值为0x0028
3.通过比较两个不同时刻的cx寄存器在16进制下最后两位的比较，发现跳转时发生了低特权级(11=3)到高特权级的转换(00=0)

B.RPL的意义(如下图所示)

1.位置意义-选择子或段寄存器的最低2位
2.请求意义-资源请求的特权级(不同于当前特权级CPL)
3.当需要请求获取某种资源时，处理器通过CPL,RPL和DPL共同确定请求是否合法

小结
1.TSS是通过调用门转移高特权级执行的关键
2.TSS是处理器的硬件数据结构，用于实现多任务
3.TSS结构体遵循保护模式下内存使用的规则
4.RPL在请求资源时是合法判断的依据之一
5.处理器使用CPL,RPL和DPL共同确定合法性