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