mmap() with addr 0 will start from BRK_END
[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 memory lock (proc_lock
11  * for now) is already held begin with __ (e.g. __do_munmap()).
12  *
13  * Note that if we were called from kern/src/syscall.c, we probably don't have
14  * an edible reference to p. */
15
16 #include <frontend.h>
17 #include <ros/common.h>
18 #include <ros/mman.h>
19 #include <pmap.h>
20 #include <mm.h>
21 #include <process.h>
22 #include <stdio.h>
23 #include <syscall.h>
24 #include <slab.h>
25 #include <kmalloc.h>
26 #include <vfs.h>
27 #include <smp.h>
28
29 struct kmem_cache *vmr_kcache;
30
31 void vmr_init(void)
32 {
33         vmr_kcache = kmem_cache_create("vm_regions", sizeof(struct vm_region),
34                                        __alignof__(struct dentry), 0, 0, 0);
35 }
36
37 /* For now, the caller will set the prot, flags, file, and offset.  In the
38  * future, we may put those in here, to do clever things with merging vm_regions
39  * that are the same.
40  *
41  * TODO: take a look at solari's vmem alloc.  And consider keeping these in a
42  * tree of some sort for easier lookups. */
43 struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
44 {
45         struct vm_region *vmr = 0, *vm_i, *vm_next;
46         uintptr_t gap_end;
47
48         assert(!PGOFF(va));
49         assert(!PGOFF(len));
50         assert(va + len <= UMAPTOP);
51
52         /* Is there room before the first one: */
53         vm_i = TAILQ_FIRST(&p->vm_regions);
54         /* This works for now, but if all we have is BRK_END ones, we'll start
55          * growing backwards (TODO) */
56         if (!vm_i || (va + len < vm_i->vm_base)) {
57                 vmr = kmem_cache_alloc(vmr_kcache, 0);
58                 if (!vmr)
59                         panic("EOM!");
60                 memset(vmr, 0, sizeof(struct vm_region));
61                 vmr->vm_base = va;
62                 TAILQ_INSERT_HEAD(&p->vm_regions, vmr, vm_link);
63         } else {
64                 TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
65                         vm_next = TAILQ_NEXT(vm_i, vm_link);
66                         gap_end = vm_next ? vm_next->vm_base : UMAPTOP;
67                         /* skip til we get past the 'hint' va */
68                         if (va >= gap_end)
69                                 continue;
70                         /* Find a gap that is big enough */
71                         if (gap_end - vm_i->vm_end >= len) {
72                                 vmr = kmem_cache_alloc(vmr_kcache, 0);
73                                 if (!vmr)
74                                         panic("EOM!");
75                                 memset(vmr, 0, sizeof(struct vm_region));
76                                 /* if we can put it at va, let's do that.  o/w, put it so it
77                                  * fits */
78                                 if ((gap_end >= va + len) && (va >= vm_i->vm_end))
79                                         vmr->vm_base = va;
80                                 else
81                                         vmr->vm_base = vm_i->vm_end;
82                                 TAILQ_INSERT_AFTER(&p->vm_regions, vm_i, vmr, vm_link);
83                                 break;
84                         }
85                 }
86         }
87         /* Finalize the creation, if we got one */
88         if (vmr) {
89                 vmr->vm_proc = p;
90                 vmr->vm_end = vmr->vm_base + len;
91         }
92         if (!vmr)
93                 warn("Not making a VMR, wanted %08p, + %p = %p", va, len, va + len);
94         return vmr;
95 }
96
97 /* Split a VMR at va, returning the new VMR.  It is set up the same way, with
98  * file offsets fixed accordingly.  'va' is the beginning of the new one, and
99  * must be page aligned. */
100 struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
101 {
102         struct vm_region *new_vmr;
103
104         assert(!PGOFF(va));
105         if ((old_vmr->vm_base >= va) || (old_vmr->vm_end <= va))
106                 return 0;
107         new_vmr = kmem_cache_alloc(vmr_kcache, 0);
108         TAILQ_INSERT_AFTER(&old_vmr->vm_proc->vm_regions, old_vmr, new_vmr,
109                            vm_link);
110         new_vmr->vm_proc = old_vmr->vm_proc;
111         new_vmr->vm_base = va;
112         new_vmr->vm_end = old_vmr->vm_end;
113         old_vmr->vm_end = va;
114         new_vmr->vm_prot = old_vmr->vm_prot;
115         new_vmr->vm_flags = old_vmr->vm_flags;
116         if (old_vmr->vm_file) {
117                 kref_get(&old_vmr->vm_file->f_kref, 1);
118                 new_vmr->vm_file = old_vmr->vm_file;
119                 new_vmr->vm_foff = old_vmr->vm_foff +
120                                       old_vmr->vm_end - old_vmr->vm_base;
121         } else {
122                 new_vmr->vm_file = 0;
123                 new_vmr->vm_foff = 0;
124         }
125         return new_vmr;
126 }
127
128 /* Merges two vm regions.  For now, it will check to make sure they are the
129  * same.  The second one will be destroyed. */
130 int merge_vmr(struct vm_region *first, struct vm_region *second)
131 {
132         assert(first->vm_proc == second->vm_proc);
133         if ((first->vm_end != second->vm_base) ||
134             (first->vm_prot != second->vm_prot) ||
135             (first->vm_flags != second->vm_flags) ||
136             (first->vm_file != second->vm_file))
137                 return -1;
138         if ((first->vm_file) && (second->vm_foff != first->vm_foff +
139                                  first->vm_end - first->vm_base))
140                 return -1;
141         first->vm_end = second->vm_end;
142         destroy_vmr(second);
143         return 0;
144 }
145
146 /* Attempts to merge vmr with adjacent VMRs, returning a ptr to be used for vmr.
147  * It could be the same struct vmr, or possibly another one (usually lower in
148  * the address space. */
149 struct vm_region *merge_me(struct vm_region *vmr)
150 {
151         struct vm_region *vmr_temp;
152         /* Merge will fail if it cannot do it.  If it succeeds, the second VMR is
153          * destroyed, so we need to be a bit careful. */
154         vmr_temp = TAILQ_PREV(vmr, vmr_tailq, vm_link);
155         if (vmr_temp)
156                 if (!merge_vmr(vmr_temp, vmr))
157                         vmr = vmr_temp;
158         vmr_temp = TAILQ_NEXT(vmr, vm_link);
159         if (vmr_temp)
160                 merge_vmr(vmr, vmr_temp);
161         return vmr;
162 }
163
164 /* Grows the vm region up to (and not including) va.  Fails if another is in the
165  * way, etc. */
166 int grow_vmr(struct vm_region *vmr, uintptr_t va)
167 {
168         assert(!PGOFF(va));
169         struct vm_region *next = TAILQ_NEXT(vmr, vm_link);
170         if (next && next->vm_base < va)
171                 return -1;
172         if (va <= vmr->vm_end)
173                 return -1;
174         vmr->vm_end = va;
175         return 0;
176 }
177
178 /* Shrinks the vm region down to (and not including) va.  Whoever calls this
179  * will need to sort out the page table entries. */
180 int shrink_vmr(struct vm_region *vmr, uintptr_t va)
181 {
182         assert(!PGOFF(va));
183         if ((va < vmr->vm_base) || (va > vmr->vm_end))
184                 return -1;
185         vmr->vm_end = va;
186         return 0;
187 }
188
189 /* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
190  * out the page table entries. */
191 void destroy_vmr(struct vm_region *vmr)
192 {
193         if (vmr->vm_file)
194                 kref_put(&vmr->vm_file->f_kref);
195         TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
196         kmem_cache_free(vmr_kcache, vmr);
197 }
198
199 /* Given a va and a proc (later an mm, possibly), returns the owning vmr, or 0
200  * if there is none. */
201 struct vm_region *find_vmr(struct proc *p, uintptr_t va)
202 {
203         struct vm_region *vmr;
204         /* ugly linear seach */
205         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
206                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
207                         return vmr;
208         }
209         return 0;
210 }
211
212 /* Finds the first vmr after va (including the one holding va), or 0 if there is
213  * none. */
214 struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
215 {
216         struct vm_region *vmr;
217         /* ugly linear seach */
218         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
219                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
220                         return vmr;
221                 if (vmr->vm_base > va)
222                         return vmr;
223         }
224         return 0;
225 }
226
227 /* Makes sure that no VMRs cross either the start or end of the given region
228  * [va, va + len), splitting any VMRs that are on the endpoints. */
229 void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
230 {
231         struct vm_region *vmr;
232         if ((vmr = find_vmr(p, va)))
233                 split_vmr(vmr, va);
234         /* TODO: don't want to do another find (linear search) */
235         if ((vmr = find_vmr(p, va + len)))
236                 split_vmr(vmr, va + len);
237 }
238
239 /* Destroys all vmrs of a process - important for when files are mmap()d and
240  * probably later when we share memory regions */
241 void destroy_vmrs(struct proc *p)
242 {
243         struct vm_region *vm_i;
244         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link)
245                 destroy_vmr(vm_i);
246 }
247
248 /* This will make new_p have the same VMRs as p, though it does nothing to
249  * ensure the physical pages or whatever are shared/mapped/copied/whatever.
250  * This is used by fork().
251  *
252  * Note that if you are working on a VMR that is a file, you'll want to be
253  * careful about how it is mapped (SHARED, PRIVATE, etc). */
254 void duplicate_vmrs(struct proc *p, struct proc *new_p)
255 {
256         struct vm_region *vmr, *vm_i;
257         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
258                 vmr = kmem_cache_alloc(vmr_kcache, 0);
259                 if (!vmr)
260                         panic("EOM!");
261                 vmr->vm_proc = new_p;
262                 vmr->vm_base = vm_i->vm_base;
263                 vmr->vm_end = vm_i->vm_end;
264                 vmr->vm_prot = vm_i->vm_prot;   
265                 vmr->vm_flags = vm_i->vm_flags; 
266                 if (vm_i->vm_file)
267                         kref_get(&vm_i->vm_file->f_kref, 1);
268                 vmr->vm_file = vm_i->vm_file;
269                 vmr->vm_foff = vm_i->vm_foff;
270                 TAILQ_INSERT_TAIL(&new_p->vm_regions, vmr, vm_link);
271         }
272 }
273
274 void print_vmrs(struct proc *p)
275 {
276         int count = 0;
277         struct vm_region *vmr;
278         printk("VM Regions for proc %d\n", p->pid);
279         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
280                 printk("%02d: (0x%08x - 0x%08x): %08p, %08p, %08p, %08p\n", count++,
281                        vmr->vm_base, vmr->vm_end, vmr->vm_prot, vmr->vm_flags,
282                        vmr->vm_file, vmr->vm_foff);
283 }
284
285
286 /* Error values aren't quite comprehensive - check man mmap() once we do better
287  * with the FS.
288  *
289  * The mmap call's offset is in units of PGSIZE (like Linux's mmap2()), but
290  * internally, the offset is tracked in bytes.  The reason for the PGSIZE is for
291  * 32bit apps to enumerate large files, but a full 64bit system won't need that.
292  * We track things internally in bytes since that is how file pointers work, vmr
293  * bases and ends, and similar math.  While it's not a hard change, there's no
294  * need for it, and ideally we'll be a fully 64bit system before we deal with
295  * files that large. */
296 void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
297            int fd, size_t offset)
298 {
299         struct file *file = NULL;
300         offset <<= PGSHIFT;
301         printd("mmap(addr %x, len %x, prot %x, flags %x, fd %x, off %x)\n", addr,
302                len, prot, flags, fd, offset);
303         if (fd >= 0 && (flags & MAP_ANON)) {
304                 set_errno(EBADF);
305                 return MAP_FAILED;
306         }
307         if ((addr + len > UMAPTOP) || (PGOFF(addr))) {
308                 set_errno(EINVAL);
309                 return MAP_FAILED;
310         }
311         if (!len) {
312                 set_errno(EINVAL);
313                 return MAP_FAILED;
314         }
315         if (fd != -1) {
316                 file = get_file_from_fd(&p->open_files, fd);
317                 if (!file) {
318                         set_errno(EBADF);
319                         return MAP_FAILED;
320                 }
321         }
322         /* If they don't care where to put it, we'll start looking after the break.
323          * We could just have userspace handle this (in glibc's mmap), so we don't
324          * need to know about BRK_END, but this will work for now (and may avoid
325          * bugs).  Note that this limits mmap(0) a bit. */
326         if (addr == 0)
327                 addr = BRK_END;
328         /* Still need to enforce this: */
329         addr = MAX(addr, MMAP_LOWEST_VA);
330         void *result = do_mmap(p, addr, len, prot, flags, file, offset);
331         if (file)
332                 kref_put(&file->f_kref);
333         return result;
334 }
335
336 void *do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
337               struct file *file, size_t offset)
338 {
339         // TODO: grab the appropriate mm_lock
340         spin_lock(&p->proc_lock);
341         void *ret = __do_mmap(p, addr, len, prot, flags, file, offset);
342         spin_unlock(&p->proc_lock);
343         return ret;
344 }
345
346 void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
347                 struct file *file, size_t offset)
348 {
349         len = ROUNDUP(len, PGSIZE);
350         int num_pages = len / PGSIZE;
351         int retval;
352
353         struct vm_region *vmr, *vmr_temp;
354
355 #ifndef __CONFIG_DEMAND_PAGING__
356         flags |= MAP_POPULATE;
357 #endif
358         /* Need to make sure nothing is in our way when we want a FIXED location.
359          * We just need to split on the end points (if they exist), and then remove
360          * everything in between.  __do_munmap() will do this.  Careful, this means
361          * an mmap can be an implied munmap() (not my call...). */
362         if (flags & MAP_FIXED)
363                 __do_munmap(p, addr, len);
364         vmr = create_vmr(p, addr, len);
365         if (!vmr) {
366                 printk("[kernel] do_mmap() aborted for %08p + %d!\n", addr, len);
367                 set_errno(ENOMEM);
368                 return MAP_FAILED;              /* TODO: error propagation for mmap() */
369         }
370         vmr->vm_prot = prot;
371         vmr->vm_flags = flags;
372         if (file)
373                 kref_get(&file->f_kref, 1);
374         vmr->vm_file = file;
375         vmr->vm_foff = offset;
376         /* Prep the FS to make sure it can mmap the file.  Slightly weird semantics:
377          * they will have a hole in their VM now. */
378         if (file && file->f_op->mmap(file, vmr)) {
379                 destroy_vmr(vmr);
380                 set_errno(EACCES);      /* not quite */
381                 return MAP_FAILED;
382         }
383         addr = vmr->vm_base;            /* so we know which pages to populate later */
384         vmr = merge_me(vmr);            /* attempts to merge with neighbors */
385         /* Fault in pages now if MAP_POPULATE.  We want to populate the region
386          * requested, but we need to be careful and only populate the requested
387          * length and not any merged regions, which is why we set addr above and use
388          * it here.
389          *
390          * If HPF errors out, we'll warn for now, since it is likely a bug in
391          * userspace, though since POPULATE is an opportunistic thing, we don't need
392          * to actually kill the process.  If we do kill them, make sure to
393          * incref/decref around proc_destroy, since we likely don't have an edible
394          * reference to p. */
395         if (flags & MAP_POPULATE)
396                 for (int i = 0; i < num_pages; i++) {
397                         retval = __handle_page_fault(p, addr + i * PGSIZE, vmr->vm_prot);
398                         if (retval) {
399                                 warn("do_mmap() failing (%d) on addr %08p with prot %p\n",
400                                      retval, addr + i * PGSIZE,  vmr->vm_prot);
401                                 break;
402                         }
403                 }
404         return (void*SAFE)TC(addr);
405 }
406
407 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
408 {
409         printd("mprotect: (addr %08p, len %08p, prot %08p)\n", addr, len, prot);
410         if (!len)
411                 return 0;
412         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
413                 set_errno(EINVAL);
414                 return -1;
415         }
416         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
417         if (end > UMAPTOP || addr > end) {
418                 set_errno(ENOMEM);
419                 return -1;
420         }
421         spin_lock(&p->proc_lock);
422         int ret = __do_mprotect(p, addr, len, prot);
423         spin_unlock(&p->proc_lock);
424         return ret;
425 }
426
427 /* This does not care if the region is not mapped.  POSIX says you should return
428  * ENOMEM if any part of it is unmapped.  Can do this later if we care, based on
429  * the VMRs, not the actual page residency. */
430 int __do_mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
431 {
432         struct vm_region *vmr, *next_vmr;
433         pte_t *pte;
434         bool shootdown_needed = FALSE;
435         int pte_prot = (prot & PROT_WRITE) ? PTE_USER_RW :
436                        (prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
437         /* TODO: this is aggressively splitting, when we might not need to if the
438          * prots are the same as the previous.  Plus, there are three excessive
439          * scans.  Finally, we might be able to merge when we are done. */
440         isolate_vmrs(p, addr, len);
441         vmr = find_first_vmr(p, addr);
442         while (vmr && vmr->vm_base < addr + len) {
443                 if (vmr->vm_prot == prot)
444                         continue;
445                 if (vmr->vm_file && (prot & PROT_WRITE)) {
446                         /* if vmr maps a file as MAP_SHARED, then we need to make sure the
447                          * protection change is in compliance with the open mode of the
448                          * file. */
449                     if (vmr->vm_flags & MAP_SHARED) {
450                                 if (!(vmr->vm_file->f_mode & S_IWUSR)) {
451                                         /* at this point, we have a file opened in the wrong mode,
452                                          * but we may be allowed to access it still. */
453                                         if (check_perms(vmr->vm_file->f_dentry->d_inode, S_IWUSR)) {
454                                                 set_errno(EACCES);
455                                                 return -1;
456                                         } else {
457                                                 /* it is okay, though we need to change the file mode.
458                                                  */
459                                                 vmr->vm_file->f_mode |= S_IWUSR;
460                                         }
461                                 }
462                         } else {        /* PRIVATE mapping */
463                                 /* TODO: we want a CoW mapping (like we want in handle_page_fault()),
464                                  * since there is a concern of a process having the page already
465                                  * mapped in to a file it does not have permissions to, and then
466                                  * mprotecting it so it can access it.  So we can't just change
467                                  * the prot, and we don't know yet if a page is mapped in.  To
468                                  * handle this, we ought to sort out the CoW bit, and then this
469                                  * will be easy.  Til then, just do a permissions check.  If we
470                                  * start having weird issues with libc overwriting itself (since
471                                  * procs mprotect that W), then change this. */
472                                 if (check_perms(vmr->vm_file->f_dentry->d_inode, S_IWUSR)) {
473                                         set_errno(EACCES);
474                                         return -1;
475                                 }
476                         }
477                 }
478                 vmr->vm_prot = prot;
479                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
480                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
481                         if (pte && PAGE_PRESENT(*pte)) {
482                                 *pte = (*pte & ~PTE_PERM) | pte_prot;
483                                 shootdown_needed = TRUE;
484                         }
485                 }
486                 next_vmr = TAILQ_NEXT(vmr, vm_link);
487                 vmr = next_vmr;
488         }
489         if (shootdown_needed)
490                 __proc_tlbshootdown(p, addr, addr + len);
491         return 0;
492 }
493
494 int munmap(struct proc *p, uintptr_t addr, size_t len)
495 {
496         printd("munmap(addr %x, len %x, prot %x)\n", addr, len, prot);
497         if (!len)
498                 return 0;
499         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
500                 set_errno(EINVAL);
501                 return -1;
502         }
503         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
504         if (end > UMAPTOP || addr > end) {
505                 set_errno(EINVAL);
506                 return -1;
507         }
508         spin_lock(&p->proc_lock);
509         int ret = __do_munmap(p, addr, len);
510         spin_unlock(&p->proc_lock);
511         return ret;
512 }
513
514 int __do_munmap(struct proc *p, uintptr_t addr, size_t len)
515 {
516         struct vm_region *vmr, *next_vmr;
517         pte_t *pte;
518         bool shootdown_needed = FALSE;
519
520         /* TODO: this will be a bit slow, since we end up doing three linear
521          * searches (two in isolate, one in find_first). */
522         isolate_vmrs(p, addr, len);
523         vmr = find_first_vmr(p, addr);
524         while (vmr && vmr->vm_base < addr + len) {
525                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
526                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
527                         if (!pte)
528                                 continue;
529                         if (PAGE_PRESENT(*pte)) {
530                                 /* TODO: (TLB) race here, where the page can be given out before
531                                  * the shootdown happened.  Need to put it on a temp list. */
532                                 page_t *page = ppn2page(PTE2PPN(*pte));
533                                 *pte = 0;
534                                 page_decref(page);
535                                 shootdown_needed = TRUE;
536                         } else if (PAGE_PAGED_OUT(*pte)) {
537                                 /* TODO: (SWAP) mark free in the swapfile or whatever.  For now,
538                                  * PAGED_OUT is also being used to mean "hasn't been mapped
539                                  * yet".  Note we now allow PAGE_UNMAPPED, unlike older
540                                  * versions of mmap(). */
541                                 panic("Swapping not supported!");
542                                 *pte = 0;
543                         }
544                 }
545                 next_vmr = TAILQ_NEXT(vmr, vm_link);
546                 destroy_vmr(vmr);
547                 vmr = next_vmr;
548         }
549         if (shootdown_needed)
550                 __proc_tlbshootdown(p, addr, addr + len);
551         return 0;
552 }
553
554 int handle_page_fault(struct proc* p, uintptr_t va, int prot)
555 {
556         va = ROUNDDOWN(va,PGSIZE);
557
558         if (prot != PROT_READ && prot != PROT_WRITE && prot != PROT_EXEC)
559                 panic("bad prot!");
560         spin_lock(&p->proc_lock);
561         int ret = __handle_page_fault(p, va, prot);
562         spin_unlock(&p->proc_lock);
563         return ret;
564 }
565
566 /* Returns 0 on success, or an appropriate -error code.  Assumes you hold the
567  * appropriate lock.
568  *
569  * Notes: if your TLB caches negative results, you'll need to flush the
570  * appropriate tlb entry.  Also, you could have a weird race where a present PTE
571  * faulted for a different reason (was mprotected on another core), and the
572  * shootdown is on its way.  Userspace should have waited for the mprotect to
573  * return before trying to write (or whatever), so we don't care and will fault
574  * them. */
575 int __handle_page_fault(struct proc *p, uintptr_t va, int prot)
576 {
577         struct vm_region *vmr;
578         struct page *a_page;
579         unsigned int f_idx;     /* index of the missing page in the file */
580         int retval;
581
582         /* Check the vmr's protection */
583         vmr = find_vmr(p, va);
584         if (!vmr)                                                       /* not mapped at all */
585                 return -EFAULT;
586         if (!(vmr->vm_prot & prot))                     /* wrong prots for this vmr */
587                 return -EPERM;
588         /* find offending PTE (prob don't read this in).  This might alloc an
589          * intermediate page table page. */
590         pte_t *pte = pgdir_walk(p->env_pgdir, (void*)va, 1);
591         if (!pte)
592                 return -ENOMEM;
593         /* a spurious, valid PF is possible due to a legit race: the page might have
594          * been faulted in by another core already (and raced on the memory lock),
595          * in which case we should just return. */
596         if (PAGE_PRESENT(*pte)) {
597                 return 0;
598         } else if (PAGE_PAGED_OUT(*pte)) {
599                 /* TODO: (SWAP) bring in the paged out frame. (BLK) */
600                 panic("Swapping not supported!");
601                 return -1;
602         }
603         if (!vmr->vm_file) {
604                 /* No file - just want anonymous memory */
605                 if (upage_alloc(p, &a_page, TRUE))
606                         return -ENOMEM;
607         } else {
608                 /* Load the file's page in the page cache.
609                  * TODO: (BLK) Note, we are holding the mem lock!  We need to rewrite
610                  * this stuff so we aren't hold the lock as excessively as we are, and
611                  * such that we can block and resume later. */
612                 f_idx = (va - vmr->vm_base + vmr->vm_foff) >> PGSHIFT;
613                 retval = pm_load_page(vmr->vm_file->f_mapping, f_idx, &a_page);
614                 if (retval)
615                         return retval;
616                 /* If we want a private map that is writable, we'll preemptively give
617                  * you a new page.  In the future, we want to CoW this. */
618                 if ((vmr->vm_flags |= MAP_PRIVATE) && (vmr->vm_prot |= PROT_WRITE)) {
619                         struct page *cache_page = a_page;
620                         if (upage_alloc(p, &a_page, FALSE)) {
621                                 page_decref(cache_page);        /* was the original a_page */
622                                 return -ENOMEM;
623                         }
624                         memcpy(page2kva(a_page), page2kva(cache_page), PGSIZE);
625                         page_decref(cache_page);                /* was the original a_page */
626                 }
627                 /* if this is an executable page, we might have to flush the instruction
628                  * cache if our HW requires it. */
629                 if (vmr->vm_prot & PROT_EXEC)
630                         icache_flush_page((void*)va, page2kva(a_page));
631         }
632         /* update the page table TODO: careful with MAP_PRIVATE etc.  might do this
633          * separately (file, no file) */
634         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
635                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
636         /* We have a ref to a_page, which we are storing in the PTE */
637         *pte = PTE(page2ppn(a_page), PTE_P | pte_prot);
638         return 0;
639 }