GDT Tutorial

Difficulty level Beginner On the IA-32 and x86-64 architectures, and more precisely in Protected Mode or , Interrupt Service Routines and a good deal of memory management are controlled through tables of descriptors. Each descriptor stores information about a single object (e.g.

https://wiki.osdev.org/GDT_Tutorial

1 关键词汇

Segment （段）

段寄存器

段选择器

段描述符

2 在 GDT 中放入什么

2.1 基本数据

• 描述符表中的条目 0 或 Null Descriptor 永远不会被处理器引用，并且应该始终不包含任何数据。某些模拟器，比如 Bochs，当你的 GPT 中没有一个空条目时，就会抛出一个限制异常。有些人使用这个描述符来存储指向 GDT 本身的指针（与 LGDT 指令一起使用）。空描述符为 8 字节宽，指针为 6 字节宽，因此它可能是处理此问题的理想场所。

• 一个 DPL 0 为0的代码段描述符（用于您的内核）

• 数据段描述符（代码段不允许写入）

• 一个任务状态段段描述符（它非常有用，至少有一个）

• 如果需要，为更多的细分市场留出空间(例如，用户级、ldt、更多的TSS等等)

2.2 Flat / Long Mode Setup（平面/长模式设置）

2.3 Small Kernel Setup（小内核设置）

2.4 SYSENTER / SYSEXIT（系统输入/系统退出）

3 如何设置 GDT

3.1 关中断

3.2 填表

void encodeGdtEntry(uint8_t *target, struct GDT source)
{
    // Check the limit to make sure that it can be encoded
    if (source.limit > 0xFFFFF) {kerror("GDT cannot encode limits larger than 0xFFFFF");}

    // Encode the limit
    target[0] = source.limit & 0xFF;
    target[1] = (source.limit >> 8) & 0xFF;
    target[6] = (source.limit >> 16) & 0x0F;

    // Encode the base
    target[2] = source.base & 0xFF;
    target[3] = (source.base >> 8) & 0xFF;
    target[4] = (source.base >> 16) & 0xFF;
    target[7] = (source.base >> 24) & 0xFF;

    // Encode the access byte
    target[5] = source.access_byte;

    // Encode the flags
    target[6] |= (source.flags << 4)
}

3.3 告诉 CPU 表在哪里

3.3.1 实模式

gdtr DW 0 ; For limit storage 16 位
     DD 0 ; For base storage

setGdt:
   XOR   EAX, EAX	; 清空EAX
   MOV   AX, DS		; 将数据段地址赋值给 ax
   SHL   EAX, 4		; 左移四位
   ADD   EAX, ''GDT''	; ?加上 GDT 的偏移？
   MOV   [gdtr + 2], eax	; 将 EAX 中的值，赋值到 gdtr + 2 上，存储 base
   MOV   EAX, ''GDT_end''	; 将 GDT_end 赋值到 EAX
   SUB   EAX, ''GDT''	; 计算 GDT 的长度？
   MOV   [gdtr], AX	; 储存低16位，limit
   LGDT  [gdtr]		; 加载 GDT 地址到相应的不可见寄存器
   RET

3.3.2 保护模式，平面模型

gdtr DW 0 ; For limit storage
     DD 0 ; For base storage

setGdt:
   MOV   AX, [esp + 4]		; 取出 limit
   MOV   [gdtr], AX		; 存储 limit
   MOV   EAX, [ESP + 8]		; 取出 base
   MOV   [gdtr + 2], EAX	; 存储 base
   LGDT  [gdtr]			; 加载到 对应寄存器
   RET

3.3.3 保护模式，非平面模型

gdtr DW 0 ; For limit storage
     DD 0 ; For base storage

setGdt:
   MOV   AX, [esp + 4]
   MOV   [gdtr], AX
   MOV   EAX, [ESP + 8]
   ADD   EAX, [ESP + 12]
   MOV   [gdtr + 2], EAX
   LGDT  [gdtr]
   RET

3.3.4 长模式

gdtr DW 0 ; For limit storage
     DQ 0 ; For base storage

setGdt:
   MOV   [gdtr], DI	; 存储 limit 32 位
   MOV   [gdtr+2], RSI	; 存储 base 64 位
   LGDT  [gdtr]
   RET

3.4 重新加载段寄存器

3.4.1 保护模式

reloadSegments:
   ; Reload CS register containing code selector:
   JMP   0x08:.reload_CS ; 0x08 is a stand-in for your code segment
.reload_CS:
   ; Reload data segment registers:
   MOV   AX, 0x10 ; 0x10 is a stand-in for your data segment
   MOV   DS, AX
   MOV   ES, AX
   MOV   FS, AX
   MOV   GS, AX
   MOV   SS, AX
   RET

3.4.2 长模式

reloadSegments:
   ; Reload CS register:
   PUSH 0x08                 ; Push code segment to stack, 0x08 is a stand-in for your code segment
   LEA RAX, [rel .reload_CS] ; Load address of .reload_CS into RAX
   PUSH RAX                  ; Push this value to the stack
   RETFQ                     ; Perform a far return, RETFQ or LRETQ depending on syntax
.reload_CS:
   ; Reload data segment registers
   MOV   AX, 0x10 ; 0x10 is a stand-in for your data segment
   MOV   DS, AX
   MOV   ES, AX
   MOV   FS, AX
   MOV   GS, AX
   MOV   SS, AX
   RET

4 LDT

5 IDT 以及为什么需要它

6 一些让你的生活更轻松的东西

// Used for creating GDT segment descriptors in 64-bit integer form.

#include <stdio.h>
#include <stdint.h>

// Each define here is for a specific flag in the descriptor.
// Refer to the intel documentation for a description of what each one does.
#define SEG_DESCTYPE(x)  ((x) << 0x04) // Descriptor type (0 for system, 1 for code/data)
#define SEG_PRES(x)      ((x) << 0x07) // Present
#define SEG_SAVL(x)      ((x) << 0x0C) // Available for system use
#define SEG_LONG(x)      ((x) << 0x0D) // Long mode
#define SEG_SIZE(x)      ((x) << 0x0E) // Size (0 for 16-bit, 1 for 32)
#define SEG_GRAN(x)      ((x) << 0x0F) // Granularity (0 for 1B - 1MB, 1 for 4KB - 4GB)
#define SEG_PRIV(x)     (((x) &  0x03) << 0x05)   // Set privilege level (0 - 3)

#define SEG_DATA_RD        0x00 // Read-Only
#define SEG_DATA_RDA       0x01 // Read-Only, accessed
#define SEG_DATA_RDWR      0x02 // Read/Write
#define SEG_DATA_RDWRA     0x03 // Read/Write, accessed
#define SEG_DATA_RDEXPD    0x04 // Read-Only, expand-down
#define SEG_DATA_RDEXPDA   0x05 // Read-Only, expand-down, accessed
#define SEG_DATA_RDWREXPD  0x06 // Read/Write, expand-down
#define SEG_DATA_RDWREXPDA 0x07 // Read/Write, expand-down, accessed
#define SEG_CODE_EX        0x08 // Execute-Only
#define SEG_CODE_EXA       0x09 // Execute-Only, accessed
#define SEG_CODE_EXRD      0x0A // Execute/Read
#define SEG_CODE_EXRDA     0x0B // Execute/Read, accessed
#define SEG_CODE_EXC       0x0C // Execute-Only, conforming
#define SEG_CODE_EXCA      0x0D // Execute-Only, conforming, accessed
#define SEG_CODE_EXRDC     0x0E // Execute/Read, conforming
#define SEG_CODE_EXRDCA    0x0F // Execute/Read, conforming, accessed

#define GDT_CODE_PL0 SEG_DESCTYPE(1) | SEG_PRES(1) | SEG_SAVL(0) | \\
                     SEG_LONG(0)     | SEG_SIZE(1) | SEG_GRAN(1) | \\
                     SEG_PRIV(0)     | SEG_CODE_EXRD

#define GDT_DATA_PL0 SEG_DESCTYPE(1) | SEG_PRES(1) | SEG_SAVL(0) | \\
                     SEG_LONG(0)     | SEG_SIZE(1) | SEG_GRAN(1) | \\
                     SEG_PRIV(0)     | SEG_DATA_RDWR

#define GDT_CODE_PL3 SEG_DESCTYPE(1) | SEG_PRES(1) | SEG_SAVL(0) | \\
                     SEG_LONG(0)     | SEG_SIZE(1) | SEG_GRAN(1) | \\
                     SEG_PRIV(3)     | SEG_CODE_EXRD

#define GDT_DATA_PL3 SEG_DESCTYPE(1) | SEG_PRES(1) | SEG_SAVL(0) | \\
                     SEG_LONG(0)     | SEG_SIZE(1) | SEG_GRAN(1) | \\
                     SEG_PRIV(3)     | SEG_DATA_RDWR

void
create_descriptor(uint32_t base, uint32_t limit, uint16_t flag)
{
    uint64_t descriptor;

    // Create the high 32 bit segment
    descriptor  =  limit       & 0x000F0000;         // set limit bits 19:16
    descriptor |= (flag <<  8) & 0x00F0FF00;         // set type, p, dpl, s, g, d/b, l and avl fields
    descriptor |= (base >> 16) & 0x000000FF;         // set base bits 23:16
    descriptor |=  base        & 0xFF000000;         // set base bits 31:24

    // Shift by 32 to allow for low part of segment
    descriptor <<= 32;

    // Create the low 32 bit segment
    descriptor |= base  << 16;                       // set base bits 15:0
    descriptor |= limit  & 0x0000FFFF;               // set limit bits 15:0

    printf("0x%.16llX\\n", descriptor);
}

int
main(void)
{
    create_descriptor(0, 0, 0);
    create_descriptor(0, 0x000FFFFF, (GDT_CODE_PL0));
    create_descriptor(0, 0x000FFFFF, (GDT_DATA_PL0));
    create_descriptor(0, 0x000FFFFF, (GDT_CODE_PL3));
    create_descriptor(0, 0x000FFFFF, (GDT_DATA_PL3));

    return 0;
}

7 See Also

7.1 Articles

• Global Descriptor Table

• http://web.archive.org/web/20190424213806/http://www.osdever.net/tutorials/view/the-world-of-protected-mode - how to set up GDT in assembler