Lab3 initial merge
[akaros.git] / inc / mmu.h
1 #ifndef JOS_INC_MMU_H
2 #define JOS_INC_MMU_H
3
4 /*
5  * This file contains definitions for the x86 memory management unit (MMU),
6  * including paging- and segmentation-related data structures and constants,
7  * the %cr0, %cr4, and %eflags registers, and traps.
8  */
9
10 /*
11  *
12  *      Part 1.  Paging data structures and constants.
13  *
14  */
15
16 // A linear address 'la' has a three-part structure as follows:
17 //
18 // +--------10------+-------10-------+---------12----------+
19 // | Page Directory |   Page Table   | Offset within Page  |
20 // |      Index     |      Index     |                     |
21 // +----------------+----------------+---------------------+
22 //  \--- PDX(la) --/ \--- PTX(la) --/ \---- PGOFF(la) ----/
23 //  \----------- PPN(la) -----------/
24 //
25 // The PDX, PTX, PGOFF, and PPN macros decompose linear addresses as shown.
26 // To construct a linear address la from PDX(la), PTX(la), and PGOFF(la),
27 // use PGADDR(PDX(la), PTX(la), PGOFF(la)).
28
29 // page number field of address
30 #define PPN(la)         (((uintptr_t) (la)) >> PTXSHIFT)
31 #define VPN(la)         PPN(la)         // used to index into vpt[]
32
33 // page directory index
34 #define PDX(la)         ((((uintptr_t) (la)) >> PDXSHIFT) & 0x3FF)
35 #define VPD(la)         PDX(la)         // used to index into vpd[]
36
37 // page table index
38 #define PTX(la)         ((((uintptr_t) (la)) >> PTXSHIFT) & 0x3FF)
39
40 // offset in page
41 #define PGOFF(la)       (((uintptr_t) (la)) & 0xFFF)
42
43 // offset in jumbo page
44 #define JPGOFF(la)      (((uintptr_t) (la)) & 0x003FFFFF)
45
46 // construct linear address from indexes and offset
47 #define PGADDR(d, t, o) ((void*) ((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))
48
49 // Page directory and page table constants.
50 #define NPDENTRIES      1024            // page directory entries per page directory
51 #define NPTENTRIES      1024            // page table entries per page table
52
53 #define PGSIZE          4096            // bytes mapped by a page
54 #define JPGSIZE         4096*1024       // bytes mapped by a jumbo page (4MB)
55 #define PGSHIFT         12              // log2(PGSIZE)
56
57 #define PTSIZE          (PGSIZE*NPTENTRIES) // bytes mapped by a page directory entry
58 #define PTSHIFT         22              // log2(PTSIZE)
59
60 #define PTXSHIFT        12              // offset of PTX in a linear address
61 #define PDXSHIFT        22              // offset of PDX in a linear address
62
63 // Page table/directory entry flags.
64 #define PTE_P           0x001   // Present
65 #define PTE_W           0x002   // Writeable
66 #define PTE_U           0x004   // User
67 #define PTE_PWT         0x008   // Write-Through
68 #define PTE_PCD         0x010   // Cache-Disable
69 #define PTE_A           0x020   // Accessed
70 #define PTE_D           0x040   // Dirty
71 #define PTE_PS          0x080   // Page Size
72 #define PTE_MBZ         0x180   // Bits must be zero
73
74 // The PTE_AVAIL bits aren't used by the kernel or interpreted by the
75 // hardware, so user processes are allowed to set them arbitrarily.
76 #define PTE_AVAIL       0xE00   // Available for software use
77
78 // Only flags in PTE_USER may be used in system calls.
79 #define PTE_USER        (PTE_AVAIL | PTE_P | PTE_W | PTE_U)
80
81 // address in page table entry
82 #define PTE_ADDR(pte)   ((physaddr_t) (pte) & ~0xFFF)
83
84 // Control Register flags
85 #define CR0_PE          0x00000001      // Protection Enable
86 #define CR0_MP          0x00000002      // Monitor coProcessor
87 #define CR0_EM          0x00000004      // Emulation
88 #define CR0_TS          0x00000008      // Task Switched
89 #define CR0_ET          0x00000010      // Extension Type
90 #define CR0_NE          0x00000020      // Numeric Errror
91 #define CR0_WP          0x00010000      // Write Protect
92 #define CR0_AM          0x00040000      // Alignment Mask
93 #define CR0_NW          0x20000000      // Not Writethrough
94 #define CR0_CD          0x40000000      // Cache Disable
95 #define CR0_PG          0x80000000      // Paging
96
97 #define CR4_PCE         0x00000100      // Performance counter enable
98 #define CR4_MCE         0x00000040      // Machine Check Enable
99 #define CR4_PSE         0x00000010      // Page Size Extensions
100 #define CR4_DE          0x00000008      // Debugging Extensions
101 #define CR4_TSD         0x00000004      // Time Stamp Disable
102 #define CR4_PVI         0x00000002      // Protected-Mode Virtual Interrupts
103 #define CR4_VME         0x00000001      // V86 Mode Extensions
104
105 // Eflags register
106 #define FL_CF           0x00000001      // Carry Flag
107 #define FL_PF           0x00000004      // Parity Flag
108 #define FL_AF           0x00000010      // Auxiliary carry Flag
109 #define FL_ZF           0x00000040      // Zero Flag
110 #define FL_SF           0x00000080      // Sign Flag
111 #define FL_TF           0x00000100      // Trap Flag
112 #define FL_IF           0x00000200      // Interrupt Flag
113 #define FL_DF           0x00000400      // Direction Flag
114 #define FL_OF           0x00000800      // Overflow Flag
115 #define FL_IOPL_MASK    0x00003000      // I/O Privilege Level bitmask
116 #define FL_IOPL_0       0x00000000      //   IOPL == 0
117 #define FL_IOPL_1       0x00001000      //   IOPL == 1
118 #define FL_IOPL_2       0x00002000      //   IOPL == 2
119 #define FL_IOPL_3       0x00003000      //   IOPL == 3
120 #define FL_NT           0x00004000      // Nested Task
121 #define FL_RF           0x00010000      // Resume Flag
122 #define FL_VM           0x00020000      // Virtual 8086 mode
123 #define FL_AC           0x00040000      // Alignment Check
124 #define FL_VIF          0x00080000      // Virtual Interrupt Flag
125 #define FL_VIP          0x00100000      // Virtual Interrupt Pending
126 #define FL_ID           0x00200000      // ID flag
127
128 // Page fault error codes
129 #define FEC_PR          0x1     // Page fault caused by protection violation
130 #define FEC_WR          0x2     // Page fault caused by a write
131 #define FEC_U           0x4     // Page fault occured while in user mode
132
133
134 /*
135  *
136  *      Part 2.  Segmentation data structures and constants.
137  *
138  */
139
140 #ifdef __ASSEMBLER__
141
142 /*
143  * Macros to build GDT entries in assembly.
144  */
145 #define SEG_NULL                                                \
146         .word 0, 0;                                             \
147         .byte 0, 0, 0, 0
148 #define SEG(type,base,lim)                                      \
149         .word (((lim) >> 12) & 0xffff), ((base) & 0xffff);      \
150         .byte (((base) >> 16) & 0xff), (0x90 | (type)),         \
151                 (0xC0 | (((lim) >> 28) & 0xf)), (((base) >> 24) & 0xff)
152
153 #else   // not __ASSEMBLER__
154
155 #include <inc/types.h>
156
157 // Segment Descriptors
158 struct Segdesc {
159         unsigned sd_lim_15_0 : 16;  // Low bits of segment limit
160         unsigned sd_base_15_0 : 16; // Low bits of segment base address
161         unsigned sd_base_23_16 : 8; // Middle bits of segment base address
162         unsigned sd_type : 4;       // Segment type (see STS_ constants)
163         unsigned sd_s : 1;          // 0 = system, 1 = application
164         unsigned sd_dpl : 2;        // Descriptor Privilege Level
165         unsigned sd_p : 1;          // Present
166         unsigned sd_lim_19_16 : 4;  // High bits of segment limit
167         unsigned sd_avl : 1;        // Unused (available for software use)
168         unsigned sd_rsv1 : 1;       // Reserved
169         unsigned sd_db : 1;         // 0 = 16-bit segment, 1 = 32-bit segment
170         unsigned sd_g : 1;          // Granularity: limit scaled by 4K when set
171         unsigned sd_base_31_24 : 8; // High bits of segment base address
172 };
173 // Null segment
174 #define SEG_NULL        (struct Segdesc){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
175 // Segment that is loadable but faults when used
176 #define SEG_FAULT       (struct Segdesc){ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
177 // Normal segment
178 #define SEG(type, base, lim, dpl) (struct Segdesc)                      \
179 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,       \
180     type, 1, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                \
181     (unsigned) (base) >> 24 }
182 #define SEG16(type, base, lim, dpl) (struct Segdesc)                    \
183 { (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,               \
184     type, 1, dpl, 1, (unsigned) (lim) >> 16, 0, 0, 1, 0,                \
185     (unsigned) (base) >> 24 }
186
187 #endif /* !__ASSEMBLER__ */
188
189 // Application segment type bits
190 #define STA_X           0x8         // Executable segment
191 #define STA_E           0x4         // Expand down (non-executable segments)
192 #define STA_C           0x4         // Conforming code segment (executable only)
193 #define STA_W           0x2         // Writeable (non-executable segments)
194 #define STA_R           0x2         // Readable (executable segments)
195 #define STA_A           0x1         // Accessed
196
197 // System segment type bits
198 #define STS_T16A        0x1         // Available 16-bit TSS
199 #define STS_LDT         0x2         // Local Descriptor Table
200 #define STS_T16B        0x3         // Busy 16-bit TSS
201 #define STS_CG16        0x4         // 16-bit Call Gate
202 #define STS_TG          0x5         // Task Gate / Coum Transmitions
203 #define STS_IG16        0x6         // 16-bit Interrupt Gate
204 #define STS_TG16        0x7         // 16-bit Trap Gate
205 #define STS_T32A        0x9         // Available 32-bit TSS
206 #define STS_T32B        0xB         // Busy 32-bit TSS
207 #define STS_CG32        0xC         // 32-bit Call Gate
208 #define STS_IG32        0xE         // 32-bit Interrupt Gate
209 #define STS_TG32        0xF         // 32-bit Trap Gate
210
211
212 /*
213  *
214  *      Part 3.  Traps.
215  *
216  */
217
218 #ifndef __ASSEMBLER__
219
220 // Task state segment format (as described by the Pentium architecture book)
221 struct Taskstate {
222         uint32_t ts_link;       // Old ts selector
223         uintptr_t ts_esp0;      // Stack pointers and segment selectors
224         uint16_t ts_ss0;        //   after an increase in privilege level
225         uint16_t ts_padding1;
226         uintptr_t ts_esp1;
227         uint16_t ts_ss1;
228         uint16_t ts_padding2;
229         uintptr_t ts_esp2;
230         uint16_t ts_ss2;
231         uint16_t ts_padding3;
232         physaddr_t ts_cr3;      // Page directory base
233         uintptr_t ts_eip;       // Saved state from last task switch
234         uint32_t ts_eflags;
235         uint32_t ts_eax;        // More saved state (registers)
236         uint32_t ts_ecx;
237         uint32_t ts_edx;
238         uint32_t ts_ebx;
239         uintptr_t ts_esp;
240         uintptr_t ts_ebp;
241         uint32_t ts_esi;
242         uint32_t ts_edi;
243         uint16_t ts_es;         // Even more saved state (segment selectors)
244         uint16_t ts_padding4;
245         uint16_t ts_cs;
246         uint16_t ts_padding5;
247         uint16_t ts_ss;
248         uint16_t ts_padding6;
249         uint16_t ts_ds;
250         uint16_t ts_padding7;
251         uint16_t ts_fs;
252         uint16_t ts_padding8;
253         uint16_t ts_gs;
254         uint16_t ts_padding9;
255         uint16_t ts_ldt;
256         uint16_t ts_padding10;
257         uint16_t ts_t;          // Trap on task switch
258         uint16_t ts_iomb;       // I/O map base address
259 };
260
261 // Gate descriptors for interrupts and traps
262 struct Gatedesc {
263         unsigned gd_off_15_0 : 16;   // low 16 bits of offset in segment
264         unsigned gd_ss : 16;         // segment selector
265         unsigned gd_args : 5;        // # args, 0 for interrupt/trap gates
266         unsigned gd_rsv1 : 3;        // reserved(should be zero I guess)
267         unsigned gd_type : 4;        // type(STS_{TG,IG32,TG32})
268         unsigned gd_s : 1;           // must be 0 (system)
269         unsigned gd_dpl : 2;         // descriptor(meaning new) privilege level
270         unsigned gd_p : 1;           // Present
271         unsigned gd_off_31_16 : 16;  // high bits of offset in segment
272 };
273
274 // Set up a normal interrupt/trap gate descriptor.
275 // - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
276 // - sel: Code segment selector for interrupt/trap handler
277 // - off: Offset in code segment for interrupt/trap handler
278 // - dpl: Descriptor Privilege Level -
279 //        the privilege level required for software to invoke
280 //        this interrupt/trap gate explicitly using an int instruction.
281 #define SETGATE(gate, istrap, sel, off, dpl)                    \
282 {                                                               \
283         (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;         \
284         (gate).gd_ss = (sel);                                   \
285         (gate).gd_args = 0;                                     \
286         (gate).gd_rsv1 = 0;                                     \
287         (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32;        \
288         (gate).gd_s = 0;                                        \
289         (gate).gd_dpl = (dpl);                                  \
290         (gate).gd_p = 1;                                        \
291         (gate).gd_off_31_16 = (uint32_t) (off) >> 16;           \
292 }
293
294 // Set up a call gate descriptor.
295 #define SETCALLGATE(gate, ss, off, dpl)                         \
296 {                                                               \
297         (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;         \
298         (gate).gd_ss = (ss);                                    \
299         (gate).gd_args = 0;                                     \
300         (gate).gd_rsv1 = 0;                                     \
301         (gate).gd_type = STS_CG32;                              \
302         (gate).gd_s = 0;                                        \
303         (gate).gd_dpl = (dpl);                                  \
304         (gate).gd_p = 1;                                        \
305         (gate).gd_off_31_16 = (uint32_t) (off) >> 16;           \
306 }
307
308 // Pseudo-descriptors used for LGDT, LLDT and LIDT instructions.
309 struct Pseudodesc {
310         uint16_t pd_lim;                // Limit
311         uint32_t pd_base;               // Base address
312 } __attribute__ ((packed));
313
314 #endif /* !__ASSEMBLER__ */
315
316 #endif /* !JOS_INC_MMU_H */