uaccess.h 9.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
/*
 *  include/asm-s390/uaccess.h
 *
 *  S390 version
 *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Hartmut Penner (hp@de.ibm.com),
 *               Martin Schwidefsky (schwidefsky@de.ibm.com)
 *
 *  Derived from "include/asm-i386/uaccess.h"
 */
#ifndef __S390_UACCESS_H
#define __S390_UACCESS_H

/*
 * User space memory access functions
 */
#include <linux/sched.h>
#include <linux/errno.h>

#define VERIFY_READ     0
#define VERIFY_WRITE    1


/*
 * The fs value determines whether argument validity checking should be
 * performed or not.  If get_fs() == USER_DS, checking is performed, with
 * get_fs() == KERNEL_DS, checking is bypassed.
 *
 * For historical reasons, these macros are grossly misnamed.
 */

#define MAKE_MM_SEG(a)  ((mm_segment_t) { (a) })


#define KERNEL_DS       MAKE_MM_SEG(0)
#define USER_DS         MAKE_MM_SEG(1)

#define get_ds()        (KERNEL_DS)
#define get_fs()        (current->thread.mm_segment)

#define set_fs(x) \
({									\
	unsigned long __pto;						\
	current->thread.mm_segment = (x);				\
	__pto = current->thread.mm_segment.ar4 ?			\
		S390_lowcore.user_asce : S390_lowcore.kernel_asce;	\
47
	__ctl_load(__pto, 7, 7);					\
L
Linus Torvalds 已提交
48 49 50 51 52
})

#define segment_eq(a,b) ((a).ar4 == (b).ar4)


A
Al Viro 已提交
53
static inline int __access_ok(const void __user *addr, unsigned long size)
54 55 56
{
	return 1;
}
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
#define access_ok(type,addr,size) __access_ok(addr,size)

/*
 * The exception table consists of pairs of addresses: the first is the
 * address of an instruction that is allowed to fault, and the second is
 * the address at which the program should continue.  No registers are
 * modified, so it is entirely up to the continuation code to figure out
 * what to do.
 *
 * All the routines below use bits of fixup code that are out of line
 * with the main instruction path.  This means when everything is well,
 * we don't even have to jump over them.  Further, they do not intrude
 * on our cache or tlb entries.
 */

struct exception_table_entry
{
        unsigned long insn, fixup;
};

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
struct uaccess_ops {
	size_t (*copy_from_user)(size_t, const void __user *, void *);
	size_t (*copy_from_user_small)(size_t, const void __user *, void *);
	size_t (*copy_to_user)(size_t, void __user *, const void *);
	size_t (*copy_to_user_small)(size_t, void __user *, const void *);
	size_t (*copy_in_user)(size_t, void __user *, const void __user *);
	size_t (*clear_user)(size_t, void __user *);
	size_t (*strnlen_user)(size_t, const char __user *);
	size_t (*strncpy_from_user)(size_t, const char __user *, char *);
	int (*futex_atomic_op)(int op, int __user *, int oparg, int *old);
	int (*futex_atomic_cmpxchg)(int __user *, int old, int new);
};

extern struct uaccess_ops uaccess;
extern struct uaccess_ops uaccess_std;
92
extern struct uaccess_ops uaccess_mvcos;
G
Gerald Schaefer 已提交
93 94
extern struct uaccess_ops uaccess_mvcos_switch;
extern struct uaccess_ops uaccess_pt;
95 96 97 98 99 100 101 102 103 104 105 106

static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
{
	size = uaccess.copy_to_user_small(size, ptr, x);
	return size ? -EFAULT : size;
}

static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
{
	size = uaccess.copy_from_user_small(size, ptr, x);
	return size ? -EFAULT : size;
}
L
Linus Torvalds 已提交
107 108 109 110 111 112 113 114

/*
 * These are the main single-value transfer routines.  They automatically
 * use the right size if we just have the right pointer type.
 */
#define __put_user(x, ptr) \
({								\
	__typeof__(*(ptr)) __x = (x);				\
115
	int __pu_err = -EFAULT;					\
A
Al Viro 已提交
116
        __chk_user_ptr(ptr);                                    \
L
Linus Torvalds 已提交
117 118 119 120 121
	switch (sizeof (*(ptr))) {				\
	case 1:							\
	case 2:							\
	case 4:							\
	case 8:							\
122 123
		__pu_err = __put_user_fn(sizeof (*(ptr)),	\
					 ptr, &__x);		\
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
		break;						\
	default:						\
		__put_user_bad();				\
		break;						\
	 }							\
	__pu_err;						\
})

#define put_user(x, ptr)					\
({								\
	might_sleep();						\
	__put_user(x, ptr);					\
})


extern int __put_user_bad(void) __attribute__((noreturn));

#define __get_user(x, ptr)					\
({								\
143 144
	int __gu_err = -EFAULT;					\
	__chk_user_ptr(ptr);					\
L
Linus Torvalds 已提交
145
	switch (sizeof(*(ptr))) {				\
146 147
	case 1: {						\
		unsigned char __x;				\
148 149
		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
					 ptr, &__x);		\
150
		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
151 152 153 154
		break;						\
	};							\
	case 2: {						\
		unsigned short __x;				\
155 156
		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
					 ptr, &__x);		\
157
		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
158 159 160 161
		break;						\
	};							\
	case 4: {						\
		unsigned int __x;				\
162 163
		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
					 ptr, &__x);		\
164
		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
165 166 167 168
		break;						\
	};							\
	case 8: {						\
		unsigned long long __x;				\
169 170
		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
					 ptr, &__x);		\
