arch/mmu.h contents now in ros/arch/mmu.h (XCC)
[akaros.git] / kern / arch / i686 / ros / mmu.h
1 /* Contains macros and constants for the kernel VM mapping, page tables,
2  * segmentation, control registers, etc. */
3
4 #ifndef ROS_INC_ARCH_MMU_H
5 #define ROS_INC_ARCH_MMU_H
6
7 #ifndef __ASSEMBLER__
8 #include <ros/common.h>
9 typedef unsigned long pte_t;
10 typedef unsigned long pde_t;
11 #endif
12
13 /* **************************************** */
14 /* Kernel Virtual Memory Mapping  (not really an MMU thing) */
15
16 #define KERNBASE        0xC0000000
17 #define KERN_LOAD_ADDR  KERNBASE
18
19 /* Static kernel mappings */
20 /* Virtual page table.  Entry PDX(VPT) in the PD contains a pointer to
21  * the page directory itself, thereby turning the PD into a page table,
22  * which maps all the PTEs containing the page mappings for the entire
23  * virtual address space into that 4 Meg region starting at VPT. */
24 #define VPT                             (KERNBASE - PTSIZE)
25 #define LAPIC_BASE              (VPT - PGSIZE)
26 #define IOAPIC_BASE             (LAPIC_BASE - PGSIZE)
27
28 /* All arches must define this, which is the lower limit of their static
29  * mappings, and where the dynamic mappings will start. */
30 #define KERN_DYN_TOP    IOAPIC_BASE
31
32 #define ULIM            0x80000000
33
34 // Use this if needed in annotations
35 #define IVY_KERNBASE (0xC000U << 16)
36
37 /* **************************************** */
38 /* Page table constants, macros, etc */
39
40 // A linear address 'la' has a three-part structure as follows:
41 //
42 // +--------10------+-------10-------+---------12----------+
43 // | Page Directory |   Page Table   | Offset within Page  |
44 // |      Index     |      Index     |                     |
45 // +----------------+----------------+---------------------+
46 //  \--- PDX(la) --/ \--- PTX(la) --/ \---- PGOFF(la) ----/
47 //  \----------- PPN(la) -----------/
48 //
49 // The PDX, PTX, PGOFF, and PPN macros decompose linear addresses as shown.
50 // To construct a linear address la from PDX(la), PTX(la), and PGOFF(la),
51 // use PGADDR(PDX(la), PTX(la), PGOFF(la)).
52
53 // page number field of address
54 #define LA2PPN(la)      (((uintptr_t) (la)) >> PTXSHIFT)
55 #define PTE2PPN(pte)    LA2PPN(pte)
56 #define VPN(la)         PPN(la)         // used to index into vpt[]
57
58 // page directory index
59 #define PDX(la)         ((((uintptr_t) (la)) >> PDXSHIFT) & 0x3FF)
60 #define VPD(la)         PDX(la)         // used to index into vpd[]
61
62 // page table index
63 #define PTX(la)         ((((uintptr_t) (la)) >> PTXSHIFT) & 0x3FF)
64
65 // offset in page
66 #define PGOFF(la)       (((uintptr_t) (la)) & 0xFFF)
67
68 // offset in jumbo page
69 #define JPGOFF(la)      (((uintptr_t) (la)) & 0x003FFFFF)
70
71 // construct PTE from PPN and flags
72 #define PTE(ppn, flags) ((ppn) << PTXSHIFT | (flags))
73
74 // construct linear address from indexes and offset
75 #define PGADDR(d, t, o) ((void*SNT) ((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))
76
77 // Page directory and page table constants.
78 #define NPDENTRIES      1024            // page directory entries per page directory
79 #define NPTENTRIES      1024            // page table entries per page table
80
81 #define PTXSHIFT        12              // offset of PTX in a linear address
82 #define PDXSHIFT        22              // offset of PDX in a linear address
83
84 // Page table/directory entry flags.
85 #define PTE_P           0x001   // Present
86 #define PTE_W           0x002   // Writeable
87 #define PTE_U           0x004   // User
88 #define PTE_PWT         0x008   // Write-Through
89 #define PTE_PCD         0x010   // Cache-Disable
90 #define PTE_A           0x020   // Accessed
91 #define PTE_D           0x040   // Dirty
92 #define PTE_PS          0x080   // Page Size (only applies to PDEs)
93 #define PTE_PAT         0x080   // PAT (only applies to second layer PTEs)
94 #define PTE_G           0x100   // Global Page
95
96 #define PTE_PERM        (PTE_W | PTE_U) // The permissions fields
97 // commly used access modes
98 #define PTE_KERN_RW     PTE_W           // Kernel Read/Write
99 #define PTE_KERN_RO     0               // Kernel Read-Only
100 #define PTE_USER_RW     (PTE_W | PTE_U) // Kernel/User Read/Write
101 #define PTE_USER_RO     PTE_U           // Kernel/User Read-Only
102
103 // The PTE_AVAIL bits aren't used by the kernel or interpreted by the
104 // hardware, so user processes are allowed to set them arbitrarily.
105 #define PTE_AVAIL       0xE00   // Available for software use
106
107 // Only flags in PTE_USER may be used in system calls.
108 #define PTE_USER        (PTE_AVAIL | PTE_P | PTE_W | PTE_U)
109
110 // address in page table entry
111 #define PTE_ADDR(pte)   ((physaddr_t) (pte) & ~0xFFF)
112
113 #define PTSHIFT 22
114 #define PTSIZE (1 << PTSHIFT)
115 #define PGSHIFT 12
116 #define PGSIZE (1 << PGSHIFT)
117 #define JPGSIZE PTSIZE
118
119 // we must guarantee that for any PTE, exactly one of the following is true
120 #define PAGE_PRESENT(pte) ((pte) & PTE_P)
121 #define PAGE_UNMAPPED(pte) ((pte) == 0)
122 #define PAGE_PAGED_OUT(pte) (!PAGE_PRESENT(pte) && !PAGE_UNMAPPED(pte))
123
124 /* **************************************** */
125 /* Control Registers */
126
127 // Control Register flags
128 #define CR0_PE          0x00000001      // Protection Enable
129 #define CR0_MP          0x00000002      // Monitor coProcessor
130 #define CR0_EM          0x00000004      // Emulation
131 #define CR0_TS          0x00000008      // Task Switched
132 #define CR0_ET          0x00000010      // Extension Type
133 #define CR0_NE          0x00000020      // Numeric Error
134 #define CR0_WP          0x00010000      // Write Protect
135 #define CR0_AM          0x00040000      // Alignment Mask
136 #define CR0_NW          0x20000000      // Not Writethrough - more tricky than it sounds
137 #define CR0_CD          0x40000000      // Cache Disable
138 #define CR0_PG          0x80000000      // Paging
139
140 // These two relate to the cacheability (L1, etc) of the page directory
141 #define CR3_PWT         0x00000008      // Page directory caching write through
142 #define CR3_PCD         0x00000010      // Page directory caching disabled
143
144 #define CR4_VME         0x00000001      // V86 Mode Extensions
145 #define CR4_PVI         0x00000002      // Protected-Mode Virtual Interrupts
146 #define CR4_TSD         0x00000004      // Time Stamp Disable
147 #define CR4_DE          0x00000008      // Debugging Extensions
148 #define CR4_PSE         0x00000010      // Page Size Extensions
149 #define CR4_PAE         0x00000020      // Physical Address Extensions
150 #define CR4_MCE         0x00000040      // Machine Check Enable
151 #define CR4_PGE         0x00000080      // Global Pages Enabled
152 #define CR4_PCE         0x00000100      // Performance counter enable
153 #define CR4_OSFXSR      0x00000200      // OS support for FXSAVE/FXRSTOR
154 #define CR4_OSXMME      0x00000400      // OS support for unmasked SIMD FP exceptions
155 #define CR4_VMXE        0x00002000      // VMX enable
156 #define CR4_SMXE        0x00004000      // SMX enable
157 #define CR4_OSXSAVE     0x00040000      // XSAVE and processor extended states-enabled
158
159 // Eflags register
160 #define FL_CF           0x00000001      // Carry Flag
161 #define FL_PF           0x00000004      // Parity Flag
162 #define FL_AF           0x00000010      // Auxiliary carry Flag
163 #define FL_ZF           0x00000040      // Zero Flag
164 #define FL_SF           0x00000080      // Sign Flag
165 #define FL_TF           0x00000100      // Trap Flag
166 #define FL_IF           0x00000200      // Interrupt Flag
167 #define FL_DF           0x00000400      // Direction Flag
168 #define FL_OF           0x00000800      // Overflow Flag
169 #define FL_IOPL_MASK    0x00003000      // I/O Privilege Level bitmask
170 #define FL_IOPL_0       0x00000000      //   IOPL == 0
171 #define FL_IOPL_1       0x00001000      //   IOPL == 1
172 #define FL_IOPL_2       0x00002000      //   IOPL == 2
173 #define FL_IOPL_3       0x00003000      //   IOPL == 3
174 #define FL_NT           0x00004000      // Nested Task
175 #define FL_RF           0x00010000      // Resume Flag
176 #define FL_VM           0x00020000      // Virtual 8086 mode
177 #define FL_AC           0x00040000      // Alignment Check
178 #define FL_VIF          0x00080000      // Virtual Interrupt Flag
179 #define FL_VIP          0x00100000      // Virtual Interrupt Pending
180 #define FL_ID           0x00200000      // ID flag
181
182 // Page fault error codes
183 #define FEC_PR          0x1     // Page fault caused by protection violation
184 #define FEC_WR          0x2     // Page fault caused by a write
185 #define FEC_U           0x4     // Page fault occured while in user mode
186
187 /* **************************************** */
188 /* Segmentation */
189
190 // Global descriptor numbers
191 #define GD_NULL   0x00     // NULL descriptor
192 #define GD_KT     0x08     // kernel text
193 #define GD_KD     0x10     // kernel data
194 #define GD_UT     0x18     // user text
195 #define GD_UD     0x20     // user data
196 #define GD_TSS    0x28     // Task segment selector
197 #define GD_LDT    0x30     // local descriptor table
198
199 #ifdef __ASSEMBLER__
200
201 /*
202  * Macros to build GDT entries in assembly.
203  */
204 #define SEG_NULL                                                \
205         .word 0, 0;                                             \
206         .byte 0, 0, 0, 0
207 #define SEG(type,base,lim)                                      \
208         .word (((lim) >> 12) & 0xffff), ((base) & 0xffff);      \
209         .byte (((base) >> 16) & 0xff), (0x90 | (type)),         \
210                 (0xC0 | (((lim) >> 28) & 0xf)), (((base) >> 24) & 0xff)
211
212 #else   // not __ASSEMBLER__
213
214 // Segment Descriptors
215 typedef struct Segdesc {
216         unsigned sd_lim_15_0 : 16;  // Low bits of segment limit
217         unsigned sd_base_15_0 : 16; // Low bits of segment base address
218         unsigned sd_base_23_16 : 8; // Middle bits of segment base address
219         unsigned sd_type : 4;       // Segment type (see STS_ constants)
220         unsigned sd_s : 1;          // 0 = system, 1 = application
221         unsigned sd_dpl : 2;        // Descriptor Privilege Level
222         unsigned sd_p : 1;          // Present
223         unsigned sd_lim_19_16 : 4;  // High bits of segment limit
224         unsigned sd_avl : 1;        // Unused (available for software use)
225         unsigned sd_rsv1 : 1;       // Reserved
226         unsigned sd_db : 1;         // 0 = 16-bit segment, 1 = 32-bit segment
227         unsigned sd_g : 1;          // Granularity: limit scaled by 4K when set
228         unsigned sd_base_31_24 : 8; // High bits of segment base address
229 } segdesc_t;
230 // Null segment
231 #define SEG_NULL        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
232 // Segment that is loadable but faults when used
233 #define SEG_FAULT       { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
234 // Normal segment
235 #define SEG(type, base, lim, dpl)                                                                       \
236 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,       \
237     type, 1, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                        \
238     (unsigned) (base) >> 24 }
239 // System segment (LDT)
240 #define SEG_SYS(type, base, lim, dpl)                                                                   \
241 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,       \
242     type, 0, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                        \
243     (unsigned) (base) >> 24 }
244
245 #define SEG16(type, base, lim, dpl)                                                             \
246 { (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,                       \
247     type, 1, dpl, 1, (unsigned) (lim) >> 16, 0, 0, 1, 0,                        \
248     (unsigned) (base) >> 24 }
249
250 #define SEG16ROINIT(seg,type,base,lim,dpl) \
251         {\
252                 (seg).sd_lim_15_0 = SINIT((lim) & 0xffff);\
253                 (seg).sd_base_15_0 = SINIT((base)&0xffff);\
254                 (seg).sd_base_23_16 = SINIT(((base)>>16)&0xff);\
255                 (seg).sd_type = SINIT(type);\
256                 (seg).sd_s = SINIT(1);\
257                 (seg).sd_dpl = SINIT(dpl);\
258                 (seg).sd_p = SINIT(1);\
259                 (seg).sd_lim_19_16 = SINIT((unsigned)(lim)>>16);\
260                 (seg).sd_avl = SINIT(0);\
261                 (seg).sd_rsv1 = SINIT(0);\
262                 (seg).sd_db = SINIT(1);\
263                 (seg).sd_g = SINIT(0);\
264                 (seg).sd_base_31_24 = SINIT((unsigned)(base)>> 24);\
265         }
266
267 // Task state segment format (as described by the Pentium architecture book)
268 typedef struct Taskstate {
269         uint32_t ts_link;       // Old ts selector
270         uintptr_t ts_esp0;      // Stack pointers and segment selectors
271         uint16_t ts_ss0;        //   after an increase in privilege level
272         uint16_t ts_padding1;
273         uintptr_t ts_esp1;
274         uint16_t ts_ss1;
275         uint16_t ts_padding2;
276         uintptr_t ts_esp2;
277         uint16_t ts_ss2;
278         uint16_t ts_padding3;
279         physaddr_t ts_cr3;      // Page directory base
280         uintptr_t ts_eip;       // Saved state from last task switch
281         uint32_t ts_eflags;
282         uint32_t ts_eax;        // More saved state (registers)
283         uint32_t ts_ecx;
284         uint32_t ts_edx;
285         uint32_t ts_ebx;
286         uintptr_t ts_esp;
287         uintptr_t ts_ebp;
288         uint32_t ts_esi;
289         uint32_t ts_edi;
290         uint16_t ts_es;         // Even more saved state (segment selectors)
291         uint16_t ts_padding4;
292         uint16_t ts_cs;
293         uint16_t ts_padding5;
294         uint16_t ts_ss;
295         uint16_t ts_padding6;
296         uint16_t ts_ds;
297         uint16_t ts_padding7;
298         uint16_t ts_fs;
299         uint16_t ts_padding8;
300         uint16_t ts_gs;
301         uint16_t ts_padding9;
302         uint16_t ts_ldt;
303         uint16_t ts_padding10;
304         uint16_t ts_t;          // Trap on task switch
305         uint16_t ts_iomb;       // I/O map base address
306 } taskstate_t;
307
308 // Gate descriptors for interrupts and traps
309 typedef struct Gatedesc {
310         unsigned gd_off_15_0 : 16;   // low 16 bits of offset in segment
311         unsigned gd_ss : 16;         // segment selector
312         unsigned gd_args : 5;        // # args, 0 for interrupt/trap gates
313         unsigned gd_rsv1 : 3;        // reserved(should be zero I guess)
314         unsigned gd_type : 4;        // type(STS_{TG,IG32,TG32})
315         unsigned gd_s : 1;           // must be 0 (system)
316         unsigned gd_dpl : 2;         // DPL - highest ring allowed to use this
317         unsigned gd_p : 1;           // Present
318         unsigned gd_off_31_16 : 16;  // high bits of offset in segment
319 } gatedesc_t;
320
321 // Set up a normal interrupt/trap gate descriptor.
322 // - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
323 //   - interrupt gates automatically disable interrupts (cli)
324 // - sel: Code segment selector for interrupt/trap handler
325 // - off: Offset in code segment for interrupt/trap handler
326 // - dpl: Descriptor Privilege Level -
327 //        the privilege level required for software to invoke
328 //        this interrupt/trap gate explicitly using an int instruction.
329 #define SETGATE(gate, istrap, sel, off, dpl)                    \
330 {                                                               \
331         (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;         \
332         (gate).gd_ss = (sel);                                   \
333         (gate).gd_args = 0;                                     \
334         (gate).gd_rsv1 = 0;                                     \
335         (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32;        \
336         (gate).gd_s = 0;                                        \
337         (gate).gd_dpl = (dpl);                                  \
338         (gate).gd_p = 1;                                        \
339         (gate).gd_off_31_16 = (uint32_t) (off) >> 16;           \
340 }
341
342 #define ROSETGATE(gate, istrap, sel, off, dpl)                  \
343 {                                                               \
344         (gate).gd_off_15_0 = SINIT((uint32_t) (off) & 0xffff);          \
345         (gate).gd_ss = SINIT(sel);                                      \
346         (gate).gd_args = SINIT(0);                                      \
347         (gate).gd_rsv1 = SINIT(0);                                      \
348         (gate).gd_type = SINIT((istrap) ? STS_TG32 : STS_IG32); \
349         (gate).gd_s = SINIT(0);                                 \
350         (gate).gd_dpl = SINIT(dpl);                                     \
351         (gate).gd_p = SINIT(1);                                 \
352         (gate).gd_off_31_16 = SINIT((uint32_t) (off) >> 16);            \
353 }
354
355 // Set up a call gate descriptor.
356 #define SETCALLGATE(gate, ss, off, dpl)                         \
357 {                                                               \
358         (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;         \
359         (gate).gd_ss = (ss);                                    \
360         (gate).gd_args = 0;                                     \
361         (gate).gd_rsv1 = 0;                                     \
362         (gate).gd_type = STS_CG32;                              \
363         (gate).gd_s = 0;                                        \
364         (gate).gd_dpl = (dpl);                                  \
365         (gate).gd_p = 1;                                        \
366         (gate).gd_off_31_16 = (uint32_t) (off) >> 16;           \
367 }
368
369 // Pseudo-descriptors used for LGDT, LLDT and LIDT instructions.
370 typedef struct Pseudodesc {
371         uint16_t pd_lim;                // Limit
372         uint32_t pd_base;               // Base address
373 } __attribute__ ((packed)) pseudodesc_t;
374
375 extern segdesc_t (COUNT(SEG_COUNT) RO gdt)[];
376 extern pseudodesc_t gdt_pd;
377
378 #endif /* !__ASSEMBLER__ */
379
380 // Application segment type bits
381 #define STA_X           0x8         // Executable segment
382 #define STA_E           0x4         // Expand down (non-executable segments)
383 #define STA_C           0x4         // Conforming code segment (executable only)
384 #define STA_W           0x2         // Writeable (non-executable segments)
385 #define STA_R           0x2         // Readable (executable segments)
386 #define STA_A           0x1         // Accessed
387
388 // System segment type bits
389 #define STS_T16A        0x1         // Available 16-bit TSS
390 #define STS_LDT         0x2         // Local Descriptor Table
391 #define STS_T16B        0x3         // Busy 16-bit TSS
392 #define STS_CG16        0x4         // 16-bit Call Gate
393 #define STS_TG          0x5         // Task Gate / Coum Transmitions
394 #define STS_IG16        0x6         // 16-bit Interrupt Gate
395 #define STS_TG16        0x7         // 16-bit Trap Gate
396 #define STS_T32A        0x9         // Available 32-bit TSS
397 #define STS_T32B        0xB         // Busy 32-bit TSS
398 #define STS_CG32        0xC         // 32-bit Call Gate
399 #define STS_IG32        0xE         // 32-bit Interrupt Gate
400 #define STS_TG32        0xF         // 32-bit Trap Gate
401
402 #define SEG_COUNT       7               // Number of segments in the steady state
403 #define LDT_SIZE        (8192 * sizeof(segdesc_t))
404
405 #endif /* ROS_INC_ARCH_MMU_H */