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