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