Robert Richter | 1ac2e6c | 2011-06-07 11:49:55 +0200 | [diff] [blame] | 1 | /* |
| 2 | * User address space access functions. |
| 3 | * |
| 4 | * For licencing details see kernel-base/COPYING |
| 5 | */ |
| 6 | |
| 7 | #include <linux/highmem.h> |
| 8 | #include <linux/module.h> |
| 9 | |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 10 | #include <asm/word-at-a-time.h> |
| 11 | |
Robert Richter | 1ac2e6c | 2011-06-07 11:49:55 +0200 | [diff] [blame] | 12 | /* |
| 13 | * best effort, GUP based copy_from_user() that is NMI-safe |
| 14 | */ |
| 15 | unsigned long |
| 16 | copy_from_user_nmi(void *to, const void __user *from, unsigned long n) |
| 17 | { |
| 18 | unsigned long offset, addr = (unsigned long)from; |
| 19 | unsigned long size, len = 0; |
| 20 | struct page *page; |
| 21 | void *map; |
| 22 | int ret; |
| 23 | |
| 24 | do { |
| 25 | ret = __get_user_pages_fast(addr, 1, 0, &page); |
| 26 | if (!ret) |
| 27 | break; |
| 28 | |
| 29 | offset = addr & (PAGE_SIZE - 1); |
| 30 | size = min(PAGE_SIZE - offset, n - len); |
| 31 | |
| 32 | map = kmap_atomic(page); |
| 33 | memcpy(to, map+offset, size); |
| 34 | kunmap_atomic(map); |
| 35 | put_page(page); |
| 36 | |
| 37 | len += size; |
| 38 | to += size; |
| 39 | addr += size; |
| 40 | |
| 41 | } while (len < n); |
| 42 | |
| 43 | return len; |
| 44 | } |
| 45 | EXPORT_SYMBOL_GPL(copy_from_user_nmi); |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 46 | |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 47 | /* |
| 48 | * Do a strncpy, return length of string without final '\0'. |
| 49 | * 'count' is the user-supplied count (return 'count' if we |
| 50 | * hit it), 'max' is the address space maximum (and we return |
| 51 | * -EFAULT if we hit it). |
| 52 | */ |
Linus Torvalds | 12e993b | 2012-04-15 17:23:00 -0700 | [diff] [blame] | 53 | static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max) |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 54 | { |
| 55 | long res = 0; |
| 56 | |
| 57 | /* |
| 58 | * Truncate 'max' to the user-specified limit, so that |
| 59 | * we only have one limit we need to check in the loop |
| 60 | */ |
| 61 | if (max > count) |
| 62 | max = count; |
| 63 | |
| 64 | while (max >= sizeof(unsigned long)) { |
Linus Torvalds | 0749708 | 2012-04-28 14:27:38 -0700 | [diff] [blame] | 65 | unsigned long c, mask; |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 66 | |
| 67 | /* Fall back to byte-at-a-time if we get a page fault */ |
| 68 | if (unlikely(__get_user(c,(unsigned long __user *)(src+res)))) |
| 69 | break; |
Linus Torvalds | 0749708 | 2012-04-28 14:27:38 -0700 | [diff] [blame] | 70 | mask = has_zero(c); |
| 71 | if (mask) { |
| 72 | mask = (mask - 1) & ~mask; |
| 73 | mask >>= 7; |
| 74 | *(unsigned long *)(dst+res) = c & mask; |
| 75 | return res + count_masked_bytes(mask); |
| 76 | } |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 77 | *(unsigned long *)(dst+res) = c; |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 78 | res += sizeof(unsigned long); |
| 79 | max -= sizeof(unsigned long); |
| 80 | } |
| 81 | |
| 82 | while (max) { |
| 83 | char c; |
| 84 | |
| 85 | if (unlikely(__get_user(c,src+res))) |
| 86 | return -EFAULT; |
| 87 | dst[res] = c; |
| 88 | if (!c) |
| 89 | return res; |
| 90 | res++; |
| 91 | max--; |
| 92 | } |
| 93 | |
| 94 | /* |
| 95 | * Uhhuh. We hit 'max'. But was that the user-specified maximum |
| 96 | * too? If so, that's ok - we got as much as the user asked for. |
| 97 | */ |
| 98 | if (res >= count) |
Linus Torvalds | 12e993b | 2012-04-15 17:23:00 -0700 | [diff] [blame] | 99 | return res; |
Linus Torvalds | 92ae03f | 2012-04-06 14:32:32 -0700 | [diff] [blame] | 100 | |
| 101 | /* |
| 102 | * Nope: we hit the address space limit, and we still had more |
| 103 | * characters the caller would have wanted. That's an EFAULT. |
| 104 | */ |
| 105 | return -EFAULT; |
| 106 | } |
| 107 | |
| 108 | /** |
| 109 | * strncpy_from_user: - Copy a NUL terminated string from userspace. |
| 110 | * @dst: Destination address, in kernel space. This buffer must be at |
| 111 | * least @count bytes long. |
| 112 | * @src: Source address, in user space. |
| 113 | * @count: Maximum number of bytes to copy, including the trailing NUL. |
| 114 | * |
| 115 | * Copies a NUL-terminated string from userspace to kernel space. |
| 116 | * |
| 117 | * On success, returns the length of the string (not including the trailing |
| 118 | * NUL). |
| 119 | * |
| 120 | * If access to userspace fails, returns -EFAULT (some data may have been |
| 121 | * copied). |
| 122 | * |
| 123 | * If @count is smaller than the length of the string, copies @count bytes |
| 124 | * and returns @count. |
| 125 | */ |
| 126 | long |
| 127 | strncpy_from_user(char *dst, const char __user *src, long count) |
| 128 | { |
| 129 | unsigned long max_addr, src_addr; |
| 130 | |
| 131 | if (unlikely(count <= 0)) |
| 132 | return 0; |
| 133 | |
| 134 | max_addr = current_thread_info()->addr_limit.seg; |
| 135 | src_addr = (unsigned long)src; |
| 136 | if (likely(src_addr < max_addr)) { |
| 137 | unsigned long max = max_addr - src_addr; |
| 138 | return do_strncpy_from_user(dst, src, count, max); |
| 139 | } |
| 140 | return -EFAULT; |
| 141 | } |
| 142 | EXPORT_SYMBOL(strncpy_from_user); |