1 #ifndef __H8300_UACCESS_H
2 #define __H8300_UACCESS_H
5 * User space memory access functions
7 #include <linux/sched.h>
9 #include <linux/string.h>
11 #include <asm/segment.h>
14 #define VERIFY_WRITE 1
16 /* We let the MMU do all checking */
17 extern inline int access_ok(int type
, const void * addr
, unsigned long size
)
19 #define RANGE_CHECK_OK(addr, size, lower, upper) \
20 (((addr) >= (lower)) && (((addr) + (size)) < (upper)))
22 extern unsigned long _ramend
;
23 return(RANGE_CHECK_OK((unsigned long) addr
, size
, 0L, (unsigned long)&_ramend
));
26 extern inline int verify_area(int type
, const void * addr
, unsigned long size
)
28 return access_ok(type
,addr
,size
)?0:-EFAULT
;
32 * The exception table consists of pairs of addresses: the first is the
33 * address of an instruction that is allowed to fault, and the second is
34 * the address at which the program should continue. No registers are
35 * modified, so it is entirely up to the continuation code to figure out
38 * All the routines below use bits of fixup code that are out of line
39 * with the main instruction path. This means when everything is well,
40 * we don't even have to jump over them. Further, they do not intrude
41 * on our cache or tlb entries.
44 struct exception_table_entry
46 unsigned long insn
, fixup
;
49 /* Returns 0 if exception not found and fixup otherwise. */
50 extern unsigned long search_exception_table(unsigned long);
54 * These are the main single-value transfer routines. They automatically
55 * use the right size if we just have the right pointer type.
58 #define put_user(x, ptr) \
61 typeof(*(ptr)) __pu_val = (x); \
62 switch (sizeof (*(ptr))) { \
66 *(ptr) = (__pu_val); \
69 memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
72 __pu_err = __put_user_bad(); \
77 #define __put_user(x, ptr) put_user(x, ptr)
79 extern int __put_user_bad(void);
82 * Tell gcc we read from memory instead of writing: this is because
83 * we do not write to any memory gcc knows about, so there are no
87 #define __ptr(x) ((unsigned long *)(x))
90 * Tell gcc we read from memory instead of writing: this is because
91 * we do not write to any memory gcc knows about, so there are no
95 #define get_user(x, ptr) \
98 typeof(*(ptr)) __gu_val = 0; \
99 switch (sizeof(*(ptr))) { \
106 memcpy(&__gu_val, ptr, sizeof (*(ptr))); \
110 __gu_err = __get_user_bad(); \
116 #define __get_user(x, ptr) get_user(x, ptr)
118 extern int __get_user_bad(void);
120 #define copy_from_user(to, from, n) (memcpy(to, from, n), 0)
121 #define copy_to_user(to, from, n) (memcpy(to, from, n), 0)
123 #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
124 #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
126 #define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; })
128 #define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; })
131 * Copy a null terminated string from userspace.
135 strncpy_from_user(char *dst
, const char *src
, long count
)
138 strncpy(dst
, src
, count
);
139 for (tmp
= dst
; *tmp
&& count
> 0; tmp
++, count
--)
141 return(tmp
- dst
); /* DAVIDM should we count a NUL ? check getname */
145 * Return the size of a string (including the ending 0)
147 * Return 0 on exception, a value greater than N if too long
149 static inline long strnlen_user(const char *src
, long n
)
151 return(strlen(src
) + 1); /* DAVIDM make safer */
154 #define strlen_user(str) strnlen_user(str, 32767)
160 static inline unsigned long
161 clear_user(void *to
, unsigned long n
)
167 #endif /* _H8300_UACCESS_H */