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