Replaces %08p with %p
[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 (mm_lock) is
11  * 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 <pmap.h>
19 #include <mm.h>
20 #include <process.h>
21 #include <stdio.h>
22 #include <syscall.h>
23 #include <slab.h>
24 #include <kmalloc.h>
25 #include <vfs.h>
26 #include <smp.h>
27
28 struct kmem_cache *vmr_kcache;
29
30 void vmr_init(void)
31 {
32         vmr_kcache = kmem_cache_create("vm_regions", sizeof(struct vm_region),
33                                        __alignof__(struct dentry), 0, 0, 0);
34 }
35
36 /* For now, the caller will set the prot, flags, file, and offset.  In the
37  * future, we may put those in here, to do clever things with merging vm_regions
38  * that are the same.
39  *
40  * TODO: take a look at solari's vmem alloc.  And consider keeping these in a
41  * tree of some sort for easier lookups. */
42 struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
43 {
44         struct vm_region *vmr = 0, *vm_i, *vm_next;
45         uintptr_t gap_end;
46
47         assert(!PGOFF(va));
48         assert(!PGOFF(len));
49         assert(va + len <= UMAPTOP);
50         /* Is there room before the first one: */
51         vm_i = TAILQ_FIRST(&p->vm_regions);
52         /* This works for now, but if all we have is BRK_END ones, we'll start
53          * growing backwards (TODO) */
54         if (!vm_i || (va + len < vm_i->vm_base)) {
55                 vmr = kmem_cache_alloc(vmr_kcache, 0);
56                 if (!vmr)
57                         panic("EOM!");
58                 memset(vmr, 0, sizeof(struct vm_region));
59                 vmr->vm_base = va;
60                 TAILQ_INSERT_HEAD(&p->vm_regions, vmr, vm_link);
61         } else {
62                 TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
63                         vm_next = TAILQ_NEXT(vm_i, vm_link);
64                         gap_end = vm_next ? vm_next->vm_base : UMAPTOP;
65                         /* skip til we get past the 'hint' va */
66                         if (va >= gap_end)
67                                 continue;
68                         /* Find a gap that is big enough */
69                         if (gap_end - vm_i->vm_end >= len) {
70                                 vmr = kmem_cache_alloc(vmr_kcache, 0);
71                                 if (!vmr)
72                                         panic("EOM!");
73                                 memset(vmr, 0, sizeof(struct vm_region));
74                                 /* if we can put it at va, let's do that.  o/w, put it so it
75                                  * fits */
76                                 if ((gap_end >= va + len) && (va >= vm_i->vm_end))
77                                         vmr->vm_base = va;
78                                 else
79                                         vmr->vm_base = vm_i->vm_end;
80                                 TAILQ_INSERT_AFTER(&p->vm_regions, vm_i, vmr, vm_link);
81                                 break;
82                         }
83                 }
84         }
85         /* Finalize the creation, if we got one */
86         if (vmr) {
87                 vmr->vm_proc = p;
88                 vmr->vm_end = vmr->vm_base + len;
89         }
90         if (!vmr)
91                 warn("Not making a VMR, wanted %p, + %p = %p", va, len, va + len);
92         return vmr;
93 }
94
95 /* Split a VMR at va, returning the new VMR.  It is set up the same way, with
96  * file offsets fixed accordingly.  'va' is the beginning of the new one, and
97  * must be page aligned. */
98 struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
99 {
100         struct vm_region *new_vmr;
101
102         assert(!PGOFF(va));
103         if ((old_vmr->vm_base >= va) || (old_vmr->vm_end <= va))
104                 return 0;
105         new_vmr = kmem_cache_alloc(vmr_kcache, 0);
106         TAILQ_INSERT_AFTER(&old_vmr->vm_proc->vm_regions, old_vmr, new_vmr,
107                            vm_link);
108         new_vmr->vm_proc = old_vmr->vm_proc;
109         new_vmr->vm_base = va;
110         new_vmr->vm_end = old_vmr->vm_end;
111         old_vmr->vm_end = va;
112         new_vmr->vm_prot = old_vmr->vm_prot;
113         new_vmr->vm_flags = old_vmr->vm_flags;
114         if (old_vmr->vm_file) {
115                 kref_get(&old_vmr->vm_file->f_kref, 1);
116                 new_vmr->vm_file = old_vmr->vm_file;
117                 new_vmr->vm_foff = old_vmr->vm_foff +
118                                       old_vmr->vm_end - old_vmr->vm_base;
119         } else {
120                 new_vmr->vm_file = 0;
121                 new_vmr->vm_foff = 0;
122         }
123         return new_vmr;
124 }
125
126 /* Merges two vm regions.  For now, it will check to make sure they are the
127  * same.  The second one will be destroyed. */
128 int merge_vmr(struct vm_region *first, struct vm_region *second)
129 {
130         assert(first->vm_proc == second->vm_proc);
131         if ((first->vm_end != second->vm_base) ||
132             (first->vm_prot != second->vm_prot) ||
133             (first->vm_flags != second->vm_flags) ||
134             (first->vm_file != second->vm_file))
135                 return -1;
136         if ((first->vm_file) && (second->vm_foff != first->vm_foff +
137                                  first->vm_end - first->vm_base))
138                 return -1;
139         first->vm_end = second->vm_end;
140         destroy_vmr(second);
141         return 0;
142 }
143
144 /* Attempts to merge vmr with adjacent VMRs, returning a ptr to be used for vmr.
145  * It could be the same struct vmr, or possibly another one (usually lower in
146  * the address space. */
147 struct vm_region *merge_me(struct vm_region *vmr)
148 {
149         struct vm_region *vmr_temp;
150         /* Merge will fail if it cannot do it.  If it succeeds, the second VMR is
151          * destroyed, so we need to be a bit careful. */
152         vmr_temp = TAILQ_PREV(vmr, vmr_tailq, vm_link);
153         if (vmr_temp)
154                 if (!merge_vmr(vmr_temp, vmr))
155                         vmr = vmr_temp;
156         vmr_temp = TAILQ_NEXT(vmr, vm_link);
157         if (vmr_temp)
158                 merge_vmr(vmr, vmr_temp);
159         return vmr;
160 }
161
162 /* Grows the vm region up to (and not including) va.  Fails if another is in the
163  * way, etc. */
164 int grow_vmr(struct vm_region *vmr, uintptr_t va)
165 {
166         assert(!PGOFF(va));
167         struct vm_region *next = TAILQ_NEXT(vmr, vm_link);
168         if (next && next->vm_base < va)
169                 return -1;
170         if (va <= vmr->vm_end)
171                 return -1;
172         vmr->vm_end = va;
173         return 0;
174 }
175
176 /* Shrinks the vm region down to (and not including) va.  Whoever calls this
177  * will need to sort out the page table entries. */
178 int shrink_vmr(struct vm_region *vmr, uintptr_t va)
179 {
180         assert(!PGOFF(va));
181         if ((va < vmr->vm_base) || (va > vmr->vm_end))
182                 return -1;
183         vmr->vm_end = va;
184         return 0;
185 }
186
187 /* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
188  * out the page table entries. */
189 void destroy_vmr(struct vm_region *vmr)
190 {
191         if (vmr->vm_file)
192                 kref_put(&vmr->vm_file->f_kref);
193         TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
194         kmem_cache_free(vmr_kcache, vmr);
195 }
196
197 /* Given a va and a proc (later an mm, possibly), returns the owning vmr, or 0
198  * if there is none. */
199 struct vm_region *find_vmr(struct proc *p, uintptr_t va)
200 {
201         struct vm_region *vmr;
202         /* ugly linear seach */
203         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
204                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
205                         return vmr;
206         }
207         return 0;
208 }
209
210 /* Finds the first vmr after va (including the one holding va), or 0 if there is
211  * none. */
212 struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
213 {
214         struct vm_region *vmr;
215         /* ugly linear seach */
216         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
217                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
218                         return vmr;
219                 if (vmr->vm_base > va)
220                         return vmr;
221         }
222         return 0;
223 }
224
225 /* Makes sure that no VMRs cross either the start or end of the given region
226  * [va, va + len), splitting any VMRs that are on the endpoints. */
227 void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
228 {
229         struct vm_region *vmr;
230         if ((vmr = find_vmr(p, va)))
231                 split_vmr(vmr, va);
232         /* TODO: don't want to do another find (linear search) */
233         if ((vmr = find_vmr(p, va + len)))
234                 split_vmr(vmr, va + len);
235 }
236
237 /* Destroys all vmrs of a process - important for when files are mmap()d and
238  * probably later when we share memory regions */
239 void destroy_vmrs(struct proc *p)
240 {
241         struct vm_region *vm_i;
242         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link)
243                 destroy_vmr(vm_i);
244 }
245
246 /* Helper: copies the contents of pages from p to new p.  For pages that aren't
247  * present, once we support swapping or CoW, we can do something more
248  * intelligent.  0 on success, -ERROR on failure. */
249 static int copy_pages(struct proc *p, struct proc *new_p, uintptr_t va_start,
250                       uintptr_t va_end)
251 {
252         /* Sanity checks.  If these fail, we had a screwed up VMR.
253          * Check for: alignment, wraparound, or userspace addresses */
254         if ((PGOFF(va_start)) ||
255             (PGOFF(va_end)) ||
256             (va_end < va_start) ||      /* now, start > UMAPTOP -> end > UMAPTOP */
257             (va_end > UMAPTOP)) {
258                 warn("VMR mapping is probably screwed up (%p - %p)", va_start,
259                      va_end);
260                 return -EINVAL;
261         }
262         int copy_page(struct proc *p, pte_t *pte, void *va, void *arg) {
263                 struct proc *new_p = (struct proc*)arg;
264                 struct page *pp;
265                 if (PAGE_PRESENT(*pte)) {
266                         /* TODO: check for jumbos */
267                         if (upage_alloc(new_p, &pp, 0))
268                                 return -ENOMEM;
269                         if (page_insert(new_p->env_pgdir, pp, va, *pte & PTE_PERM)) {
270                                 page_decref(pp);
271                                 return -ENOMEM;
272                         }
273                         memcpy(page2kva(pp), ppn2kva(PTE2PPN(*pte)), PGSIZE);
274                         page_decref(pp);
275                 } else if (PAGE_PAGED_OUT(*pte)) {
276                         /* TODO: (SWAP) will need to either make a copy or CoW/refcnt the
277                          * backend store.  For now, this PTE will be the same as the
278                          * original PTE */
279                         panic("Swapping not supported!");
280                 } else {
281                         panic("Weird PTE %p in %s!", *pte, __FUNCTION__);
282                 }
283                 return 0;
284         }
285         return env_user_mem_walk(p, (void*)va_start, va_end - va_start, &copy_page,
286                                  new_p);
287         /* here's how to do it without the env_user_mem_walk */
288 #if 0
289         pte_t *old_pte;
290         struct page *pp;
291         /* For each page, check the old PTE and copy present pages over */
292         for (uintptr_t va_i = va_start; va_i < va_end; va_i += PGSIZE) {
293                 old_pte = pgdir_walk(p->env_pgdir, (void*)va_i, 0);
294                 if (!old_pte)
295                         continue;
296                 if (PAGE_PRESENT(*old_pte)) {
297                         /* TODO: check for jumbos */
298                         if (upage_alloc(new_p, &pp, 0))
299                                 return -ENOMEM;
300                         if (page_insert(new_p->env_pgdir, pp, (void*)va_i,
301                                         *old_pte & PTE_PERM)) {
302                                 page_decref(pp);
303                                 return -ENOMEM;
304                         }
305                         pagecopy(page2kva(pp), ppn2kva(PTE2PPN(*old_pte)));
306                         page_decref(pp);
307                 } else if (PAGE_PAGED_OUT(*old_pte)) {
308                         /* TODO: (SWAP) will need to either make a copy or CoW/refcnt the
309                          * backend store.  For now, this PTE will be the same as the
310                          * original PTE */
311                         panic("Swapping not supported!");
312                 } else {
313                         panic("Weird PTE %p in %s!", *old_pte, __FUNCTION__);
314                 }
315         }
316         return 0;
317 #endif
318 }
319
320 /* This will make new_p have the same VMRs as p, and it will make sure all
321  * physical pages are copied over, with the exception of MAP_SHARED files.
322  * This is used by fork().
323  *
324  * Note that if you are working on a VMR that is a file, you'll want to be
325  * careful about how it is mapped (SHARED, PRIVATE, etc). */
326 int duplicate_vmrs(struct proc *p, struct proc *new_p)
327 {
328         int ret = 0;
329         struct vm_region *vmr, *vm_i;
330         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
331                 vmr = kmem_cache_alloc(vmr_kcache, 0);
332                 if (!vmr)
333                         return -ENOMEM;
334                 vmr->vm_proc = new_p;
335                 vmr->vm_base = vm_i->vm_base;
336                 vmr->vm_end = vm_i->vm_end;
337                 vmr->vm_prot = vm_i->vm_prot;   
338                 vmr->vm_flags = vm_i->vm_flags; 
339                 if (vm_i->vm_file)
340                         kref_get(&vm_i->vm_file->f_kref, 1);
341                 vmr->vm_file = vm_i->vm_file;
342                 vmr->vm_foff = vm_i->vm_foff;
343                 if (!vmr->vm_file || vmr->vm_flags & MAP_PRIVATE) {
344                         assert(!(vmr->vm_flags & MAP_SHARED));
345                         /* Copy over the memory from one VMR to the other */
346                         if ((ret = copy_pages(p, new_p, vmr->vm_base, vmr->vm_end)))
347                                 return ret;
348                 }
349                 TAILQ_INSERT_TAIL(&new_p->vm_regions, vmr, vm_link);
350         }
351         return 0;
352 }
353
354 void print_vmrs(struct proc *p)
355 {
356         int count = 0;
357         struct vm_region *vmr;
358         printk("VM Regions for proc %d\n", p->pid);
359         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
360                 printk("%02d: (%p - %p): 0x%08x, 0x%08x, %p, %p\n", count++,
361                        vmr->vm_base, vmr->vm_end, vmr->vm_prot, vmr->vm_flags,
362                        vmr->vm_file, vmr->vm_foff);
363 }
364
365 /* Helper: returns the number of pages required to hold nr_bytes */
366 unsigned long nr_pages(unsigned long nr_bytes)
367 {
368         return (nr_bytes >> PGSHIFT) + (PGOFF(nr_bytes) ? 1 : 0);
369 }
370
371 /* Error values aren't quite comprehensive - check man mmap() once we do better
372  * with the FS.
373  *
374  * The mmap call's offset is in units of PGSIZE (like Linux's mmap2()), but
375  * internally, the offset is tracked in bytes.  The reason for the PGSIZE is for
376  * 32bit apps to enumerate large files, but a full 64bit system won't need that.
377  * We track things internally in bytes since that is how file pointers work, vmr
378  * bases and ends, and similar math.  While it's not a hard change, there's no
379  * need for it, and ideally we'll be a fully 64bit system before we deal with
380  * files that large. */
381 void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
382            int fd, size_t offset)
383 {
384         struct file *file = NULL;
385         offset <<= PGSHIFT;
386         printd("mmap(addr %x, len %x, prot %x, flags %x, fd %x, off %x)\n", addr,
387                len, prot, flags, fd, offset);
388         if (fd >= 0 && (flags & MAP_ANON)) {
389                 set_errno(EBADF);
390                 return MAP_FAILED;
391         }
392         if (!len) {
393                 set_errno(EINVAL);
394                 return MAP_FAILED;
395         }
396         if (fd != -1) {
397                 file = get_file_from_fd(&p->open_files, fd);
398                 if (!file) {
399                         set_errno(EBADF);
400                         return MAP_FAILED;
401                 }
402         }
403         /* If they don't care where to put it, we'll start looking after the break.
404          * We could just have userspace handle this (in glibc's mmap), so we don't
405          * need to know about BRK_END, but this will work for now (and may avoid
406          * bugs).  Note that this limits mmap(0) a bit.  Keep this in sync with
407          * __do_mmap()'s check.  (Both are necessary).  */
408         if (addr == 0)
409                 addr = BRK_END;
410         /* Still need to enforce this: */
411         addr = MAX(addr, MMAP_LOWEST_VA);
412         /* Need to check addr + len, after we do our addr adjustments */
413         if ((addr + len > UMAPTOP) || (PGOFF(addr))) {
414                 set_errno(EINVAL);
415                 return MAP_FAILED;
416         }
417         void *result = do_mmap(p, addr, len, prot, flags, file, offset);
418         if (file)
419                 kref_put(&file->f_kref);
420         return result;
421 }
422
423 void *do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
424               struct file *file, size_t offset)
425 {
426         spin_lock(&p->mm_lock);
427         void *ret = __do_mmap(p, addr, len, prot, flags, file, offset);
428         spin_unlock(&p->mm_lock);
429         return ret;
430 }
431
432 /* Helper: returns TRUE if the VMR is allowed to access the file with prot.
433  * This is a bit ghetto still: messes with the file mode and assumes it can walk
434  * the dentry/inode paths without locking.  It also ignores the CoW stuff we'll
435  * need to do eventually. */
436 static bool check_file_perms(struct vm_region *vmr, struct file *file, int prot)
437 {
438         assert(file);
439         if (prot & PROT_READ) {
440                 if (check_perms(file->f_dentry->d_inode, S_IRUSR))
441                         goto out_error;
442         }
443         if (prot & PROT_WRITE) {
444                 /* if vmr maps a file as MAP_SHARED, then we need to make sure the
445                  * protection change is in compliance with the open mode of the
446                  * file. */
447                 if (vmr->vm_flags & MAP_SHARED) {
448                         if (!(file->f_mode & S_IWUSR)) {
449                                 /* at this point, we have a file opened in the wrong mode,
450                                  * but we may be allowed to access it still. */
451                                 if (check_perms(file->f_dentry->d_inode, S_IWUSR)) {
452                                         goto out_error;
453                                 } else {
454                                         /* it is okay, though we need to change the file mode. (note
455                                          * the lack of a lock/protection (TODO) */
456                                         file->f_mode |= S_IWUSR;
457                                 }
458                         }
459                 } else {        /* PRIVATE mapping */
460                         /* TODO: we want a CoW mapping (like we want in handle_page_fault()),
461                          * since there is a concern of a process having the page already
462                          * mapped in to a file it does not have permissions to, and then
463                          * mprotecting it so it can access it.  So we can't just change
464                          * the prot, and we don't know yet if a page is mapped in.  To
465                          * handle this, we ought to sort out the CoW bit, and then this
466                          * will be easy.  Til then, just do a permissions check.  If we
467                          * start having weird issues with libc overwriting itself (since
468                          * procs mprotect that W), then change this. */
469                         if (check_perms(file->f_dentry->d_inode, S_IWUSR))
470                                 goto out_error;
471                 }
472         }
473         return TRUE;
474 out_error:      /* for debugging */
475         printk("[kernel] mmap perm check failed for %s for access %d\n",
476                file_name(file), prot);
477         return FALSE;
478 }
479
480 void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
481                 struct file *file, size_t offset)
482 {
483         len = ROUNDUP(len, PGSIZE);
484         int num_pages = len / PGSIZE;
485         int retval;
486
487         struct vm_region *vmr, *vmr_temp;
488
489         /* Sanity check, for callers that bypass mmap().  We want addr for anon
490          * memory to start above the break limit (BRK_END), but not 0.  Keep this in
491          * sync with BRK_END in mmap(). */
492         if (addr == 0)
493                 addr = BRK_END;
494         assert(!PGOFF(offset));
495
496 #ifndef __CONFIG_DEMAND_PAGING__
497         flags |= MAP_POPULATE;
498 #endif
499         /* Need to make sure nothing is in our way when we want a FIXED location.
500          * We just need to split on the end points (if they exist), and then remove
501          * everything in between.  __do_munmap() will do this.  Careful, this means
502          * an mmap can be an implied munmap() (not my call...). */
503         if (flags & MAP_FIXED)
504                 __do_munmap(p, addr, len);
505         vmr = create_vmr(p, addr, len);
506         if (!vmr) {
507                 printk("[kernel] do_mmap() aborted for %p + %d!\n", addr, len);
508                 set_errno(ENOMEM);
509                 return MAP_FAILED;              /* TODO: error propagation for mmap() */
510         }
511         vmr->vm_prot = prot;
512         vmr->vm_flags = flags;
513         if (file) {
514                 if (!check_file_perms(vmr, file, prot)) {
515                         destroy_vmr(vmr);
516                         set_errno(EACCES);
517                         return MAP_FAILED;
518                 }
519                 /* TODO: consider locking the file while checking (not as manadatory as
520                  * in handle_page_fault() */
521                 if (nr_pages(offset + len) > nr_pages(file->f_dentry->d_inode->i_size)) {
522                         destroy_vmr(vmr);
523                         set_errno(ESPIPE); /* linux sends a SIGBUS at access time */
524                         return MAP_FAILED;
525                 }
526                 kref_get(&file->f_kref, 1);
527         }
528         vmr->vm_file = file;
529         vmr->vm_foff = offset;
530         /* Prep the FS to make sure it can mmap the file.  Slightly weird semantics:
531          * they will have a hole in their VM now. */
532         if (file && file->f_op->mmap(file, vmr)) {
533                 destroy_vmr(vmr);
534                 set_errno(EACCES);      /* not quite */
535                 return MAP_FAILED;
536         }
537         addr = vmr->vm_base;            /* so we know which pages to populate later */
538         vmr = merge_me(vmr);            /* attempts to merge with neighbors */
539         /* Fault in pages now if MAP_POPULATE.  We want to populate the region
540          * requested, but we need to be careful and only populate the requested
541          * length and not any merged regions, which is why we set addr above and use
542          * it here.
543          *
544          * If HPF errors out, we'll warn and fail for now.  This could be due to
545          * some userspace error, but also occurs when we run out of memory.  If we
546          * are out of memory, the kernel can't really handle it. */
547         if (flags & MAP_POPULATE && vmr->vm_prot != PROT_NONE)
548                 for (int i = 0; i < num_pages; i++) {
549                         retval = __handle_page_fault(p, addr + i * PGSIZE, vmr->vm_prot);
550                         if (retval) {
551                                 warn("do_mmap() failing (%d) on addr %p with prot 0x%x",
552                                      retval, addr + i * PGSIZE,  vmr->vm_prot);
553                                 destroy_vmr(vmr);
554                                 set_errno(-retval);
555                                 if (retval == -ENOMEM) {
556                                         printk("[kernel] ENOMEM, killing %d\n", p->pid);
557                                         proc_destroy(p);
558                                 }
559                                 return MAP_FAILED;
560                         }
561                 }
562         return (void*SAFE)TC(addr);
563 }
564
565 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
566 {
567         printd("mprotect: (addr %p, len %p, prot 0x%x)\n", addr, len, prot);
568         if (!len)
569                 return 0;
570         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
571                 set_errno(EINVAL);
572                 return -1;
573         }
574         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
575         if (end > UMAPTOP || addr > end) {
576                 set_errno(ENOMEM);
577                 return -1;
578         }
579         spin_lock(&p->mm_lock);
580         int ret = __do_mprotect(p, addr, len, prot);
581         spin_unlock(&p->mm_lock);
582         return ret;
583 }
584
585 /* This does not care if the region is not mapped.  POSIX says you should return
586  * ENOMEM if any part of it is unmapped.  Can do this later if we care, based on
587  * the VMRs, not the actual page residency. */
588 int __do_mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
589 {
590         struct vm_region *vmr, *next_vmr;
591         pte_t *pte;
592         bool shootdown_needed = FALSE;
593         int pte_prot = (prot & PROT_WRITE) ? PTE_USER_RW :
594                        (prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
595         /* TODO: this is aggressively splitting, when we might not need to if the
596          * prots are the same as the previous.  Plus, there are three excessive
597          * scans.  Finally, we might be able to merge when we are done. */
598         isolate_vmrs(p, addr, len);
599         vmr = find_first_vmr(p, addr);
600         while (vmr && vmr->vm_base < addr + len) {
601                 if (vmr->vm_prot == prot)
602                         continue;
603                 if (vmr->vm_file && !check_file_perms(vmr, vmr->vm_file, prot)) {
604                         set_errno(EACCES);
605                         return -1;
606                 }
607                 vmr->vm_prot = prot;
608                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
609                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
610                         if (pte && PAGE_PRESENT(*pte)) {
611                                 *pte = (*pte & ~PTE_PERM) | pte_prot;
612                                 shootdown_needed = TRUE;
613                         }
614                 }
615                 next_vmr = TAILQ_NEXT(vmr, vm_link);
616                 vmr = next_vmr;
617         }
618         if (shootdown_needed)
619                 proc_tlbshootdown(p, addr, addr + len);
620         return 0;
621 }
622
623 int munmap(struct proc *p, uintptr_t addr, size_t len)
624 {
625         printd("munmap(addr %x, len %x)\n", addr, len);
626         if (!len)
627                 return 0;
628         if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
629                 set_errno(EINVAL);
630                 return -1;
631         }
632         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
633         if (end > UMAPTOP || addr > end) {
634                 set_errno(EINVAL);
635                 return -1;
636         }
637         spin_lock(&p->mm_lock);
638         int ret = __do_munmap(p, addr, len);
639         spin_unlock(&p->mm_lock);
640         return ret;
641 }
642
643 int __do_munmap(struct proc *p, uintptr_t addr, size_t len)
644 {
645         struct vm_region *vmr, *next_vmr;
646         pte_t *pte;
647         bool shootdown_needed = FALSE;
648
649         /* TODO: this will be a bit slow, since we end up doing three linear
650          * searches (two in isolate, one in find_first). */
651         isolate_vmrs(p, addr, len);
652         vmr = find_first_vmr(p, addr);
653         while (vmr && vmr->vm_base < addr + len) {
654                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
655                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
656                         if (!pte)
657                                 continue;
658                         if (PAGE_PRESENT(*pte)) {
659                                 /* TODO: (TLB) race here, where the page can be given out before
660                                  * the shootdown happened.  Need to put it on a temp list. */
661                                 page_t *page = ppn2page(PTE2PPN(*pte));
662                                 *pte = 0;
663                                 page_decref(page);
664                                 shootdown_needed = TRUE;
665                         } else if (PAGE_PAGED_OUT(*pte)) {
666                                 /* TODO: (SWAP) mark free in the swapfile or whatever.  For now,
667                                  * PAGED_OUT is also being used to mean "hasn't been mapped
668                                  * yet".  Note we now allow PAGE_UNMAPPED, unlike older
669                                  * versions of mmap(). */
670                                 panic("Swapping not supported!");
671                                 *pte = 0;
672                         }
673                 }
674                 next_vmr = TAILQ_NEXT(vmr, vm_link);
675                 destroy_vmr(vmr);
676                 vmr = next_vmr;
677         }
678         if (shootdown_needed)
679                 proc_tlbshootdown(p, addr, addr + len);
680         return 0;
681 }
682
683 int handle_page_fault(struct proc* p, uintptr_t va, int prot)
684 {
685         va = ROUNDDOWN(va,PGSIZE);
686
687         if (prot != PROT_READ && prot != PROT_WRITE && prot != PROT_EXEC)
688                 panic("bad prot!");
689         spin_lock(&p->mm_lock);
690         int ret = __handle_page_fault(p, va, prot);
691         spin_unlock(&p->mm_lock);
692         return ret;
693 }
694
695 /* Returns 0 on success, or an appropriate -error code.  Assumes you hold the
696  * mm_lock.
697  *
698  * Notes: if your TLB caches negative results, you'll need to flush the
699  * appropriate tlb entry.  Also, you could have a weird race where a present PTE
700  * faulted for a different reason (was mprotected on another core), and the
701  * shootdown is on its way.  Userspace should have waited for the mprotect to
702  * return before trying to write (or whatever), so we don't care and will fault
703  * them. */
704 int __handle_page_fault(struct proc *p, uintptr_t va, int prot)
705 {
706         struct vm_region *vmr;
707         struct page *a_page;
708         unsigned int f_idx;     /* index of the missing page in the file */
709         int retval;
710
711         /* Check the vmr's protection */
712         vmr = find_vmr(p, va);
713         if (!vmr)                                                       /* not mapped at all */
714                 return -EFAULT;
715         if (!(vmr->vm_prot & prot))                     /* wrong prots for this vmr */
716                 return -EPERM;
717         /* find offending PTE (prob don't read this in).  This might alloc an
718          * intermediate page table page. */
719         pte_t *pte = pgdir_walk(p->env_pgdir, (void*)va, 1);
720         if (!pte)
721                 return -ENOMEM;
722         /* a spurious, valid PF is possible due to a legit race: the page might have
723          * been faulted in by another core already (and raced on the memory lock),
724          * in which case we should just return. */
725         if (PAGE_PRESENT(*pte)) {
726                 return 0;
727         } else if (PAGE_PAGED_OUT(*pte)) {
728                 /* TODO: (SWAP) bring in the paged out frame. (BLK) */
729                 panic("Swapping not supported!");
730                 return -1;
731         }
732         if (!vmr->vm_file) {
733                 /* No file - just want anonymous memory */
734                 if (upage_alloc(p, &a_page, TRUE))
735                         return -ENOMEM;
736         } else {
737                 /* If this fails, either something got screwed up with the VMR, or the
738                  * permissions changed after mmap/mprotect.  Either way, I want to know
739                  * (though it's not critical). */
740                 if (!check_file_perms(vmr, vmr->vm_file, prot))
741                         printk("[kernel] possible issue with VMR prots on file %s!\n",
742                                file_name(vmr->vm_file));
743                 /* Load the file's page in the page cache.
744                  * TODO: (BLK) Note, we are holding the mem lock!  We need to rewrite
745                  * this stuff so we aren't hold the lock as excessively as we are, and
746                  * such that we can block and resume later. */
747                 assert(!PGOFF(va - vmr->vm_base + vmr->vm_foff));
748                 f_idx = (va - vmr->vm_base + vmr->vm_foff) >> PGSHIFT;
749                 /* TODO: need some sort of lock on the file to deal with someone
750                  * concurrently shrinking it.  Adding 1 to f_idx, since it is
751                  * zero-indexed */
752                 if (f_idx + 1 > nr_pages(vmr->vm_file->f_dentry->d_inode->i_size)) {
753                         /* We're asking for pages that don't exist in the file */
754                         /* TODO: unlock the file */
755                         return -ESPIPE; /* linux sends a SIGBUS at access time */
756                 }
757                 retval = pm_load_page(vmr->vm_file->f_mapping, f_idx, &a_page);
758                 /* TODO: should be able to let go of that file shrink-lock now.  We have
759                  * a page refcnt, which might be enough (depending on how it works) */
760                 if (retval)
761                         return retval;
762                 /* If we want a private map, we'll preemptively give you a new page.  We
763                  * used to just care if it was private and writable, but were running
764                  * into issues with libc changing its mapping (map private, then
765                  * mprotect to writable...)  In the future, we want to CoW this anyway,
766                  * so it's not a big deal. */
767                 if ((vmr->vm_flags & MAP_PRIVATE)) {
768                         struct page *cache_page = a_page;
769                         if (upage_alloc(p, &a_page, FALSE)) {
770                                 page_decref(cache_page);        /* was the original a_page */
771                                 return -ENOMEM;
772                         }
773                         memcpy(page2kva(a_page), page2kva(cache_page), PGSIZE);
774                         page_decref(cache_page);                /* was the original a_page */
775                         /* Debugging */
776                         if (!(vmr->vm_prot & PROT_WRITE))
777                                 printd("[kernel] private, but unwritable file mapping of %s "
778                                        "at va %p\n", file_name(vmr->vm_file), va);
779                 }
780                 /* if this is an executable page, we might have to flush the instruction
781                  * cache if our HW requires it. */
782                 if (vmr->vm_prot & PROT_EXEC)
783                         icache_flush_page((void*)va, page2kva(a_page));
784         }
785         /* update the page table TODO: careful with MAP_PRIVATE etc.  might do this
786          * separately (file, no file) */
787         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
788                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
789         /* We have a ref to a_page, which we are storing in the PTE */
790         *pte = PTE(page2ppn(a_page), PTE_P | pte_prot);
791         return 0;
792 }
793
794 /* Kernel Dynamic Memory Mappings */
795 uintptr_t dyn_vmap_llim = KERN_DYN_TOP;
796 spinlock_t dyn_vmap_lock = SPINLOCK_INITIALIZER;
797
798 /* Reserve space in the kernel dynamic memory map area */
799 uintptr_t get_vmap_segment(unsigned long num_pages)
800 {
801         uintptr_t retval;
802         spin_lock(&dyn_vmap_lock);
803         retval = dyn_vmap_llim - num_pages * PGSIZE;
804         if ((retval > ULIM) && (retval < KERN_DYN_TOP)) {
805                 dyn_vmap_llim = retval;
806         } else {
807                 warn("[kernel] dynamic mapping failed!");
808                 retval = 0;
809         }
810         spin_unlock(&dyn_vmap_lock);
811         return retval;
812 }
813
814 /* Give up your space.  Note this isn't supported yet */
815 uintptr_t put_vmap_segment(uintptr_t vaddr, unsigned long num_pages)
816 {
817         /* TODO: use vmem regions for adjustable vmap segments */
818         panic("Unsupported.\n");
819 }
820
821 /* Map a virtual address chunk to physical addresses.  Make sure you got a vmap
822  * segment before actually trying to do the mapping.
823  *
824  * Careful with more than one 'page', since it will assume your physical pages
825  * are also contiguous.  Most callers will only use one page.
826  *
827  * Finally, note that this does not care whether or not there are real pages
828  * being mapped, and will not attempt to incref your page (if there is such a
829  * thing).  Handle your own refcnting for pages. */
830 int map_vmap_segment(uintptr_t vaddr, uintptr_t paddr, unsigned long num_pages,
831                      int perm)
832 {
833         /* For now, we only handle the root pgdir, and not any of the other ones
834          * (like for processes).  To do so, we'll need to insert into every pgdir,
835          * and send tlb shootdowns to those that are active (which we don't track
836          * yet). */
837         extern int booting;
838         assert(booting);
839
840         /* TODO: (MM) you should lock on boot pgdir modifications.  A vm region lock
841          * isn't enough, since there might be a race on outer levels of page tables.
842          * For now, we'll just use the dyn_vmap_lock (which technically works). */
843         spin_lock(&dyn_vmap_lock);
844         pte_t *pte;
845 #ifdef __i386__
846         perm |= PTE_G;
847 #endif
848         for (int i = 0; i < num_pages; i++) {
849                 pte = pgdir_walk(boot_pgdir, (void*)(vaddr + i * PGSIZE), 1);
850                 if (!pte) {
851                         spin_unlock(&dyn_vmap_lock);
852                         return -ENOMEM;
853                 }
854                 /* You probably should have unmapped first */
855                 if (*pte)
856                         warn("Existing PTE value %p\n", *pte);
857                 *pte = PTE(pa2ppn(paddr + i * PGSIZE), perm);
858         }
859         spin_unlock(&dyn_vmap_lock);
860         return 0;
861 }
862
863 /* Unmaps / 0's the PTEs of a chunk of vaddr space */
864 int unmap_vmap_segment(uintptr_t vaddr, unsigned long num_pages)
865 {
866         /* Not a big deal - won't need this til we do something with kthreads */
867         panic("Incomplete, don't call this yet.");
868         spin_lock(&dyn_vmap_lock);
869         /* TODO: For all pgdirs */
870         pte_t *pte;
871         for (int i = 0; i < num_pages; i++) {
872                 pte = pgdir_walk(boot_pgdir, (void*)(vaddr + i * PGSIZE), 1);
873                 *pte = 0;
874         }
875         /* TODO: TLB shootdown.  Also note that the global flag is set on the PTE
876          * (for x86 for now), which requires a global shootdown.  bigger issue is
877          * the TLB shootdowns for multiple pgdirs.  We'll need to remove from every
878          * pgdir, and send tlb shootdowns to those that are active (which we don't
879          * track yet). */
880         spin_unlock(&dyn_vmap_lock);
881         return 0;
882 }