Renamed vm_prot from vm_perm to be more consistent
[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_link;
42         uintptr_t gap_end;
43
44         /* Don't allow a vm region into the 0'th page (null ptr issues) */
45         if (va == 0)
46                 va = 1 * PGSIZE;
47
48         assert(!PGOFF(va));
49         assert(!PGOFF(len));
50         assert(va + len <= UMAPTOP);
51
52         /* Is there room before the first one: */
53         vm_i = TAILQ_FIRST(&p->vm_regions);
54         if (!vm_i || (va + len < vm_i->vm_base)) {
55                 vmr = kmem_cache_alloc(vmr_kcache, 0);
56                 if (!vmr)
57                         panic("EOM!");
58                 vmr->vm_base = va;
59                 TAILQ_INSERT_HEAD(&p->vm_regions, vmr, vm_link);
60         } else {
61                 TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
62                         vm_link = TAILQ_NEXT(vm_i, vm_link);
63                         gap_end = vm_link ? vm_link->vm_base : UMAPTOP;
64                         /* skip til we get past the 'hint' va */
65                         if (va >= gap_end)
66                                 continue;
67                         /* Found a gap that is big enough */
68                         if (gap_end - vm_i->vm_end >= len) {
69                                 vmr = kmem_cache_alloc(vmr_kcache, 0);
70                                 /* if we can put it at va, let's do that.  o/w, put it so it
71                                  * fits */
72                                 if (gap_end >= va + len)
73                                         vmr->vm_base = va;
74                                 else
75                                         vmr->vm_base = vm_i->vm_end;
76                                 TAILQ_INSERT_AFTER(&p->vm_regions, vm_i, vmr, vm_link);
77                                 break;
78                         }
79                 }
80         }
81         /* Finalize the creation, if we got one */
82         if (vmr) {
83                 vmr->vm_proc = p;
84                 vmr->vm_end = vmr->vm_base + len;
85         }
86         if (!vmr)
87                 warn("Not making a VMR, wanted %08p, + %p = %p", va, len, va + len);
88         return vmr;
89 }
90
91 /* Split a VMR at va, returning the new VMR.  It is set up the same way, with
92  * file offsets fixed accordingly.  'va' is the beginning of the new one, and
93  * must be page aligned. */
94 struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
95 {
96         struct vm_region *new_vmr;
97
98         assert(!PGOFF(va));
99         if ((old_vmr->vm_base >= va) || (old_vmr->vm_end <= va))
100                 return 0;
101         new_vmr = kmem_cache_alloc(vmr_kcache, 0);
102         TAILQ_INSERT_AFTER(&old_vmr->vm_proc->vm_regions, old_vmr, new_vmr,
103                            vm_link);
104         new_vmr->vm_proc = old_vmr->vm_proc;
105         new_vmr->vm_base = va;
106         new_vmr->vm_end = old_vmr->vm_end;
107         old_vmr->vm_end = va;
108         new_vmr->vm_prot = old_vmr->vm_prot;
109         new_vmr->vm_flags = old_vmr->vm_flags;
110         if (old_vmr->vm_file) {
111                 new_vmr->vm_file = old_vmr->vm_file;
112                 atomic_inc(&new_vmr->vm_file->f_refcnt);
113                 new_vmr->vm_foff = old_vmr->vm_foff +
114                                       old_vmr->vm_end - old_vmr->vm_base;
115         } else {
116                 new_vmr->vm_file = 0;
117                 new_vmr->vm_foff = 0;
118         }
119         return new_vmr;
120 }
121
122 /* Merges two vm regions.  For now, it will check to make sure they are the
123  * same.  The second one will be destroyed. */
124 int merge_vmr(struct vm_region *first, struct vm_region *second)
125 {
126         assert(first->vm_proc == second->vm_proc);
127         if ((first->vm_end != second->vm_base) ||
128             (first->vm_prot != second->vm_prot) ||
129             (first->vm_flags != second->vm_flags) ||
130             (first->vm_file != second->vm_file))
131                 return -1;
132         if ((first->vm_file) && (second->vm_foff != first->vm_foff +
133                                  first->vm_end - first->vm_base))
134                 return -1;
135         first->vm_end = second->vm_end;
136         destroy_vmr(second);
137         return 0;
138 }
139
140 /* Grows the vm region up to (and not including) va.  Fails if another is in the
141  * way, etc. */
142 int grow_vmr(struct vm_region *vmr, uintptr_t va)
143 {
144         assert(!PGOFF(va));
145         struct vm_region *next = TAILQ_NEXT(vmr, vm_link);
146         if (next && next->vm_base < va)
147                 return -1;
148         if (va <= vmr->vm_end)
149                 return -1;
150         vmr->vm_end = va;
151         return 0;
152 }
153
154 /* Shrinks the vm region down to (and not including) va.  Whoever calls this
155  * will need to sort out the page table entries. */
156 int shrink_vmr(struct vm_region *vmr, uintptr_t va)
157 {
158         assert(!PGOFF(va));
159         if ((va < vmr->vm_base) || (va > vmr->vm_end))
160                 return -1;
161         vmr->vm_end = va;
162         return 0;
163 }
164
165 /* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
166  * out the page table entries. */
167 void destroy_vmr(struct vm_region *vmr)
168 {
169         if (vmr->vm_file)
170                 atomic_dec(&vmr->vm_file->f_refcnt);
171         TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
172         kmem_cache_free(vmr_kcache, vmr);
173 }
174
175 /* Given a va and a proc (later an mm, possibly), returns the owning vmr, or 0
176  * if there is none. */
177 struct vm_region *find_vmr(struct proc *p, uintptr_t va)
178 {
179         struct vm_region *vmr;
180         /* ugly linear seach */
181         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
182                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
183                         return vmr;
184         }
185         return 0;
186 }
187
188 /* Finds the first vmr after va (including the one holding va), or 0 if there is
189  * none. */
190 struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
191 {
192         struct vm_region *vmr;
193         /* ugly linear seach */
194         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
195                 if ((vmr->vm_base <= va) && (vmr->vm_end > va))
196                         return vmr;
197                 if (vmr->vm_base > va)
198                         return vmr;
199         }
200         return 0;
201 }
202
203 /* Makes sure that no VMRs cross either the start or end of the given region
204  * [va, va + len), splitting any VMRs that are on the endpoints. */
205 void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
206 {
207         struct vm_region *vmr;
208         if ((vmr = find_vmr(p, va)))
209                 split_vmr(vmr, va);
210         /* TODO: don't want to do another find (linear search) */
211         if ((vmr = find_vmr(p, va + len)))
212                 split_vmr(vmr, va + len);
213 }
214
215 /* This will make new_p have the same VMRs as p, though it does nothing to
216  * ensure the physical pages or whatever are shared/mapped/copied/whatever.
217  * This is used by fork().
218  *
219  * Note that if you are working on a VMR that is a file, you'll want to be
220  * careful about how it is mapped (SHARED, PRIVATE, etc). */
221 void duplicate_vmrs(struct proc *p, struct proc *new_p)
222 {
223         struct vm_region *vmr, *vm_i;
224         TAILQ_FOREACH(vm_i, &p->vm_regions, vm_link) {
225                 vmr = kmem_cache_alloc(vmr_kcache, 0);
226                 if (!vmr)
227                         panic("EOM!");
228                 vmr->vm_proc = new_p;
229                 vmr->vm_base = vm_i->vm_base;
230                 vmr->vm_end = vm_i->vm_end;
231                 vmr->vm_prot = vm_i->vm_prot;   
232                 vmr->vm_flags = vm_i->vm_flags; 
233                 vmr->vm_file = vm_i->vm_file;
234                 if (vmr->vm_file)
235                         atomic_inc(&vmr->vm_file->f_refcnt);
236                 vmr->vm_foff = vm_i->vm_foff;
237                 TAILQ_INSERT_TAIL(&new_p->vm_regions, vmr, vm_link);
238         }
239 }
240
241 void print_vmrs(struct proc *p)
242 {
243         int count = 0;
244         struct vm_region *vmr;
245         printk("VM Regions for proc %d\n", p->pid);
246         TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
247                 printk("%02d: (0x%08x - 0x%08x)\n", count++, vmr->vm_base, vmr->vm_end);
248 }
249
250
251 void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
252            int fd, size_t offset)
253 {
254         struct file *file = NULL;
255         printd("mmap(addr %x, len %x, prot %x, flags %x, fd %x, off %x)\n", addr,
256                len, prot, flags, fd, offset);
257         if (fd >= 0 && (flags & MAP_SHARED)) {
258                 printk("[kernel] mmap() for files requires !MAP_SHARED.\n");
259                 return MAP_FAILED;
260         }
261         if (fd >= 0 && (flags & MAP_ANON)) {
262                 printk("[kernel] mmap() with MAP_ANONYMOUS requires fd == -1.\n");
263                 return MAP_FAILED;
264         }
265         if ((flags & MAP_FIXED) && PGOFF(addr)) {
266                 printk("[kernel] mmap() page align your addr.\n");
267                 return MAP_FAILED;
268         }
269         if (!len)
270                 return 0;
271         if (addr + len > UMAPTOP) {
272                 printk("[kernel] mmap() tried to map above UMAPTOP.\n");
273                 return MAP_FAILED;
274         }
275         if (fd != -1) {
276                 file = file_open_from_fd(p, fd);
277                 if (!file)
278                         return MAP_FAILED;
279         }
280         void *result = do_mmap(p, addr, len, prot, flags, file, offset);
281         if (file)
282                 file_decref(file);
283         return result;
284 }
285
286 void *do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
287               struct file *file, size_t offset)
288 {
289         // TODO: grab the appropriate mm_lock
290         spin_lock(&p->proc_lock);
291         void *ret = __do_mmap(p, addr, len, prot, flags, file, offset);
292         spin_unlock(&p->proc_lock);
293         return ret;
294 }
295
296 void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
297                 struct file *file, size_t offset)
298 {
299         len = ROUNDUP(len, PGSIZE);
300         int num_pages = len / PGSIZE;
301
302         struct vm_region *vmr;
303
304 #ifndef __CONFIG_DEMAND_PAGING__
305         flags |= MAP_POPULATE;
306 #endif
307         /* Need to make sure nothing is in our way when we want a FIXED location.
308          * We just need to split on the end points (if they exist), and then remove
309          * everything in between.  __do_munmap() will do this. */
310         if (flags & MAP_FIXED)
311                 __do_munmap(p, addr, len);
312         vmr = create_vmr(p, addr, len);
313         if (!vmr) {
314                 printk("[kernel] do_mmap() aborted for %08p + %d!\n", addr, len);
315                 return MAP_FAILED;              /* TODO: error propagation for mmap() */
316         }
317         vmr->vm_prot = prot;
318         vmr->vm_flags = flags;
319         vmr->vm_file = file;
320         vmr->vm_foff = offset;
321         /* TODO: consider checking to see if we can merge vmrs */
322
323         /* Fault in pages now if MAP_POPULATE - die on failure.  We want to populate
324          * the region requested, but we ought to be careful and only populate the
325          * requested length and not any merged regions.  doing this by page for now,
326          * though some form of a helper would be nice. */
327         if (flags & MAP_POPULATE)
328                 for (int i = 0; i < num_pages; i++)
329                         if (__handle_page_fault(p, vmr->vm_base + i*PGSIZE, vmr->vm_prot)) {
330                                 spin_unlock(&p->proc_lock);
331                                 proc_destroy(p);
332                         }
333         return (void*SAFE)TC(vmr->vm_base);
334 }
335
336 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
337 {
338         printd("mprotect(addr %x, len %x, prot %x)\n", addr, len, prot);
339         if (!len)
340                 return 0;
341         if (addr % PGSIZE) {
342                 set_errno(current_tf, EINVAL);
343                 return -1;
344         }
345         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
346         if (end > UMAPTOP || addr > end) {
347                 set_errno(current_tf, ENOMEM);
348                 return -1;
349         }
350         spin_lock(&p->proc_lock);
351         int ret = __do_mprotect(p, addr, len, prot);
352         spin_unlock(&p->proc_lock);
353         return ret;
354 }
355
356 /* This does not care if the region is not mapped.  POSIX says you should return
357  * ENOMEM if any part of it is unmapped.  Can do this later if we care, based on
358  * the VMRs, not the actual page residency. */
359 int __do_mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
360 {
361         struct vm_region *vmr, *next_vmr;
362         pte_t *pte;
363         bool shootdown_needed = FALSE;
364         int pte_prot = (prot & PROT_WRITE) ? PTE_USER_RW :
365                        (prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
366         /* TODO: this is aggressively splitting, when we might not need to if the
367          * prots are the same as the previous.  Plus, there are three excessive
368          * scans.  Finally, we might be able to merge when we are done. */
369         isolate_vmrs(p, addr, addr + len);
370         vmr = find_first_vmr(p, addr);
371         while (vmr && vmr->vm_base < addr + len) {
372                 if (vmr->vm_prot == prot)
373                         continue;
374                 /* if vmr maps a file, then we need to make sure the protection change
375                  * is in compliance with the open mode of the file.  At least for any
376                  * mapping that is write-backed to a file.  For now, we just do it for
377                  * all file mappings.  And this hasn't been tested */
378                 if (vmr->vm_file && (prot & PROT_WRITE)) {
379                         if (!(vmr->vm_file->f_mode & PROT_WRITE)) {
380                                 set_errno(current_tf, EACCES);
381                                 return -1;
382                         }
383                 }
384                 vmr->vm_prot = prot;
385                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
386                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
387                         if (pte && PAGE_PRESENT(*pte)) {
388                                 *pte = (*pte & ~PTE_PERM) | pte_prot;
389                                 shootdown_needed = TRUE;
390                         }
391                 }
392                 next_vmr = TAILQ_NEXT(vmr, vm_link);
393                 vmr = next_vmr;
394         }
395         if (shootdown_needed)
396                 __proc_tlbshootdown(p, addr, addr + len);
397         return 0;
398 }
399
400 int munmap(struct proc *p, uintptr_t addr, size_t len)
401 {
402         printd("munmap(addr %x, len %x, prot %x)\n", addr, len, prot);
403         if (!len)
404                 return 0;
405         if (addr % PGSIZE) {
406                 set_errno(current_tf, EINVAL);
407                 return -1;
408         }
409         uintptr_t end = ROUNDUP(addr + len, PGSIZE);
410         if (end > UMAPTOP || addr > end) {
411                 set_errno(current_tf, EINVAL);
412                 return -1;
413         }
414         spin_lock(&p->proc_lock);
415         int ret = __do_munmap(p, addr, len);
416         spin_unlock(&p->proc_lock);
417         return ret;
418 }
419
420 int __do_munmap(struct proc *p, uintptr_t addr, size_t len)
421 {
422         struct vm_region *vmr, *next_vmr;
423         pte_t *pte;
424         bool shootdown_needed = FALSE;
425
426         /* TODO: this will be a bit slow, since we end up doing three linear
427          * searches (two in isolate, one in find_first). */
428         isolate_vmrs(p, addr, addr + len);
429         vmr = find_first_vmr(p, addr);
430         while (vmr && vmr->vm_base < addr + len) {
431                 for (uintptr_t va = vmr->vm_base; va < vmr->vm_end; va += PGSIZE) { 
432                         pte = pgdir_walk(p->env_pgdir, (void*)va, 0);
433                         if (!pte)
434                                 continue;
435                         if (PAGE_PRESENT(*pte)) {
436                                 /* TODO: (TLB) race here, where the page can be given out before
437                                  * the shootdown happened.  Need to put it on a temp list. */
438                                 page_t *page = ppn2page(PTE2PPN(*pte));
439                                 *pte = 0;
440                                 page_decref(page);
441                                 shootdown_needed = TRUE;
442                         } else if (PAGE_PAGED_OUT(*pte)) {
443                                 /* TODO: (SWAP) mark free in the swapfile or whatever.  For now,
444                                  * PAGED_OUT is also being used to mean "hasn't been mapped
445                                  * yet".  Note we now allow PAGE_UNMAPPED, unlike older
446                                  * versions of mmap(). */
447                                 panic("Swapping not supported!");
448                                 *pte = 0;
449                         }
450                 }
451                 next_vmr = TAILQ_NEXT(vmr, vm_link);
452                 destroy_vmr(vmr);
453                 vmr = next_vmr;
454         }
455         if (shootdown_needed)
456                 __proc_tlbshootdown(p, addr, addr + len);
457         return 0;
458 }
459
460 int handle_page_fault(struct proc* p, uintptr_t va, int prot)
461 {
462         va = ROUNDDOWN(va,PGSIZE);
463
464         if (prot != PROT_READ && prot != PROT_WRITE && prot != PROT_EXEC)
465                 panic("bad prot!");
466
467         spin_lock(&p->proc_lock);
468         int ret = __handle_page_fault(p, va, prot);
469         spin_unlock(&p->proc_lock);
470         return ret;
471 }
472
473 /* Returns 0 on success, or an appropriate -error code.  Assumes you hold the
474  * appropriate lock.
475  *
476  * Notes: if your TLB caches negative results, you'll need to flush the
477  * appropriate tlb entry.  Also, you could have a weird race where a present PTE
478  * faulted for a different reason (was mprotected on another core), and the
479  * shootdown is on its way.  Userspace should have waited for the mprotect to
480  * return before trying to write (or whatever), so we don't care and will fault
481  * them.
482  *
483  * We did away with mmapping too much of a file, and will map an entire page, if
484  * that file is big enough.  The alternative is to zerofill the last bit if the
485  * vmr had a lesser length.  This makes shared mappings and mappings backed by
486  * the FS problematic. */
487 int __handle_page_fault(struct proc* p, uintptr_t va, int prot)
488 {
489         struct vm_region *vmr;
490         /* Check the vmr's protection */
491         vmr = find_vmr(p, va);
492         if (!vmr)                                                       /* not mapped at all */
493                 return -EFAULT;
494         if (!(vmr->vm_prot & prot))                     /* wrong prots for this vmr */
495                 return -EFAULT;
496         /* find offending PTE (prob don't read this in).  This might alloc an
497          * intermediate page table page. */
498         pte_t *pte = pgdir_walk(p->env_pgdir, (void*)va, 1);
499         if (!pte)
500                 return -ENOMEM;
501         /* a spurious, valid PF is possible due to a legit race: the page might have
502          * been faulted in by another core already (and raced on the memory lock),
503          * in which case we should just return. */
504         if (PAGE_PRESENT(*pte)) {
505                 return 0;
506         } else if (PAGE_PAGED_OUT(*pte)) {
507                 /* TODO: (SWAP) bring in the paged out frame. (BLK) */
508                 panic("Swapping not supported!");
509                 return 0;
510         }
511         /* allocate a page; maybe zero-fill it */
512         bool zerofill = (vmr->vm_file == NULL);
513         page_t *a_page;
514         if (upage_alloc(p, &a_page, zerofill))
515                 return -ENOMEM;
516         /* if this isn't a zero-filled page, read it in from file.  it is the FS's
517          * responsibility to zero out the end of the last page if the EOF is not at
518          * the end of the page.
519          *
520          * TODO: (BLK) doing this while holding the mem lock!  prob want to block
521          * and return to userspace if it's not in the buffer cache.  will want to
522          * set a flag in the vmr so that subsequent faults will know the work is in
523          * progress. */
524         if (!zerofill) {
525                 int foffset = ROUNDDOWN(va, PGSIZE) - vmr->vm_base + vmr->vm_foff;
526                 int read_len = file_read_page(vmr->vm_file, page2pa(a_page), foffset);
527                 if (read_len < 0) {
528                         page_free(a_page);
529                         return read_len;                        /* pass out the error code, for now */
530                 }
531                 /* if this is an executable page, we might have to flush the instruction
532                  * cache if our HW requires it. */
533                 if (vmr->vm_prot & PROT_EXEC)
534                         icache_flush_page((void*)va, page2kva(a_page));
535         }
536         /* update the page table */
537         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
538                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
539         page_incref(a_page);
540         *pte = PTE(page2ppn(a_page), PTE_P | pte_prot);
541         return 0;
542 }