arm: fix caps_map_l1 for armv5 and remove panic()s in armv7
[barrelfish] / kernel / arch / armv7 / paging.c
1 /*
2  * Copyright (c) 2009 - 2013 ETH Zurich.
3  * All rights reserved.
4  *
5  * This file is distributed under the terms in the attached LICENSE file.
6  * If you do not find this file, copies can be found by writing to:
7  * ETH Zurich D-INFK, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
8  */
9
10 #include <kernel.h>
11 #include <dispatch.h>
12 #include <cp15.h>
13 #include <paging_kernel_arch.h>
14 #include <string.h>
15 #include <exceptions.h>
16 #include <arm_hal.h>
17 #include <cap_predicates.h>
18 #include <dispatch.h>
19
20 inline static uintptr_t paging_round_down(uintptr_t address, uintptr_t size)
21 {
22     return address & ~(size - 1);
23 }
24
25 inline static uintptr_t paging_round_up(uintptr_t address, uintptr_t size)
26 {
27     return (address + size - 1) & ~(size - 1);
28 }
29
30 inline static int aligned(uintptr_t address, uintptr_t bytes)
31 {
32     return (address & (bytes - 1)) == 0;
33 }
34
35
36 union arm_l2_entry;
37 static void
38 paging_set_flags(union arm_l2_entry *entry, uintptr_t kpi_paging_flags)
39 {
40         entry->small_page.bufferable = 1;
41         entry->small_page.cacheable =
42             (kpi_paging_flags & KPI_PAGING_FLAGS_NOCACHE) ? 0 : 1;
43         entry->small_page.ap10  =
44             (kpi_paging_flags & KPI_PAGING_FLAGS_READ)  ? 2 : 0;
45         entry->small_page.ap10 |=
46             (kpi_paging_flags & KPI_PAGING_FLAGS_WRITE) ? 3 : 0;
47         entry->small_page.ap2 = 0;
48 }
49
50 static errval_t
51 caps_map_l1(struct capability* dest,
52             cslot_t            slot,
53             struct capability* src,
54             uintptr_t          kpi_paging_flags,
55             uintptr_t          offset,
56             uintptr_t          pte_count)
57 {
58     //
59     // Note:
60     //
61     // We have chicken-and-egg problem in initializing resources so
62     // instead of treating an L2 table it's actual 1K size, we treat
63     // it as being 4K. As a result when we map an "L2" table we actually
64     // map a page of memory as if it is 4 consecutive L2 tables.
65     //
66     // See lib/barrelfish/arch/arm/pmap_arch.c for more discussion.
67     //
68     const int ARM_L1_SCALE = 4;
69
70     if (src->type != ObjType_VNode_ARM_l2) {
71         //large page mapping goes here
72         assert(0 == (kpi_paging_flags & ~KPI_PAGING_FLAGS_MASK));
73
74         // ARM L1 has 4K entries, we need to fill in individual entries for
75         // 1M sections
76         // XXX: magic constant
77         if (slot >= 4096) {
78             panic("oops: slot >= 4096");
79             return SYS_ERR_VNODE_SLOT_INVALID;
80         }
81
82         if (src->type != ObjType_Frame && src->type != ObjType_DevFrame) {
83             panic("oops: src->type != ObjType_Frame && src->type != ObjType_DevFrame");
84             return SYS_ERR_WRONG_MAPPING;
85         }
86
87         // check offset within frame
88         if ((offset + pte_count * BYTES_PER_SECTION > get_size(src)) ||
89             ((offset % BYTES_PER_SECTION) != 0)) {
90             printf("offset = %"PRIuPTR", pte_count=%"PRIuPTR
91                    ", src->size = %"PRIuGENSIZE", src->type = %d\n",
92                     offset, pte_count, get_size(src), src->type);
93             panic("oops: frame offset invalid");
94             return SYS_ERR_FRAME_OFFSET_INVALID;
95         }
96
97         // check mapping does not overlap leaf page table
98         if (slot + pte_count > 4096) {
99             return SYS_ERR_VM_MAP_SIZE;
100         }
101
102         // Destination
103         lpaddr_t dest_lpaddr = gen_phys_to_local_phys(get_address(dest));
104         lvaddr_t dest_lvaddr = local_phys_to_mem(dest_lpaddr);
105
106         union arm_l1_entry* entry = ((union arm_l1_entry*)dest_lvaddr) + slot;
107         if (entry->invalid.type != L1_TYPE_INVALID_ENTRY) {
108             panic("Remapping valid page.");
109         }
110
111         lpaddr_t src_lpaddr = gen_phys_to_local_phys(get_address(src) + offset);
112         if ((src_lpaddr & (LARGE_PAGE_SIZE - 1))) {
113             panic("Invalid target");
114         }
115
116         struct cte *src_cte = cte_for_cap(src);
117         src_cte->mapping_info.pte_count = pte_count;
118         src_cte->mapping_info.pte = dest_lpaddr;
119         src_cte->mapping_info.offset = offset;
120
121         for (int i = 0; i < pte_count; i++) {
122             entry->raw = 0;
123
124             entry->section.type = L1_TYPE_SECTION_ENTRY;
125             entry->section.bufferable = 1;
126             entry->section.cacheable = (kpi_paging_flags & KPI_PAGING_FLAGS_NOCACHE)? 0: 1;
127             entry->section.ap10 = (kpi_paging_flags & KPI_PAGING_FLAGS_READ)? 2:0;
128             entry->section.ap10 |= (kpi_paging_flags & KPI_PAGING_FLAGS_WRITE)? 3:0;
129             entry->section.ap2 = 0;
130             entry->section.base_address = (src_lpaddr + i * BYTES_PER_SECTION) >> 20;
131
132             entry++;
133
134             debug(SUBSYS_PAGING, "L2 mapping %08"PRIxLVADDR"[%"PRIuCSLOT"] @%p = %08"PRIx32"\n",
135                    dest_lvaddr, slot, entry, entry->raw);
136         }
137
138         // Flush TLB if remapping.
139         cp15_invalidate_tlb();
140         return SYS_ERR_OK;
141     }
142
143     // XXX: magic constant
144     if (slot >= 4096) {
145         printf("slot = %"PRIuCSLOT"\n",slot);
146         return SYS_ERR_VNODE_SLOT_INVALID;
147     }
148
149
150     // check offset within frame
151     if ((offset + pte_count * 1024 > get_size(src)) ||
152             ((offset % 1024) != 0)) {
153         printf("offset = %"PRIuPTR", pte_count=%"PRIuPTR
154                 ", src->size = %"PRIuGENSIZE", src->type = %d\n",
155                 offset, pte_count, get_size(src), src->type);
156         return SYS_ERR_FRAME_OFFSET_INVALID;
157     }
158
159     // check mapping does not overlap leaf page table
160     if (slot + pte_count > 4096) {
161         return SYS_ERR_VM_MAP_SIZE;
162     }
163
164
165     if (slot >= ARM_L1_OFFSET(MEMORY_OFFSET)) {
166         printf("slot = %"PRIuCSLOT"\n",slot);
167         return SYS_ERR_VNODE_SLOT_RESERVED;
168     }
169
170     debug(SUBSYS_PAGING, "caps_map_l1: mapping %"PRIuPTR" L2 tables @%"PRIuCSLOT"\n",
171             pte_count, slot);
172     // Destination
173     lpaddr_t dest_lpaddr = gen_phys_to_local_phys(get_address(dest));
174     lvaddr_t dest_lvaddr = local_phys_to_mem(dest_lpaddr);
175
176     union arm_l1_entry* entry = (union arm_l1_entry*)dest_lvaddr + slot;
177
178     // Source
179     genpaddr_t src_gpaddr = get_address(src);
180     lpaddr_t   src_lpaddr = gen_phys_to_local_phys(src_gpaddr) + offset;
181
182     assert(aligned(src_lpaddr, 1u << 10));
183     assert((src_lpaddr < dest_lpaddr) || (src_lpaddr >= dest_lpaddr + 16384));
184
185     struct cte *src_cte = cte_for_cap(src);
186     src_cte->mapping_info.pte_count = pte_count;
187     src_cte->mapping_info.pte = dest_lpaddr + slot;
188     src_cte->mapping_info.offset = 0;
189
190     for (int i = 0; i < pte_count; i++, entry++)
191     {
192         entry->raw = 0;
193         entry->page_table.type   = L1_TYPE_PAGE_TABLE_ENTRY;
194         entry->page_table.domain = 0;
195         entry->page_table.base_address =
196             (src_lpaddr + i * BASE_PAGE_SIZE / ARM_L1_SCALE) >> 10;
197         debug(SUBSYS_PAGING, "L1 mapping %"PRIuCSLOT". @%p = %08"PRIx32"\n",
198               slot + i, entry, entry->raw);
199     }
200
201     cp15_invalidate_tlb();
202
203     return SYS_ERR_OK;
204 }
205
206 static errval_t
207 caps_map_l2(struct capability* dest,
208             cslot_t            slot,
209             struct capability* src,
210             uintptr_t          kpi_paging_flags,
211             uintptr_t          offset,
212             uintptr_t          pte_count)
213 {
214     assert(0 == (kpi_paging_flags & ~KPI_PAGING_FLAGS_MASK));
215
216     // ARM L2 has 256 entries, but we treat a 4K page as a consecutive
217     // region of L2 with a single index. 4K == 4 * 1K
218     if (slot >= (256 * 4)) {
219         panic("oops: slot >= (256 * 4)");
220         return SYS_ERR_VNODE_SLOT_INVALID;
221     }
222
223     if (src->type != ObjType_Frame && src->type != ObjType_DevFrame) {
224         panic("oops: src->type != ObjType_Frame && src->type != ObjType_DevFrame");
225         return SYS_ERR_WRONG_MAPPING;
226     }
227
228     // check offset within frame
229     if ((offset + BYTES_PER_PAGE > get_size(src)) ||
230         ((offset % BYTES_PER_PAGE) != 0)) {
231         panic("oops: frame offset invalid");
232         return SYS_ERR_FRAME_OFFSET_INVALID;
233     }
234
235     // check mapping does not overlap leaf page table
236     if (slot + pte_count > (256 * 4)) {
237         return SYS_ERR_VM_MAP_SIZE;
238     }
239
240     // Destination
241     lpaddr_t dest_lpaddr = gen_phys_to_local_phys(get_address(dest));
242     lvaddr_t dest_lvaddr = local_phys_to_mem(dest_lpaddr);
243
244     union arm_l2_entry* entry = (union arm_l2_entry*)dest_lvaddr + slot;
245     if (entry->small_page.type != L2_TYPE_INVALID_PAGE) {
246         panic("Remapping valid page.");
247     }
248
249     lpaddr_t src_lpaddr = gen_phys_to_local_phys(get_address(src) + offset);
250     if ((src_lpaddr & (BASE_PAGE_SIZE - 1))) {
251         panic("Invalid target");
252     }
253
254     struct cte *src_cte = cte_for_cap(src);
255     src_cte->mapping_info.pte_count = pte_count;
256     src_cte->mapping_info.pte = dest_lpaddr;
257     src_cte->mapping_info.offset = offset;
258
259     for (int i = 0; i < pte_count; i++) {
260         entry->raw = 0;
261
262         entry->small_page.type = L2_TYPE_SMALL_PAGE;
263         paging_set_flags(entry, kpi_paging_flags);
264         entry->small_page.base_address = (src_lpaddr + i * BYTES_PER_PAGE) >> 12;
265
266         debug(SUBSYS_PAGING, "L2 mapping %08"PRIxLVADDR"[%"PRIuCSLOT"] @%p = %08"PRIx32"\n",
267                dest_lvaddr, slot, entry, entry->raw);
268
269         entry++;
270     }
271
272     // Flush TLB if remapping.
273     cp15_invalidate_tlb();
274
275     return SYS_ERR_OK;
276 }
277
278 /// Create page mappings
279 errval_t caps_copy_to_vnode(struct cte *dest_vnode_cte, cslot_t dest_slot,
280                             struct cte *src_cte, uintptr_t flags,
281                             uintptr_t offset, uintptr_t pte_count)
282 {
283     struct capability *src_cap  = &src_cte->cap;
284     struct capability *dest_cap = &dest_vnode_cte->cap;
285
286     if (src_cte->mapping_info.pte) {
287         return SYS_ERR_VM_ALREADY_MAPPED;
288     }
289
290     if (ObjType_VNode_ARM_l1 == dest_cap->type) {
291         //printf("caps_map_l1: %zu\n", (size_t)pte_count);
292         return caps_map_l1(dest_cap, dest_slot, src_cap,
293                            flags,
294                            offset,
295                            pte_count
296                           );
297     }
298     else if (ObjType_VNode_ARM_l2 == dest_cap->type) {
299         //printf("caps_map_l2: %zu\n", (size_t)pte_count);
300         return caps_map_l2(dest_cap, dest_slot, src_cap,
301                            flags,
302                            offset,
303                            pte_count
304                           );
305     }
306     else {
307         panic("ObjType not VNode");
308     }
309 }
310
311 size_t do_unmap(lvaddr_t pt, cslot_t slot, size_t num_pages)
312 {
313     size_t unmapped_pages = 0;
314     union arm_l2_entry *ptentry = (union arm_l2_entry *)pt + slot;
315     for (int i = 0; i < num_pages; i++) {
316         ptentry++->raw = 0;
317         unmapped_pages++;
318     }
319     return unmapped_pages;
320 }
321
322 static inline void read_pt_entry(struct capability *pgtable,
323         size_t slot, bool is_section, genpaddr_t *paddr)
324 {
325     assert(type_is_vnode(pgtable->type));
326     assert(paddr);
327
328     genpaddr_t gp = get_address(pgtable);
329     lpaddr_t lp = gen_phys_to_local_phys(gp);
330     lvaddr_t lv = local_phys_to_mem(lp);
331
332     switch (pgtable->type) {
333         case ObjType_VNode_ARM_l1:
334         {
335             union arm_l1_entry *e = (union arm_l1_entry*)lv;
336             if (is_section) {
337                 *paddr = (genpaddr_t)(e->section.base_address) << 20;
338                 return;
339             } else {
340                 *paddr = (genpaddr_t)(e->page_table.base_address) << 10;
341                 return;
342             }
343         }
344         case ObjType_VNode_ARM_l2:
345         {
346             union arm_l2_entry *e = (union arm_l2_entry*)lv;
347             *paddr = (genpaddr_t)(e->small_page.base_address) << 12;
348             return;
349         }
350         default:
351             assert(!"Should not get here");
352     }
353 }
354
355 errval_t page_mappings_unmap(struct capability *pgtable, struct cte *mapping, size_t slot, size_t num_pages)
356 {
357     assert(type_is_vnode(pgtable->type));
358     //printf("page_mappings_unmap(%zd pages, slot = %zd)\n", num_pages, slot);
359
360     bool is_section = false;
361     if (pgtable->type == ObjType_VNode_ARM_l1) {
362         // transform slot to hw slot
363         if (mapping->cap.type == ObjType_VNode_ARM_l2) {
364             // l2 table
365             debug(SUBSYS_PAGING, "unmapping l2 tables: %zu, #pages: %zu\n",
366                     slot, num_pages);
367         }
368         else {
369             // section
370             is_section = true;
371             debug(SUBSYS_PAGING, "unmapping section: %zu, #pages: %zu\n",
372                     slot, num_pages);
373         }
374     }
375     // get page table entry data
376     genpaddr_t paddr;
377     //lpaddr_t pte;
378     read_pt_entry(pgtable, slot, is_section, &paddr);
379     lvaddr_t pt = local_phys_to_mem(gen_phys_to_local_phys(get_address(pgtable)));
380
381     // get virtual address of first page
382     // TODO: error checking
383     genvaddr_t vaddr;
384     struct cte *leaf_pt = cte_for_cap(pgtable);
385     compile_vaddr(leaf_pt, slot, &vaddr);
386     //genvaddr_t vend = vaddr + num_pages * BASE_PAGE_SIZE;
387     // printf("vaddr = 0x%"PRIxGENVADDR"\n", vaddr);
388     // printf("num_pages = %zu\n", num_pages);
389
390     // get cap for mapping
391     /*
392     struct cte *mem;
393     errval_t err = lookup_cap_for_mapping(paddr, pte, &mem);
394     if (err_is_fail(err)) {
395         printf("page_mappings_unmap: %ld\n", err);
396         return err;
397     }
398     */
399     //printf("state before unmap: mapped_pages = %zd\n", mem->mapping_info.mapped_pages);
400     //printf("state before unmap: num_pages    = %zd\n", num_pages);
401
402     if (num_pages != mapping->mapping_info.pte_count) {
403         debug(SUBSYS_PAGING, "num_pages = %zu, mapping = %zu\n",
404                 num_pages, mapping->mapping_info.pte_count);
405         // want to unmap a different amount of pages than was mapped
406         return SYS_ERR_VM_MAP_SIZE;
407     }
408
409     do_unmap(pt, slot, num_pages);
410
411     // flush TLB for unmapped pages
412     // TODO: selective TLB flush
413     cp15_invalidate_tlb();
414
415     // update mapping info
416     memset(&mapping->mapping_info, 0, sizeof(struct mapping_info));
417
418     return SYS_ERR_OK;
419 }
420
421 errval_t paging_modify_flags(struct capability *frame, uintptr_t offset,
422                              uintptr_t pages, uintptr_t kpi_paging_flags)
423 {
424     // check flags
425     assert(0 == (kpi_paging_flags & ~KPI_PAGING_FLAGS_MASK));
426
427     struct cte *mapping = cte_for_cap(frame);
428     struct mapping_info *info = &mapping->mapping_info;
429
430     /* Calculate location of page table entries we need to modify */
431     lvaddr_t base = local_phys_to_mem(info->pte) + offset;
432
433     for (int i = 0; i < pages; i++) {
434         union arm_l2_entry *entry =
435             (union arm_l2_entry *)base + i;
436         paging_set_flags(entry, kpi_paging_flags);
437     }
438
439     return paging_tlb_flush_range(mapping, offset, pages);
440 }
441
442 void paging_dump_tables(struct dcb *dispatcher)
443 {
444     printf("dump_hw_page_tables\n");
445     lvaddr_t l1 = local_phys_to_mem(dispatcher->vspace);
446
447     for (int l1_index = 0; l1_index < ARM_L1_MAX_ENTRIES; l1_index++) {
448         // get level2 table
449         union arm_l1_entry *l1_e = (union arm_l1_entry *)l1 + l1_index;
450         if (!l1_e->raw) { continue; }
451         if (l1_e->invalid.type == 2) { // section 
452             genpaddr_t paddr = (genpaddr_t)(l1_e->section.base_address) << 20;
453             printf("%d: (section) 0x%"PRIxGENPADDR"\n", l1_index, paddr);
454         } else if (l1_e->invalid.type == 1) { // l2 table
455             genpaddr_t ptable_gp = (genpaddr_t)(l1_e->page_table.base_address) << 10;
456             lvaddr_t ptable_lv = local_phys_to_mem(gen_phys_to_local_phys(ptable_gp));
457
458             printf("%d: (l2table) 0x%"PRIxGENPADDR"\n", l1_index, ptable_gp);
459
460             for (int entry = 0; entry < ARM_L2_MAX_ENTRIES; entry++) {
461                 union arm_l2_entry *e =
462                     (union arm_l2_entry *)ptable_lv + entry;
463                 genpaddr_t paddr = (genpaddr_t)(e->small_page.base_address) << BASE_PAGE_BITS;
464                 if (!paddr) {
465                     continue;
466                 }
467                 printf("%d.%d: 0x%"PRIxGENPADDR"\n", l1_index, entry, paddr);
468             }
469         }
470     }
471 }