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