857b2b07576074889be29093c81b00602af6e5ab
[akaros.git] / kern / arch / x86 / ros / mmu64.h
1 #ifndef ROS_INC_ARCH_MMU64_H
2 #define ROS_INC_ARCH_MMU64_H
3
4 #ifndef ROS_INC_ARCH_MMU_H
5 #error "Do not include include ros/arch/mmu64.h directly"
6 #endif
7
8 #ifndef __ASSEMBLER__
9 #include <ros/common.h>
10 typedef unsigned long pte_t;
11 typedef unsigned long pde_t;
12 #endif
13
14 // TODO: 64 bit
15 /* x86's 32 bit Virtual Memory Map.  Symbols are similar on other archs
16  *
17  * Virtual memory map:                                Permissions
18  *                                                    kernel/user
19  *
20  *    4 Gig -------->  +------------------------------+
21  *                     :              .               :
22  *  KERN_LOAD_ADDR,    +------------------------------+ 0xffffffffc0000000
23  *  KERN_VMAP_TOP      |                              |
24  *                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ RW/--
25  *                     :              .               :
26  *                     :              .               :
27  *                     :              .               :
28  *                     |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| RW/--
29  *                     |                              | RW/--
30  *                     |   Remapped Physical Memory   | RW/--
31  *                     |                              | RW/--
32  *    KERNBASE ----->  +------------------------------+ 0xffff80000000
33  *
34  *
35  *
36  *                     |  Cur. Page Table (Kern. RW)  | RW/--  PTSIZE
37  *    VPT          --> +------------------------------+ 0xbfc00000
38  *                     |          Local APIC          | RW/--  PGSIZE
39  *    LAPIC        --> +------------------------------+ 0xbfbff000
40  *                     |            IOAPIC            | RW/--  PGSIZE
41  *    IOAPIC,      --> +------------------------------+ 0xbfbfe000
42  *  KERN_DYN_TOP       |   Kernel Dynamic Mappings    |
43  *                     |              .               |
44  *                     :              .               :
45  *                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ RW/--
46  *                     :                              :
47  *                     |      Invalid Memory (*)      | --/--
48  *    ULIM      ---->  +------------------------------+ 0x80000000      --+
49  *                     |  Cur. Page Table (User R-)   | R-/R-  PTSIZE     |
50  *    UVPT      ---->  +------------------------------+ 0x7fc00000      --+
51  *                     | Unmapped (expandable region) |                   |
52  *                     |                              | R-/R-            PTSIZE
53  *                     |     Per-Process R/O Info     |                   |
54  * UWLIM, UINFO ---->  +------------------------------+ 0x7f800000      --+
55  *                     | Unmapped (expandable region) |                   |
56  *                     |                              | RW/RW            PTSIZE
57  *                     |     Per-Process R/W Data     |                   |
58  *    UDATA     ---->  +------------------------------+ 0x7f400000      --+
59  *    UMAPTOP,         |    Global Shared R/W Data    | RW/RW  PGSIZE
60  * UXSTACKTOP,UGDATA ->+------------------------------+ 0x7f3ff000
61  *                     |     User Exception Stack     | RW/RW  PGSIZE
62  *                     +------------------------------+ 0x7f3fe000
63  *                     |       Empty Memory (*)       | --/--  PGSIZE
64  *    USTACKTOP  --->  +------------------------------+ 0x7f3fd000
65  *                     |      Normal User Stack       | RW/RW  256*PGSIZE (1MB)
66  *                     +------------------------------+ 0x7f2fd000
67  *                     |       Empty Memory (*)       | --/--  PGSIZE
68  *    USTACKBOT  --->  +------------------------------+ 0x7f2fc000
69  *                     |                              |
70  *                     |                              |
71  *                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
72  *                     .                              .
73  *                     .                              .
74  *                     .                              .
75  *                     |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
76  *                     |     Program Data & Heap      |
77  *    UTEXT -------->  +------------------------------+ 0x00800000
78  *    PFTEMP ------->  |       Empty Memory (*)       |        PTSIZE
79  *                     |                              |
80  *    UTEMP -------->  +------------------------------+ 0x00400000      --+
81  *                     |       Empty Memory (*)       |                   |
82  *                     | - - - - - - - - - - - - - - -|                   |
83  *                     |  User STAB Data (optional)   |                 PTSIZE
84  *    USTABDATA ---->  +------------------------------+ 0x00200000        |
85  *                     |       Empty Memory (*)       |                   |
86  *    0 ------------>  +------------------------------+                 --+
87  *
88  * (*) Note: The kernel ensures that "Invalid Memory" (ULIM) is *never*
89  *     mapped.  "Empty Memory" is normally unmapped, but user programs may
90  *     map pages there if desired.  ROS user programs map pages temporarily
91  *     at UTEMP.
92  */
93
94
95 // At IOPHYSMEM (640K) there is a 384K hole for I/O.  From the kernel,
96 // IOPHYSMEM can be addressed at KERNBASE + IOPHYSMEM.  The hole ends
97 // at physical address EXTPHYSMEM.
98 #define IOPHYSMEM       0x0A0000
99 #define VGAPHYSMEM      0x0A0000
100 #define DEVPHYSMEM      0x0C0000
101 #define BIOSPHYSMEM     0x0F0000
102 #define EXTPHYSMEM      0x100000
103
104 /* **************************************** */
105 /* Kernel Virtual Memory Mapping  (not really an MMU thing) */
106
107 #define KERNBASE        0xffff800000000000
108 #define KERN_LOAD_ADDR  0xffffffffc0000000
109 /* Top of the kernel virtual mapping area (KERNBASE) */
110 #define KERN_VMAP_TOP   KERN_LOAD_ADDR /* upper 2GB reserved */
111
112 /* Static kernel mappings */
113 /* Virtual page table.  Entry PDX(VPT) in the PD contains a pointer to
114  * the page directory itself, thereby turning the PD into a page table,
115  * which maps all the PTEs containing the page mappings for the entire
116  * virtual address space into that 4 Meg region starting at VPT. */
117 #define VPT                             (KERN_LOAD_ADDR - PTSIZE)
118 #define LAPIC_BASE              (VPT - PGSIZE)
119 #define IOAPIC_BASE             (LAPIC_BASE - PGSIZE)
120
121 /* All arches must define this, which is the lower limit of their static
122  * mappings, and where the dynamic mappings will start. */
123 #define KERN_DYN_TOP    IOAPIC_BASE
124
125 /* Highest user address: 0x00007fffffffffff: 1 zero, 47 ones, sign extended */
126 #define ULIM            0x0000800000000000
127
128 // Use this if needed in annotations
129 //#define IVY_KERNBASE (0xC000U << 16)
130
131 /* **************************************** */
132 /* Page table constants, macros, etc */
133
134 // A linear address 'la' has a three-part structure as follows:
135 //
136 // +--------10------+-------10-------+---------12----------+
137 // | Page Directory |   Page Table   | Offset within Page  |
138 // |      Index     |      Index     |                     |
139 // +----------------+----------------+---------------------+
140 //  \--- PDX(la) --/ \--- PTX(la) --/ \---- PGOFF(la) ----/
141 //  \----------- PPN(la) -----------/
142 //
143 // The PDX, PTX, PGOFF, and PPN macros decompose linear addresses as shown.
144 // To construct a linear address la from PDX(la), PTX(la), and PGOFF(la),
145 // use PGADDR(PDX(la), PTX(la), PGOFF(la)).
146
147 // page number field of address
148 #define LA2PPN(la)      (((uintptr_t) (la)) >> PGSHIFT)
149 #define PTE2PPN(pte)    LA2PPN(pte)
150 #define VPN(la)         PPN(la)         // used to index into vpt[]
151
152 // page directory index
153 #define PDX(la)         ((((uintptr_t) (la)) >> PDXSHIFT) & 0x3FF)
154 #define VPD(la)         PDX(la)         // used to index into vpd[]
155
156 // page table index
157 #define PTX(la)         ((((uintptr_t) (la)) >> PTXSHIFT) & 0x3FF)
158
159 // offset in page
160 #define PGOFF(la)       (((uintptr_t) (la)) & 0xFFF)
161
162 // offset in jumbo page
163 #define JPGOFF(la)      (((uintptr_t) (la)) & 0x003FFFFF)
164
165 // construct PTE from PPN and flags
166 #define PTE(ppn, flags) ((ppn) << PTXSHIFT | PGOFF(flags))
167
168 // construct linear address from indexes and offset
169 #define PGADDR(d, t, o) ((void*SNT) ((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))
170
171 // Page directory and page table constants.
172 #define NPDENTRIES      1024            // page directory entries per page directory
173 #define NPTENTRIES      1024            // page table entries per page table
174
175 #define PTXSHIFT        12              // offset of PTX in a linear address
176 #define PDXSHIFT        22              // offset of PDX in a linear address
177
178 // Page table/directory entry flags.
179 #define PTE_P           0x001   // Present
180 #define PTE_W           0x002   // Writeable
181 #define PTE_U           0x004   // User
182 #define PTE_PWT         0x008   // Write-Through
183 #define PTE_PCD         0x010   // Cache-Disable
184 #define PTE_A           0x020   // Accessed
185 #define PTE_D           0x040   // Dirty
186 #define PTE_PS          0x080   // Page Size (only applies to PDEs)
187 #define PTE_PAT         0x080   // PAT (only applies to second layer PTEs)
188 #define PTE_G           0x100   // Global Page
189
190 #define PTE_PERM        (PTE_W | PTE_U) // The permissions fields
191 // commly used access modes
192 #define PTE_KERN_RW     PTE_W           // Kernel Read/Write
193 #define PTE_KERN_RO     0               // Kernel Read-Only
194 #define PTE_USER_RW     (PTE_W | PTE_U) // Kernel/User Read/Write
195 #define PTE_USER_RO     PTE_U           // Kernel/User Read-Only
196
197 // The PTE_AVAIL bits aren't used by the kernel or interpreted by the
198 // hardware, so user processes are allowed to set them arbitrarily.
199 #define PTE_AVAIL       0xE00   // Available for software use
200
201 // Only flags in PTE_USER may be used in system calls.
202 #define PTE_USER        (PTE_AVAIL | PTE_P | PTE_W | PTE_U)
203
204 // address in page table entry
205 #define PTE_ADDR(pte)   ((physaddr_t) (pte) & ~0xFFF)
206
207 #define PTSHIFT 22
208 #define PTSIZE (1 << PTSHIFT)
209 #define PGSHIFT 12
210 #define PGSIZE (1 << PGSHIFT)
211 #define JPGSIZE PTSIZE
212
213 // we must guarantee that for any PTE, exactly one of the following is true
214 #define PAGE_PRESENT(pte) ((pte) & PTE_P)
215 #define PAGE_UNMAPPED(pte) ((pte) == 0)
216 #define PAGE_PAGED_OUT(pte) (!PAGE_PRESENT(pte) && !PAGE_UNMAPPED(pte))
217
218 /* **************************************** */
219 /* Segmentation */
220 // XXX 64b: these all need redone
221
222 // Global descriptor numbers
223 #define GD_NULL   0x00     // NULL descriptor
224 #define GD_KT     0x08     // kernel text
225 #define GD_KD     0x10     // kernel data
226 #define GD_UT     0x18     // user text
227 #define GD_UD     0x20     // user data
228 #define GD_TSS    0x28     // Task segment selector
229 #define GD_LDT    0x30     // local descriptor table
230
231 #ifdef __ASSEMBLER__
232
233 /* Macros to build GDT entries in assembly. */
234 #define SEG_NULL                                                \
235         .word 0, 0;                                             \
236         .byte 0, 0, 0, 0
237
238 /* 64 bit code segment.  This is for long mode, no compatibility.  If we want
239  * to support 32 bit apps later, we'll want to adjust this. */
240 #define SEG_CODE_64(dpl)                                                    \
241         .word 0, 0;                                                             \
242         .byte 0;                                                                \
243         .byte (((1/*p*/) << 7) | ((dpl) << 5) | 0x18 | ((0/*c*/) << 2));        \
244         .byte (((0/*d*/) << 6) | ((1/*l*/) << 5));                              \
245         .byte 0;
246
247 /* 64 bit data segment.  These are pretty much completely ignored (except if we
248  * use them for fs/gs, or compatibility mode */
249 #define SEG_DATA_64                                                         \
250         .word 0, 0;                                                             \
251         .byte 0;                                                                \
252         .byte 0x90;                                                             \
253         .word 0;
254
255 /* Default segment (32 bit style).  Would work for fs/gs, if needed */
256 #define SEG(type, base, lim)                                                \
257         .word (((lim) >> 12) & 0xffff);                                         \
258         .word ((base) & 0xffff);                                                \
259         .byte (((base) >> 16) & 0xff);                                          \
260         .byte (0x90 | (type));                                                  \
261         .byte (0xC0 | (((lim) >> 28) & 0xf));                                   \
262         .byte (((base) >> 24) & 0xff)
263
264 #else   // not __ASSEMBLER__
265
266 // Segment Descriptors
267 typedef struct Segdesc {
268         unsigned sd_lim_15_0 : 16;  // Low bits of segment limit
269         unsigned sd_base_15_0 : 16; // Low bits of segment base address
270         unsigned sd_base_23_16 : 8; // Middle bits of segment base address
271         unsigned sd_type : 4;       // Segment type (see STS_ constants)
272         unsigned sd_s : 1;          // 0 = system, 1 = application
273         unsigned sd_dpl : 2;        // Descriptor Privilege Level
274         unsigned sd_p : 1;          // Present
275         unsigned sd_lim_19_16 : 4;  // High bits of segment limit
276         unsigned sd_avl : 1;        // Unused (available for software use)
277         unsigned sd_rsv1 : 1;       // Reserved
278         unsigned sd_db : 1;         // 0 = 16-bit segment, 1 = 32-bit segment
279         unsigned sd_g : 1;          // Granularity: limit scaled by 4K when set
280         unsigned sd_base_31_24 : 8; // High bits of segment base address
281 } segdesc_t;
282 // Null segment
283 #define SEG_NULL        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
284 // Segment that is loadable but faults when used
285 #define SEG_FAULT       { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
286 // Normal segment
287 #define SEG(type, base, lim, dpl)                                                                       \
288 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,       \
289     type, 1, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                        \
290     (unsigned) (base) >> 24 }
291 // System segment (LDT)
292 #define SEG_SYS(type, base, lim, dpl)                                                                   \
293 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,       \
294     type, 0, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                        \
295     (unsigned) (base) >> 24 }
296
297 #define SEG16(type, base, lim, dpl)                                                             \
298 { (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,                       \
299     type, 1, dpl, 1, (unsigned) (lim) >> 16, 0, 0, 1, 0,                        \
300     (unsigned) (base) >> 24 }
301
302 #define SEG16ROINIT(seg,type,base,lim,dpl) \
303         {\
304                 (seg).sd_lim_15_0 = SINIT((lim) & 0xffff);\
305                 (seg).sd_base_15_0 = SINIT((uintptr_t)(base)&0xffff);\
306                 (seg).sd_base_23_16 = SINIT(((uintptr_t)(base)>>16)&0xff);\
307                 (seg).sd_type = SINIT(type);\
308                 (seg).sd_s = SINIT(1);\
309                 (seg).sd_dpl = SINIT(dpl);\
310                 (seg).sd_p = SINIT(1);\
311                 (seg).sd_lim_19_16 = SINIT((unsigned)(lim)>>16);\
312                 (seg).sd_avl = SINIT(0);\
313                 (seg).sd_rsv1 = SINIT(0);\
314                 (seg).sd_db = SINIT(1);\
315                 (seg).sd_g = SINIT(0);\
316                 (seg).sd_base_31_24 = SINIT((uintptr_t)(base)>> 24);\
317         }
318
319 // Task state segment format (as described by the Pentium architecture book)
320 typedef struct Taskstate {
321         uintptr_t ts_link;      // Old ts selector
322         uintptr_t ts_esp0;      // Stack pointers and segment selectors
323         uint16_t ts_ss0;        //   after an increase in privilege level
324         uint16_t ts_padding1;
325         uintptr_t ts_esp1;
326         uint16_t ts_ss1;
327         uint16_t ts_padding2;
328         uintptr_t ts_esp2;
329         uint16_t ts_ss2;
330         uint16_t ts_padding3;
331         physaddr_t ts_cr3;      // Page directory base
332         uintptr_t ts_eip;       // Saved state from last task switch
333         uintptr_t ts_eflags;
334         uintptr_t ts_eax;       // More saved state (registers)
335         uintptr_t ts_ecx;
336         uintptr_t ts_edx;
337         uintptr_t ts_ebx;
338         uintptr_t ts_esp;
339         uintptr_t ts_ebp;
340         uintptr_t ts_esi;
341         uintptr_t ts_edi;
342         uint16_t ts_es;         // Even more saved state (segment selectors)
343         uint16_t ts_padding4;
344         uint16_t ts_cs;
345         uint16_t ts_padding5;
346         uint16_t ts_ss;
347         uint16_t ts_padding6;
348         uint16_t ts_ds;
349         uint16_t ts_padding7;
350         uint16_t ts_fs;
351         uint16_t ts_padding8;
352         uint16_t ts_gs;
353         uint16_t ts_padding9;
354         uint16_t ts_ldt;
355         uint16_t ts_padding10;
356         uint16_t ts_t;          // Trap on task switch
357         uint16_t ts_iomb;       // I/O map base address
358 } taskstate_t;
359
360 // Gate descriptors for interrupts and traps
361 typedef struct Gatedesc {
362         unsigned gd_off_15_0 : 16;   // low 16 bits of offset in segment
363         unsigned gd_ss : 16;         // segment selector
364         unsigned gd_args : 5;        // # args, 0 for interrupt/trap gates
365         unsigned gd_rsv1 : 3;        // reserved(should be zero I guess)
366         unsigned gd_type : 4;        // type(STS_{TG,IG32,TG32})
367         unsigned gd_s : 1;           // must be 0 (system)
368         unsigned gd_dpl : 2;         // DPL - highest ring allowed to use this
369         unsigned gd_p : 1;           // Present
370         unsigned gd_off_31_16 : 16;  // high bits of offset in segment
371 } gatedesc_t;
372
373 // Set up a normal interrupt/trap gate descriptor.
374 // - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
375 //   - interrupt gates automatically disable interrupts (cli)
376 // - sel: Code segment selector for interrupt/trap handler
377 // - off: Offset in code segment for interrupt/trap handler
378 // - dpl: Descriptor Privilege Level -
379 //        the privilege level required for software to invoke
380 //        this interrupt/trap gate explicitly using an int instruction.
381 #define SETGATE(gate, istrap, sel, off, dpl)                    \
382 {                                                               \
383         (gate).gd_off_15_0 = (uintptr_t) (off) & 0xffff;                \
384         (gate).gd_ss = (sel);                                   \
385         (gate).gd_args = 0;                                     \
386         (gate).gd_rsv1 = 0;                                     \
387         (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32;        \
388         (gate).gd_s = 0;                                        \
389         (gate).gd_dpl = (dpl);                                  \
390         (gate).gd_p = 1;                                        \
391         (gate).gd_off_31_16 = (uintptr_t) (off) >> 16;          \
392 }
393
394 #define ROSETGATE(gate, istrap, sel, off, dpl)                  \
395 {                                                               \
396         (gate).gd_off_15_0 = SINIT((uintptr_t) (off) & 0xffff);         \
397         (gate).gd_ss = SINIT(sel);                                      \
398         (gate).gd_args = SINIT(0);                                      \
399         (gate).gd_rsv1 = SINIT(0);                                      \
400         (gate).gd_type = SINIT((istrap) ? STS_TG32 : STS_IG32); \
401         (gate).gd_s = SINIT(0);                                 \
402         (gate).gd_dpl = SINIT(dpl);                                     \
403         (gate).gd_p = SINIT(1);                                 \
404         (gate).gd_off_31_16 = SINIT((uintptr_t) (off) >> 16);           \
405 }
406
407 // Set up a call gate descriptor.
408 #define SETCALLGATE(gate, ss, off, dpl)                         \
409 {                                                               \
410         (gate).gd_off_15_0 = (uintptr_t) (off) & 0xffff;                \
411         (gate).gd_ss = (ss);                                    \
412         (gate).gd_args = 0;                                     \
413         (gate).gd_rsv1 = 0;                                     \
414         (gate).gd_type = STS_CG32;                              \
415         (gate).gd_s = 0;                                        \
416         (gate).gd_dpl = (dpl);                                  \
417         (gate).gd_p = 1;                                        \
418         (gate).gd_off_31_16 = (uintptr_t) (off) >> 16;          \
419 }
420
421 // Pseudo-descriptors used for LGDT, LLDT and LIDT instructions.
422 typedef struct Pseudodesc {
423         uint16_t pd_lim;                // Limit
424         uintptr_t pd_base;              // Base address
425 } __attribute__ ((packed)) pseudodesc_t;
426
427 extern segdesc_t (COUNT(SEG_COUNT) RO gdt)[];
428 extern pseudodesc_t gdt_pd;
429
430 #endif /* !__ASSEMBLER__ */
431
432 // Application segment type bits
433 #define STA_X           0x8         // Executable segment
434 #define STA_E           0x4         // Expand down (non-executable segments)
435 #define STA_C           0x4         // Conforming code segment (executable only)
436 #define STA_W           0x2         // Writeable (non-executable segments)
437 #define STA_R           0x2         // Readable (executable segments)
438 #define STA_A           0x1         // Accessed
439
440 // System segment type bits
441 #define STS_T16A        0x1         // Available 16-bit TSS
442 #define STS_LDT         0x2         // Local Descriptor Table
443 #define STS_T16B        0x3         // Busy 16-bit TSS
444 #define STS_CG16        0x4         // 16-bit Call Gate
445 #define STS_TG          0x5         // Task Gate / Coum Transmitions
446 #define STS_IG16        0x6         // 16-bit Interrupt Gate
447 #define STS_TG16        0x7         // 16-bit Trap Gate
448 #define STS_T32A        0x9         // Available 32-bit TSS
449 #define STS_T32B        0xB         // Busy 32-bit TSS
450 #define STS_CG32        0xC         // 32-bit Call Gate
451 #define STS_IG32        0xE         // 32-bit Interrupt Gate
452 #define STS_TG32        0xF         // 32-bit Trap Gate
453
454 #define SEG_COUNT       7               // Number of segments in the steady state
455 #define LDT_SIZE        (8192 * sizeof(segdesc_t))
456 #endif /* ROS_INC_ARCH_MMU64_H */