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