[mirror_ubuntu-bionic-kernel.git] / arch / m68k / include / asm / uaccess_no.h

#ifndef __M68KNOMMU_UACCESS_H
#define __M68KNOMMU_UACCESS_H

/*
 * User space memory access functions
 */
#include <linux/mm.h>
#include <linux/string.h>

#include <asm/segment.h>

#define access_ok(type,addr,size)	_access_ok((unsigned long)(addr),(size))

/*
 * It is not enough to just have access_ok check for a real RAM address.
 * This would disallow the case of code/ro-data running XIP in flash/rom.
 * Ideally we would check the possible flash ranges too, but that is
 * currently not so easy.
 */
static inline int _access_ok(unsigned long addr, unsigned long size)
{
	return 1;
}

/*
 * 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)				\
({							\
    int __pu_err = 0;					\
    typeof(*(ptr)) __pu_val = (x);			\
    switch (sizeof (*(ptr))) {				\
    case 1:						\
	__put_user_asm(__pu_err, __pu_val, ptr, b);	\
	break;						\
    case 2:						\
	__put_user_asm(__pu_err, __pu_val, ptr, w);	\
	break;						\
    case 4:						\
	__put_user_asm(__pu_err, __pu_val, ptr, l);	\
	break;						\
    case 8:						\
	memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
	break;						\
    default:						\
	__pu_err = __put_user_bad();			\
	break;						\
    }							\
    __pu_err;						\
})
#define __put_user(x, ptr) put_user(x, ptr)

extern int __put_user_bad(void);

/*
 * Tell gcc we read from memory instead of writing: this is because
 * we do not write to any memory gcc knows about, so there are no
 * aliasing issues.
 */

#define __ptr(x) ((unsigned long *)(x))

#define __put_user_asm(err,x,ptr,bwl)				\
	__asm__ ("move" #bwl " %0,%1"				\
		: /* no outputs */						\
		:"d" (x),"m" (*__ptr(ptr)) : "memory")

#define get_user(x, ptr)					\
({								\
    int __gu_err = 0;						\
    typeof(x) __gu_val = 0;					\
    switch (sizeof(*(ptr))) {					\
    case 1:							\
	__get_user_asm(__gu_err, __gu_val, ptr, b, "=d");	\
	break;							\
    case 2:							\
	__get_user_asm(__gu_err, __gu_val, ptr, w, "=r");	\
	break;							\
    case 4:							\
	__get_user_asm(__gu_err, __gu_val, ptr, l, "=r");	\
	break;							\
    case 8:							\
	memcpy((void *) &__gu_val, ptr, sizeof (*(ptr)));	\
	break;							\
    default:							\
	__gu_val = 0;						\
	__gu_err = __get_user_bad();				\
	break;							\
    }								\
    (x) = (typeof(*(ptr))) __gu_val;				\
    __gu_err;							\
})
#define __get_user(x, ptr) get_user(x, ptr)

extern int __get_user_bad(void);

#define __get_user_asm(err,x,ptr,bwl,reg)			\
	__asm__ ("move" #bwl " %1,%0"				\
		 : "=d" (x)					\
		 : "m" (*__ptr(ptr)))

static inline unsigned long
raw_copy_from_user(void *to, const void __user *from, unsigned long n)
{
	memcpy(to, (__force const void *)from, n);
	return 0;
}

static inline unsigned long
raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
	memcpy((__force void *)to, from, n);
	return 0;
}
#define INLINE_COPY_FROM_USER
#define INLINE_COPY_TO_USER

/*
 * Copy a null terminated string from userspace.
 */

static inline long
strncpy_from_user(char *dst, const char *src, long count)
{
	char *tmp;
	strncpy(dst, src, count);
	for (tmp = dst; *tmp && count > 0; tmp++, count--)
		;
	return(tmp - dst); /* DAVIDM should we count a NUL ?  check getname */
}

/*
 * Return the size of a string (including the ending 0)
 *
 * Return 0 on exception, a value greater than N if too long
 */
static inline long strnlen_user(const char *src, long n)
{
	return(strlen(src) + 1); /* DAVIDM make safer */
}

/*
 * Zero Userspace
 */

static inline unsigned long
__clear_user(void *to, unsigned long n)
{
	memset(to, 0, n);
	return 0;
}

#define	clear_user(to,n)	__clear_user(to,n)

#endif /* _M68KNOMMU_UACCESS_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __M68KNOMMU_UACCESS_H
	2	#define __M68KNOMMU_UACCESS_H
	3
	4	/*
	5	* User space memory access functions
	6	*/
1da177e4 LT	7	#include <linux/mm.h>
	8	#include <linux/string.h>
	9
	10	#include <asm/segment.h>
	11
1da177e4 LT	12	#define access_ok(type,addr,size) _access_ok((unsigned long)(addr),(size))
1da177e4 LT	13
10146801 GU	14	/*
	15	* It is not enough to just have access_ok check for a real RAM address.
	16	* This would disallow the case of code/ro-data running XIP in flash/rom.
	17	* Ideally we would check the possible flash ranges too, but that is
	18	* currently not so easy.
	19	*/
