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