include/asm-sparc64/uaccess.h

   1 /* $Id: uaccess.h,v 1.35 2002/02/09 19:49:31 davem Exp $ */
   2 #ifndef _ASM_UACCESS_H
   3 #define _ASM_UACCESS_H
   4
   5 /*
   6  * User space memory access functions
   7  */
   8
   9 #ifdef __KERNEL__
  10 #include <linux/compiler.h>
  11 #include <linux/sched.h>
  12 #include <linux/string.h>
  13 #include <asm/a.out.h>
  14 #include <asm/asi.h>
  15 #include <asm/system.h>
  16 #include <asm/spitfire.h>
  17 #include <asm-generic/uaccess.h>
  18 #endif
  19
  20 #ifndef __ASSEMBLY__
  21
  22 /*
  23  * Sparc64 is segmented, though more like the M68K than the I386.
  24  * We use the secondary ASI to address user memory, which references a
  25  * completely different VM map, thus there is zero chance of the user
  26  * doing something queer and tricking us into poking kernel memory.
  27  *
  28  * What is left here is basically what is needed for the other parts of
  29  * the kernel that expect to be able to manipulate, erum, "segments".
  30  * Or perhaps more properly, permissions.
  31  *
  32  * "For historical reasons, these macros are grossly misnamed." -Linus
  33  */
  34
  35 #define KERNEL_DS   ((mm_segment_t) { ASI_P })
  36 #define USER_DS     ((mm_segment_t) { ASI_AIUS })       /* har har har */
  37
  38 #define VERIFY_READ     0
  39 #define VERIFY_WRITE    1
  40
  41 #define get_fs() ((mm_segment_t) { get_thread_current_ds() })
  42 #define get_ds() (KERNEL_DS)
  43
  44 #define segment_eq(a,b)  ((a).seg == (b).seg)
  45
  46 #define set_fs(val)                                                             \
  47 do {                                                                            \
  48         set_thread_current_ds((val).seg);                                       \
  49         __asm__ __volatile__ ("wr %%g0, %0, %%asi" : : "r" ((val).seg));        \
  50 } while(0)
  51
  52 static inline int __access_ok(const void __user * addr, unsigned long size)
  53 {
  54         return 1;
  55 }
  56
  57 static inline int access_ok(int type, const void __user * addr, unsigned long size)
  58 {
  59         return 1;
  60 }
  61
  62 /* this function will go away soon - use access_ok() instead */
  63 static inline int __deprecated verify_area(int type, const void __user * addr, unsigned long size)
  64 {
  65         return 0;
  66 }
  67
  68 /*
  69  * The exception table consists of pairs of addresses: the first is the
  70  * address of an instruction that is allowed to fault, and the second is
  71  * the address at which the program should continue.  No registers are
  72  * modified, so it is entirely up to the continuation code to figure out
  73  * what to do.
  74  *
  75  * All the routines below use bits of fixup code that are out of line
  76  * with the main instruction path.  This means when everything is well,
  77  * we don't even have to jump over them.  Further, they do not intrude
  78  * on our cache or tlb entries.
  79  *
  80  * There is a special way how to put a range of potentially faulting
  81  * insns (like twenty ldd/std's with now intervening other instructions)
  82  * You specify address of first in insn and 0 in fixup and in the next
  83  * exception_table_entry you specify last potentially faulting insn + 1
  84  * and in fixup the routine which should handle the fault.
  85  * That fixup code will get
  86  * (faulting_insn_address - first_insn_in_the_range_address)/4
  87  * in %g2 (ie. index of the faulting instruction in the range).
  88  */
  89
  90 struct exception_table_entry
  91 {
  92         unsigned insn, fixup;
  93 };
  94
  95 /* Special exable search, which handles ranges.  Returns fixup */
  96 unsigned long search_extables_range(unsigned long addr, unsigned long *g2);
  97
  98 extern void __ret_efault(void);
  99
 100 /* Uh, these should become the main single-value transfer routines..
 101  * They automatically use the right size if we just have the right
 102  * pointer type..
 103  *
 104  * This gets kind of ugly. We want to return _two_ values in "get_user()"
 105  * and yet we don't want to do any pointers, because that is too much
 106  * of a performance impact. Thus we have a few rather ugly macros here,
 107  * and hide all the ugliness from the user.
 108  */
 109 #define put_user(x,ptr) ({ \
 110 unsigned long __pu_addr = (unsigned long)(ptr); \
 111 __chk_user_ptr(ptr); \
 112 __put_user_nocheck((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr))); })
 113
 114 #define get_user(x,ptr) ({ \
 115 unsigned long __gu_addr = (unsigned long)(ptr); \
 116 __chk_user_ptr(ptr); \
 117 __get_user_nocheck((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr))); })
 118
 119 #define __put_user(x,ptr) put_user(x,ptr)
 120 #define __get_user(x,ptr) get_user(x,ptr)
 121
 122 struct __large_struct { unsigned long buf[100]; };
 123 #define __m(x) ((struct __large_struct *)(x))
 124
 125 #define __put_user_nocheck(data,addr,size) ({ \
 126 register int __pu_ret; \
 127 switch (size) { \
 128 case 1: __put_user_asm(data,b,addr,__pu_ret); break; \
 129 case 2: __put_user_asm(data,h,addr,__pu_ret); break; \
 130 case 4: __put_user_asm(data,w,addr,__pu_ret); break; \
 131 case 8: __put_user_asm(data,x,addr,__pu_ret); break; \
 132 default: __pu_ret = __put_user_bad(); break; \
 133 } __pu_ret; })
 134
 135 #define __put_user_nocheck_ret(data,addr,size,retval) ({ \
 136 register int __foo __asm__ ("l1"); \
 137 switch (size) { \
 138 case 1: __put_user_asm_ret(data,b,addr,retval,__foo); break; \
 139 case 2: __put_user_asm_ret(data,h,addr,retval,__foo); break; \
 140 case 4: __put_user_asm_ret(data,w,addr,retval,__foo); break; \
 141 case 8: __put_user_asm_ret(data,x,addr,retval,__foo); break; \
 142 default: if (__put_user_bad()) return retval; break; \
 143 } })
 144
 145 #define __put_user_asm(x,size,addr,ret)                                 \
 146 __asm__ __volatile__(                                                   \
 147         "/* Put user asm, inline. */\n"                                 \
 148 "1:\t"  "st"#size "a %1, [%2] %%asi\n\t"                                \
 149         "clr    %0\n"                                                   \
 150 "2:\n\n\t"                                                              \
 151         ".section .fixup,#alloc,#execinstr\n\t"                         \
 152         ".align 4\n"                                                    \
 153 "3:\n\t"                                                                \
 154         "b      2b\n\t"                                                 \
 155         " mov   %3, %0\n\n\t"                                           \
 156         ".previous\n\t"                                                 \
 157         ".section __ex_table,#alloc\n\t"                                \
 158         ".align 4\n\t"                                                  \
 159         ".word  1b, 3b\n\t"                                             \
 160         ".previous\n\n\t"                                               \
 161        : "=r" (ret) : "r" (x), "r" (__m(addr)),                         \
 162          "i" (-EFAULT))
 163
 164 #define __put_user_asm_ret(x,size,addr,ret,foo)                         \
 165 if (__builtin_constant_p(ret) && ret == -EFAULT)                        \
 166 __asm__ __volatile__(                                                   \
 167         "/* Put user asm ret, inline. */\n"                             \
 168 "1:\t"  "st"#size "a %1, [%2] %%asi\n\n\t"                              \
 169         ".section __ex_table,#alloc\n\t"                                \
 170         ".align 4\n\t"                                                  \
 171         ".word  1b, __ret_efault\n\n\t"                                 \
 172         ".previous\n\n\t"                                               \
 173        : "=r" (foo) : "r" (x), "r" (__m(addr)));                        \
 174 else                                                                    \
 175 __asm__ __volatile__(                                                   \
 176         "/* Put user asm ret, inline. */\n"                             \
 177 "1:\t"  "st"#size "a %1, [%2] %%asi\n\n\t"                              \
 178         ".section .fixup,#alloc,#execinstr\n\t"                         \
 179         ".align 4\n"                                                    \
 180 "3:\n\t"                                                                \
 181         "ret\n\t"                                                       \
 182         " restore %%g0, %3, %%o0\n\n\t"                                 \
 183         ".previous\n\t"                                                 \
 184         ".section __ex_table,#alloc\n\t"                                \
 185         ".align 4\n\t"                                                  \
 186         ".word  1b, 3b\n\n\t"                                           \
 187         ".previous\n\n\t"                                               \
 188        : "=r" (foo) : "r" (x), "r" (__m(addr)),                         \
 189          "i" (ret))
 190
 191 extern int __put_user_bad(void);
 192
 193 #define __get_user_nocheck(data,addr,size,type) ({ \
 194 register int __gu_ret; \
 195 register unsigned long __gu_val; \
 196 switch (size) { \
 197 case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \
 198 case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \
 199 case 4: __get_user_asm(__gu_val,uw,addr,__gu_ret); break; \
 200 case 8: __get_user_asm(__gu_val,x,addr,__gu_ret); break; \
 201 default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \
 202 } data = (type) __gu_val; __gu_ret; })
 203
 204 #define __get_user_nocheck_ret(data,addr,size,type,retval) ({ \
 205 register unsigned long __gu_val __asm__ ("l1"); \
 206 switch (size) { \
 207 case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \
 208 case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \
 209 case 4: __get_user_asm_ret(__gu_val,uw,addr,retval); break; \
 210 case 8: __get_user_asm_ret(__gu_val,x,addr,retval); break; \
 211 default: if (__get_user_bad()) return retval; \
 212 } data = (type) __gu_val; })
 213
 214 #define __get_user_asm(x,size,addr,ret)                                 \
 215 __asm__ __volatile__(                                                   \
 216         "/* Get user asm, inline. */\n"                                 \
 217 "1:\t"  "ld"#size "a [%2] %%asi, %1\n\t"                                \
 218         "clr    %0\n"                                                   \
 219 "2:\n\n\t"                                                              \
 220         ".section .fixup,#alloc,#execinstr\n\t"                         \
 221         ".align 4\n"                                                    \
 222 "3:\n\t"                                                                \
 223         "clr    %1\n\t"                                                 \
 224         "b      2b\n\t"                                                 \
 225         " mov   %3, %0\n\n\t"                                           \
 226         ".previous\n\t"                                                 \
 227         ".section __ex_table,#alloc\n\t"                                \
 228         ".align 4\n\t"                                                  \
 229         ".word  1b, 3b\n\n\t"                                           \
 230         ".previous\n\t"                                                 \
 231        : "=r" (ret), "=r" (x) : "r" (__m(addr)),                        \
 232          "i" (-EFAULT))
 233
 234 #define __get_user_asm_ret(x,size,addr,retval)                          \
 235 if (__builtin_constant_p(retval) && retval == -EFAULT)                  \
 236 __asm__ __volatile__(                                                   \
 237         "/* Get user asm ret, inline. */\n"                             \
 238 "1:\t"  "ld"#size "a [%1] %%asi, %0\n\n\t"                              \
 239         ".section __ex_table,#alloc\n\t"                                \
 240         ".align 4\n\t"                                                  \
 241         ".word  1b,__ret_efault\n\n\t"                                  \
 242         ".previous\n\t"                                                 \
 243        : "=r" (x) : "r" (__m(addr)));                                   \
 244 else                                                                    \
 245 __asm__ __volatile__(                                                   \
 246         "/* Get user asm ret, inline. */\n"                             \
 247 "1:\t"  "ld"#size "a [%1] %%asi, %0\n\n\t"                              \
 248         ".section .fixup,#alloc,#execinstr\n\t"                         \
 249         ".align 4\n"                                                    \
 250 "3:\n\t"                                                                \
 251         "ret\n\t"                                                       \
 252         " restore %%g0, %2, %%o0\n\n\t"                                 \
 253         ".previous\n\t"                                                 \
 254         ".section __ex_table,#alloc\n\t"                                \
 255         ".align 4\n\t"                                                  \
 256         ".word  1b, 3b\n\n\t"                                           \
 257         ".previous\n\t"                                                 \
 258        : "=r" (x) : "r" (__m(addr)), "i" (retval))
 259
 260 extern int __get_user_bad(void);
 261
 262 extern unsigned long __must_check ___copy_from_user(void *to,
 263                                                     const void __user *from,
 264                                                     unsigned long size);
 265 extern unsigned long copy_from_user_fixup(void *to, const void __user *from,
 266                                           unsigned long size);
 267 static inline unsigned long __must_check
 268 copy_from_user(void *to, const void __user *from, unsigned long size)
 269 {
 270         unsigned long ret = ___copy_from_user(to, from, size);
 271
 272         if (ret)
 273                 ret = copy_from_user_fixup(to, from, size);
 274         return ret;
 275 }
 276 #define __copy_from_user copy_from_user
 277
 278 extern unsigned long __must_check ___copy_to_user(void __user *to,
 279                                                   const void *from,
 280                                                   unsigned long size);
 281 extern unsigned long copy_to_user_fixup(void __user *to, const void *from,
 282                                         unsigned long size);
 283 static inline unsigned long __must_check
 284 copy_to_user(void __user *to, const void *from, unsigned long size)
 285 {
 286         unsigned long ret = ___copy_to_user(to, from, size);
 287
 288         if (ret)
 289                 ret = copy_to_user_fixup(to, from, size);
 290         return ret;
 291 }
 292 #define __copy_to_user copy_to_user
 293
 294 extern unsigned long __must_check ___copy_in_user(void __user *to,
 295                                                   const void __user *from,
 296                                                   unsigned long size);
 297 extern unsigned long copy_in_user_fixup(void __user *to, void __user *from,
 298                                         unsigned long size);
 299 static inline unsigned long __must_check
 300 copy_in_user(void __user *to, void __user *from, unsigned long size)
 301 {
 302         unsigned long ret = ___copy_in_user(to, from, size);
 303
 304         if (ret)
 305                 ret = copy_in_user_fixup(to, from, size);
 306         return ret;
 307 }
 308 #define __copy_in_user copy_in_user
 309
 310 extern unsigned long __must_check __bzero_noasi(void __user *, unsigned long);
 311
 312 static inline unsigned long __must_check
 313 __clear_user(void __user *addr, unsigned long size)
 314 {
 315
 316         return __bzero_noasi(addr, size);
 317 }
 318
 319 #define clear_user __clear_user
 320
 321 extern long __must_check __strncpy_from_user(char *dest, const char __user *src, long count);
 322
 323 #define strncpy_from_user __strncpy_from_user
 324
 325 extern long __strlen_user(const char __user *);
 326 extern long __strnlen_user(const char __user *, long len);
 327
 328 #define strlen_user __strlen_user
 329 #define strnlen_user __strnlen_user
 330 #define __copy_to_user_inatomic __copy_to_user
 331 #define __copy_from_user_inatomic __copy_from_user
 332
 333 #endif  /* __ASSEMBLY__ */
 334
 335 #endif /* _ASM_UACCESS_H */