Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 2 | * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Jeff Dike | 8192ab4 | 2008-02-04 22:30:53 -0800 | [diff] [blame] | 6 | #include <linux/err.h> |
| 7 | #include <linux/highmem.h> |
| 8 | #include <linux/mm.h> |
| 9 | #include <linux/sched.h> |
| 10 | #include <asm/current.h> |
| 11 | #include <asm/page.h> |
| 12 | #include <asm/pgtable.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include "kern_util.h" |
Gennady Sharapov | 4fef0c1 | 2006-01-18 17:42:41 -0800 | [diff] [blame] | 14 | #include "os.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 16 | pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr) |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 17 | { |
| 18 | pgd_t *pgd; |
| 19 | pud_t *pud; |
| 20 | pmd_t *pmd; |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 21 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 22 | if (mm == NULL) |
| 23 | return NULL; |
| 24 | |
| 25 | pgd = pgd_offset(mm, addr); |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 26 | if (!pgd_present(*pgd)) |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 27 | return NULL; |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 28 | |
| 29 | pud = pud_offset(pgd, addr); |
| 30 | if (!pud_present(*pud)) |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 31 | return NULL; |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 32 | |
| 33 | pmd = pmd_offset(pud, addr); |
| 34 | if (!pmd_present(*pmd)) |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 35 | return NULL; |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 36 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 37 | return pte_offset_kernel(pmd, addr); |
Jeff Dike | 9157f90 | 2008-02-04 22:30:52 -0800 | [diff] [blame] | 38 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 40 | static pte_t *maybe_map(unsigned long virt, int is_write) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | { |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 42 | pte_t *pte = virt_to_pte(current->mm, virt); |
| 43 | int err, dummy_code; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 45 | if ((pte == NULL) || !pte_present(*pte) || |
| 46 | (is_write && !pte_write(*pte))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | err = handle_page_fault(virt, 0, is_write, 1, &dummy_code); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 48 | if (err) |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 49 | return NULL; |
| 50 | pte = virt_to_pte(current->mm, virt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | } |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 52 | if (!pte_present(*pte)) |
| 53 | pte = NULL; |
Jeff Dike | 2d58cc9 | 2005-05-06 21:30:55 -0700 | [diff] [blame] | 54 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 55 | return pte; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | } |
| 57 | |
Paolo 'Blaisorblade' Giarrusso | 47e5243 | 2006-07-01 04:36:19 -0700 | [diff] [blame] | 58 | static int do_op_one_page(unsigned long addr, int len, int is_write, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | int (*op)(unsigned long addr, int len, void *arg), void *arg) |
| 60 | { |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 61 | jmp_buf buf; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | struct page *page; |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 63 | pte_t *pte; |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 64 | int n, faulted; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 66 | pte = maybe_map(addr, is_write); |
| 67 | if (pte == NULL) |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 68 | return -1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | |
Jeff Dike | ca77b55 | 2008-02-04 22:30:55 -0800 | [diff] [blame] | 70 | page = pte_page(*pte); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 71 | addr = (unsigned long) kmap_atomic(page, KM_UML_USERCOPY) + |
| 72 | (addr & ~PAGE_MASK); |
Paolo 'Blaisorblade' Giarrusso | 47e5243 | 2006-07-01 04:36:19 -0700 | [diff] [blame] | 73 | |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 74 | current->thread.fault_catcher = &buf; |
| 75 | |
| 76 | faulted = UML_SETJMP(&buf); |
| 77 | if (faulted == 0) |
| 78 | n = (*op)(addr, len, arg); |
| 79 | else |
| 80 | n = -1; |
| 81 | |
| 82 | current->thread.fault_catcher = NULL; |
Paolo 'Blaisorblade' Giarrusso | 47e5243 | 2006-07-01 04:36:19 -0700 | [diff] [blame] | 83 | |
| 84 | kunmap_atomic(page, KM_UML_USERCOPY); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 86 | return n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 89 | static int buffer_op(unsigned long addr, int len, int is_write, |
| 90 | int (*op)(unsigned long, int, void *), void *arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | { |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 92 | int size, remain, n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | size = min(PAGE_ALIGN(addr) - addr, (unsigned long) len); |
| 95 | remain = len; |
| 96 | |
Paolo 'Blaisorblade' Giarrusso | 47e5243 | 2006-07-01 04:36:19 -0700 | [diff] [blame] | 97 | n = do_op_one_page(addr, size, is_write, op, arg); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 98 | if (n != 0) { |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 99 | remain = (n < 0 ? remain : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | goto out; |
| 101 | } |
| 102 | |
| 103 | addr += size; |
| 104 | remain -= size; |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 105 | if (remain == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 108 | while (addr < ((addr + remain) & PAGE_MASK)) { |
Paolo 'Blaisorblade' Giarrusso | 47e5243 | 2006-07-01 04:36:19 -0700 | [diff] [blame] | 109 | n = do_op_one_page(addr, PAGE_SIZE, is_write, op, arg); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 110 | if (n != 0) { |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 111 | remain = (n < 0 ? remain : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | goto out; |
| 113 | } |
| 114 | |
| 115 | addr += PAGE_SIZE; |
| 116 | remain -= PAGE_SIZE; |
| 117 | } |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 118 | if (remain == 0) |
| 119 | goto out; |
| 120 | |
| 121 | n = do_op_one_page(addr, remain, is_write, op, arg); |
| 122 | if (n != 0) { |
| 123 | remain = (n < 0 ? remain : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | goto out; |
| 125 | } |
| 126 | |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 127 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | out: |
Jeff Dike | 8efa3c9 | 2008-02-04 22:31:07 -0800 | [diff] [blame] | 129 | return remain; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | static int copy_chunk_from_user(unsigned long from, int len, void *arg) |
| 133 | { |
| 134 | unsigned long *to_ptr = arg, to = *to_ptr; |
| 135 | |
| 136 | memcpy((void *) to, (void *) from, len); |
| 137 | *to_ptr += len; |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 138 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 141 | int copy_from_user(void *to, const void __user *from, int n) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | { |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 143 | if (segment_eq(get_fs(), KERNEL_DS)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | memcpy(to, (__force void*)from, n); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 145 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | } |
| 147 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 148 | return access_ok(VERIFY_READ, from, n) ? |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | buffer_op((unsigned long) from, n, 0, copy_chunk_from_user, &to): |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 150 | n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | static int copy_chunk_to_user(unsigned long to, int len, void *arg) |
| 154 | { |
| 155 | unsigned long *from_ptr = arg, from = *from_ptr; |
| 156 | |
| 157 | memcpy((void *) to, (void *) from, len); |
| 158 | *from_ptr += len; |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 159 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 162 | int copy_to_user(void __user *to, const void *from, int n) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | { |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 164 | if (segment_eq(get_fs(), KERNEL_DS)) { |
| 165 | memcpy((__force void *) to, from, n); |
| 166 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | } |
| 168 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 169 | return access_ok(VERIFY_WRITE, to, n) ? |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | buffer_op((unsigned long) to, n, 1, copy_chunk_to_user, &from) : |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 171 | n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | static int strncpy_chunk_from_user(unsigned long from, int len, void *arg) |
| 175 | { |
| 176 | char **to_ptr = arg, *to = *to_ptr; |
| 177 | int n; |
| 178 | |
| 179 | strncpy(to, (void *) from, len); |
| 180 | n = strnlen(to, len); |
| 181 | *to_ptr += n; |
| 182 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 183 | if (n < len) |
| 184 | return 1; |
| 185 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 188 | int strncpy_from_user(char *dst, const char __user *src, int count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | { |
| 190 | int n; |
| 191 | char *ptr = dst; |
| 192 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 193 | if (segment_eq(get_fs(), KERNEL_DS)) { |
| 194 | strncpy(dst, (__force void *) src, count); |
| 195 | return strnlen(dst, count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 198 | if (!access_ok(VERIFY_READ, src, 1)) |
| 199 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | |
| 201 | n = buffer_op((unsigned long) src, count, 0, strncpy_chunk_from_user, |
| 202 | &ptr); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 203 | if (n != 0) |
| 204 | return -EFAULT; |
| 205 | return strnlen(dst, count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | static int clear_chunk(unsigned long addr, int len, void *unused) |
| 209 | { |
| 210 | memset((void *) addr, 0, len); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 211 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | } |
| 213 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 214 | int __clear_user(void __user *mem, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | { |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 216 | return buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | } |
| 218 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 219 | int clear_user(void __user *mem, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | { |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 221 | if (segment_eq(get_fs(), KERNEL_DS)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | memset((__force void*)mem, 0, len); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 223 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | } |
| 225 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 226 | return access_ok(VERIFY_WRITE, mem, len) ? |
| 227 | buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL) : len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | } |
| 229 | |
| 230 | static int strnlen_chunk(unsigned long str, int len, void *arg) |
| 231 | { |
| 232 | int *len_ptr = arg, n; |
| 233 | |
| 234 | n = strnlen((void *) str, len); |
| 235 | *len_ptr += n; |
| 236 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 237 | if (n < len) |
| 238 | return 1; |
| 239 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | } |
| 241 | |
Jeff Dike | 6aa802c | 2007-10-16 01:26:56 -0700 | [diff] [blame] | 242 | int strnlen_user(const void __user *str, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | { |
| 244 | int count = 0, n; |
| 245 | |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 246 | if (segment_eq(get_fs(), KERNEL_DS)) |
| 247 | return strnlen((__force char*)str, len) + 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | |
| 249 | n = buffer_op((unsigned long) str, len, 0, strnlen_chunk, &count); |
Jeff Dike | 8ca842c | 2007-10-16 01:27:08 -0700 | [diff] [blame] | 250 | if (n == 0) |
| 251 | return count + 1; |
| 252 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | } |