mm: 9ns: Add support for mmap
[akaros.git] / kern / include / mm.h
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  * Memory management for processes: syscall related functions, virtual memory
6  * regions, etc. */
7
8 #pragma once
9
10 #include <ros/common.h>
11 #include <ros/mman.h>
12 #include <atomic.h>
13 #include <sys/queue.h>
14 #include <slab.h>
15 #include <kref.h>
16
17 struct file;
18 struct chan;
19 struct fd_table;
20 struct proc;                                                            /* preprocessor games */
21
22 #define F_OR_C_NONE 0
23 #define F_OR_C_FILE 1
24 #define F_OR_C_CHAN 2
25
26 struct file_or_chan {
27         int type;
28         struct file *file;
29         struct chan *chan;
30         struct fs_file *fsf;    /* weak ref, set during mmap. */
31         struct kref kref;
32 };
33
34 char *foc_to_name(struct file_or_chan *foc);
35 char *foc_abs_path(struct file_or_chan *foc, char *path, size_t max_size);
36 ssize_t foc_read(struct file_or_chan *foc, void *buf, size_t amt, off64_t off);
37 struct file_or_chan *foc_open(char *path, int omode, int perm);
38 struct file_or_chan *fd_to_foc(struct fd_table *fdt, int fd);
39 void foc_incref(struct file_or_chan *foc);
40 void foc_decref(struct file_or_chan *foc);
41 void *foc_pointer(struct file_or_chan *foc);
42 size_t foc_get_len(struct file_or_chan *foc);
43
44 /* Basic structure defining a region of a process's virtual memory.  Note we
45  * don't refcnt these.  Either they are in the TAILQ/tree, or they should be
46  * freed.  There should be no other references floating around.  We still need
47  * to sort out how we share memory and how we'll do private memory with these
48  * VMRs. */
49 struct vm_region {
50         TAILQ_ENTRY(vm_region)          vm_link;
51         TAILQ_ENTRY(vm_region)          vm_pm_link;
52         struct proc                                     *vm_proc;       /* owning process, for now */
53         uintptr_t                                       vm_base;
54         uintptr_t                                       vm_end;
55         int                                                     vm_prot;
56         int                                                     vm_flags;
57         struct file_or_chan                     *__vm_foc;
58         size_t                                          vm_foff;
59         bool                                            vm_ready;       /* racy, for the PM checks */
60 };
61 TAILQ_HEAD(vmr_tailq, vm_region);                       /* Declares 'struct vmr_tailq' */
62
63 static inline bool vmr_has_file(struct vm_region *vmr)
64 {
65         return vmr->__vm_foc ? true : false;
66 }
67
68 static inline char *vmr_to_filename(struct vm_region *vmr)
69 {
70         assert(vmr_has_file(vmr));
71         return foc_to_name(vmr->__vm_foc);
72 }
73
74 void vmr_init(void);
75 void unmap_and_destroy_vmrs(struct proc *p);
76 int duplicate_vmrs(struct proc *p, struct proc *new_p);
77 void print_vmrs(struct proc *p);
78 void enumerate_vmrs(struct proc *p,
79                                         void (*func)(struct vm_region *vmr, void *opaque),
80                                         void *opaque);
81
82 /* mmap() related functions.  These manipulate VMRs and change the hardware page
83  * tables.  Any requests below the LOWEST_VA will silently be upped.  This may
84  * be a dynamic proc-specific variable later. */
85 #define MMAP_LOWEST_VA PAGE_SIZE
86 #define MMAP_LD_FIXED_VA 0x100000
87 void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
88            int fd, size_t offset);
89 void *do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
90               struct file_or_chan *foc, size_t offset);
91 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot);
92 int munmap(struct proc *p, uintptr_t addr, size_t len);
93 int handle_page_fault(struct proc *p, uintptr_t va, int prot);
94 int handle_page_fault_nofile(struct proc *p, uintptr_t va, int prot);
95 unsigned long populate_va(struct proc *p, uintptr_t va, unsigned long nr_pgs);
96
97 /* These assume the mm_lock is held already */
98 int __do_mprotect(struct proc *p, uintptr_t addr, size_t len, int prot);
99 int __do_munmap(struct proc *p, uintptr_t addr, size_t len);
100
101 /* Kernel Dynamic Memory Mappings */
102 struct arena *vmap_arena;
103 void vmap_init(void);
104 /* Gets PML1 page-aligned virtual addresses for the kernel's dynamic vmap.
105  * You'll need to map it to something.  When you're done, 'put-' will also unmap
106  * the vaddr for you. */
107 uintptr_t get_vmap_segment(size_t nr_bytes);
108 void put_vmap_segment(uintptr_t vaddr, size_t nr_bytes);
109 int map_vmap_segment(uintptr_t vaddr, uintptr_t paddr, unsigned long num_pages,
110                      int perm);
111 /* Helper wrappers for getting and mapping a specific paddr. */
112 uintptr_t vmap_pmem(uintptr_t paddr, size_t nr_bytes);
113 uintptr_t vmap_pmem_nocache(uintptr_t paddr, size_t nr_bytes);
114 uintptr_t vmap_pmem_writecomb(uintptr_t paddr, size_t nr_bytes);
115 int vunmap_vmem(uintptr_t vaddr, size_t nr_bytes);