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