arch/s390/include/asm/uaccess.h - linux - Git at Google

 /* SPDX-License-Identifier: GPL-2.0 */
 /*
  *  S390 version
  *    Copyright IBM Corp. 1999, 2000
  *    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 <asm/asm-extable.h>
 #include <asm/processor.h>
 #include <asm/ctl_reg.h>
 #include <asm/extable.h>
 #include <asm/facility.h>
 #include <asm-generic/access_ok.h>

 void debug_user_asce(int exit);

 unsigned long __must_check
 raw_copy_from_user(void *to, const void __user *from, unsigned long n);

 unsigned long __must_check
 raw_copy_to_user(void __user *to, const void *from, unsigned long n);

 #ifndef CONFIG_KASAN
 #define INLINE_COPY_FROM_USER
 #define INLINE_COPY_TO_USER
 #endif

 unsigned long __must_check
 _copy_from_user_key(void *to, const void __user *from, unsigned long n, unsigned long key);

 static __always_inline unsigned long __must_check
 copy_from_user_key(void *to, const void __user *from, unsigned long n, unsigned long key)
 {
 	if (check_copy_size(to, n, false))
 		n = _copy_from_user_key(to, from, n, key);
 	return n;
 }

 unsigned long __must_check
 _copy_to_user_key(void __user *to, const void *from, unsigned long n, unsigned long key);

 static __always_inline unsigned long __must_check
 copy_to_user_key(void __user *to, const void *from, unsigned long n, unsigned long key)
 {
 	if (check_copy_size(from, n, true))
 		n = _copy_to_user_key(to, from, n, key);
 	return n;
 }

 union oac {
 	unsigned int val;
 	struct {
 		struct {
 			unsigned short key : 4;
 			unsigned short	   : 4;
 			unsigned short as  : 2;
 			unsigned short	   : 4;
 			unsigned short k   : 1;
 			unsigned short a   : 1;
 		} oac1;
 		struct {
 			unsigned short key : 4;
 			unsigned short	   : 4;
 			unsigned short as  : 2;
 			unsigned short	   : 4;
 			unsigned short k   : 1;
 			unsigned short a   : 1;
 		} oac2;
 	};
 };

 int __noreturn __put_user_bad(void);

 #define __put_user_asm(to, from, size)					\
 ({									\
 	union oac __oac_spec = {					\
 		.oac1.as = PSW_BITS_AS_SECONDARY,			\
 		.oac1.a = 1,						\
 	};								\
 	int __rc;							\
 									\
 	asm volatile(							\
 		"	lr	0,%[spec]\n"				\
 		"0:	mvcos	%[_to],%[_from],%[_size]\n"		\
 		"1:	xr	%[rc],%[rc]\n"				\
 		"2:\n"							\
 		EX_TABLE_UA_STORE(0b, 2b, %[rc])			\
 		EX_TABLE_UA_STORE(1b, 2b, %[rc])			\
 		: [rc] "=&d" (__rc), [_to] "+Q" (*(to))			\
 		: [_size] "d" (size), [_from] "Q" (*(from)),		\
 		  [spec] "d" (__oac_spec.val)				\
 		: "cc", "0");						\
 	__rc;								\
 })

 static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned long size)
 {
 	int rc;

 	switch (size) {
 	case 1:
 		rc = __put_user_asm((unsigned char __user *)ptr,
 				    (unsigned char *)x,
 				    size);
 		break;
 	case 2:
 		rc = __put_user_asm((unsigned short __user *)ptr,
 				    (unsigned short *)x,
 				    size);
 		break;
 	case 4:
 		rc = __put_user_asm((unsigned int __user *)ptr,
 				    (unsigned int *)x,
 				    size);
 		break;
 	case 8:
 		rc = __put_user_asm((unsigned long __user *)ptr,
 				    (unsigned long *)x,
 				    size);
 		break;
 	default:
 		__put_user_bad();
 		break;
 	}
 	return rc;
 }

 int __noreturn __get_user_bad(void);

 #define __get_user_asm(to, from, size)					\
 ({									\
 	union oac __oac_spec = {					\
 		.oac2.as = PSW_BITS_AS_SECONDARY,			\
 		.oac2.a = 1,						\
 	};								\
 	int __rc;							\
 									\
 	asm volatile(							\
 		"	lr	0,%[spec]\n"				\
 		"0:	mvcos	0(%[_to]),%[_from],%[_size]\n"		\
 		"1:	xr	%[rc],%[rc]\n"				\
 		"2:\n"							\
 		EX_TABLE_UA_LOAD_MEM(0b, 2b, %[rc], %[_to], %[_ksize])	\
 		EX_TABLE_UA_LOAD_MEM(1b, 2b, %[rc], %[_to], %[_ksize])	\
 		: [rc] "=&d" (__rc), "=Q" (*(to))			\
 		: [_size] "d" (size), [_from] "Q" (*(from)),		\
 		  [spec] "d" (__oac_spec.val), [_to] "a" (to),		\
 		  [_ksize] "K" (size)					\
 		: "cc", "0");						\
 	__rc;								\
 })

 static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size)
 {
 	int rc;

 	switch (size) {
 	case 1:
 		rc = __get_user_asm((unsigned char *)x,
 				    (unsigned char __user *)ptr,
 				    size);
 		break;
 	case 2:
 		rc = __get_user_asm((unsigned short *)x,
 				    (unsigned short __user *)ptr,
 				    size);
 		break;
 	case 4:
 		rc = __get_user_asm((unsigned int *)x,
 				    (unsigned int __user *)ptr,
 				    size);
 		break;
 	case 8:
 		rc = __get_user_asm((unsigned long *)x,
 				    (unsigned long __user *)ptr,
 				    size);
 		break;
 	default:
 		__get_user_bad();
 		break;
 	}
 	return rc;
 }

 /*
  * 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);					\
 	int __pu_err = -EFAULT;						\
 									\
 	__chk_user_ptr(ptr);						\
 	switch (sizeof(*(ptr))) {					\
 	case 1:								\
 	case 2:								\
 	case 4:								\
 	case 8:								\
 		__pu_err = __put_user_fn(&__x, ptr, sizeof(*(ptr)));	\
 		break;							\
 	default:							\
 		__put_user_bad();					\
 		break;							\
 	}								\
 	__builtin_expect(__pu_err, 0);					\
 })

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

 #define __get_user(x, ptr)						\
 ({									\
 	int __gu_err = -EFAULT;						\
 									\
 	__chk_user_ptr(ptr);						\
 	switch (sizeof(*(ptr))) {					\
 	case 1: {							\
 		unsigned char __x;					\
 									\
 		__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));	\
 		(x) = *(__force __typeof__(*(ptr)) *)&__x;		\
 		break;							\
 	};								\
 	case 2: {							\
 		unsigned short __x;					\
 									\
 		__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));	\
 		(x) = *(__force __typeof__(*(ptr)) *)&__x;		\
 		break;							\
 	};								\
 	case 4: {							\
 		unsigned int __x;					\
 									\
 		__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));	\
 		(x) = *(__force __typeof__(*(ptr)) *)&__x;		\
 		break;							\
 	};								\
 	case 8: {							\
 		unsigned long __x;					\
 									\
 		__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));	\
 		(x) = *(__force __typeof__(*(ptr)) *)&__x;		\
 		break;							\
 	};								\
 	default:							\
 		__get_user_bad();					\
 		break;							\
 	}								\
 	__builtin_expect(__gu_err, 0);					\
 })

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

 /*
  * Copy a null terminated string from userspace.
  */
 long __must_check strncpy_from_user(char *dst, const char __user *src, long count);

 long __must_check strnlen_user(const char __user *src, long count);

 /*
  * Zero Userspace
  */
 unsigned long __must_check __clear_user(void __user *to, unsigned long size);

 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
 {
 	might_fault();
 	return __clear_user(to, n);
 }

 void *s390_kernel_write(void *dst, const void *src, size_t size);

 int __noreturn __put_kernel_bad(void);

 #define __put_kernel_asm(val, to, insn)					\
 ({									\
 	int __rc;							\
 									\
 	asm volatile(							\
 		"0:   " insn "  %[_val],%[_to]\n"			\
 		"1:	xr	%[rc],%[rc]\n"				\
 		"2:\n"							\
 		EX_TABLE_UA_STORE(0b, 2b, %[rc])			\
 		EX_TABLE_UA_STORE(1b, 2b, %[rc])			\
 		: [rc] "=d" (__rc), [_to] "+Q" (*(to))			\
 		: [_val] "d" (val)					\
 		: "cc");						\
 	__rc;								\
 })

 #define __put_kernel_nofault(dst, src, type, err_label)			\
 do {									\
 	unsigned long __x = (unsigned long)(*((type *)(src)));		\
 	int __pk_err;							\
 									\
 	switch (sizeof(type)) {						\
 	case 1:								\
 		__pk_err = __put_kernel_asm(__x, (type *)(dst), "stc"); \
 		break;							\
 	case 2:								\
 		__pk_err = __put_kernel_asm(__x, (type *)(dst), "sth"); \
 		break;							\
 	case 4:								\
 		__pk_err = __put_kernel_asm(__x, (type *)(dst), "st");	\
 		break;							\
 	case 8:								\
 		__pk_err = __put_kernel_asm(__x, (type *)(dst), "stg"); \
 		break;							\
 	default:							\
 		__pk_err = __put_kernel_bad();				\
 		break;							\
 	}								\
 	if (unlikely(__pk_err))						\
 		goto err_label;						\
 } while (0)

 int __noreturn __get_kernel_bad(void);

 #define __get_kernel_asm(val, from, insn)				\
 ({									\
 	int __rc;							\
 									\
 	asm volatile(							\
 		"0:   " insn "  %[_val],%[_from]\n"			\
 		"1:	xr	%[rc],%[rc]\n"				\
 		"2:\n"							\
 		EX_TABLE_UA_LOAD_REG(0b, 2b, %[rc], %[_val])		\
 		EX_TABLE_UA_LOAD_REG(1b, 2b, %[rc], %[_val])		\
 		: [rc] "=d" (__rc), [_val] "=d" (val)			\
 		: [_from] "Q" (*(from))					\
 		: "cc");						\
 	__rc;								\
 })

 #define __get_kernel_nofault(dst, src, type, err_label)			\
 do {									\
 	int __gk_err;							\
 									\
 	switch (sizeof(type)) {						\
 	case 1: {							\
 		unsigned char __x;					\
 									\
 		__gk_err = __get_kernel_asm(__x, (type *)(src), "ic");	\
 		*((type *)(dst)) = (type)__x;				\
 		break;							\
 	};								\
 	case 2: {							\
 		unsigned short __x;					\
 									\
 		__gk_err = __get_kernel_asm(__x, (type *)(src), "lh");	\
 		*((type *)(dst)) = (type)__x;				\
 		break;							\
 	};								\
 	case 4: {							\
 		unsigned int __x;					\
 									\
 		__gk_err = __get_kernel_asm(__x, (type *)(src), "l");	\
 		*((type *)(dst)) = (type)__x;				\
 		break;							\
 	};								\
 	case 8: {							\
 		unsigned long __x;					\
 									\
 		__gk_err = __get_kernel_asm(__x, (type *)(src), "lg");	\
 		*((type *)(dst)) = (type)__x;				\
 		break;							\
 	};								\
 	default:							\
 		__gk_err = __get_kernel_bad();				\
 		break;							\
 	}								\
 	if (unlikely(__gk_err))						\
 		goto err_label;						\
 } while (0)

 #endif /* __S390_UACCESS_H */
	/* SPDX-License-Identifier: GPL-2.0 */
	/*
	* S390 version
	* Copyright IBM Corp. 1999, 2000
	* 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 <asm/asm-extable.h>
	#include <asm/processor.h>
	#include <asm/ctl_reg.h>
	#include <asm/extable.h>
	#include <asm/facility.h>
	#include <asm-generic/access_ok.h>

	void debug_user_asce(int exit);

	unsigned long __must_check
	raw_copy_from_user(void to, const void __user from, unsigned long n);

	unsigned long __must_check
	raw_copy_to_user(void __user to, const void from, unsigned long n);

	#ifndef CONFIG_KASAN
	#define INLINE_COPY_FROM_USER
	#define INLINE_COPY_TO_USER
	#endif

	unsigned long __must_check
	_copy_from_user_key(void to, const void __user from, unsigned long n, unsigned long key);

	static __always_inline unsigned long __must_check
	copy_from_user_key(void to, const void __user from, unsigned long n, unsigned long key)
	{
	if (check_copy_size(to, n, false))
	n = _copy_from_user_key(to, from, n, key);
	return n;
	}

	unsigned long __must_check
	_copy_to_user_key(void __user to, const void from, unsigned long n, unsigned long key);

	static __always_inline unsigned long __must_check
	copy_to_user_key(void __user to, const void from, unsigned long n, unsigned long key)
	{
	if (check_copy_size(from, n, true))
	n = _copy_to_user_key(to, from, n, key);
	return n;
	}

	union oac {
	unsigned int val;
	struct {
	struct {
	unsigned short key : 4;
	unsigned short : 4;
	unsigned short as : 2;
	unsigned short : 4;
	unsigned short k : 1;
	unsigned short a : 1;
	} oac1;
	struct {
	unsigned short key : 4;
	unsigned short : 4;
	unsigned short as : 2;
	unsigned short : 4;
	unsigned short k : 1;
	unsigned short a : 1;
	} oac2;
	};
	};

	int __noreturn __put_user_bad(void);

	#define __put_user_asm(to, from, size) \
	({ \
	union oac __oac_spec = { \
	.oac1.as = PSW_BITS_AS_SECONDARY, \
	.oac1.a = 1, \
	}; \
	int __rc; \
	\
	asm volatile( \
	" lr 0,%[spec]\n" \
	"0: mvcos %[_to],%[_from],%[_size]\n" \
	"1: xr %[rc],%[rc]\n" \
	"2:\n" \
	EX_TABLE_UA_STORE(0b, 2b, %[rc]) \
	EX_TABLE_UA_STORE(1b, 2b, %[rc]) \
	: [rc] "=&d" (__rc), [_to] "+Q" (*(to)) \
	: [_size] "d" (size), [_from] "Q" (*(from)), \
	[spec] "d" (__oac_spec.val) \
	: "cc", "0"); \
	__rc; \
	})

	static __always_inline int __put_user_fn(void x, void __user ptr, unsigned long size)
	{
	int rc;

	switch (size) {
	case 1:
	rc = __put_user_asm((unsigned char __user *)ptr,
	(unsigned char *)x,
	size);
	break;
	case 2:
	rc = __put_user_asm((unsigned short __user *)ptr,
	(unsigned short *)x,
	size);
	break;
	case 4:
	rc = __put_user_asm((unsigned int __user *)ptr,
	(unsigned int *)x,
	size);
	break;
	case 8:
	rc = __put_user_asm((unsigned long __user *)ptr,
	(unsigned long *)x,
	size);
	break;
	default:
	__put_user_bad();
	break;
	}
	return rc;
	}

	int __noreturn __get_user_bad(void);

	#define __get_user_asm(to, from, size) \
	({ \
	union oac __oac_spec = { \
	.oac2.as = PSW_BITS_AS_SECONDARY, \
	.oac2.a = 1, \
	}; \
	int __rc; \
	\
	asm volatile( \
	" lr 0,%[spec]\n" \
	"0: mvcos 0(%[_to]),%[_from],%[_size]\n" \
	"1: xr %[rc],%[rc]\n" \
	"2:\n" \
	EX_TABLE_UA_LOAD_MEM(0b, 2b, %[rc], %[_to], %[_ksize]) \
	EX_TABLE_UA_LOAD_MEM(1b, 2b, %[rc], %[_to], %[_ksize]) \
	: [rc] "=&d" (__rc), "=Q" (*(to)) \
	: [_size] "d" (size), [_from] "Q" (*(from)), \
	[spec] "d" (__oac_spec.val), [_to] "a" (to), \
	[_ksize] "K" (size) \
	: "cc", "0"); \
	__rc; \
	})

	static __always_inline int __get_user_fn(void x, const void __user ptr, unsigned long size)
	{
	int rc;

	switch (size) {
	case 1:
	rc = __get_user_asm((unsigned char *)x,
	(unsigned char __user *)ptr,
	size);
	break;
	case 2:
	rc = __get_user_asm((unsigned short *)x,
	(unsigned short __user *)ptr,
	size);
	break;
	case 4:
	rc = __get_user_asm((unsigned int *)x,
	(unsigned int __user *)ptr,
	size);
	break;
	case 8:
	rc = __get_user_asm((unsigned long *)x,
	(unsigned long __user *)ptr,
	size);
	break;
	default:
	__get_user_bad();
	break;
	}
	return rc;
	}

	/*
	* 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); \
	int __pu_err = -EFAULT; \
	\
	__chk_user_ptr(ptr); \
	switch (sizeof(*(ptr))) { \
	case 1: \
	case 2: \
	case 4: \
	case 8: \
	__pu_err = __put_user_fn(&__x, ptr, sizeof(*(ptr))); \
	break; \
	default: \
	__put_user_bad(); \
	break; \
	} \
	__builtin_expect(__pu_err, 0); \
	})

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

	#define __get_user(x, ptr) \
	({ \
	int __gu_err = -EFAULT; \
	\
	__chk_user_ptr(ptr); \
	switch (sizeof(*(ptr))) { \
	case 1: { \
	unsigned char __x; \
	\
	__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \
	(x) = (__force __typeof__((ptr)) *)&__x; \
	break; \
	}; \
	case 2: { \
	unsigned short __x; \
	\
	__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \
	(x) = (__force __typeof__((ptr)) *)&__x; \
	break; \
	}; \
	case 4: { \
	unsigned int __x; \
	\
	__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \
	(x) = (__force __typeof__((ptr)) *)&__x; \
	break; \
	}; \
	case 8: { \
	unsigned long __x; \
	\
	__gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \
	(x) = (__force __typeof__((ptr)) *)&__x; \
	break; \
	}; \
	default: \
	__get_user_bad(); \
	break; \
	} \
	__builtin_expect(__gu_err, 0); \
	})

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

	/*
	* Copy a null terminated string from userspace.
	*/
	long __must_check strncpy_from_user(char dst, const char __user src, long count);

	long __must_check strnlen_user(const char __user *src, long count);

	/*
	* Zero Userspace
	*/
	unsigned long __must_check __clear_user(void __user *to, unsigned long size);

	static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
	{
	might_fault();
	return __clear_user(to, n);
	}

	void s390_kernel_write(void dst, const void *src, size_t size);

	int __noreturn __put_kernel_bad(void);

	#define __put_kernel_asm(val, to, insn) \
	({ \
	int __rc; \
	\
	asm volatile( \
	"0: " insn " %[_val],%[_to]\n" \
	"1: xr %[rc],%[rc]\n" \
	"2:\n" \
	EX_TABLE_UA_STORE(0b, 2b, %[rc]) \
	EX_TABLE_UA_STORE(1b, 2b, %[rc]) \
	: [rc] "=d" (__rc), [_to] "+Q" (*(to)) \
	: [_val] "d" (val) \
	: "cc"); \
	__rc; \
	})

	#define __put_kernel_nofault(dst, src, type, err_label) \
	do { \
	unsigned long __x = (unsigned long)(((type )(src))); \
	int __pk_err; \
	\
	switch (sizeof(type)) { \
	case 1: \
	__pk_err = __put_kernel_asm(__x, (type *)(dst), "stc"); \
	break; \
	case 2: \
	__pk_err = __put_kernel_asm(__x, (type *)(dst), "sth"); \
	break; \
	case 4: \
	__pk_err = __put_kernel_asm(__x, (type *)(dst), "st"); \
	break; \
	case 8: \
	__pk_err = __put_kernel_asm(__x, (type *)(dst), "stg"); \
	break; \
	default: \
	__pk_err = __put_kernel_bad(); \
	break; \
	} \
	if (unlikely(__pk_err)) \
	goto err_label; \
	} while (0)

	int __noreturn __get_kernel_bad(void);

	#define __get_kernel_asm(val, from, insn) \
	({ \
	int __rc; \
	\
	asm volatile( \
	"0: " insn " %[_val],%[_from]\n" \
	"1: xr %[rc],%[rc]\n" \
	"2:\n" \
	EX_TABLE_UA_LOAD_REG(0b, 2b, %[rc], %[_val]) \
	EX_TABLE_UA_LOAD_REG(1b, 2b, %[rc], %[_val]) \
	: [rc] "=d" (__rc), [_val] "=d" (val) \
	: [_from] "Q" (*(from)) \
	: "cc"); \
	__rc; \
	})

	#define __get_kernel_nofault(dst, src, type, err_label) \
	do { \
	int __gk_err; \
	\
	switch (sizeof(type)) { \
	case 1: { \
	unsigned char __x; \
	\
	__gk_err = __get_kernel_asm(__x, (type *)(src), "ic"); \
	((type )(dst)) = (type)__x; \
	break; \
	}; \
	case 2: { \
	unsigned short __x; \
	\
	__gk_err = __get_kernel_asm(__x, (type *)(src), "lh"); \
	((type )(dst)) = (type)__x; \
	break; \
	}; \
	case 4: { \
	unsigned int __x; \
	\
	__gk_err = __get_kernel_asm(__x, (type *)(src), "l"); \
	((type )(dst)) = (type)__x; \
	break; \
	}; \
	case 8: { \
	unsigned long __x; \
	\
	__gk_err = __get_kernel_asm(__x, (type *)(src), "lg"); \
	((type )(dst)) = (type)__x; \
	break; \
	}; \
	default: \
	__gk_err = __get_kernel_bad(); \
	break; \
	} \
	if (unlikely(__gk_err)) \
	goto err_label; \
	} while (0)

	#endif /* __S390_UACCESS_H */