kern/src/umem.c

   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.  The user_mem ones need
   7  * to involve some form of pinning (TODO), and that global static needs to go. */
   8
   9 #include <ros/common.h>
  10 #include <arch/uaccess.h>
  11 #include <umem.h>
  12 #include <process.h>
  13 #include <error.h>
  14 #include <kmalloc.h>
  15 #include <assert.h>
  16 #include <pmap.h>
  17 #include <smp.h>
  18
  19 static int string_copy_from_user(char *dst, const char *src)
  20 {
  21         int error;
  22         const char *top = src + valid_user_rbytes_from(src);
  23
  24         for (;; dst++, src++) {
  25                 if (unlikely(src >= top))
  26                         return -EFAULT;
  27                 error = __get_user(dst, src, 1);
  28                 if (unlikely(error))
  29                         return error;
  30                 if (unlikely(!*dst))
  31                         break;
  32         }
  33
  34         return 0;
  35 }
  36
  37 static int string_copy_to_user(char *dst, const char *src)
  38 {
  39         int error;
  40         char *top = dst + valid_user_rwbytes_from(dst);
  41
  42         for (;; dst++, src++) {
  43                 if (unlikely(dst >= top))
  44                         return -EFAULT;
  45                 error = __put_user(dst, src, 1);
  46                 if (unlikely(error))
  47                         return error;
  48                 if (unlikely(!*src))
  49                         break;
  50         }
  51
  52         return 0;
  53 }
  54
  55 int strcpy_from_user(struct proc *p, char *dst, const char *src)
  56 {
  57         uintptr_t prev = switch_to(p);
  58         int error = string_copy_from_user(dst, src);
  59
  60         switch_back(p, prev);
  61
  62         return error;
  63 }
  64
  65 int strcpy_to_user(struct proc *p, char *dst, const char *src)
  66 {
  67         uintptr_t prev = switch_to(p);
  68         int error = string_copy_to_user(dst, src);
  69
  70         switch_back(p, prev);
  71
  72         return error;
  73 }
  74
  75 int memcpy_from_user(struct proc *p, void *dest, const void *va, size_t len)
  76 {
  77         uintptr_t prev = switch_to(p);
  78         int error = copy_from_user(dest, va, len);
  79
  80         switch_back(p, prev);
  81
  82         return error;
  83 }
  84
  85 int memcpy_to_user(struct proc *p, void *dest, const void *src, size_t len)
  86 {
  87         uintptr_t prev = switch_to(p);
  88         int error = copy_to_user(dest, src, len);
  89
  90         switch_back(p, prev);
  91
  92         return error;
  93 }
  94
  95 /* Same as above, but sets errno */
  96 int memcpy_from_user_errno(struct proc *p, void *dst, const void *src, int len)
  97 {
  98         int error = memcpy_from_user(p, dst, src, len);
  99
 100         if (unlikely(error < 0))
 101                 set_errno(-error);
 102
 103         return error;
 104 }
 105
 106 /* Same as above, but sets errno */
 107 int memcpy_to_user_errno(struct proc *p, void *dst, const void *src, int len)
 108 {
 109         int error = memcpy_to_user(p, dst, src, len);
 110
 111         if (unlikely(error < 0))
 112                 set_errno(-error);
 113
 114         return error;
 115 }
 116
 117 /* Creates a buffer (kmalloc) and safely copies into it from va.  Can return an
 118  * error code.  Check its response with IS_ERR().  Must be paired with
 119  * user_memdup_free() if this succeeded. */
 120 void *user_memdup(struct proc *p, const void *va, int len)
 121 {
 122         void* kva = NULL;
 123         if (len < 0 || (kva = kmalloc(len, 0)) == NULL)
 124                 return ERR_PTR(-ENOMEM);
 125         if (memcpy_from_user(p, kva, va, len)) {
 126                 kfree(kva);
 127                 return ERR_PTR(-EFAULT);
 128         }
 129         return kva;
 130 }
 131
 132 void *user_memdup_errno(struct proc *p, const void *va, int len)
 133 {
 134         void *kva = user_memdup(p, va, len);
 135         if (IS_ERR(kva)) {
 136                 set_errno(-PTR_ERR(kva));
 137                 return NULL;
 138         }
 139         return kva;
 140 }
 141
 142 void user_memdup_free(struct proc *p, void *va)
 143 {
 144         kfree(va);
 145 }
 146
 147 /* Same as memdup, but just does strings, and needs to know the actual strlen.
 148  * Still needs memdup_free()d.  This will enforce that the string is null
 149  * terminated.  The parameter strlen does not include the \0, though it can if
 150  * someone else is playing it safe.  Since strlen() doesn't count the \0, we'll
 151  * play it safe here. */
 152 char *user_strdup(struct proc *p, const char *u_string, size_t strlen)
 153 {
 154         char *k_string = user_memdup(p, u_string, strlen + 1);
 155         if (!IS_ERR(k_string))
 156                 k_string[strlen] = '\0';
 157         return k_string;
 158 }
 159
 160 /* user_strdup, but this handles the errno.  0 on failure, ptr on success */
 161 char *user_strdup_errno(struct proc *p, const char *u_string, size_t strlen)
 162 {
 163         void *k_string = user_strdup(p, u_string, strlen);
 164         if (IS_ERR(k_string)) {
 165                 set_errno(-PTR_ERR(k_string));
 166                 return NULL;
 167         }
 168         return k_string;
 169 }
 170
 171 void *kmalloc_errno(int len)
 172 {
 173         void *kva = NULL;
 174         if (len < 0 || (kva = kmalloc(len, 0)) == NULL)
 175                 set_errno(ENOMEM);
 176         return kva;
 177 }
 178
 179 /* Returns true if uva and kva both resolve to the same phys addr.  If uva is
 180  * unmapped, it will return FALSE.  This is probably what you want, since after
 181  * all uva isn't kva. */
 182 bool uva_is_kva(struct proc *p, void *uva, void *kva)
 183 {
 184         struct page *u_page;
 185         assert(kva);                            /* catch bugs */
 186         /* Check offsets first */
 187         if (PGOFF(uva) != PGOFF(kva))
 188                 return FALSE;
 189         /* Check to see if it is the same physical page */
 190         u_page = page_lookup(p->env_pgdir, uva, 0);
 191         if (!u_page)
 192                 return FALSE;
 193         return (kva2page(kva) == u_page) ? TRUE : FALSE;
 194 }
 195
 196 /* Given a proc and a user virtual address, gives us the KVA.  Useful for
 197  * debugging.  Returns 0 if the page is unmapped (page lookup fails).  This
 198  * doesn't play nice with Jumbo pages. */
 199 uintptr_t uva2kva(struct proc *p, void *uva, size_t len, int prot)
 200 {
 201         struct page *u_page;
 202         uintptr_t offset = PGOFF(uva);
 203         if (!p)
 204                 return 0;
 205         if (prot & PROT_WRITE) {
 206                 if (!is_user_rwaddr(uva, len))
 207                         return 0;
 208         } else {
 209                 if (!is_user_raddr(uva, len))
 210                         return 0;
 211         }
 212         u_page = page_lookup(p->env_pgdir, uva, 0);
 213         if (!u_page)
 214                 return 0;
 215         return (uintptr_t)page2kva(u_page) + offset;
 216 }
 217
 218 /* Helper, copies a pathname from the process into the kernel.  Returns a string
 219  * on success, which you must free with free_path.  Returns 0 on failure and
 220  * sets errno. */
 221 char *copy_in_path(struct proc *p, const char *path, size_t path_l)
 222 {
 223         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 224         char *t_path;
 225
 226         /* PATH_MAX includes the \0 */
 227         if (path_l > PATH_MAX) {
 228                 set_errno(ENAMETOOLONG);
 229                 return 0;
 230         }
 231         t_path = user_strdup_errno(p, path, path_l);
 232         if (!t_path)
 233                 return 0;
 234         return t_path;
 235 }
 236
 237 /* Helper, frees a path that was allocated with copy_in_path. */
 238 void free_path(struct proc *p, char *t_path)
 239 {
 240         user_memdup_free(p, t_path);
 241 }