Fix minor leaks in mm.c
[akaros.git] / kern / src / mm.c
1 /* Copyright (c) 2009, 2010 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Virtual memory management functions.  Creation, modification, etc, of virtual
6  * memory regions (VMRs) as well as mmap(), mprotect(), and munmap().
7  *
8  * In general, error checking / bounds checks are done in the main function
9  * (e.g. mmap()), and the work is done in a do_ function (e.g. do_mmap()).
10  * Versions of those functions that are called when the vmr lock is already held
11  * begin with __ (e.g. __do_munmap()).
12  *
13  * Note that if we were called from kern/src/syscall.c, we probably don't have
14  * an edible reference to p. */
15
16 #include <frontend.h>
17 #include <ros/common.h>
18 #include <pmap.h>
19 #include <mm.h>
20 #include <process.h>
21 #include <stdio.h>
22 #include <syscall.h>
23 #include <slab.h>
24 #include <kmalloc.h>
25 #include <vfs.h>
26 #include <smp.h>
27 #include <profiler.h>
28
29 struct kmem_cache *vmr_kcache;
30
31 static int __vmr_free_pgs(struct proc *p, pte_t pte, void *va, void *arg);
32 /* minor helper, will ease the file->chan transition */
33 static struct page_map *file2pm(struct file *file)
34 {
35         return file->f_mapping;
36 }
37
38 void vmr_init(void)
39 {
40         vmr_kcache = kmem_cache_create("vm_regions", sizeof(struct vm_region),
41                                        __alignof__(struct dentry), 0, 0, 0);
42 }
43
44 /* For now, the caller will set the prot, flags, file, and offset.  In the
45  * future, we may put those in here, to do clever things with merging vm_regions
46  * that are the same.
47  *
48  * TODO: take a look at solari's vmem alloc.  And consider keeping these in a
49  * tree of some sort for easier lookups. */
50 struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
51 {
52         struct vm_region *vmr = 0, *vm_i, *vm_next;
53         uintptr_t gap_end;
54
55         assert(!PGOFF(va));
56         assert(!PGOFF(len));
57         assert(va + len <= UMAPTOP);
58         /* Is there room before the first one: */
59         vm_i = TAILQ_FIRST(&p->vm_regions);
60         /* This works for now, but if all we have is BRK_END ones, we'll start
61          * growing backwards (TODO) */
62         if (!vm_i || (va + len <= vm_i->vm_base)) {
63                 vmr = kmem_cache_alloc(vmr_kcache, 0);
64                 if (!vmr)
65                         panic("EOM!");
66                 memset(vmr, 0, sizeof(struct vm_region));
67                 vmr->vm_base = va;
68                 TAILQ_INSERT_HEAD(&p->vm_regions, vmr, vm_link);
69         } else {
70                 TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
71                         vm_next = TAILQ_NEXT(vm_i, vm_link);
72                         gap_end = vm_next ? vm_next->vm_base : UMAPTOP;
73                         /* skip til we get past the 'hint' va */
74                         if (va >= gap_end)
75                                 continue;
76                         /* Find a gap that is big enough */
77                         if (gap_end - vm_i->vm_end >= len) {
78                                 vmr = kmem_cache_alloc(vmr_kcache, 0);
79                                 if (!vmr)
80                                         panic("EOM!");
81                                 memset(vmr, 0, sizeof(struct vm_region));
82                                 /* if we can put it at va, let's do that.  o/w, put it so it
83                                  * fits */
84                                 if ((gap_end >= va + len) && (va >= vm_i->vm_end))
85                                         vmr->vm_base = va;
86                                 else
87                                         vmr->vm_base = vm_i->vm_end;
88                                 TAILQ_INSERT_AFTER(&p->vm_regions, vm_i, vmr, vm_link);
89                                 break;
90                         }
91                 }
92         }
93         /* Finalize the creation, if we got one */
94         if (vmr) {
95                 vmr->vm_proc = p;
96                 vmr->vm_end = vmr->vm_base + len;
97         }
98         if (!vmr)
99                 warn("Not making a VMR, wanted %p, + %p = %p", va, len, va + len);
100         return vmr;
101 }
102
103 /* Split a VMR at va, returning the new VMR.  It is set up the same way, with
104  * file offsets fixed accordingly.  'va' is the beginning of the new one, and
105  * must be page aligned. */
106 struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
107 {
108         struct vm_region *new_vmr;
109
110         assert(!PGOFF(va));
111         if ((old_vmr->vm_base >= va) || (old_vmr->vm_end <= va))
112                 return 0;
113         new_vmr = kmem_cache_alloc(vmr_kcache, 0);
114         TAILQ_INSERT_AFTER(&old_vmr->vm_proc->vm_regions, old_vmr, new_vmr,
115                            vm_link);
116         new_vmr->vm_proc = old_vmr->vm_proc;
117         new_vmr->vm_base = va;
118         new_vmr->vm_end = old_vmr->vm_end;
119         old_vmr->vm_end = va;
120         new_vmr->vm_prot = old_vmr->vm_prot;
121         new_vmr->vm_flags = old_vmr->vm_flags;
122         if (old_vmr->vm_file) {
123                 kref_get(&old_vmr->vm_file->f_kref, 1);
124                 new_vmr->vm_file = old_vmr->vm_file;
125                 new_vmr->vm_foff = old_vmr->vm_foff +
126                                       old_vmr->vm_end - old_vmr->vm_base;
127                 pm_add_vmr(file2pm(old_vmr->vm_file), new_vmr);
128         } else {
129                 new_vmr->vm_file = 0;
130                 new_vmr->vm_foff = 0;
131         }
132         return new_vmr;
133 }
134
135 /* Merges two vm regions.  For now, it will check to make sure they are the
136  * same.  The second one will be destroyed. */
137 int merge_vmr(struct vm_region *first, struct vm_region *second)
138 {
139         assert(first->vm_proc == second->vm_proc);
140         if ((first->vm_end != second->vm_base) ||
141             (first->vm_prot != second->vm_prot) ||
142             (first->vm_flags != second->vm_flags) ||
143             (first->vm_file != second->vm_file))
144                 return -1;
145         if ((first->vm_file) && (second->vm_foff != first->vm_foff +
146                                  first->vm_end - first->vm_base))
147                 return -1;
148         first->vm_end = second->vm_end;
149         destroy_vmr(second);
150         return 0;
151 }
152
153 /* Attempts to merge vmr with adjacent VMRs, returning a ptr to be used for vmr.
154  * It could be the same struct vmr, or possibly another one (usually lower in
155  * the address space. */
156 struct vm_region *merge_me(struct vm_region *vmr)
157 {
158         struct vm_region *vmr_temp;
159         /* Merge will fail if it cannot do it.  If it succeeds, the second VMR is
160          * destroyed, so we need to be a bit careful. */
161         vmr_temp = TAILQ_PREV(vmr, vmr_tailq, vm_link);
162         if (vmr_temp)
163                 if (!merge_vmr(vmr_temp, vmr))
164                         vmr = vmr_temp;
165         vmr_temp = TAILQ_NEXT(vmr, vm_link);
166         if (vmr_temp)
167                 merge_vmr(vmr, vmr_temp);
168         return vmr;
169 }
170
171 /* Grows the vm region up to (and not including) va.  Fails if another is in the
172  * way, etc. */
173 int grow_vmr(struct vm_region *vmr, uintptr_t va)
174 {
175         assert(!PGOFF(va));
176         struct vm_region *next = TAILQ_NEXT(vmr, vm_link);
177         if (next && next->vm_base < va)
178                 return -1;
179         if (va <= vmr->vm_end)
180                 return -1;
181         vmr->vm_end = va;
182         return 0;
183 }
184
185 /* Shrinks the vm region down to (and not including) va.  Whoever calls this
186  * will need to sort out the page table entries. */
187 int shrink_vmr(struct vm_region *vmr, uintptr_t va)
188 {
189         assert(!PGOFF(va));
190         if ((va < vmr->vm_base) || (va > vmr->vm_end))
191                 return -1;
192         vmr->vm_end = va;
193         return 0;
194 }
195
196 /* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
197  * out the page table entries. */
198 void destroy_vmr(struct vm_region *vmr)
199 {
200         if (vmr->vm_file) {
201                 pm_remove_vmr(file2pm(vmr->vm_file), vmr);
202                 kref_put(&vmr->vm_file->f_kref);
203         }
204         TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
205         kmem_cache_free(vmr_kcache, vmr);
206 }
207
208 /* Given a va and a proc (later an mm, possibly), returns the owning vmr, or 0
209  * if there is none. */
210 struct vm_region *find_vmr(struct proc *p, uintptr_t va)
211 {
212         struct vm_region *vmr;
213         /* ugly linear seach */
214         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
215                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
216                         return vmr;
217         }
218         return 0;
219 }
220
221 /* Finds the first vmr after va (including the one holding va), or 0 if there is
222  * none. */
223 struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
224 {
225         struct vm_region *vmr;
226         /* ugly linear seach */
227         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
228                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
229                         return vmr;
230                 if (vmr->vm_base > va)
231                         return vmr;
232         }
233         return 0;
234 }
235
236 /* Makes sure that no VMRs cross either the start or end of the given region
237  * [va, va + len), splitting any VMRs that are on the endpoints. */
238 void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
239 {
240         struct vm_region *vmr;
241         if ((vmr = find_vmr(p, va)))
242                 split_vmr(vmr, va);
243         /* TODO: don't want to do another find (linear search) */
244         if ((vmr = find_vmr(p, va + len)))
245                 split_vmr(vmr, va + len);
246 }
247
248 void unmap_and_destroy_vmrs(struct proc *p)
249 {
250         struct vm_region *vmr_i, *vmr_temp;
251         /* this only gets called from __proc_free, so there should be no sync
252          * concerns.  still, better safe than sorry. */
253         spin_lock(&p->vmr_lock);
254         p->vmr_history++;
255         spin_lock(&p->pte_lock);
256         TAILQ_FOREACH(vmr_i, &p->vm_regions, vm_link) {
257                 /* note this CB sets the PTE = 0, regardless of if it was P or not */
258                 env_user_mem_walk(p, (void*)vmr_i->vm_base,
259                                   vmr_i->vm_end - vmr_i->vm_base, __vmr_free_pgs, 0);
260         }
261         spin_unlock(&p->pte_lock);
262         /* need the safe style, since destroy_vmr modifies the list.  also, we want
263          * to do this outside the pte lock, since it grabs the pm lock. */
264         TAILQ_FOREACH_SAFE(vmr_i, &p->vm_regions, vm_link, vmr_temp)
265                 destroy_vmr(vmr_i);
266         spin_unlock(&p->vmr_lock);
267 }
268
269 /* Helper: copies the contents of pages from p to new p.  For pages that aren't
270  * present, once we support swapping or CoW, we can do something more
271  * intelligent.  0 on success, -ERROR on failure.  Can't handle jumbos. */
272 static int copy_pages(struct proc *p, struct proc *new_p, uintptr_t va_start,
273                       uintptr_t va_end)
274 {
275         /* Sanity checks.  If these fail, we had a screwed up VMR.
276          * Check for: alignment, wraparound, or userspace addresses */
277         if ((PGOFF(va_start)) ||
278             (PGOFF(va_end)) ||
279             (va_end < va_start) ||      /* now, start > UMAPTOP -> end > UMAPTOP */
280             (va_end > UMAPTOP)) {
281                 warn("VMR mapping is probably screwed up (%p - %p)", va_start,
282                      va_end);
283                 return -EINVAL;
284         }
285         int copy_page(struct proc *p, pte_t pte, void *va, void *arg) {
286                 struct proc *new_p = (struct proc*)arg;
287                 struct page *pp;
288                 if (pte_is_unmapped(pte))
289                         return 0;
290                 /* pages could be !P, but right now that's only for file backed VMRs
291                  * undergoing page removal, which isn't the caller of copy_pages. */
292                 if (pte_is_mapped(pte)) {
293                         /* TODO: check for jumbos */
294                         if (upage_alloc(new_p, &pp, 0))
295                                 return -ENOMEM;
296                         if (page_insert(new_p->env_pgdir, pp, va, pte_get_settings(pte))) {
297                                 page_decref(pp);
298                                 return -ENOMEM;
299                         }
300                         memcpy(page2kva(pp), KADDR(pte_get_paddr(pte)), PGSIZE);
301                         page_decref(pp);
302                 } else if (pte_is_paged_out(pte)) {
303                         /* TODO: (SWAP) will need to either make a copy or CoW/refcnt the
304                          * backend store.  For now, this PTE will be the same as the
305                          * original PTE */
306                         panic("Swapping not supported!");
307                 } else {
308                         panic("Weird PTE %p in %s!", pte_print(pte), __FUNCTION__);
309                 }
310                 return 0;
311         }
312         return env_user_mem_walk(p, (void*)va_start, va_end - va_start, &copy_page,
313                                  new_p);
314 }
315
316 /* This will make new_p have the same VMRs as p, and it will make sure all
317  * physical pages are copied over, with the exception of MAP_SHARED files.
318  * This is used by fork().
319  *
320  * Note that if you are working on a VMR that is a file, you'll want to be
321  * careful about how it is mapped (SHARED, PRIVATE, etc). */
322 int duplicate_vmrs(struct proc *p, struct proc *new_p)
323 {
324         int ret = 0;
325         struct vm_region *vmr, *vm_i;
326         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
327                 vmr = kmem_cache_alloc(vmr_kcache, 0);
328                 if (!vmr)
329                         return -ENOMEM;
330                 vmr->vm_proc = new_p;
331                 vmr->vm_base = vm_i->vm_base;
332                 vmr->vm_end = vm_i->vm_end;
333                 vmr->vm_prot = vm_i->vm_prot;   
334                 vmr->vm_flags = vm_i->vm_flags; 
335                 vmr->vm_file = vm_i->vm_file;
336                 vmr->vm_foff = vm_i->vm_foff;
337                 if (vm_i->vm_file) {
338                         kref_get(&vm_i->vm_file->f_kref, 1);
339                         pm_add_vmr(file2pm(vm_i->vm_file), vmr);
340                 }
341                 if (!vmr->vm_file || vmr->vm_flags & MAP_PRIVATE) {
342                         assert(!(vmr->vm_flags & MAP_SHARED));
343                         /* Copy over the memory from one VMR to the other */
344                         if ((ret = copy_pages(p, new_p, vmr->vm_base, vmr->vm_end))) {
345                                 if (vm_i->vm_file) {
346                                         pm_remove_vmr(file2pm(vm_i->vm_file), vmr);
347                                         kref_put(&vm_i->vm_file->f_kref);
348                                 }
349                                 kmem_cache_free(vmr_kcache, vm_i);
350                                 return ret;
351                         }
352                 }
353                 TAILQ_INSERT_TAIL(&new_p->vm_regions, vmr, vm_link);
354         }
355         return 0;
356 }
357
358 void print_vmrs(struct proc *p)
359 {
360         int count = 0;
361         struct vm_region *vmr;
362         printk("VM Regions for proc %d\n", p->pid);
363         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
364                 printk("%02d: (%p - %p): 0x%08x, 0x%08x, %p, %p\n", count++,
365                        vmr->vm_base, vmr->vm_end, vmr->vm_prot, vmr->vm_flags,
366                        vmr->vm_file, vmr->vm_foff);
367 }
368
369 void enumerate_vmrs(struct proc *p,
370                                         void (*func)(struct vm_region *vmr, void *opaque),
371                                         void *opaque)
372 {
373         struct vm_region *vmr;
374
375         spin_lock(&p->vmr_lock);
376         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
377                 func(vmr, opaque);
378         spin_unlock(&p->vmr_lock);
379 }
380
381 /* Error values aren't quite comprehensive - check man mmap() once we do better
382  * with the FS.
383  *
384  * The mmap call's offset is in units of PGSIZE (like Linux's mmap2()), but
385  * internally, the offset is tracked in bytes.  The reason for the PGSIZE is for
386  * 32bit apps to enumerate large files, but a full 64bit system won't need that.
387  * We track things internally in bytes since that is how file pointers work, vmr
388  * bases and ends, and similar math.  While it's not a hard change, there's no
389  * need for it, and ideally we'll be a fully 64bit system before we deal with
390  * files that large. */
391 void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
392            int fd, size_t offset)
393 {
394         struct file *file = NULL;
395         offset <<= PGSHIFT;
396         printd("mmap(addr %x, len %x, prot %x, flags %x, fd %x, off %x)\n", addr,
397                len, prot, flags, fd, offset);
398         if (fd >= 0 && (flags & MAP_ANON)) {
399                 set_errno(EBADF);
400                 return MAP_FAILED;
401         }
402         if (!len) {
403                 set_errno(EINVAL);
404                 return MAP_FAILED;
405         }
406         if (fd != -1) {
407                 file = get_file_from_fd(&p->open_files, fd);
408                 if (!file) {
409                         set_errno(EBADF);
410                         return MAP_FAILED;
411                 }
412         }
413         /* If they don't care where to put it, we'll start looking after the break.
414          * We could just have userspace handle this (in glibc's mmap), so we don't
415          * need to know about BRK_END, but this will work for now (and may avoid
416          * bugs).  Note that this limits mmap(0) a bit.  Keep this in sync with
417          * __do_mmap()'s check.  (Both are necessary).  */
418         if (addr == 0)
419                 addr = BRK_END;
420         /* Still need to enforce this: */
421         addr = MAX(addr, MMAP_LOWEST_VA);
422         /* Need to check addr + len, after we do our addr adjustments */
423         if ((addr + len > UMAPTOP) || (PGOFF(addr))) {
424                 set_errno(EINVAL);
425                 return MAP_FAILED;
426         }
427         void *result = do_mmap(p, addr, len, prot, flags, file, offset);
428         if (file)
429                 kref_put(&file->f_kref);
430         return result;
431 }
432
433 /* Helper: returns TRUE if the VMR is allowed to access the file with prot.
434  * This is a bit ghetto still: messes with the file mode and assumes it can walk
435  * the dentry/inode paths without locking.  It also ignores the CoW stuff we'll
436  * need to do eventually. */
437 static bool check_file_perms(struct vm_region *vmr, struct file *file, int prot)
438 {
439         assert(file);
440         if (prot & PROT_READ) {
441                 if (check_perms(file->f_dentry->d_inode, S_IRUSR))
442                         goto out_error;
443         }
444         if (prot & PROT_WRITE) {
445                 /* if vmr maps a file as MAP_SHARED, then we need to make sure the
446                  * protection change is in compliance with the open mode of the
447                  * file. */
448                 if (vmr->vm_flags & MAP_SHARED) {
449                         if (!(file->f_mode & S_IWUSR)) {
450                                 /* at this point, we have a file opened in the wrong mode,
451                                  * but we may be allowed to access it still. */
452                                 if (check_perms(file->f_dentry->d_inode, S_IWUSR)) {
453                                         goto out_error;
454                                 } else {
455                                         /* it is okay, though we need to change the file mode. (note
456                                          * the lack of a lock/protection (TODO) */
457                                         file->f_mode |= S_IWUSR;
458                                 }
459                         }
460                 } else {        /* PRIVATE mapping */
461                         /* TODO: we want a CoW mapping (like we want in handle_page_fault()),
462                          * since there is a concern of a process having the page already
463                          * mapped in to a file it does not have permissions to, and then
464                          * mprotecting it so it can access it.  So we can't just change
465                          * the prot, and we don't know yet if a page is mapped in.  To
466                          * handle this, we ought to sort out the CoW bit, and then this
467                          * will be easy.  Til then, just do a permissions check.  If we
468                          * start having weird issues with libc overwriting itself (since
469                          * procs mprotect that W), then change this. */
470                         if (check_perms(file->f_dentry->d_inode, S_IWUSR))
471                                 goto out_error;
472                 }
473         }
474         return TRUE;
475 out_error:      /* for debugging */
476         printk("[kernel] mmap perm check failed for %s for access %d\n",
477                file_name(file), prot);
478         return FALSE;
479 }
480
481 /* Helper, maps in page at addr, but only if nothing is mapped there.  Returns
482  * 0 on success.  If this is called by non-PM code, we'll store your ref in the
483  * PTE. */
484 static int map_page_at_addr(struct proc *p, struct page *page, uintptr_t addr,
485                             int prot)
486 {
487         pte_t pte;
488         spin_lock(&p->pte_lock);        /* walking and changing PTEs */
489         /* find offending PTE (prob don't read this in).  This might alloc an
490          * intermediate page table page. */
491         pte = pgdir_walk(p->env_pgdir, (void*)addr, TRUE);
492         if (!pte_walk_okay(pte)) {
493                 spin_unlock(&p->pte_lock);
494                 return -ENOMEM;
495         }
496         /* a spurious, valid PF is possible due to a legit race: the page might have
497          * been faulted in by another core already (and raced on the memory lock),
498          * in which case we should just return. */
499         if (pte_is_present(pte)) {
500                 spin_unlock(&p->pte_lock);
501                 /* callers expect us to eat the ref if we succeed. */
502                 page_decref(page);
503                 return 0;
504         }
505         if (pte_is_mapped(pte)) {
506                 /* we're clobbering an old entry.  if we're just updating the prot, then
507                  * it's no big deal.  o/w, there might be an issue. */
508                 if (page2pa(page) != pte_get_paddr(pte)) {
509                         warn_once("Clobbered a PTE mapping (%p -> %p)\n", pte_print(pte),
510                                   page2pa(page) | prot);
511                 }
512                 page_decref(pa2page(pte_get_paddr(pte)));
513         }
514         /* preserve the dirty bit - pm removal could be looking concurrently */
515         prot |= (pte_is_dirty(pte) ? PTE_D : 0);
516         /* We have a ref to page, which we are storing in the PTE */
517         pte_write(pte, page2pa(page), prot);
518         spin_unlock(&p->pte_lock);
519         return 0;
520 }
521
522 /* Helper: copies *pp's contents to a new page, replacing your page pointer.  If
523  * this succeeds, you'll have a non-PM page, which matters for how you put it.*/
524 static int __copy_and_swap_pmpg(struct proc *p, struct page **pp)
525 {
526         struct page *new_page, *old_page = *pp;
527         if (upage_alloc(p, &new_page, FALSE))
528                 return -ENOMEM;
529         memcpy(page2kva(new_page), page2kva(old_page), PGSIZE);
530         pm_put_page(old_page);
531         *pp = new_page;
532         return 0;
533 }
534
535 /* Hold the VMR lock when you call this - it'll assume the entire VA range is
536  * mappable, which isn't true if there are concurrent changes to the VMRs. */
537 static int populate_anon_va(struct proc *p, uintptr_t va, unsigned long nr_pgs,
538                             int pte_prot)
539 {
540         struct page *page;
541         int ret;
542         for (long i = 0; i < nr_pgs; i++) {
543                 if (upage_alloc(p, &page, TRUE))
544                         return -ENOMEM;
545                 /* could imagine doing a memwalk instead of a for loop */
546                 ret = map_page_at_addr(p, page, va + i * PGSIZE, pte_prot);
547                 if (ret) {
548                         page_decref(page);
549                         return ret;
550                 }
551         }
552         return 0;
553 }
554
555 /* This will periodically unlock the vmr lock. */
556 static int populate_pm_va(struct proc *p, uintptr_t va, unsigned long nr_pgs,
557                           int pte_prot, struct page_map *pm, size_t offset,
558                           int flags, bool exec)
559 {
560         int ret = 0;
561         unsigned long pm_idx0 = offset >> PGSHIFT;
562         int vmr_history = ACCESS_ONCE(p->vmr_history);
563         struct page *page;
564
565         /* locking rules: start the loop holding the vmr lock, enter and exit the
566          * entire func holding the lock. */
567         for (long i = 0; i < nr_pgs; i++) {
568                 ret = pm_load_page_nowait(pm, pm_idx0 + i, &page);
569                 if (ret) {
570                         if (ret != -EAGAIN)
571                                 break;
572                         spin_unlock(&p->vmr_lock);
573                         /* might block here, can't hold the spinlock */
574                         ret = pm_load_page(pm, pm_idx0 + i, &page);
575                         spin_lock(&p->vmr_lock);
576                         if (ret)
577                                 break;
578                         /* while we were sleeping, the VMRs could have changed on us. */
579                         if (vmr_history != ACCESS_ONCE(p->vmr_history)) {
580                                 pm_put_page(page);
581                                 printk("[kernel] FYI: VMR changed during populate\n");
582                                 break;
583                         }
584                 }
585                 if (flags & MAP_PRIVATE) {
586                         ret = __copy_and_swap_pmpg(p, &page);
587                         if (ret) {
588                                 pm_put_page(page);
589                                 break;
590                         }
591                 }
592                 /* if this is an executable page, we might have to flush the
593                  * instruction cache if our HW requires it.
594                  * TODO: is this still needed?  andrew put this in a while ago*/
595                 if (exec)
596                         icache_flush_page(0, page2kva(page));
597                 ret = map_page_at_addr(p, page, va + i * PGSIZE, pte_prot);
598                 if (atomic_read(&page->pg_flags) & PG_PAGEMAP)
599                         pm_put_page(page);
600                 if (ret)
601                         break;
602         }
603         return ret;
604 }
605
606 void *do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
607               struct file *file, size_t offset)
608 {
609         len = ROUNDUP(len, PGSIZE);
610         struct vm_region *vmr, *vmr_temp;
611
612         /* read/write vmr lock (will change the tree) */
613         spin_lock(&p->vmr_lock);
614         p->vmr_history++;
615         /* Sanity check, for callers that bypass mmap().  We want addr for anon
616          * memory to start above the break limit (BRK_END), but not 0.  Keep this in
617          * sync with BRK_END in mmap(). */
618         if (addr == 0)
619                 addr = BRK_END;
620         assert(!PGOFF(offset));
621
622         /* MCPs will need their code and data pinned.  This check will start to fail
623          * after uthread_slim_init(), at which point userspace should have enough
624          * control over its mmaps (i.e. no longer done by LD or load_elf) that it
625          * can ask for pinned and populated pages.  Except for dl_opens(). */
626         struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[0];
627         if (file && (atomic_read(&vcpd->flags) & VC_SCP_NOVCCTX))
628                 flags |= MAP_POPULATE | MAP_LOCKED;
629         /* Need to make sure nothing is in our way when we want a FIXED location.
630          * We just need to split on the end points (if they exist), and then remove
631          * everything in between.  __do_munmap() will do this.  Careful, this means
632          * an mmap can be an implied munmap() (not my call...). */
633         if (flags & MAP_FIXED)
634                 __do_munmap(p, addr, len);
635         vmr = create_vmr(p, addr, len);
636         if (!vmr) {
637                 printk("[kernel] do_mmap() aborted for %p + %d!\n", addr, len);
638                 set_errno(ENOMEM);
639                 spin_unlock(&p->vmr_lock);
640                 return MAP_FAILED;
641         }
642         addr = vmr->vm_base;
643         vmr->vm_prot = prot;
644         vmr->vm_flags = flags;
645         vmr->vm_foff = offset;
646         if (file) {
647                 if (!check_file_perms(vmr, file, prot)) {
648                         assert(!vmr->vm_file);
649                         destroy_vmr(vmr);
650                         set_errno(EACCES);
651                         spin_unlock(&p->vmr_lock);
652                         return MAP_FAILED;
653                 }
654                 /* TODO: consider locking the file while checking (not as manadatory as
655                  * in handle_page_fault() */
656                 if (nr_pages(offset + len) > nr_pages(file->f_dentry->d_inode->i_size)) {
657                         /* We're allowing them to set up the VMR, though if they attempt to
658                          * fault in any pages beyond the file's limit, they'll fail.  Since
659                          * they might not access the region, we need to make sure POPULATE
660                          * is off.  FYI, 64 bit glibc shared libs map in an extra 2MB of
661                          * unaligned space between their RO and RW sections, but then
662                          * immediately mprotect it to PROT_NONE. */
663                         flags &= ~MAP_POPULATE;
664                 }
665                 /* Prep the FS to make sure it can mmap the file.  Slightly weird
666                  * semantics: if we fail and had munmapped the space, they will have a
667                  * hole in their VM now. */
668                 if (file->f_op->mmap(file, vmr)) {
669                         assert(!vmr->vm_file);
670                         destroy_vmr(vmr);
671                         set_errno(EACCES);      /* not quite */
672                         spin_unlock(&p->vmr_lock);
673                         return MAP_FAILED;
674                 }
675                 kref_get(&file->f_kref, 1);
676                 pm_add_vmr(file2pm(file), vmr);
677         }
678         vmr->vm_file = file;
679         vmr = merge_me(vmr);            /* attempts to merge with neighbors */
680
681         if (flags & MAP_POPULATE && prot != PROT_NONE) {
682                 int pte_prot = (prot & PROT_WRITE) ? PTE_USER_RW :
683                            (prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
684                 unsigned long nr_pgs = len >> PGSHIFT;
685                 int ret = 0;
686                 if (!file) {
687                         ret = populate_anon_va(p, addr, nr_pgs, pte_prot);
688                 } else {
689                         /* Note: this will unlock if it blocks.  our refcnt on the file
690                          * keeps the pm alive when we unlock */
691                         ret = populate_pm_va(p, addr, nr_pgs, pte_prot, file->f_mapping,
692                                              offset, flags, prot & PROT_EXEC);
693                 }
694                 if (ret == -ENOMEM) {
695                         spin_unlock(&p->vmr_lock);
696                         printk("[kernel] ENOMEM, killing %d\n", p->pid);
697                         proc_destroy(p);
698                         return MAP_FAILED;      /* will never make it back to userspace */
699                 }
700         }
701         spin_unlock(&p->vmr_lock);
702
703         profiler_notify_mmap(p, addr, len, prot, flags, file, offset);
704
705         return (void*)addr;
706 }
707
708 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
709 {
710         printd("mprotect: (addr %p, len %p, prot 0x%x)\n", addr, len, prot);
711         if (!len)
712                 return 0;
713         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
714                 set_errno(EINVAL);
715                 return -1;
716         }
717         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
718         if (end > UMAPTOP || addr > end) {
719                 set_errno(ENOMEM);
720                 return -1;
721         }
722         /* read/write lock, will probably change the tree and settings */
723         spin_lock(&p->vmr_lock);
724         p->vmr_history++;
725         int ret = __do_mprotect(p, addr, len, prot);
726         spin_unlock(&p->vmr_lock);
727         return ret;
728 }
729
730 /* This does not care if the region is not mapped.  POSIX says you should return
731  * ENOMEM if any part of it is unmapped.  Can do this later if we care, based on
732  * the VMRs, not the actual page residency. */
733 int __do_mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
734 {
735         struct vm_region *vmr, *next_vmr;
736         pte_t pte;
737         bool shootdown_needed = FALSE;
738         int pte_prot = (prot & PROT_WRITE) ? PTE_USER_RW :
739                        (prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : PTE_NONE;
740         /* TODO: this is aggressively splitting, when we might not need to if the
741          * prots are the same as the previous.  Plus, there are three excessive
742          * scans.  Finally, we might be able to merge when we are done. */
743         isolate_vmrs(p, addr, len);
744         vmr = find_first_vmr(p, addr);
745         while (vmr && vmr->vm_base < addr + len) {
746                 if (vmr->vm_prot == prot)
747                         continue;
748                 if (vmr->vm_file && !check_file_perms(vmr, vmr->vm_file, prot)) {
749                         set_errno(EACCES);
750                         return -1;
751                 }
752                 vmr->vm_prot = prot;
753                 spin_lock(&p->pte_lock);        /* walking and changing PTEs */
754                 /* TODO: use a memwalk.  At a minimum, we need to change every existing
755                  * PTE that won't trigger a PF (meaning, present PTEs) to have the new
756                  * prot.  The others will fault on access, and we'll change the PTE
757                  * then.  In the off chance we have a mapped but not present PTE, we
758                  * might as well change it too, since we're already here. */
759                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) {
760                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
761                         if (pte_walk_okay(pte) && pte_is_mapped(pte)) {
762                                 pte_replace_perm(pte, pte_prot);
763                                 shootdown_needed = TRUE;
764                         }
765                 }
766                 spin_unlock(&p->pte_lock);
767                 next_vmr = TAILQ_NEXT(vmr, vm_link);
768                 vmr = next_vmr;
769         }
770         if (shootdown_needed)
771                 proc_tlbshootdown(p, addr, addr + len);
772         return 0;
773 }
774
775 int munmap(struct proc *p, uintptr_t addr, size_t len)
776 {
777         printd("munmap(addr %x, len %x)\n", addr, len);
778         if (!len)
779                 return 0;
780         len = ROUNDUP(len, PGSIZE);
781
782         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
783                 set_errno(EINVAL);
784                 return -1;
785         }
786         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
787         if (end > UMAPTOP || addr > end) {
788                 set_errno(EINVAL);
789                 return -1;
790         }
791         /* read/write: changing the vmrs (trees, properties, and whatnot) */
792         spin_lock(&p->vmr_lock);
793         p->vmr_history++;
794         int ret = __do_munmap(p, addr, len);
795         spin_unlock(&p->vmr_lock);
796         return ret;
797 }
798
799 static int __munmap_mark_not_present(struct proc *p, pte_t pte, void *va,
800                                      void *arg)
801 {
802         bool *shootdown_needed = (bool*)arg;
803         /* could put in some checks here for !P and also !0 */
804         if (!pte_is_present(pte))       /* unmapped (== 0) *ptes are also not PTE_P */
805                 return 0;
806         pte_clear_present(pte);
807         *shootdown_needed = TRUE;
808         return 0;
809 }
810
811 /* If our page is actually in the PM, we don't do anything.  All a page map
812  * really needs is for our VMR to no longer track it (vmr being in the pm's
813  * list) and to not point at its pages (mark it 0, dude).
814  *
815  * But private mappings mess with that a bit.  Luckily, we can tell by looking
816  * at a page whether the specific page is in the PM or not.  If it isn't, we
817  * still need to free our "VMR local" copy.
818  *
819  * For pages in a PM, we're racing with PM removers.  Both of us sync with the
820  * mm lock, so once we hold the lock, it's a matter of whether or not the PTE is
821  * 0 or not.  If it isn't, then we're still okay to look at the page.  Consider
822  * the PTE a weak ref on the page.  So long as you hold the mm lock, you can
823  * look at the PTE and know the page isn't being freed. */
824 static int __vmr_free_pgs(struct proc *p, pte_t pte, void *va, void *arg)
825 {
826         struct page *page;
827         if (pte_is_unmapped(pte))
828                 return 0;
829         page = pa2page(pte_get_paddr(pte));
830         pte_clear(pte);
831         if (!(atomic_read(&page->pg_flags) & PG_PAGEMAP))
832                 page_decref(page);
833         return 0;
834 }
835
836 int __do_munmap(struct proc *p, uintptr_t addr, size_t len)
837 {
838         struct vm_region *vmr, *next_vmr, *first_vmr;
839         bool shootdown_needed = FALSE;
840
841         /* TODO: this will be a bit slow, since we end up doing three linear
842          * searches (two in isolate, one in find_first). */
843         isolate_vmrs(p, addr, len);
844         first_vmr = find_first_vmr(p, addr);
845         vmr = first_vmr;
846         spin_lock(&p->pte_lock);        /* changing PTEs */
847         while (vmr && vmr->vm_base < addr + len) {
848                 env_user_mem_walk(p, (void*)vmr->vm_base, vmr->vm_end - vmr->vm_base,
849                                   __munmap_mark_not_present, &shootdown_needed);
850                 vmr = TAILQ_NEXT(vmr, vm_link);
851         }
852         spin_unlock(&p->pte_lock);
853         /* we haven't freed the pages yet; still using the PTEs to store the them.
854          * There should be no races with inserts/faults, since we still hold the mm
855          * lock since the previous CB. */
856         if (shootdown_needed)
857                 proc_tlbshootdown(p, addr, addr + len);
858         vmr = first_vmr;
859         while (vmr && vmr->vm_base < addr + len) {
860                 /* there is rarely more than one VMR in this loop.  o/w, we'll need to
861                  * gather up the vmrs and destroy outside the pte_lock. */
862                 spin_lock(&p->pte_lock);        /* changing PTEs */
863                 env_user_mem_walk(p, (void*)vmr->vm_base, vmr->vm_end - vmr->vm_base,
864                                       __vmr_free_pgs, 0);
865                 spin_unlock(&p->pte_lock);
866                 next_vmr = TAILQ_NEXT(vmr, vm_link);
867                 destroy_vmr(vmr);
868                 vmr = next_vmr;
869         }
870         return 0;
871 }
872
873 /* Helper - drop the page differently based on where it is from */
874 static void __put_page(struct page *page)
875 {
876         if (atomic_read(&page->pg_flags) & PG_PAGEMAP)
877                 pm_put_page(page);
878         else
879                 page_decref(page);
880 }
881
882 static int __hpf_load_page(struct proc *p, struct page_map *pm,
883                            unsigned long idx, struct page **page, bool first)
884 {
885         int ret = 0;
886         int coreid = core_id();
887         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
888         bool wake_scp = FALSE;
889         spin_lock(&p->proc_lock);
890         switch (p->state) {
891                 case (PROC_RUNNING_S):
892                         wake_scp = TRUE;
893                         __proc_set_state(p, PROC_WAITING);
894                         /* it's possible for HPF to loop a few times; we can only save the
895                          * first time, o/w we could clobber. */
896                         if (first) {
897                                 __proc_save_context_s(p);
898                                 __proc_save_fpu_s(p);
899                                 /* We clear the owner, since userspace doesn't run here
900                                  * anymore, but we won't abandon since the fault handler
901                                  * still runs in our process. */
902                                 clear_owning_proc(coreid);
903                         }
904                         /* other notes: we don't currently need to tell the ksched
905                          * we switched from running to waiting, though we probably
906                          * will later for more generic scheds. */
907                         break;
908                 case (PROC_RUNNABLE_M):
909                 case (PROC_RUNNING_M):
910                         spin_unlock(&p->proc_lock);
911                         return -EAGAIN; /* will get reflected back to userspace */
912                 case (PROC_DYING):
913                         spin_unlock(&p->proc_lock);
914                         return -EINVAL;
915                 default:
916                         /* shouldn't have any waitings, under the current yield style.  if
917                          * this becomes an issue, we can branch on is_mcp(). */
918                         printk("HPF unexpectecd state(%s)", procstate2str(p->state));
919                         spin_unlock(&p->proc_lock);
920                         return -EINVAL;
921         }
922         spin_unlock(&p->proc_lock);
923         ret = pm_load_page(pm, idx, page);
924         if (wake_scp)
925                 proc_wakeup(p);
926         if (ret) {
927                 printk("load failed with ret %d\n", ret);
928                 return ret;
929         }
930         /* need to put our old ref, next time around HPF will get another. */
931         pm_put_page(*page);
932         return 0;
933 }
934
935 /* Returns 0 on success, or an appropriate -error code.
936  *
937  * Notes: if your TLB caches negative results, you'll need to flush the
938  * appropriate tlb entry.  Also, you could have a weird race where a present PTE
939  * faulted for a different reason (was mprotected on another core), and the
940  * shootdown is on its way.  Userspace should have waited for the mprotect to
941  * return before trying to write (or whatever), so we don't care and will fault
942  * them. */
943 static int __hpf(struct proc *p, uintptr_t va, int prot, bool file_ok)
944 {
945         struct vm_region *vmr;
946         struct page *a_page;
947         unsigned int f_idx;     /* index of the missing page in the file */
948         int ret = 0;
949         bool first = TRUE;
950         va = ROUNDDOWN(va,PGSIZE);
951
952 refault:
953         /* read access to the VMRs TODO: RCU */
954         spin_lock(&p->vmr_lock);
955         /* Check the vmr's protection */
956         vmr = find_vmr(p, va);
957         if (!vmr) {                                                     /* not mapped at all */
958                 printd("fault: %p not mapped\n", va);
959                 ret = -EFAULT;
960                 goto out;
961         }
962         if (!(vmr->vm_prot & prot)) {           /* wrong prots for this vmr */
963                 ret = -EPERM;
964                 goto out;
965         }
966         if (!vmr->vm_file) {
967                 /* No file - just want anonymous memory */
968                 if (upage_alloc(p, &a_page, TRUE)) {
969                         ret = -ENOMEM;
970                         goto out;
971                 }
972         } else {
973                 if (!file_ok)
974                         return -EACCES;
975                 /* If this fails, either something got screwed up with the VMR, or the
976                  * permissions changed after mmap/mprotect.  Either way, I want to know
977                  * (though it's not critical). */
978                 if (!check_file_perms(vmr, vmr->vm_file, prot))
979                         printk("[kernel] possible issue with VMR prots on file %s!\n",
980                                file_name(vmr->vm_file));
981                 /* Load the file's page in the page cache.
982                  * TODO: (BLK) Note, we are holding the mem lock!  We need to rewrite
983                  * this stuff so we aren't hold the lock as excessively as we are, and
984                  * such that we can block and resume later. */
985                 assert(!PGOFF(va - vmr->vm_base + vmr->vm_foff));
986                 f_idx = (va - vmr->vm_base + vmr->vm_foff) >> PGSHIFT;
987                 /* TODO: need some sort of lock on the file to deal with someone
988                  * concurrently shrinking it.  Adding 1 to f_idx, since it is
989                  * zero-indexed */
990                 if (f_idx + 1 > nr_pages(vmr->vm_file->f_dentry->d_inode->i_size)) {
991                         /* We're asking for pages that don't exist in the file */
992                         /* TODO: unlock the file */
993                         ret = -ESPIPE; /* linux sends a SIGBUS at access time */
994                         goto out;
995                 }
996                 ret = pm_load_page_nowait(vmr->vm_file->f_mapping, f_idx, &a_page);
997                 if (ret) {
998                         if (ret != -EAGAIN)
999                                 goto out;
1000                         /* keep the file alive after we unlock */
1001                         kref_get(&vmr->vm_file->f_kref, 1);
1002                         spin_unlock(&p->vmr_lock);
1003                         ret = __hpf_load_page(p, vmr->vm_file->f_mapping, f_idx, &a_page,
1004                                               first);
1005                         first = FALSE;
1006                         kref_put(&vmr->vm_file->f_kref);
1007                         if (ret)
1008                                 return ret;
1009                         goto refault;
1010                 }
1011                 /* If we want a private map, we'll preemptively give you a new page.  We
1012                  * used to just care if it was private and writable, but were running
1013                  * into issues with libc changing its mapping (map private, then
1014                  * mprotect to writable...)  In the future, we want to CoW this anyway,
1015                  * so it's not a big deal. */
1016                 if ((vmr->vm_flags & MAP_PRIVATE)) {
1017                         ret = __copy_and_swap_pmpg(p, &a_page);
1018                         if (ret)
1019                                 goto out_put_pg;
1020                 }
1021                 /* if this is an executable page, we might have to flush the instruction
1022                  * cache if our HW requires it. */
1023                 if (vmr->vm_prot & PROT_EXEC)
1024                         icache_flush_page((void*)va, page2kva(a_page));
1025         }
1026         /* update the page table TODO: careful with MAP_PRIVATE etc.  might do this
1027          * separately (file, no file) */
1028         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
1029                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
1030         ret = map_page_at_addr(p, a_page, va, pte_prot);
1031         if (ret) {
1032                 printd("map_page_at for %p fails with %d\n", va, ret);
1033         }
1034         /* fall through, even for errors */
1035 out_put_pg:
1036         /* the VMR's existence in the PM (via the mmap) allows us to have PTE point
1037          * to a_page without it magically being reallocated.  For non-PM memory
1038          * (anon memory or private pages) we transferred the ref to the PTE. */
1039         if (atomic_read(&a_page->pg_flags) & PG_PAGEMAP)
1040                 pm_put_page(a_page);
1041 out:
1042         spin_unlock(&p->vmr_lock);
1043         return ret;
1044 }
1045
1046 int handle_page_fault(struct proc *p, uintptr_t va, int prot)
1047 {
1048         return __hpf(p, va, prot, TRUE);
1049 }
1050
1051 int handle_page_fault_nofile(struct proc *p, uintptr_t va, int prot)
1052 {
1053         return __hpf(p, va, prot, FALSE);
1054 }
1055
1056 /* Attempts to populate the pages, as if there was a page faults.  Bails on
1057  * errors, and returns the number of pages populated.  */
1058 unsigned long populate_va(struct proc *p, uintptr_t va, unsigned long nr_pgs)
1059 {
1060         struct vm_region *vmr, vmr_copy;
1061         unsigned long nr_pgs_this_vmr;
1062         unsigned long nr_filled = 0;
1063         struct page *page;
1064         int pte_prot;
1065         int ret;
1066
1067         /* we can screw around with ways to limit the find_vmr calls (can do the
1068          * next in line if we didn't unlock, etc., but i don't expect us to do this
1069          * for more than a single VMR in most cases. */
1070         spin_lock(&p->vmr_lock);
1071         while (nr_pgs) {
1072                 vmr = find_vmr(p, va);
1073                 if (!vmr)
1074                         break;
1075                 if (vmr->vm_prot == PROT_NONE)
1076                         break;
1077                 pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
1078                            (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
1079                 nr_pgs_this_vmr = MIN(nr_pgs, (vmr->vm_end - va) >> PGSHIFT);
1080                 if (!vmr->vm_file) {
1081                         if (populate_anon_va(p, va, nr_pgs_this_vmr, pte_prot)) {
1082                                 /* on any error, we can just bail.  we might be underestimating
1083                                  * nr_filled. */
1084                                 break;
1085                         }
1086                 } else {
1087                         /* need to keep the file alive in case we unlock/block */
1088                         kref_get(&vmr->vm_file->f_kref, 1);
1089                         ret = populate_pm_va(p, va, nr_pgs_this_vmr, pte_prot,
1090                                              vmr->vm_file->f_mapping,
1091                                              vmr->vm_foff - (va - vmr->vm_base),
1092                                              vmr->vm_flags, vmr->vm_prot & PROT_EXEC);
1093                         kref_put(&vmr->vm_file->f_kref);
1094                         if (ret) {
1095                                 /* we might have failed if the underlying file doesn't cover the
1096                                  * mmap window, depending on how we'll deal with truncation. */
1097                                 break;
1098                         }
1099                 }
1100                 nr_filled += nr_pgs_this_vmr;
1101                 va += nr_pgs_this_vmr << PGSHIFT;
1102                 nr_pgs -= nr_pgs_this_vmr;
1103         }
1104         spin_unlock(&p->vmr_lock);
1105         return nr_filled;
1106 }
1107
1108 /* Kernel Dynamic Memory Mappings */
1109 uintptr_t dyn_vmap_llim = KERN_DYN_TOP;
1110 spinlock_t dyn_vmap_lock = SPINLOCK_INITIALIZER;
1111
1112 /* Reserve space in the kernel dynamic memory map area */
1113 uintptr_t get_vmap_segment(unsigned long num_pages)
1114 {
1115         uintptr_t retval;
1116         spin_lock(&dyn_vmap_lock);
1117         retval = dyn_vmap_llim - num_pages * PGSIZE;
1118         if ((retval > ULIM) && (retval < KERN_DYN_TOP)) {
1119                 dyn_vmap_llim = retval;
1120         } else {
1121                 warn("[kernel] dynamic mapping failed!");
1122                 retval = 0;
1123         }
1124         spin_unlock(&dyn_vmap_lock);
1125         return retval;
1126 }
1127
1128 /* Give up your space.  Note this isn't supported yet */
1129 uintptr_t put_vmap_segment(uintptr_t vaddr, unsigned long num_pages)
1130 {
1131         /* TODO: use vmem regions for adjustable vmap segments */
1132         warn("Not implemented, leaking vmem space.\n");
1133         return 0;
1134 }
1135
1136 /* Map a virtual address chunk to physical addresses.  Make sure you got a vmap
1137  * segment before actually trying to do the mapping.
1138  *
1139  * Careful with more than one 'page', since it will assume your physical pages
1140  * are also contiguous.  Most callers will only use one page.
1141  *
1142  * Finally, note that this does not care whether or not there are real pages
1143  * being mapped, and will not attempt to incref your page (if there is such a
1144  * thing).  Handle your own refcnting for pages. */
1145 int map_vmap_segment(uintptr_t vaddr, uintptr_t paddr, unsigned long num_pages,
1146                      int perm)
1147 {
1148         /* For now, we only handle the root pgdir, and not any of the other ones
1149          * (like for processes).  To do so, we'll need to insert into every pgdir,
1150          * and send tlb shootdowns to those that are active (which we don't track
1151          * yet). */
1152         extern int booting;
1153         assert(booting);
1154
1155         /* TODO: (MM) you should lock on boot pgdir modifications.  A vm region lock
1156          * isn't enough, since there might be a race on outer levels of page tables.
1157          * For now, we'll just use the dyn_vmap_lock (which technically works). */
1158         spin_lock(&dyn_vmap_lock);
1159         pte_t pte;
1160 #ifdef CONFIG_X86
1161         perm |= PTE_G;
1162 #endif
1163         for (int i = 0; i < num_pages; i++) {
1164                 pte = pgdir_walk(boot_pgdir, (void*)(vaddr + i * PGSIZE), 1);
1165                 if (!pte_walk_okay(pte)) {
1166                         spin_unlock(&dyn_vmap_lock);
1167                         return -ENOMEM;
1168                 }
1169                 /* You probably should have unmapped first */
1170                 if (pte_is_mapped(pte))
1171                         warn("Existing PTE value %p\n", pte_print(pte));
1172                 pte_write(pte, paddr + i * PGSIZE, perm);
1173         }
1174         spin_unlock(&dyn_vmap_lock);
1175         return 0;
1176 }
1177
1178 /* Unmaps / 0's the PTEs of a chunk of vaddr space */
1179 int unmap_vmap_segment(uintptr_t vaddr, unsigned long num_pages)
1180 {
1181         /* Not a big deal - won't need this til we do something with kthreads */
1182         warn("Incomplete, don't call this yet.");
1183         spin_lock(&dyn_vmap_lock);
1184         /* TODO: For all pgdirs */
1185         pte_t pte;
1186         for (int i = 0; i < num_pages; i++) {
1187                 pte = pgdir_walk(boot_pgdir, (void*)(vaddr + i * PGSIZE), 1);
1188                 if (pte_walk_okay(pte))
1189                         pte_clear(pte);
1190         }
1191         /* TODO: TLB shootdown.  Also note that the global flag is set on the PTE
1192          * (for x86 for now), which requires a global shootdown.  bigger issue is
1193          * the TLB shootdowns for multiple pgdirs.  We'll need to remove from every
1194          * pgdir, and send tlb shootdowns to those that are active (which we don't
1195          * track yet). */
1196         spin_unlock(&dyn_vmap_lock);
1197         return 0;
1198 }
1199
1200 /* This can handle unaligned paddrs */
1201 static uintptr_t vmap_pmem_flags(uintptr_t paddr, size_t nr_bytes, int flags)
1202 {
1203         uintptr_t vaddr;
1204         unsigned long nr_pages;
1205         assert(nr_bytes && paddr);
1206         nr_bytes += PGOFF(paddr);
1207         nr_pages = ROUNDUP(nr_bytes, PGSIZE) >> PGSHIFT;
1208         vaddr = get_vmap_segment(nr_pages);
1209         if (!vaddr) {
1210                 warn("Unable to get a vmap segment");   /* probably a bug */
1211                 return 0;
1212         }
1213         /* it's not strictly necessary to drop paddr's pgoff, but it might save some
1214          * vmap heartache in the future. */
1215         if (map_vmap_segment(vaddr, PG_ADDR(paddr), nr_pages,
1216                              PTE_KERN_RW | flags)) {
1217                 warn("Unable to map a vmap segment");   /* probably a bug */
1218                 return 0;
1219         }
1220         return vaddr + PGOFF(paddr);
1221 }
1222
1223 uintptr_t vmap_pmem(uintptr_t paddr, size_t nr_bytes)
1224 {
1225         return vmap_pmem_flags(paddr, nr_bytes, 0);
1226 }
1227
1228 uintptr_t vmap_pmem_nocache(uintptr_t paddr, size_t nr_bytes)
1229 {
1230         return vmap_pmem_flags(paddr, nr_bytes, PTE_NOCACHE);
1231 }
1232
1233 uintptr_t vmap_pmem_writecomb(uintptr_t paddr, size_t nr_bytes)
1234 {
1235         return vmap_pmem_flags(paddr, nr_bytes, PTE_WRITECOMB);
1236 }
1237
1238 int vunmap_vmem(uintptr_t vaddr, size_t nr_bytes)
1239 {
1240         unsigned long nr_pages = ROUNDUP(nr_bytes, PGSIZE) >> PGSHIFT;
1241         unmap_vmap_segment(vaddr, nr_pages);
1242         put_vmap_segment(vaddr, nr_pages);
1243         return 0;
1244 }