1 #include "userprog/gdt.h"
3 #include "userprog/tss.h"
4 #include "threads/palloc.h"
5 #include "threads/vaddr.h"
7 /* The Global Descriptor Table (GDT).
9 The GDT, an x86-specific structure, defines segments that can
10 potentially be used by all processes in a system, subject to
11 their permissions. There is also a per-process Local
12 Descriptor Table (LDT) but that is not used by modern
15 Each entry in the GDT, which is known by its byte offset in
16 the table, identifies a segment. For our purposes only three
17 types of segments are of interest: code, data, and TSS or
18 Task-State Segment descriptors. The former two types are
19 exactly what they sound like. The TSS is used primarily for
20 stack switching on interrupts.
22 For more information on the GDT as used here, refer to
23 [IA32-v3a] 3.2 "Using Segments" through 3.5 "System Descriptor
25 static uint64_t gdt[SEL_CNT];
28 static uint64_t make_code_desc (int dpl);
29 static uint64_t make_data_desc (int dpl);
30 static uint64_t make_tss_desc (void *laddr);
31 static uint64_t make_gdtr_operand (uint16_t limit, void *base);
33 /* Sets up a proper GDT. The bootstrap loader's GDT didn't
34 include user-mode selectors or a TSS, but we need both now. */
38 uint64_t gdtr_operand;
41 gdt[SEL_NULL / sizeof *gdt] = 0;
42 gdt[SEL_KCSEG / sizeof *gdt] = make_code_desc (0);
43 gdt[SEL_KDSEG / sizeof *gdt] = make_data_desc (0);
44 gdt[SEL_UCSEG / sizeof *gdt] = make_code_desc (3);
45 gdt[SEL_UDSEG / sizeof *gdt] = make_data_desc (3);
46 gdt[SEL_TSS / sizeof *gdt] = make_tss_desc (tss_get ());
48 /* Load GDTR, TR. See [IA32-v3a] 2.4.1 "Global Descriptor
49 Table Register (GDTR)", 2.4.4 "Task Register (TR)", and
50 6.2.4 "Task Register". */
51 gdtr_operand = make_gdtr_operand (sizeof gdt - 1, gdt);
52 asm volatile ("lgdt %0" : : "m" (gdtr_operand));
53 asm volatile ("ltr %w0" : : "q" (SEL_TSS));
56 /* System segment or code/data segment? */
59 CLS_SYSTEM = 0, /* System segment. */
60 CLS_CODE_DATA = 1 /* Code or data segment. */
63 /* Limit has byte or 4 kB page granularity? */
66 GRAN_BYTE = 0, /* Limit has 1-byte granularity. */
67 GRAN_PAGE = 1 /* Limit has 4 kB granularity. */
70 /* Returns a segment descriptor with the given 32-bit BASE and
71 20-bit LIMIT (whose interpretation depends on GRANULARITY).
72 The descriptor represents a system or code/data segment
73 according to CLASS, and TYPE is its type (whose interpretation
74 depends on the class).
76 The segment has descriptor privilege level DPL, meaning that
77 it can be used in rings numbered DPL or lower. In practice,
78 DPL==3 means that user processes can use the segment and
79 DPL==0 means that only the kernel can use the segment. See
80 [IA32-v3a] 4.5 "Privilege Levels" for further discussion. */
82 make_seg_desc (uint32_t base,
87 enum seg_granularity granularity)
91 ASSERT (limit <= 0xfffff);
92 ASSERT (class == CLS_SYSTEM || class == CLS_CODE_DATA);
93 ASSERT (type >= 0 && type <= 15);
94 ASSERT (dpl >= 0 && dpl <= 3);
95 ASSERT (granularity == GRAN_BYTE || granularity == GRAN_PAGE);
97 e0 = ((limit & 0xffff) /* Limit 15:0. */
98 | (base << 16)); /* Base 15:0. */
100 e1 = (((base >> 16) & 0xff) /* Base 23:16. */
101 | (type << 8) /* Segment type. */
102 | (class << 12) /* 0=system, 1=code/data. */
103 | (dpl << 13) /* Descriptor privilege. */
104 | (1 << 15) /* Present. */
105 | (limit & 0xf0000) /* Limit 16:19. */
106 | (1 << 22) /* 32-bit segment. */
107 | (granularity << 23) /* Byte/page granularity. */
108 | (base & 0xff000000)); /* Base 31:24. */
110 return e0 | ((uint64_t) e1 << 32);
113 /* Returns a descriptor for a readable code segment with base at
114 0, a limit of 4 GB, and the given DPL. */
116 make_code_desc (int dpl)
118 return make_seg_desc (0, 0xfffff, CLS_CODE_DATA, 10, dpl, GRAN_PAGE);
121 /* Returns a descriptor for a writable data segment with base at
122 0, a limit of 4 GB, and the given DPL. */
124 make_data_desc (int dpl)
126 return make_seg_desc (0, 0xfffff, CLS_CODE_DATA, 2, dpl, GRAN_PAGE);
129 /* Returns a descriptor for an "available" 32-bit Task-State
130 Segment with its base at the given linear address, a limit of
131 0x67 bytes (the size of a 32-bit TSS), and a DPL of 0.
132 See [IA32-v3a] 6.2.2 "TSS Descriptor". */
134 make_tss_desc (void *laddr)
136 return make_seg_desc ((uint32_t) laddr, 0x67, CLS_SYSTEM, 9, 0, GRAN_BYTE);
140 /* Returns a descriptor that yields the given LIMIT and BASE when
141 used as an operand for the LGDT instruction. */
143 make_gdtr_operand (uint16_t limit, void *base)
145 return limit | ((uint64_t) (uint32_t) base << 16);