vm mmu support
[akaros.git] / kern / arch / x86 / paging_tmpl.h
1 /*
2  * We need the mmu code to access both 32-bit and 64-bit guest ptes,
3  * so the code in this file is compiled twice, once per pte size.
4  */
5
6 #if PTTYPE == 64
7         #define pt_element_t uint64_t
8         #define guest_walker guest_walker64
9         #define FNAME(name) paging##64_##name
10         #define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK
11         #define PT_DIR_BASE_ADDR_MASK PT64_DIR_BASE_ADDR_MASK
12         #define PT_INDEX(addr, level) PT64_INDEX(addr, level)
13         #define SHADOW_PT_INDEX(addr, level) PT64_INDEX(addr, level)
14         #define PT_LEVEL_MASK(level) PT64_LEVEL_MASK(level)
15         #define PT_PTE_COPY_MASK PT64_PTE_COPY_MASK
16         #define PT_NON_PTE_COPY_MASK PT64_NON_PTE_COPY_MASK
17 #elif PTTYPE == 32
18         #define pt_element_t uint32_t
19         #define guest_walker guest_walker32
20         #define FNAME(name) paging##32_##name
21         #define PT_BASE_ADDR_MASK PT32_BASE_ADDR_MASK
22         #define PT_DIR_BASE_ADDR_MASK PT32_DIR_BASE_ADDR_MASK
23         #define PT_INDEX(addr, level) PT32_INDEX(addr, level)
24         #define SHADOW_PT_INDEX(addr, level) PT64_INDEX(addr, level)
25         #define PT_LEVEL_MASK(level) PT32_LEVEL_MASK(level)
26         #define PT_PTE_COPY_MASK PT32_PTE_COPY_MASK
27         #define PT_NON_PTE_COPY_MASK PT32_NON_PTE_COPY_MASK
28 #else
29         #error Invalid PTTYPE value
30 #endif
31
32 /*
33  * The guest_walker structure emulates the behavior of the hardware page
34  * table walker.
35  */
36 struct guest_walker {
37         int level;
38         pt_element_t *table;
39         pt_element_t inherited_ar;
40 };
41
42 static void FNAME(init_walker)(struct guest_walker *walker,
43                                struct litevm_vcpu *vcpu)
44 {
45         hpa_t hpa;
46         struct litevm_memory_slot *slot;
47
48         walker->level = vcpu->mmu.root_level;
49         slot = gfn_to_memslot(vcpu->litevm,
50                               (vcpu->cr3 & PT64_BASE_ADDR_MASK) >> PAGE_SHIFT);
51         hpa = safe_gpa_to_hpa(vcpu, vcpu->cr3 & PT64_BASE_ADDR_MASK);
52         walker->table = kmap_atomic(ppn2page(hpa >> PAGE_SHIFT));
53
54         ASSERT((!is_long_mode() && is_pae()) ||
55                (vcpu->cr3 & ~(PAGE_MASK | CR3_FLAGS_MASK)) == 0);
56
57         walker->table = (pt_element_t *)( (unsigned long)walker->table |
58                 (unsigned long)(vcpu->cr3 & ~(PAGE_MASK | CR3_FLAGS_MASK)) );
59         walker->inherited_ar = PT_USER_MASK | PT_WRITABLE_MASK;
60 }
61
62 static void FNAME(release_walker)(struct guest_walker *walker)
63 {
64         kunmap_atomic(walker->table);
65 }
66
67 static void FNAME(set_pte)(struct litevm_vcpu *vcpu, uint64_t guest_pte,
68                            uint64_t *shadow_pte, uint64_t access_bits)
69 {
70         ASSERT(*shadow_pte == 0);
71         access_bits &= guest_pte;
72         *shadow_pte = (guest_pte & PT_PTE_COPY_MASK);
73         set_pte_common(vcpu, shadow_pte, guest_pte & PT_BASE_ADDR_MASK,
74                        guest_pte & PT_DIRTY_MASK, access_bits);
75 }
76
77 static void FNAME(set_pde)(struct litevm_vcpu *vcpu, uint64_t guest_pde,
78                            uint64_t *shadow_pte, uint64_t access_bits,
79                            int index)
80 {
81         gpa_t gaddr;
82
83         ASSERT(*shadow_pte == 0);
84         access_bits &= guest_pde;
85         gaddr = (guest_pde & PT_DIR_BASE_ADDR_MASK) + PAGE_SIZE * index;
86         if (PTTYPE == 32 && is_cpuid_PSE36())
87                 gaddr |= (guest_pde & PT32_DIR_PSE36_MASK) <<
88                         (32 - PT32_DIR_PSE36_SHIFT);
89         *shadow_pte = (guest_pde & PT_NON_PTE_COPY_MASK) |
90                           ((guest_pde & PT_DIR_PAT_MASK) >>
91                                     (PT_DIR_PAT_SHIFT - PT_PAT_SHIFT));
92         set_pte_common(vcpu, shadow_pte, gaddr,
93                        guest_pde & PT_DIRTY_MASK, access_bits);
94 }
95
96 /*
97  * Fetch a guest pte from a specific level in the paging hierarchy.
98  */
99 static pt_element_t *FNAME(fetch_guest)(struct litevm_vcpu *vcpu,
100                                         struct guest_walker *walker,
101                                         int level,
102                                         gva_t addr)
103 {
104
105         ASSERT(level > 0  && level <= walker->level);
106
107         for (;;) {
108                 int index = PT_INDEX(addr, walker->level);
109                 hpa_t paddr;
110
111                 ASSERT(((unsigned long)walker->table & PAGE_MASK) ==
112                        ((unsigned long)&walker->table[index] & PAGE_MASK));
113                 if (level == walker->level ||
114                     !is_present_pte(walker->table[index]) ||
115                     (walker->level == PT_DIRECTORY_LEVEL &&
116                      (walker->table[index] & PT_PAGE_SIZE_MASK) &&
117                      (PTTYPE == 64 || is_pse())))
118                         return &walker->table[index];
119                 if (walker->level != 3 || is_long_mode())
120                         walker->inherited_ar &= walker->table[index];
121                 paddr = safe_gpa_to_hpa(vcpu, walker->table[index] & PT_BASE_ADDR_MASK);
122                 kunmap_atomic(walker->table);
123                 walker->table = kmap_atomic(pfn_to_page(paddr >> PAGE_SHIFT));
124                 --walker->level;
125         }
126 }
127
128 /*
129  * Fetch a shadow pte for a specific level in the paging hierarchy.
130  */
131 static uint64_t *FNAME(fetch)(struct litevm_vcpu *vcpu, gva_t addr,
132                               struct guest_walker *walker)
133 {
134         hpa_t shadow_addr;
135         int level;
136         uint64_t *prev_shadow_ent = NULL;
137
138         shadow_addr = vcpu->mmu.root_hpa;
139         level = vcpu->mmu.shadow_root_level;
140
141         for (; ; level--) {
142                 uint32_t index = SHADOW_PT_INDEX(addr, level);
143                 uint64_t *shadow_ent = ((uint64_t *)KADDR(shadow_addr)) + index;
144                 pt_element_t *guest_ent;
145
146                 if (is_present_pte(*shadow_ent) || is_io_pte(*shadow_ent)) {
147                         if (level == PT_PAGE_TABLE_LEVEL)
148                                 return shadow_ent;
149                         shadow_addr = *shadow_ent & PT64_BASE_ADDR_MASK;
150                         prev_shadow_ent = shadow_ent;
151                         continue;
152                 }
153
154                 if (PTTYPE == 32 && level > PT32_ROOT_LEVEL) {
155                         ASSERT(level == PT32E_ROOT_LEVEL);
156                         guest_ent = FNAME(fetch_guest)(vcpu, walker,
157                                                        PT32_ROOT_LEVEL, addr);
158                 } else
159                         guest_ent = FNAME(fetch_guest)(vcpu, walker,
160                                                        level, addr);
161
162                 if (!is_present_pte(*guest_ent))
163                         return NULL;
164
165                 /* Don't set accessed bit on PAE PDPTRs */
166                 if (vcpu->mmu.root_level != 3 || walker->level != 3)
167                         *guest_ent |= PT_ACCESSED_MASK;
168
169                 if (level == PT_PAGE_TABLE_LEVEL) {
170
171                         if (walker->level == PT_DIRECTORY_LEVEL) {
172                                 if (prev_shadow_ent)
173                                         *prev_shadow_ent |= PT_SHADOW_PS_MARK;
174                                 FNAME(set_pde)(vcpu, *guest_ent, shadow_ent,
175                                                walker->inherited_ar,
176                                           PT_INDEX(addr, PT_PAGE_TABLE_LEVEL));
177                         } else {
178                                 ASSERT(walker->level == PT_PAGE_TABLE_LEVEL);
179                                 FNAME(set_pte)(vcpu, *guest_ent, shadow_ent, walker->inherited_ar);
180                         }
181                         return shadow_ent;
182                 }
183
184                 shadow_addr = litevm_mmu_alloc_page(vcpu, shadow_ent);
185                 if (!VALID_PAGE(shadow_addr))
186                         return ERR_PTR(-ENOMEM);
187                 if (!is_long_mode() && level == 3)
188                         *shadow_ent = shadow_addr |
189                                 (*guest_ent & (PT_PRESENT_MASK | PT_PWT_MASK | PT_PCD_MASK));
190                 else {
191                         *shadow_ent = shadow_addr |
192                                 (*guest_ent & PT_NON_PTE_COPY_MASK);
193                         *shadow_ent |= (PT_WRITABLE_MASK | PT_USER_MASK);
194                 }
195                 prev_shadow_ent = shadow_ent;
196         }
197 }
198
199 /*
200  * The guest faulted for write.  We need to
201  *
202  * - check write permissions
203  * - update the guest pte dirty bit
204  * - update our own dirty page tracking structures
205  */
206 static int FNAME(fix_write_pf)(struct litevm_vcpu *vcpu,
207                                uint64_t *shadow_ent,
208                                struct guest_walker *walker,
209                                gva_t addr,
210                                int user)
211 {
212         pt_element_t *guest_ent;
213         int writable_shadow;
214         gfn_t gfn;
215
216         if (is_writeble_pte(*shadow_ent))
217                 return 0;
218
219         writable_shadow = *shadow_ent & PT_SHADOW_WRITABLE_MASK;
220         if (user) {
221                 /*
222                  * User mode access.  Fail if it's a kernel page or a read-only
223                  * page.
224                  */
225                 if (!(*shadow_ent & PT_SHADOW_USER_MASK) || !writable_shadow)
226                         return 0;
227                 ASSERT(*shadow_ent & PT_USER_MASK);
228         } else
229                 /*
230                  * Kernel mode access.  Fail if it's a read-only page and
231                  * supervisor write protection is enabled.
232                  */
233                 if (!writable_shadow) {
234                         if (is_write_protection())
235                                 return 0;
236                         *shadow_ent &= ~PT_USER_MASK;
237                 }
238
239         guest_ent = FNAME(fetch_guest)(vcpu, walker, PT_PAGE_TABLE_LEVEL, addr);
240
241         if (!is_present_pte(*guest_ent)) {
242                 *shadow_ent = 0;
243                 return 0;
244         }
245
246         gfn = (*guest_ent & PT64_BASE_ADDR_MASK) >> PAGE_SHIFT;
247         mark_page_dirty(vcpu->litevm, gfn);
248         *shadow_ent |= PT_WRITABLE_MASK;
249         *guest_ent |= PT_DIRTY_MASK;
250
251         return 1;
252 }
253
254 /*
255  * Page fault handler.  There are several causes for a page fault:
256  *   - there is no shadow pte for the guest pte
257  *   - write access through a shadow pte marked read only so that we can set
258  *     the dirty bit
259  *   - write access to a shadow pte marked read only so we can update the page
260  *     dirty bitmap, when userspace requests it
261  *   - mmio access; in this case we will never install a present shadow pte
262  *   - normal guest page fault due to the guest pte marked not present, not
263  *     writable, or not executable
264  *
265  *  Returns: 1 if we need to emulate the instruction, 0 otherwise
266  */
267 static int FNAME(page_fault)(struct litevm_vcpu *vcpu, gva_t addr,
268                                uint32_t error_code)
269 {
270         int write_fault = error_code & PFERR_WRITE_MASK;
271         int pte_present = error_code & PFERR_PRESENT_MASK;
272         int user_fault = error_code & PFERR_USER_MASK;
273         struct guest_walker walker;
274         uint64_t *shadow_pte;
275         int fixed;
276
277         /*
278          * Look up the shadow pte for the faulting address.
279          */
280         for (;;) {
281                 FNAME(init_walker)(&walker, vcpu);
282                 shadow_pte = FNAME(fetch)(vcpu, addr, &walker);
283                 if (IS_ERR(shadow_pte)) {  /* must be -ENOMEM */
284                         nonpaging_flush(vcpu);
285                         FNAME(release_walker)(&walker);
286                         continue;
287                 }
288                 break;
289         }
290
291         /*
292          * The page is not mapped by the guest.  Let the guest handle it.
293          */
294         if (!shadow_pte) {
295                 inject_page_fault(vcpu, addr, error_code);
296                 FNAME(release_walker)(&walker);
297                 return 0;
298         }
299
300         /*
301          * Update the shadow pte.
302          */
303         if (write_fault)
304                 fixed = FNAME(fix_write_pf)(vcpu, shadow_pte, &walker, addr,
305                                             user_fault);
306         else
307                 fixed = fix_read_pf(shadow_pte);
308
309         FNAME(release_walker)(&walker);
310
311         /*
312          * mmio: emulate if accessible, otherwise its a guest fault.
313          */
314         if (is_io_pte(*shadow_pte)) {
315                 if (may_access(*shadow_pte, write_fault, user_fault))
316                         return 1;
317                 pgprintk("%s: io work, no access\n", __FUNCTION__);
318                 inject_page_fault(vcpu, addr,
319                                   error_code | PFERR_PRESENT_MASK);
320                 return 0;
321         }
322
323         /*
324          * pte not present, guest page fault.
325          */
326         if (pte_present && !fixed) {
327                 inject_page_fault(vcpu, addr, error_code);
328                 return 0;
329         }
330
331         ++litevm_stat.pf_fixed;
332
333         return 0;
334 }
335
336 static gpa_t FNAME(gva_to_gpa)(struct litevm_vcpu *vcpu, gva_t vaddr)
337 {
338         struct guest_walker walker;
339         pt_element_t guest_pte;
340         gpa_t gpa;
341
342         FNAME(init_walker)(&walker, vcpu);
343         guest_pte = *FNAME(fetch_guest)(vcpu, &walker, PT_PAGE_TABLE_LEVEL,
344                                         vaddr);
345         FNAME(release_walker)(&walker);
346
347         if (!is_present_pte(guest_pte))
348                 return UNMAPPED_GVA;
349
350         if (walker.level == PT_DIRECTORY_LEVEL) {
351                 ASSERT((guest_pte & PT_PAGE_SIZE_MASK));
352                 ASSERT(PTTYPE == 64 || is_pse());
353
354                 gpa = (guest_pte & PT_DIR_BASE_ADDR_MASK) | (vaddr &
355                         (PT_LEVEL_MASK(PT_PAGE_TABLE_LEVEL) | ~PAGE_MASK));
356
357                 if (PTTYPE == 32 && is_cpuid_PSE36())
358                         gpa |= (guest_pte & PT32_DIR_PSE36_MASK) <<
359                                         (32 - PT32_DIR_PSE36_SHIFT);
360         } else {
361                 gpa = (guest_pte & PT_BASE_ADDR_MASK);
362                 gpa |= (vaddr & ~PAGE_MASK);
363         }
364
365         return gpa;
366 }
367
368 #undef pt_element_t
369 #undef guest_walker
370 #undef FNAME
371 #undef PT_BASE_ADDR_MASK
372 #undef PT_INDEX
373 #undef SHADOW_PT_INDEX
374 #undef PT_LEVEL_MASK
375 #undef PT_PTE_COPY_MASK
376 #undef PT_NON_PTE_COPY_MASK
377 #undef PT_DIR_BASE_ADDR_MASK