aboutsummaryrefslogtreecommitdiffstats
path: root/include/asm-m68knommu/uaccess.h
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /include/asm-m68knommu/uaccess.h
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'include/asm-m68knommu/uaccess.h')
-rw-r--r--include/asm-m68knommu/uaccess.h182
1 files changed, 182 insertions, 0 deletions
diff --git a/include/asm-m68knommu/uaccess.h b/include/asm-m68knommu/uaccess.h
new file mode 100644
index 000000000000..f0be74bb353c
--- /dev/null
+++ b/include/asm-m68knommu/uaccess.h
@@ -0,0 +1,182 @@
1#ifndef __M68KNOMMU_UACCESS_H
2#define __M68KNOMMU_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#define access_ok(type,addr,size) _access_ok((unsigned long)(addr),(size))
17
18static inline int _access_ok(unsigned long addr, unsigned long size)
19{
20 extern unsigned long memory_start, memory_end;
21
22 return (((addr >= memory_start) && (addr+size < memory_end)) ||
23 (is_in_rom(addr) && is_in_rom(addr+size)));
24}
25
26/* this function will go away soon - use access_ok() instead */
27extern inline int __deprecated verify_area(int type, const void * addr, unsigned long size)
28{
29 return access_ok(type,addr,size)?0:-EFAULT;
30}
31
32/*
33 * The exception table consists of pairs of addresses: the first is the
34 * address of an instruction that is allowed to fault, and the second is
35 * the address at which the program should continue. No registers are
36 * modified, so it is entirely up to the continuation code to figure out
37 * what to do.
38 *
39 * All the routines below use bits of fixup code that are out of line
40 * with the main instruction path. This means when everything is well,
41 * we don't even have to jump over them. Further, they do not intrude
42 * on our cache or tlb entries.
43 */
44
45struct exception_table_entry
46{
47 unsigned long insn, fixup;
48};
49
50/* Returns 0 if exception not found and fixup otherwise. */
51extern unsigned long search_exception_table(unsigned long);
52
53
54/*
55 * These are the main single-value transfer routines. They automatically
56 * use the right size if we just have the right pointer type.
57 */
58
59#define put_user(x, ptr) \
60({ \
61 int __pu_err = 0; \
62 typeof(*(ptr)) __pu_val = (x); \
63 switch (sizeof (*(ptr))) { \
64 case 1: \
65 __put_user_asm(__pu_err, __pu_val, ptr, b); \
66 break; \
67 case 2: \
68 __put_user_asm(__pu_err, __pu_val, ptr, w); \
69 break; \
70 case 4: \
71 __put_user_asm(__pu_err, __pu_val, ptr, l); \
72 break; \
73 case 8: \
74 memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
75 break; \
76 default: \
77 __pu_err = __put_user_bad(); \
78 break; \
79 } \
80 __pu_err; \
81})
82#define __put_user(x, ptr) put_user(x, ptr)
83
84extern int __put_user_bad(void);
85
86/*
87 * Tell gcc we read from memory instead of writing: this is because
88 * we do not write to any memory gcc knows about, so there are no
89 * aliasing issues.
90 */
91
92#define __ptr(x) ((unsigned long *)(x))
93
94#define __put_user_asm(err,x,ptr,bwl) \
95 __asm__ ("move" #bwl " %0,%1" \
96 : /* no outputs */ \
97 :"d" (x),"m" (*__ptr(ptr)) : "memory")
98
99#define get_user(x, ptr) \
100({ \
101 int __gu_err = 0; \
102 typeof(*(ptr)) __gu_val = 0; \
103 switch (sizeof(*(ptr))) { \
104 case 1: \
105 __get_user_asm(__gu_err, __gu_val, ptr, b, "=d"); \
106 break; \
107 case 2: \
108 __get_user_asm(__gu_err, __gu_val, ptr, w, "=r"); \
109 break; \
110 case 4: \
111 __get_user_asm(__gu_err, __gu_val, ptr, l, "=r"); \
112 break; \
113 case 8: \
114 memcpy(&__gu_val, ptr, sizeof (*(ptr))); \
115 break; \
116 default: \
117 __gu_val = 0; \
118 __gu_err = __get_user_bad(); \
119 break; \
120 } \
121 (x) = __gu_val; \
122 __gu_err; \
123})
124#define __get_user(x, ptr) get_user(x, ptr)
125
126extern int __get_user_bad(void);
127
128#define __get_user_asm(err,x,ptr,bwl,reg) \
129 __asm__ ("move" #bwl " %1,%0" \
130 : "=d" (x) \
131 : "m" (*__ptr(ptr)))
132
133#define copy_from_user(to, from, n) (memcpy(to, from, n), 0)
134#define copy_to_user(to, from, n) (memcpy(to, from, n), 0)
135
136#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
137#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
138#define __copy_to_user_inatomic __copy_to_user
139#define __copy_from_user_inatomic __copy_from_user
140
141#define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; })
142
143#define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; })
144
145/*
146 * Copy a null terminated string from userspace.
147 */
148
149static inline long
150strncpy_from_user(char *dst, const char *src, long count)
151{
152 char *tmp;
153 strncpy(dst, src, count);
154 for (tmp = dst; *tmp && count > 0; tmp++, count--)
155 ;
156 return(tmp - dst); /* DAVIDM should we count a NUL ? check getname */
157}
158
159/*
160 * Return the size of a string (including the ending 0)
161 *
162 * Return 0 on exception, a value greater than N if too long
163 */
164static inline long strnlen_user(const char *src, long n)
165{
166 return(strlen(src) + 1); /* DAVIDM make safer */
167}
168
169#define strlen_user(str) strnlen_user(str, 32767)
170
171/*
172 * Zero Userspace
173 */
174
175static inline unsigned long
176clear_user(void *to, unsigned long n)
177{
178 memset(to, 0, n);
179 return 0;
180}
181
182#endif /* _M68KNOMMU_UACCESS_H */