Migrated user memory copy APIs to use the new exception table guards
[akaros.git] / kern / include / umem.h
1 /* Copyright (c) 2009, 2010 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * Andrew Waterman <waterman@cs.berkeley.edu>
4  * See LICENSE for details.
5  *
6  * Functions for working with userspace's address space. */
7
8 #pragma once
9
10 #include <ros/common.h>
11 #include <process.h>
12
13 /* Is this a valid user pointer for read/write?  It doesn't care if the address
14  * is paged out or even an unmapped region: simply if it is in part of the
15  * address space that could be RW user.  Will also check for len bytes. */
16 static inline bool is_user_rwaddr(const void *addr, size_t len);
17 /* Same deal, but read-only */
18 static inline bool is_user_raddr(const void *addr, size_t len);
19
20 int strcpy_from_user(struct proc *p, char *dst, const char *src);
21 int strcpy_to_user(struct proc *p, char *dst, const char *src);
22
23 /**
24  * @brief Copies data from a user buffer to a kernel buffer.
25  *
26  * @param p    the process associated with the user program
27  *             from which the buffer is being copied
28  * @param dest the destination address of the kernel buffer
29  * @param va   the address of the userspace buffer from which we are copying
30  * @param len  the length of the userspace buffer
31  *
32  * @return ESUCCESS on success
33  * @return -EFAULT  the page assocaited with 'va' is not present, the user
34  *                  lacks the proper permissions, or there was an invalid 'va'
35  */
36 int memcpy_from_user(struct proc *p, void *dest, const void *va, size_t len);
37
38 /**
39  * @brief Copies data to a user buffer from a kernel buffer.
40  *
41  * @param p    the process associated with the user program
42  *             to which the buffer is being copied
43  * @param dest the destination address of the user buffer
44  * @param src  the address of the kernel buffer from which we are copying
45  * @param len  the length of the user buffer
46  *
47  * @return ESUCCESS on success
48  * @return -EFAULT  the page assocaited with 'va' is not present, the user
49  *                  lacks the proper permissions, or there was an invalid 'va'
50  */
51 int memcpy_to_user(struct proc *p, void *dest, const void *src, size_t len);
52
53 /* Same as above, but sets errno */
54 int memcpy_from_user_errno(struct proc *p, void *dst, const void *src, int len);
55 int memcpy_to_user_errno(struct proc *p, void *dst, const void *src, int len);
56                  
57 /* Creates a buffer (kmalloc) and safely copies into it from va.  Can return an
58  * error code.  Check its response with IS_ERR().  Must be paired with
59  * user_memdup_free() if this succeeded. */
60 void *user_memdup(struct proc *p, const void *va, int len);
61 /* Same as above, but sets errno */
62 void *user_memdup_errno(struct proc *p, const void *va, int len);
63 void user_memdup_free(struct proc *p, void *va);
64 /* Same as memdup, but just does strings.  still needs memdup_freed */
65 char *user_strdup(struct proc *p, const char *u_string, size_t strlen);
66 char *user_strdup_errno(struct proc *p, const char *u_string, size_t strlen);
67 void *kmalloc_errno(int len);
68 bool uva_is_kva(struct proc *p, void *uva, void *kva);
69 uintptr_t uva2kva(struct proc *p, void *uva);
70
71 /* Helper for is_user_r{w,}addr.
72  *
73  * These checks are for addresses that the kernel accesses on behalf of the
74  * user, which are mapped into the user's address space.  One interpretation is
75  * whether or not the user is allowed to refer to this memory, hence the
76  * MMAP_LOWEST_VA check.  But note that the user is allowed to attempt virtual
77  * memory accesses outside of this range.  VMM code may interpose on low memory
78  * PFs to emulate certain instructions.  However, the kernel should never be
79  * given such a pointer.
80  *
81  * Without the MMAP_LOWEST_VA check, the kernel would still PF on a bad user
82  * pointer (say the user gave us 0x10; we have nothing mapped at addr 0).
83  * However, it would be more difficult to detect if the PF was the kernel acting
84  * on behalf of the user or if the kernel itself had a null pointer deref.  By
85  * checking early, the kernel will catch low addresses and error out before page
86  * faulting. */
87 static inline bool __is_user_addr(const void *addr, size_t len, uintptr_t lim)
88 {
89         if (unlikely((uintptr_t) addr < MMAP_LOWEST_VA))
90                 return FALSE;
91         if (unlikely((uintptr_t) addr >= lim))
92                 return FALSE;
93         if (unlikely(lim - (uintptr_t) addr < len))
94                 return FALSE;
95
96         return TRUE;
97 }
98
99 static inline size_t __valid_user_bytes_from(const void *addr, uintptr_t lim)
100 {
101         if (unlikely((uintptr_t) addr < MMAP_LOWEST_VA))
102                 return 0;
103         if (unlikely((uintptr_t) addr >= lim))
104                 return 0;
105
106         return (size_t) (lim - (uintptr_t) addr);
107 }
108
109 /* UWLIM is defined as virtual address below which a process can write */
110 static inline bool is_user_rwaddr(const void *addr, size_t len)
111 {
112         return __is_user_addr(addr, len, UWLIM);
113 }
114
115 /* ULIM is defined as virtual address below which a process can read */
116 static inline bool is_user_raddr(const void *addr, size_t len)
117 {
118         return __is_user_addr(addr, len, ULIM);
119 }
120
121 static inline size_t valid_user_rwbytes_from(const void *addr)
122 {
123         return __valid_user_bytes_from(addr, UWLIM);
124 }
125
126 static inline size_t valid_user_rbytes_from(const void *addr)
127 {
128         return __valid_user_bytes_from(addr, ULIM);
129 }