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