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