Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __H8300_UACCESS_H |
| 2 | #define __H8300_UACCESS_H |
| 3 | |
| 4 | /* |
| 5 | * User space memory access functions |
| 6 | */ |
| 7 | #include <linux/sched.h> |
| 8 | #include <linux/mm.h> |
| 9 | #include <linux/string.h> |
| 10 | |
| 11 | #include <asm/segment.h> |
| 12 | |
| 13 | #define VERIFY_READ 0 |
| 14 | #define VERIFY_WRITE 1 |
| 15 | |
| 16 | /* We let the MMU do all checking */ |
| 17 | #define access_ok(type, addr, size) __access_ok((unsigned long)addr,size) |
| 18 | static inline int __access_ok(unsigned long addr, unsigned long size) |
| 19 | { |
| 20 | #define RANGE_CHECK_OK(addr, size, lower, upper) \ |
| 21 | (((addr) >= (lower)) && (((addr) + (size)) < (upper))) |
| 22 | |
| 23 | extern unsigned long _ramend; |
| 24 | return(RANGE_CHECK_OK(addr, size, 0L, (unsigned long)&_ramend)); |
| 25 | } |
| 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | /* |
| 28 | * The exception table consists of pairs of addresses: the first is the |
| 29 | * address of an instruction that is allowed to fault, and the second is |
| 30 | * the address at which the program should continue. No registers are |
| 31 | * modified, so it is entirely up to the continuation code to figure out |
| 32 | * what to do. |
| 33 | * |
| 34 | * All the routines below use bits of fixup code that are out of line |
| 35 | * with the main instruction path. This means when everything is well, |
| 36 | * we don't even have to jump over them. Further, they do not intrude |
| 37 | * on our cache or tlb entries. |
| 38 | */ |
| 39 | |
| 40 | struct exception_table_entry |
| 41 | { |
| 42 | unsigned long insn, fixup; |
| 43 | }; |
| 44 | |
| 45 | /* Returns 0 if exception not found and fixup otherwise. */ |
| 46 | extern unsigned long search_exception_table(unsigned long); |
| 47 | |
| 48 | |
| 49 | /* |
| 50 | * These are the main single-value transfer routines. They automatically |
| 51 | * use the right size if we just have the right pointer type. |
| 52 | */ |
| 53 | |
| 54 | #define put_user(x, ptr) \ |
| 55 | ({ \ |
| 56 | int __pu_err = 0; \ |
| 57 | typeof(*(ptr)) __pu_val = (x); \ |
| 58 | switch (sizeof (*(ptr))) { \ |
| 59 | case 1: \ |
| 60 | case 2: \ |
| 61 | case 4: \ |
| 62 | *(ptr) = (__pu_val); \ |
| 63 | break; \ |
| 64 | case 8: \ |
| 65 | memcpy(ptr, &__pu_val, sizeof (*(ptr))); \ |
| 66 | break; \ |
| 67 | default: \ |
| 68 | __pu_err = __put_user_bad(); \ |
| 69 | break; \ |
| 70 | } \ |
| 71 | __pu_err; \ |
| 72 | }) |
| 73 | #define __put_user(x, ptr) put_user(x, ptr) |
| 74 | |
| 75 | extern int __put_user_bad(void); |
| 76 | |
| 77 | /* |
| 78 | * Tell gcc we read from memory instead of writing: this is because |
| 79 | * we do not write to any memory gcc knows about, so there are no |
| 80 | * aliasing issues. |
| 81 | */ |
| 82 | |
| 83 | #define __ptr(x) ((unsigned long *)(x)) |
| 84 | |
| 85 | /* |
| 86 | * Tell gcc we read from memory instead of writing: this is because |
| 87 | * we do not write to any memory gcc knows about, so there are no |
| 88 | * aliasing issues. |
| 89 | */ |
| 90 | |
| 91 | #define get_user(x, ptr) \ |
| 92 | ({ \ |
| 93 | int __gu_err = 0; \ |
Yoshinori Sato | 12d4873 | 2008-03-13 12:32:37 -0700 | [diff] [blame] | 94 | typeof(*(ptr)) __gu_val = *ptr; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | switch (sizeof(*(ptr))) { \ |
| 96 | case 1: \ |
| 97 | case 2: \ |
| 98 | case 4: \ |
Yoshinori Sato | 12d4873 | 2008-03-13 12:32:37 -0700 | [diff] [blame] | 99 | case 8: \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | break; \ |
| 101 | default: \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | __gu_err = __get_user_bad(); \ |
| 103 | break; \ |
| 104 | } \ |
Yoshinori Sato | 12d4873 | 2008-03-13 12:32:37 -0700 | [diff] [blame] | 105 | (x) = __gu_val; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | __gu_err; \ |
| 107 | }) |
| 108 | #define __get_user(x, ptr) get_user(x, ptr) |
| 109 | |
| 110 | extern int __get_user_bad(void); |
| 111 | |
| 112 | #define copy_from_user(to, from, n) (memcpy(to, from, n), 0) |
| 113 | #define copy_to_user(to, from, n) (memcpy(to, from, n), 0) |
| 114 | |
| 115 | #define __copy_from_user(to, from, n) copy_from_user(to, from, n) |
| 116 | #define __copy_to_user(to, from, n) copy_to_user(to, from, n) |
| 117 | #define __copy_to_user_inatomic __copy_to_user |
| 118 | #define __copy_from_user_inatomic __copy_from_user |
| 119 | |
| 120 | #define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; }) |
| 121 | |
| 122 | #define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; }) |
| 123 | |
| 124 | /* |
| 125 | * Copy a null terminated string from userspace. |
| 126 | */ |
| 127 | |
| 128 | static inline long |
| 129 | strncpy_from_user(char *dst, const char *src, long count) |
| 130 | { |
| 131 | char *tmp; |
| 132 | strncpy(dst, src, count); |
| 133 | for (tmp = dst; *tmp && count > 0; tmp++, count--) |
| 134 | ; |
| 135 | return(tmp - dst); /* DAVIDM should we count a NUL ? check getname */ |
| 136 | } |
| 137 | |
| 138 | /* |
| 139 | * Return the size of a string (including the ending 0) |
| 140 | * |
| 141 | * Return 0 on exception, a value greater than N if too long |
| 142 | */ |
| 143 | static inline long strnlen_user(const char *src, long n) |
| 144 | { |
| 145 | return(strlen(src) + 1); /* DAVIDM make safer */ |
| 146 | } |
| 147 | |
| 148 | #define strlen_user(str) strnlen_user(str, 32767) |
| 149 | |
| 150 | /* |
| 151 | * Zero Userspace |
| 152 | */ |
| 153 | |
| 154 | static inline unsigned long |
| 155 | clear_user(void *to, unsigned long n) |
| 156 | { |
| 157 | memset(to, 0, n); |
| 158 | return 0; |
| 159 | } |
| 160 | |
Geert Uytterhoeven | 213ab3f | 2012-07-11 14:02:28 -0700 | [diff] [blame] | 161 | #define __clear_user clear_user |
| 162 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | #endif /* _H8300_UACCESS_H */ |