5195932030507f384b9759d9851bb39222915201
[barrelfish] / kernel / arch / armv7 / paging.c
1 /*
2  * Copyright (c) 2009 - 2012 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, Haldeneggsteig 4, 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 (slot >= 1024) {
71         printf("slot = %"PRIuCSLOT"\n",slot);
72         panic("oops: slot id >= 1024");
73         return SYS_ERR_VNODE_SLOT_INVALID;
74     }
75
76     if (pte_count != 1) {
77         printf("pte_count = %zu\n",(size_t)pte_count);
78         panic("oops: pte_count");
79         return SYS_ERR_VM_MAP_SIZE;
80     }
81
82     if (src->type != ObjType_VNode_ARM_l2) {
83         panic("oops: wrong src type");
84         return SYS_ERR_WRONG_MAPPING;
85     }
86
87     if (slot >= ARM_L1_OFFSET(MEMORY_OFFSET) / ARM_L1_SCALE) {
88         printf("slot = %"PRIuCSLOT"\n",slot);
89         panic("oops: slot id");
90         return SYS_ERR_VNODE_SLOT_RESERVED;
91     }
92
93     // Destination
94     lpaddr_t dest_lpaddr = gen_phys_to_local_phys(get_address(dest));
95     lvaddr_t dest_lvaddr = local_phys_to_mem(dest_lpaddr);
96
97     union arm_l1_entry* entry = (union arm_l1_entry*)dest_lvaddr + (slot * ARM_L1_SCALE);
98
99     // Source
100     genpaddr_t src_gpaddr = get_address(src);
101     lpaddr_t   src_lpaddr = gen_phys_to_local_phys(src_gpaddr);
102
103     assert(offset == 0);
104     assert(aligned(src_lpaddr, 1u << 10));
105     assert((src_lpaddr < dest_lpaddr) || (src_lpaddr >= dest_lpaddr + 16384));
106
107     struct cte *src_cte = cte_for_cap(src);
108     src_cte->mapping_info.pte_count = pte_count;
109     src_cte->mapping_info.pte = dest_lpaddr + (slot * ARM_L1_SCALE);
110     src_cte->mapping_info.offset = 0;
111
112     for (int i = 0; i < 4; i++, entry++)
113     {
114         entry->raw = 0;
115         entry->page_table.type   = L1_TYPE_PAGE_TABLE_ENTRY;
116         entry->page_table.domain = 0;
117         entry->page_table.base_address =
118             (src_lpaddr + i * BASE_PAGE_SIZE / ARM_L1_SCALE) >> 10;
119         debug(SUBSYS_PAGING, "L1 mapping %"PRIuCSLOT". @%p = %08"PRIx32"\n",
120               slot * ARM_L1_SCALE + i, entry, entry->raw);
121     }
122
123     cp15_invalidate_tlb();
124
125     return SYS_ERR_OK;
126 }
127
128 static errval_t
129 caps_map_l2(struct capability* dest,
130             cslot_t            slot,
131             struct capability* src,
132             uintptr_t          kpi_paging_flags,
133             uintptr_t          offset,
134             uintptr_t          pte_count)
135 {
136     assert(0 == (kpi_paging_flags & ~KPI_PAGING_FLAGS_MASK));
137
138     // ARM L2 has 256 entries, but we treat a 4K page as a consecutive
139     // region of L2 with a single index. 4K == 4 * 1K
140     if (slot >= (256 * 4)) {
141         panic("oops: slot >= (256 * 4)");
142         return SYS_ERR_VNODE_SLOT_INVALID;
143     }
144
145     if (src->type != ObjType_Frame && src->type != ObjType_DevFrame) {
146         panic("oops: src->type != ObjType_Frame && src->type != ObjType_DevFrame");
147         return SYS_ERR_WRONG_MAPPING;
148     }
149
150     // check offset within frame
151     if ((offset + BYTES_PER_PAGE > get_size(src)) ||
152         ((offset % BYTES_PER_PAGE) != 0)) {
153         panic("oops: frame offset invalid");
154         return SYS_ERR_FRAME_OFFSET_INVALID;
155     }
156
157     // check mapping does not overlap leaf page table
158     if (slot + pte_count > (256 * 4)) {
159         return SYS_ERR_VM_MAP_SIZE;
160     }
161
162     // Destination
163     lpaddr_t dest_lpaddr = gen_phys_to_local_phys(get_address(dest));
164     lvaddr_t dest_lvaddr = local_phys_to_mem(dest_lpaddr);
165
166     union arm_l2_entry* entry = (union arm_l2_entry*)dest_lvaddr + slot;
167     if (entry->small_page.type != L2_TYPE_INVALID_PAGE) {
168         panic("Remapping valid page.");
169     }
170
171     lpaddr_t src_lpaddr = gen_phys_to_local_phys(get_address(src) + offset);
172     if ((src_lpaddr & (BASE_PAGE_SIZE - 1))) {
173         panic("Invalid target");
174     }
175
176     struct cte *src_cte = cte_for_cap(src);
177     src_cte->mapping_info.pte_count = pte_count;
178     src_cte->mapping_info.pte = dest_lpaddr;
179     src_cte->mapping_info.offset = offset;
180
181     for (int i = 0; i < pte_count; i++) {
182         entry->raw = 0;
183
184         entry->small_page.type = L2_TYPE_SMALL_PAGE;
185         paging_set_flags(entry, kpi_paging_flags);
186         entry->small_page.base_address = (src_lpaddr + i * BYTES_PER_PAGE) >> 12;
187
188         entry++;
189
190         debug(SUBSYS_PAGING, "L2 mapping %08"PRIxLVADDR"[%"PRIuCSLOT"] @%p = %08"PRIx32"\n",
191                dest_lvaddr, slot, entry, entry->raw);
192     }
193
194     // Flush TLB if remapping.
195     cp15_invalidate_tlb();
196
197     return SYS_ERR_OK;
198 }
199
200 /// Create page mappings
201 errval_t caps_copy_to_vnode(struct cte *dest_vnode_cte, cslot_t dest_slot,
202                             struct cte *src_cte, uintptr_t flags,
203                             uintptr_t offset, uintptr_t pte_count)
204 {
205     struct capability *src_cap  = &src_cte->cap;
206     struct capability *dest_cap = &dest_vnode_cte->cap;
207
208     if (src_cte->mapping_info.pte) {
209         return SYS_ERR_VM_ALREADY_MAPPED;
210     }
211
212     if (ObjType_VNode_ARM_l1 == dest_cap->type) {
213         //printf("caps_map_l1: %zu\n", (size_t)pte_count);
214         return caps_map_l1(dest_cap, dest_slot, src_cap,
215                            flags,
216                            offset,
217                            pte_count
218                           );
219     }
220     else if (ObjType_VNode_ARM_l2 == dest_cap->type) {
221         //printf("caps_map_l2: %zu\n", (size_t)pte_count);
222         return caps_map_l2(dest_cap, dest_slot, src_cap,
223                            flags,
224                            offset,
225                            pte_count
226                           );
227     }
228     else {
229         panic("ObjType not VNode");
230     }
231 }
232
233 size_t do_unmap(lvaddr_t pt, cslot_t slot, size_t num_pages)
234 {
235     size_t unmapped_pages = 0;
236     union arm_l2_entry *ptentry = (union arm_l2_entry *)pt + slot;
237     for (int i = 0; i < num_pages; i++) {
238         ptentry++->raw = 0;
239         unmapped_pages++;
240     }
241     return unmapped_pages;
242 }
243
244 static inline void read_pt_entry(struct capability *pgtable, size_t slot, genpaddr_t *paddr)
245 {
246     assert(type_is_vnode(pgtable->type));
247     assert(paddr);
248
249     genpaddr_t gp = get_address(pgtable);
250     lpaddr_t lp = gen_phys_to_local_phys(gp);
251     lvaddr_t lv = local_phys_to_mem(lp);
252
253     switch (pgtable->type) {
254         case ObjType_VNode_ARM_l1:
255         {
256             union arm_l1_entry *e = (union arm_l1_entry*)lv;
257             *paddr = (genpaddr_t)(e->page_table.base_address) << 10;
258             return;
259         }
260         case ObjType_VNode_ARM_l2:
261         {
262             union arm_l2_entry *e = (union arm_l2_entry*)lv;
263             *paddr = (genpaddr_t)(e->small_page.base_address) << 12;
264             return;
265         }
266         default:
267             assert(!"Should not get here");
268     }
269 }
270
271 errval_t page_mappings_unmap(struct capability *pgtable, struct cte *mapping, size_t slot, size_t num_pages)
272 {
273     assert(type_is_vnode(pgtable->type));
274     //printf("page_mappings_unmap(%zd pages, slot = %zd)\n", num_pages, slot);
275
276     // get page table entry data
277     genpaddr_t paddr;
278     //lpaddr_t pte;
279     read_pt_entry(pgtable, slot, &paddr);
280     lvaddr_t pt = local_phys_to_mem(gen_phys_to_local_phys(get_address(pgtable)));
281
282     // get virtual address of first page
283     // TODO: error checking
284     genvaddr_t vaddr;
285     struct cte *leaf_pt = cte_for_cap(pgtable);
286     compile_vaddr(leaf_pt, slot, &vaddr);
287     //genvaddr_t vend = vaddr + num_pages * BASE_PAGE_SIZE;
288     // printf("vaddr = 0x%"PRIxGENVADDR"\n", vaddr);
289     // printf("num_pages = %zu\n", num_pages);
290
291     // get cap for mapping
292     /*
293     struct cte *mem;
294     errval_t err = lookup_cap_for_mapping(paddr, pte, &mem);
295     if (err_is_fail(err)) {
296         printf("page_mappings_unmap: %ld\n", err);
297         return err;
298     }
299     */
300     //printf("state before unmap: mapped_pages = %zd\n", mem->mapping_info.mapped_pages);
301     //printf("state before unmap: num_pages    = %zd\n", num_pages);
302
303     if (num_pages != mapping->mapping_info.pte_count) {
304         printf("num_pages = %zu, mapping = %zu\n", num_pages, mapping->mapping_info.pte_count);
305         // want to unmap a different amount of pages than was mapped
306         return SYS_ERR_VM_MAP_SIZE;
307     }
308
309     do_unmap(pt, slot, num_pages);
310
311     // flush TLB for unmapped pages
312     // TODO: selective TLB flush
313     cp15_invalidate_tlb();
314
315     // update mapping info
316     memset(&mapping->mapping_info, 0, sizeof(struct mapping_info));
317
318     return SYS_ERR_OK;
319 }
320
321 errval_t paging_modify_flags(struct capability *frame, uintptr_t offset,
322                              uintptr_t pages, uintptr_t kpi_paging_flags)
323 {
324     // check flags
325     assert(0 == (kpi_paging_flags & ~KPI_PAGING_FLAGS_MASK));
326
327     struct cte *mapping = cte_for_cap(frame);
328     struct mapping_info *info = &mapping->mapping_info;
329
330     /* Calculate location of page table entries we need to modify */
331     lvaddr_t base = local_phys_to_mem(info->pte) + offset;
332
333     for (int i = 0; i < pages; i++) {
334         union arm_l2_entry *entry =
335             (union arm_l2_entry *)base + i;
336         paging_set_flags(entry, kpi_paging_flags);
337     }
338
339     return paging_tlb_flush_range(mapping, pages);
340 }
341
342 void paging_dump_tables(struct dcb *dispatcher)
343 {
344     printf("dump_hw_page_tables\n");
345     lvaddr_t l1 = local_phys_to_mem(dispatcher->vspace);
346
347     for (int l1_index = 0; l1_index < ARM_L1_MAX_ENTRIES; l1_index++) {
348         // get level2 table
349         union arm_l1_entry *l1_e = (union arm_l1_entry *)l1 + l1_index;
350         if (!l1_e->raw) { continue; }
351         genpaddr_t ptable_gp = (genpaddr_t)(l1_e->page_table.base_address) << 10;
352         lvaddr_t ptable_lv = local_phys_to_mem(gen_phys_to_local_phys(ptable_gp));
353
354         for (int entry = 0; entry < ARM_L2_MAX_ENTRIES; entry++) {
355             union arm_l2_entry *e =
356                 (union arm_l2_entry *)ptable_lv + entry;
357             genpaddr_t paddr = (genpaddr_t)(e->small_page.base_address) << BASE_PAGE_BITS;
358             if (!paddr) {
359                 continue;
360             }
361             printf("%d.%d: 0x%"PRIxGENPADDR"\n", l1_index, entry, paddr);
362         }
363     }
364 }