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