Physical memory init uses multiboot info
[akaros.git] / kern / src / pmap.c
1 /* Copyright (c) 2009,13 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details. 
4  *
5  * Arch independent physical memory and page table management.
6  *
7  * For page allocation, check out the family of page_alloc files. */
8
9 #include <arch/arch.h>
10 #include <arch/mmu.h>
11
12 #include <error.h>
13
14 #include <kmalloc.h>
15 #include <atomic.h>
16 #include <string.h>
17 #include <assert.h>
18 #include <pmap.h>
19 #include <kclock.h>
20 #include <process.h>
21 #include <stdio.h>
22 #include <mm.h>
23 #include <multiboot.h>
24
25 physaddr_t max_pmem = 0;        /* Total amount of physical memory (bytes) */
26 physaddr_t max_paddr = 0;       /* Maximum addressable physical address */
27 size_t max_nr_pages = 0;        /* Number of addressable physical memory pages */
28 size_t nr_free_pages = 0;       /* TODO: actually track this, after init */
29 struct page *pages = 0;
30 struct multiboot_info *multiboot_kaddr = 0;
31 uintptr_t boot_freemem = 0;
32 uintptr_t boot_freelimit = 0;
33
34 static size_t sizeof_mboot_mmentry(struct multiboot_mmap_entry *entry)
35 {
36         /* Careful - addr + len is a uint64 (need to cast down for 32 bit) */
37         return (size_t)(entry->addr + entry->len);
38 }
39
40 static void adjust_max_pmem(struct multiboot_mmap_entry *entry, void *data)
41 {
42         if (entry->type != MULTIBOOT_MEMORY_AVAILABLE)
43                 return;
44         max_pmem = MAX(max_pmem, sizeof_mboot_mmentry(entry));
45 }
46
47 /**
48  * @brief Initializes physical memory.  Determines the pmem layout, sets up the
49  * array of physical pages and memory free list, and turns on virtual
50  * memory/page tables.
51  *
52  * Regarding max_pmem vs max_paddr and max_nr_pages: max_pmem is the largest
53  * physical address that is in a FREE region.  It includes RESERVED regions that
54  * are below this point.  max_paddr is the largest physical address, <=
55  * max_pmem, that the KERNBASE mapping can map.  It too may include reserved
56  * ranges.  The 'pages' array will track all physical pages up to max_paddr.
57  * There are max_nr_pages of them.  On 64 bit systems, max_pmem == max_paddr. */
58 void pmem_init(struct multiboot_info *mbi)
59 {
60         mboot_detect_memory(mbi);
61         mboot_print_mmap(mbi);
62         /* adjust the max memory based on the mmaps, since the old detection doesn't
63          * help much on 64 bit systems */
64         mboot_foreach_mmap(mbi, adjust_max_pmem, 0);
65         /* KERN_VMAP_TOP - KERNBASE is the max amount of virtual addresses we can
66          * use for the physical memory mapping (aka - the KERNBASE mapping).
67          * Should't be an issue on 64b, but is usually for 32 bit. */
68         max_paddr = MIN(max_pmem, KERN_VMAP_TOP - KERNBASE);
69         /* Note not all of this memory is free. */
70         max_nr_pages = max_paddr / PGSIZE;
71         printk("Max physical RAM (appx, bytes): %lu\n", max_pmem);
72         printk("Max addressable physical RAM (appx): %lu\n", max_paddr);
73         printk("Highest page number (including reserved): %lu\n", max_nr_pages);
74         pages = (struct page*)boot_zalloc(max_nr_pages * sizeof(struct page),
75                                           PGSIZE);
76         /* Turn on paging before turning on the page allocator, we still use
77          * boot_alloc in vm_init.  Doesn't really matter much either way. */
78         vm_init();
79         page_alloc_init(mbi);
80
81         static_assert(PROCINFO_NUM_PAGES*PGSIZE <= PTSIZE);
82         static_assert(PROCDATA_NUM_PAGES*PGSIZE <= PTSIZE);
83 }
84
85 static void set_largest_freezone(struct multiboot_mmap_entry *entry, void *data)
86 {
87         struct multiboot_mmap_entry **boot_zone =
88                (struct multiboot_mmap_entry**)data;
89
90         if (entry->type != MULTIBOOT_MEMORY_AVAILABLE)
91                 return;
92         if (!*boot_zone || (sizeof_mboot_mmentry(entry) >
93                            sizeof_mboot_mmentry(*boot_zone)))
94                 *boot_zone = entry;
95 }
96
97 /* Initialize boot freemem and its limit.
98  *
99  * "end" is a symbol marking the end of the kernel.  This covers anything linked
100  * in with the kernel (KFS, etc).  However, 'end' is a kernel load address,
101  * which differs from kernbase addrs in 64 bit.  We need to use the kernbase
102  * mapping for anything dynamic (because it could go beyond 1 GB). 
103  *
104  * Ideally, we'll use the largest mmap zone, as reported by multiboot.  If we
105  * don't have one (riscv), we'll just use the memory after the kernel.
106  *
107  * If we do have a zone, there is a chance we've already used some of it (for
108  * the kernel, etc).  We'll use the lowest address in the zone that is
109  * greater than "end" (and adjust the limit accordingly).  */
110 static void boot_alloc_init(void)
111 {
112         extern char end[];
113         uintptr_t boot_zone_start, boot_zone_end;
114         uintptr_t end_kva = (uintptr_t)KBASEADDR(end);
115         struct multiboot_mmap_entry *boot_zone = 0;
116
117         /* Find our largest mmap_entry; that will set bootzone */
118         mboot_foreach_mmap(multiboot_kaddr, set_largest_freezone, &boot_zone);
119         if (boot_zone) {
120                 boot_zone_start = (uintptr_t)KADDR(boot_zone->addr);
121                 /* one issue for 32b is that the boot_zone_end could be beyond max_paddr
122                  * and even wrap-around.  Do the min check as a uint64_t.  The result
123                  * should be a safe, unwrapped 32/64b when cast to physaddr_t. */
124                 boot_zone_end = (uintptr_t)KADDR(MIN(boot_zone->addr + boot_zone->len,
125                                                  (uint64_t)max_paddr));
126                 /* using KERNBASE (kva, btw) which covers the kernel and anything before
127                  * it (like the stuff below EXTPHYSMEM on x86) */
128                 if (regions_collide_unsafe(KERNBASE, end_kva,
129                                            boot_zone_start, boot_zone_end))
130                         boot_freemem = end_kva;
131                 else
132                         boot_freemem = boot_zone_start;
133                 boot_freelimit = boot_zone_end;
134         } else {
135                 boot_freemem = end_kva;
136                 boot_freelimit = max_paddr;
137         }
138         printd("boot_zone: %p, paddr base: 0x%llx, paddr len: 0x%llx\n", boot_zone,
139                boot_zone ? boot_zone->addr : 0,
140                boot_zone ? boot_zone->len : 0);
141         printd("boot_freemem: %p, boot_freelimit %p\n", boot_freemem,
142                boot_freelimit);
143 }
144
145 /* Low-level allocator, used before page_alloc is on.  Returns size bytes,
146  * aligned to align (should be a power of 2).  Retval is a kernbase addr.  Will
147  * panic on failure. */
148 void *boot_alloc(size_t amt, size_t align)
149 {
150         uintptr_t retval;
151
152         if (!boot_freemem)
153                 boot_alloc_init();
154         boot_freemem = ROUNDUP(boot_freemem, align);
155         retval = boot_freemem;
156         if (boot_freemem + amt > boot_freelimit)
157                 panic("Out of memory in boot alloc, you fool!\n");
158         boot_freemem += amt;
159         printd("boot alloc from %p to %p\n", retval, boot_freemem);
160         /* multiboot info probably won't ever conflict with our boot alloc */
161         if (mboot_region_collides(multiboot_kaddr, retval, boot_freemem))
162                 panic("boot allocation could clobber multiboot info!  Get help!");
163         return (void*)retval;
164 }
165
166 void *boot_zalloc(size_t amt, size_t align)
167 {
168         /* boot_alloc panics on failure */
169         void *v = boot_alloc(amt, align);
170         memset(v, 0, amt);
171         return v;
172 }
173
174 /** 
175  * @brief Map the physical page 'pp' into the virtual address 'va' in page
176  *        directory 'pgdir'
177  *
178  * Map the physical page 'pp' at virtual address 'va'.
179  * The permissions (the low 12 bits) of the page table
180  * entry should be set to 'perm|PTE_P'.
181  * 
182  * Details:
183  *   - If there is already a page mapped at 'va', it is page_remove()d.
184  *   - If necessary, on demand, allocates a page table and inserts it into 
185  *     'pgdir'.
186  *   - page_incref() should be called if the insertion succeeds. 
187  *   - The TLB must be invalidated if a page was formerly present at 'va'.
188  *     (this is handled in page_remove)
189  *
190  * No support for jumbos here.  We will need to be careful when trying to
191  * insert regular pages into something that was already jumbo.  We will
192  * also need to be careful with our overloading of the PTE_PS and 
193  * PTE_PAT flags...
194  *
195  * @param[in] pgdir the page directory to insert the page into
196  * @param[in] pp    a pointr to the page struct representing the
197  *                  physical page that should be inserted.
198  * @param[in] va    the virtual address where the page should be
199  *                  inserted.
200  * @param[in] perm  the permition bits with which to set up the 
201  *                  virtual mapping.
202  *
203  * @return ESUCCESS  on success
204  * @return -ENOMEM   if a page table could not be allocated
205  *                   into which the page should be inserted
206  *
207  */
208 int page_insert(pde_t *pgdir, struct page *page, void *va, int perm) 
209 {
210         pte_t* pte = pgdir_walk(pgdir, va, 1);
211         if (!pte)
212                 return -ENOMEM;
213         /* Two things here:  First, we need to up the ref count of the page we want
214          * to insert in case it is already mapped at va.  In that case we don't want
215          * page_remove to ultimately free it, and then for us to continue as if pp
216          * wasn't freed. (moral = up the ref asap) */
217         kref_get(&page->pg_kref, 1);
218         /* Careful, page remove handles the cases where the page is PAGED_OUT. */
219         if (!PAGE_UNMAPPED(*pte))
220                 page_remove(pgdir, va);
221         *pte = PTE(page2ppn(page), PTE_P | perm);
222         return 0;
223 }
224
225 /**
226  * @brief Return the page mapped at virtual address 'va' in 
227  * page directory 'pgdir'.
228  *
229  * If pte_store is not NULL, then we store in it the address
230  * of the pte for this page.  This is used by page_remove
231  * but should not be used by other callers.
232  *
233  * For jumbos, right now this returns the first Page* in the 4MB range
234  *
235  * @param[in]  pgdir     the page directory from which we should do the lookup
236  * @param[in]  va        the virtual address of the page we are looking up
237  * @param[out] pte_store the address of the page table entry for the returned page
238  *
239  * @return PAGE the page mapped at virtual address 'va'
240  * @return NULL No mapping exists at virtual address 'va', or it's paged out
241  */
242 page_t *page_lookup(pde_t *pgdir, void *va, pte_t **pte_store)
243 {
244         pte_t* pte = pgdir_walk(pgdir, va, 0);
245         if (!pte || !PAGE_PRESENT(*pte))
246                 return 0;
247         if (pte_store)
248                 *pte_store = pte;
249         return pa2page(PTE_ADDR(*pte));
250 }
251
252 /**
253  * @brief Unmaps the physical page at virtual address 'va' in page directory
254  * 'pgdir'.
255  *
256  * If there is no physical page at that address, this function silently 
257  * does nothing.
258  *
259  * Details:
260  *   - The ref count on the physical page is decrement when the page is removed
261  *   - The physical page is freed if the refcount reaches 0.
262  *   - The pg table entry corresponding to 'va' is set to 0.
263  *     (if such a PTE exists)
264  *   - The TLB is invalidated if an entry is removes from the pg dir/pg table.
265  *
266  * This may be wonky wrt Jumbo pages and decref.  
267  *
268  * @param pgdir the page directory from with the page sholuld be removed
269  * @param va    the virtual address at which the page we are trying to 
270  *              remove is mapped
271  * TODO: consider deprecating this, or at least changing how it works with TLBs.
272  * Might want to have the caller need to manage the TLB.  Also note it is used
273  * in env_user_mem_free, minus the walk. */
274 void page_remove(pde_t *pgdir, void *va)
275 {
276         pte_t *pte;
277         page_t *page;
278
279         pte = pgdir_walk(pgdir,va,0);
280         if (!pte || PAGE_UNMAPPED(*pte))
281                 return;
282
283         if (PAGE_PRESENT(*pte)) {
284                 /* TODO: (TLB) need to do a shootdown, inval sucks.  And might want to
285                  * manage the TLB / free pages differently. (like by the caller).
286                  * Careful about the proc/memory lock here. */
287                 page = ppn2page(PTE2PPN(*pte));
288                 *pte = 0;
289                 tlb_invalidate(pgdir, va);
290                 page_decref(page);
291         } else if (PAGE_PAGED_OUT(*pte)) {
292                 /* TODO: (SWAP) need to free this from the swap */
293                 panic("Swapping not supported!");
294                 *pte = 0;
295         }
296 }
297
298 /**
299  * @brief Invalidate a TLB entry, but only if the page tables being
300  * edited are the ones currently in use by the processor.
301  *
302  * TODO: (TLB) Need to sort this for cross core lovin'
303  *
304  * @param pgdir the page directory assocaited with the tlb entry 
305  *              we are trying to invalidate
306  * @param va    the virtual address associated with the tlb entry
307  *              we are trying to invalidate
308  */
309 void tlb_invalidate(pde_t *pgdir, void *va)
310 {
311         // Flush the entry only if we're modifying the current address space.
312         // For now, there is only one address space, so always invalidate.
313         invlpg(va);
314 }
315
316 /* Helper, returns true if any part of (start1, end1) is within (start2, end2).
317  * Equality of endpoints (like end1 == start2) is okay.
318  * Assumes no wrap-around. */
319 bool regions_collide_unsafe(uintptr_t start1, uintptr_t end1, 
320                             uintptr_t start2, uintptr_t end2)
321 {
322         if (start1 <= start2) {
323                 if (end1 <= start2)
324                         return FALSE;
325                 return TRUE;
326         } else {
327                 if (end2 <= start1)
328                         return FALSE;
329                 return TRUE;
330         }
331 }