171
		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
L
Linus Torvalds 已提交
172
		break;						\
173
	};							\
L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
	default:						\
		__get_user_bad();				\
		break;						\
	}							\
	__gu_err;						\
})

#define get_user(x, ptr)					\
({								\
	might_sleep();						\
	__get_user(x, ptr);					\
})

extern int __get_user_bad(void) __attribute__((noreturn));

#define __put_user_unaligned __put_user
#define __get_user_unaligned __get_user

/**
 * __copy_to_user: - Copy a block of data into user space, with less checking.
 * @to:   Destination address, in user space.
 * @from: Source address, in kernel space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
 * Copy data from kernel space to user space.  Caller must check
 * the specified block with access_ok() before calling this function.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 */
206
static inline unsigned long __must_check
L
Linus Torvalds 已提交
207 208
__copy_to_user(void __user *to, const void *from, unsigned long n)
{
209 210 211 212
	if (__builtin_constant_p(n) && (n <= 256))
		return uaccess.copy_to_user_small(n, to, from);
	else
		return uaccess.copy_to_user(n, to, from);
L
Linus Torvalds 已提交
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
}

#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

/**
 * copy_to_user: - Copy a block of data into user space.
 * @to:   Destination address, in user space.
 * @from: Source address, in kernel space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
 * Copy data from kernel space to user space.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 */
231
static inline unsigned long __must_check
L
Linus Torvalds 已提交
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
copy_to_user(void __user *to, const void *from, unsigned long n)
{
	might_sleep();
	if (access_ok(VERIFY_WRITE, to, n))
		n = __copy_to_user(to, from, n);
	return n;
}

/**
 * __copy_from_user: - Copy a block of data from user space, with less checking.
 * @to:   Destination address, in kernel space.
 * @from: Source address, in user space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
 * Copy data from user space to kernel space.  Caller must check
 * the specified block with access_ok() before calling this function.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 *
 * If some data could not be copied, this function will pad the copied
 * data to the requested size using zero bytes.
 */
257
static inline unsigned long __must_check
L
Linus Torvalds 已提交
258 259
__copy_from_user(void *to, const void __user *from, unsigned long n)
{
260 261 262 263
	if (__builtin_constant_p(n) && (n <= 256))
		return uaccess.copy_from_user_small(n, from, to);
	else
		return uaccess.copy_from_user(n, from, to);
L
Linus Torvalds 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
}

/**
 * copy_from_user: - Copy a block of data from user space.
 * @to:   Destination address, in kernel space.
 * @from: Source address, in user space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
 * Copy data from user space to kernel space.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 *
 * If some data could not be copied, this function will pad the copied
 * data to the requested size using zero bytes.
 */
282
static inline unsigned long __must_check
L
Linus Torvalds 已提交
283 284 285 286 287 288 289 290 291 292
copy_from_user(void *to, const void __user *from, unsigned long n)
{
	might_sleep();
	if (access_ok(VERIFY_READ, from, n))
		n = __copy_from_user(to, from, n);
	else
		memset(to, 0, n);
	return n;
}

293
static inline unsigned long __must_check
L
Linus Torvalds 已提交
294 295
__copy_in_user(void __user *to, const void __user *from, unsigned long n)
{
296
	return uaccess.copy_in_user(n, to, from);
L
Linus Torvalds 已提交
297 298
}

299
static inline unsigned long __must_check
L
Linus Torvalds 已提交
300 301 302 303
copy_in_user(void __user *to, const void __user *from, unsigned long n)
{
	might_sleep();
	if (__access_ok(from,n) && __access_ok(to,n))
304
		n = __copy_in_user(to, from, n);
L
Linus Torvalds 已提交
305 306 307 308 309 310
	return n;
}

/*
 * Copy a null terminated string from userspace.
 */
311
static inline long __must_check
L
Linus Torvalds 已提交
312 313 314 315 316
strncpy_from_user(char *dst, const char __user *src, long count)
{
        long res = -EFAULT;
        might_sleep();
        if (access_ok(VERIFY_READ, src, 1))
317
		res = uaccess.strncpy_from_user(count, src, dst);
L
Linus Torvalds 已提交
318 319 320 321 322 323 324
        return res;
}

static inline unsigned long
strnlen_user(const char __user * src, unsigned long n)
{
	might_sleep();
325
	return uaccess.strnlen_user(n, src);
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
}

/**
 * strlen_user: - Get the size of a string in user space.
 * @str: The string to measure.
 *
 * Context: User context only.  This function may sleep.
 *
 * Get the size of a NUL-terminated string in user space.
 *
 * Returns the size of the string INCLUDING the terminating NUL.
 * On exception, returns 0.
 *
 * If there is a limit on the length of a valid string, you may wish to
 * consider using strnlen_user() instead.
 */
#define strlen_user(str) strnlen_user(str, ~0UL)

/*
 * Zero Userspace
 */

348
static inline unsigned long __must_check
L
Linus Torvalds 已提交
349 350
__clear_user(void __user *to, unsigned long n)
{
351
	return uaccess.clear_user(n, to);
L
Linus Torvalds 已提交
352 353
}

354
static inline unsigned long __must_check
L
Linus Torvalds 已提交
355 356 357 358
clear_user(void __user *to, unsigned long n)
{
	might_sleep();
	if (access_ok(VERIFY_WRITE, to, n))
359
		n = uaccess.clear_user(n, to);
L
Linus Torvalds 已提交
360 361 362 363
	return n;
}

#endif /* __S390_UACCESS_H */