1da177e4 LT	20	static inline int _access_ok(unsigned long addr, unsigned long size)
1da177e4 LT	21	{
10146801	22	return 1;
1da177e4 LT	23	}
1da177e4 LT	24
1da177e4 LT	25	/*
	26	* These are the main single-value transfer routines. They automatically
	27	* use the right size if we just have the right pointer type.
	28	*/
	29
	30	#define put_user(x, ptr) \
	31	({ \
	32	int __pu_err = 0; \
	33	typeof(*(ptr)) __pu_val = (x); \
	34	switch (sizeof (*(ptr))) { \
	35	case 1: \
	36	__put_user_asm(__pu_err, __pu_val, ptr, b); \
	37	break; \
	38	case 2: \
	39	__put_user_asm(__pu_err, __pu_val, ptr, w); \
	40	break; \
	41	case 4: \
	42	__put_user_asm(__pu_err, __pu_val, ptr, l); \
	43	break; \
	44	case 8: \
	45	memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
	46	break; \
	47	default: \
	48	__pu_err = __put_user_bad(); \
	49	break; \
	50	} \
	51	__pu_err; \
	52	})
	53	#define __put_user(x, ptr) put_user(x, ptr)
	54
	55	extern int __put_user_bad(void);
	56
	57	/*
	58	* Tell gcc we read from memory instead of writing: this is because
	59	* we do not write to any memory gcc knows about, so there are no
	60	* aliasing issues.
	61	*/
	62
	63	#define __ptr(x) ((unsigned long *)(x))
	64
	65	#define __put_user_asm(err,x,ptr,bwl) \
	66	__asm__ ("move" #bwl " %0,%1" \
	67	: /* no outputs */ \
	68	:"d" (x),"m" (*__ptr(ptr)) : "memory")
	69
	70	#define get_user(x, ptr) \
	71	({ \
	72	int __gu_err = 0; \
1b0f06d0	73	typeof(x) __gu_val = 0; \
1da177e4 LT	74	switch (sizeof(*(ptr))) { \
	75	case 1: \
	76	__get_user_asm(__gu_err, __gu_val, ptr, b, "=d"); \
	77	break; \
	78	case 2: \
	79	__get_user_asm(__gu_err, __gu_val, ptr, w, "=r"); \
	80	break; \
	81	case 4: \
	82	__get_user_asm(__gu_err, __gu_val, ptr, l, "=r"); \
	83	break; \
	84	case 8: \
1b0f06d0	85	memcpy((void ) &__gu_val, ptr, sizeof ((ptr))); \
1da177e4 LT	86	break; \
	87	default: \
	88	__gu_val = 0; \
	89	__gu_err = __get_user_bad(); \
	90	break; \
	91	} \
1b0f06d0	92	(x) = (typeof(*(ptr))) __gu_val; \
1da177e4 LT	93	__gu_err; \
	94	})
	95	#define __get_user(x, ptr) get_user(x, ptr)
	96
	97	extern int __get_user_bad(void);
	98
1b0f06d0 GU	99	#define __get_user_asm(err,x,ptr,bwl,reg) \
	100	__asm__ ("move" #bwl " %1,%0" \
	101	: "=d" (x) \
1da177e4 LT	102	: "m" (*__ptr(ptr)))
1da177e4 LT	103
29be02eb AV	104	static inline unsigned long
	105	raw_copy_from_user(void to, const void __user from, unsigned long n)
	106	{
	107	memcpy(to, (__force const void *)from, n);
	108	return 0;
	109	}
1da177e4	110
29be02eb AV	111	static inline unsigned long
	112	raw_copy_to_user(void __user to, const void from, unsigned long n)
	113	{
	114	memcpy((__force void *)to, from, n);
	115	return 0;
	116	}
	117	#define INLINE_COPY_FROM_USER
	118	#define INLINE_COPY_TO_USER
1da177e4	119
1da177e4 LT	120	/*
	121	* Copy a null terminated string from userspace.
	122	*/
	123
	124	static inline long
	125	strncpy_from_user(char dst, const char src, long count)
	126	{
	127	char *tmp;
	128	strncpy(dst, src, count);
	129	for (tmp = dst; *tmp && count > 0; tmp++, count--)
	130	;
	131	return(tmp - dst); /* DAVIDM should we count a NUL ? check getname */
	132	}
	133
	134	/*
	135	* Return the size of a string (including the ending 0)
	136	*
	137	* Return 0 on exception, a value greater than N if too long
	138	*/
	139	static inline long strnlen_user(const char *src, long n)
	140	{
	141	return(strlen(src) + 1); /* DAVIDM make safer */
	142	}
	143
1da177e4 LT	144	/*
	145	* Zero Userspace
	146	*/
	147
	148	static inline unsigned long
fa2eae93	149	__clear_user(void *to, unsigned long n)
1da177e4 LT	150	{
	151	memset(to, 0, n);
	152	return 0;
	153	}
	154
fa2eae93 MW	155	#define clear_user(to,n) __clear_user(to,n)
fa2eae93 MW	156
1da177e4	157	#endif /* _M68KNOMMU_UACCESS_H */