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