FM / asm

/usr/src/linux-headers-5.15.0-181/arch/arm/include/asm/

/usr/src/linux-headers-5.15.0-181/arch/arm/include/asm

Name	Size	Mode	Actions
hardware/	-	0755	rm
mach/	-	0755	rm
vdso/	-	0755	rm
xen/	-	0755	rm
archrandom.h	192	0644	edit dl rm
arch_gicv3.h	6327	0644	edit dl rm
arch_timer.h	3124	0644	edit dl rm
arm-cci.h	535	0644	edit dl rm
asm-offsets.h	35	0644	edit dl rm
assembler.h	13106	0644	edit dl rm
atomic.h	12536	0644	edit dl rm
auxvec.h	29	0644	edit dl rm
barrier.h	2910	0644	edit dl rm
bitops.h	7627	0644	edit dl rm
bitrev.h	451	0644	edit dl rm
bL_switcher.h	2186	0644	edit dl rm
bug.h	2620	0644	edit dl rm
bugs.h	297	0644	edit dl rm
cache.h	794	0644	edit dl rm
cacheflush.h	15794	0644	edit dl rm
cachetype.h	2779	0644	edit dl rm
checksum.h	4026	0644	edit dl rm
clocksource.h	161	0644	edit dl rm
cmpxchg.h	6328	0644	edit dl rm
compiler.h	978	0644	edit dl rm
cp15.h	3302	0644	edit dl rm
cpu.h	387	0644	edit dl rm
cpufeature.h	1291	0644	edit dl rm
cpuidle.h	1628	0644	edit dl rm
cputype.h	8766	0644	edit dl rm
cti.h	3703	0644	edit dl rm
dcc.h	623	0644	edit dl rm
delay.h	2903	0644	edit dl rm
device.h	636	0644	edit dl rm
div64.h	2640	0644	edit dl rm
dma-direct.h	1341	0644	edit dl rm
dma-iommu.h	908	0644	edit dl rm
dma-mapping.h	4714	0644	edit dl rm
dma.h	4287	0644	edit dl rm
dmi.h	378	0644	edit dl rm
domain.h	3751	0644	edit dl rm
ecard.h	6119	0644	edit dl rm
edac.h	995	0644	edit dl rm
efi.h	2501	0644	edit dl rm
elf.h	4636	0644	edit dl rm
entry-macro-multi.S	336	0644	edit dl rm
exception.h	416	0644	edit dl rm
fb.h	375	0644	edit dl rm
fiq.h	1391	0644	edit dl rm
firmware.h	1728	0644	edit dl rm
fixmap.h	1881	0644	edit dl rm
floppy.h	2318	0644	edit dl rm
fncpy.h	2552	0644	edit dl rm
fpstate.h	1478	0644	edit dl rm
ftrace.h	1821	0644	edit dl rm
futex.h	4357	0644	edit dl rm
glue-cache.h	3515	0644	edit dl rm
glue-df.h	2110	0644	edit dl rm
glue-pf.h	1005	0644	edit dl rm
glue-proc.h	4424	0644	edit dl rm
glue.h	613	0644	edit dl rm
gpio.h	615	0644	edit dl rm
hardirq.h	246	0644	edit dl rm
highmem.h	2379	0644	edit dl rm
hugetlb-3level.h	690	0644	edit dl rm
hugetlb.h	513	0644	edit dl rm
hwcap.h	378	0644	edit dl rm
hw_breakpoint.h	3811	0644	edit dl rm
hw_irq.h	349	0644	edit dl rm
hypervisor.h	224	0644	edit dl rm
ide.h	566	0644	edit dl rm
idmap.h	359	0644	edit dl rm
insn.h	636	0644	edit dl rm
io.h	15027	0644	edit dl rm
irq.h	887	0644	edit dl rm
irqflags.h	3969	0644	edit dl rm
irq_work.h	234	0644	edit dl rm
jump_label.h	1009	0644	edit dl rm
kasan.h	708	0644	edit dl rm
kasan_def.h	2726	0644	edit dl rm
Kbuild	186	0644	edit dl rm
kexec-internal.h	272	0644	edit dl rm
kexec.h	2255	0644	edit dl rm
kgdb.h	2783	0644	edit dl rm
kprobes.h	2248	0644	edit dl rm
krait-l2-accessors.h	231	0644	edit dl rm
linkage.h	216	0644	edit dl rm
mc146818rtc.h	720	0644	edit dl rm
mcpm.h	12061	0644	edit dl rm
mcs_spinlock.h	570	0644	edit dl rm
memblock.h	248	0644	edit dl rm
memory.h	10945	0644	edit dl rm
mmu.h	953	0644	edit dl rm
mmu_context.h	3461	0644	edit dl rm
module.h	1216	0644	edit dl rm
module.lds.h	134	0644	edit dl rm
mpu.h	3300	0644	edit dl rm
mtd-xip.h	520	0644	edit dl rm
neon.h	1041	0644	edit dl rm
nwflash.h	195	0644	edit dl rm
opcodes-sec.h	350	0644	edit dl rm
opcodes-virt.h	684	0644	edit dl rm
opcodes.h	8118	0644	edit dl rm
outercache.h	3268	0644	edit dl rm
page-nommu.h	811	0644	edit dl rm
page.h	3448	0644	edit dl rm
paravirt.h	477	0644	edit dl rm
patch.h	438	0644	edit dl rm
pci.h	794	0644	edit dl rm
percpu.h	1069	0644	edit dl rm
perf_event.h	708	0644	edit dl rm
pgalloc.h	3373	0644	edit dl rm
pgtable-2level-hwdef.h	3385	0644	edit dl rm
pgtable-2level-types.h	1278	0644	edit dl rm
pgtable-2level.h	8645	0644	edit dl rm
pgtable-3level-hwdef.h	3435	0644	edit dl rm
pgtable-3level-types.h	1331	0644	edit dl rm
pgtable-3level.h	8148	0644	edit dl rm
pgtable-hwdef.h	321	0644	edit dl rm
pgtable-nommu.h	1979	0644	edit dl rm
pgtable.h	10492	0644	edit dl rm
probes.h	1332	0644	edit dl rm
proc-fns.h	4754	0644	edit dl rm
processor.h	3166	0644	edit dl rm
procinfo.h	1152	0644	edit dl rm
prom.h	552	0644	edit dl rm
psci.h	379	0644	edit dl rm
ptdump.h	923	0644	edit dl rm
ptrace.h	4841	0644	edit dl rm
seccomp.h	281	0644	edit dl rm
sections.h	622	0644	edit dl rm
secure_cntvoff.h	152	0644	edit dl rm
setup.h	773	0644	edit dl rm
set_memory.h	720	0644	edit dl rm
shmparam.h	419	0644	edit dl rm
signal.h	559	0644	edit dl rm
smp.h	2839	0644	edit dl rm
smp_plat.h	2535	0644	edit dl rm
smp_scu.h	1352	0644	edit dl rm
smp_twd.h	590	0644	edit dl rm
sparsemem.h	716	0644	edit dl rm
spectre.h	906	0644	edit dl rm
spinlock.h	5645	0644	edit dl rm
spinlock_types.h	541	0644	edit dl rm
stackprotector.h	1357	0644	edit dl rm
stacktrace.h	742	0644	edit dl rm
string.h	2165	0644	edit dl rm
suspend.h	369	0644	edit dl rm
swab.h	1005	0644	edit dl rm
switch_to.h	1058	0644	edit dl rm
sync_bitops.h	1514	0644	edit dl rm
syscall.h	2347	0644	edit dl rm
system_info.h	763	0644	edit dl rm
system_misc.h	1005	0644	edit dl rm
tcm.h	925	0644	edit dl rm
therm.h	655	0644	edit dl rm
thread_info.h	4974	0644	edit dl rm
thread_notify.h	1086	0644	edit dl rm
timex.h	431	0644	edit dl rm
tlb.h	1442	0644	edit dl rm
tlbflush.h	17909	0644	edit dl rm
tls.h	3166	0644	edit dl rm
topology.h	1139	0644	edit dl rm
traps.h	911	0644	edit dl rm
uaccess-asm.h	2703	0644	edit dl rm
uaccess.h	17431	0644	edit dl rm
ucontext.h	2745	0644	edit dl rm
unified.h	979	0644	edit dl rm
unistd.h	1578	0644	edit dl rm
unwind.h	1173	0644	edit dl rm
uprobes.h	948	0644	edit dl rm
user.h	4302	0644	edit dl rm
v7m.h	3233	0644	edit dl rm
vdso.h	507	0644	edit dl rm
vdso_datapage.h	444	0644	edit dl rm
vermagic.h	800	0644	edit dl rm
vfp.h	2969	0644	edit dl rm
vfpmacros.h	2074	0644	edit dl rm
vga.h	305	0644	edit dl rm
virt.h	1855	0644	edit dl rm
vmalloc.h	87	0644	edit dl rm
vmlinux.lds.h	4490	0644	edit dl rm
word-at-a-time.h	2128	0644	edit dl rm
xor.h	5204	0644	edit dl rm

Edit: /usr/src/linux-headers-5.15.0-181/arch/arm/include/asm/uaccess.h (17431B)

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 *  arch/arm/include/asm/uaccess.h
 */
#ifndef _ASMARM_UACCESS_H
#define _ASMARM_UACCESS_H

/*
 * User space memory access functions
 */
#include <linux/string.h>
#include <asm/memory.h>
#include <asm/domain.h>
#include <asm/unaligned.h>
#include <asm/unified.h>
#include <asm/compiler.h>

#include <asm/extable.h>

/*
 * These two functions allow hooking accesses to userspace to increase
 * system integrity by ensuring that the kernel can not inadvertantly
 * perform such accesses (eg, via list poison values) which could then
 * be exploited for priviledge escalation.
 */
static __always_inline unsigned int uaccess_save_and_enable(void)
{
#ifdef CONFIG_CPU_SW_DOMAIN_PAN
	unsigned int old_domain = get_domain();

/* Set the current domain access to permit user accesses */
	set_domain((old_domain & ~domain_mask(DOMAIN_USER)) |
		   domain_val(DOMAIN_USER, DOMAIN_CLIENT));

return old_domain;
#else
	return 0;
#endif
}

static __always_inline void uaccess_restore(unsigned int flags)
{
#ifdef CONFIG_CPU_SW_DOMAIN_PAN
	/* Restore the user access mask */
	set_domain(flags);
#endif
}

/*
 * These two are intentionally not defined anywhere - if the kernel
 * code generates any references to them, that's a bug.
 */
extern int __get_user_bad(void);
extern int __put_user_bad(void);

#ifdef CONFIG_MMU

/*
 * We use 33-bit arithmetic here.  Success returns zero, failure returns
 * addr_limit.  We take advantage that addr_limit will be zero for KERNEL_DS,
 * so this will always return success in that case.
 */
#define __range_ok(addr, size) ({ \
	unsigned long flag, roksum; \
	__chk_user_ptr(addr);	\
	__asm__(".syntax unified\n" \
		"adds %1, %2, %3; sbcscc %1, %1, %0; movcc %0, #0" \
		: "=&r" (flag), "=&r" (roksum) \
		: "r" (addr), "Ir" (size), "0" (TASK_SIZE) \
		: "cc"); \
	flag; })

/*
 * This is a type: either unsigned long, if the argument fits into
 * that type, or otherwise unsigned long long.
 */
#define __inttype(x) \
	__typeof__(__builtin_choose_expr(sizeof(x) > sizeof(0UL), 0ULL, 0UL))

/*
 * Sanitise a uaccess pointer such that it becomes NULL if addr+size
 * is above the current addr_limit.
 */
#define uaccess_mask_range_ptr(ptr, size)			\
	((__typeof__(ptr))__uaccess_mask_range_ptr(ptr, size))
static inline void __user *__uaccess_mask_range_ptr(const void __user *ptr,
						    size_t size)
{
	void __user *safe_ptr = (void __user *)ptr;
	unsigned long tmp;

asm volatile(
	"	.syntax unified\n"
	"	sub	%1, %3, #1\n"
	"	subs	%1, %1, %0\n"
	"	addhs	%1, %1, #1\n"
	"	subshs	%1, %1, %2\n"
	"	movlo	%0, #0\n"
	: "+r" (safe_ptr), "=&r" (tmp)
	: "r" (size), "r" (TASK_SIZE)
	: "cc");

csdb();
	return safe_ptr;
}

/*
 * Single-value transfer routines.  They automatically use the right
 * size if we just have the right pointer type.  Note that the functions
 * which read from user space (*get_*) need to take care not to leak
 * kernel data even if the calling code is buggy and fails to check
 * the return value.  This means zeroing out the destination variable
 * or buffer on error.  Normally this is done out of line by the
 * fixup code, but there are a few places where it intrudes on the
 * main code path.  When we only write to user space, there is no
 * problem.
 */
extern int __get_user_1(void *);
extern int __get_user_2(void *);
extern int __get_user_4(void *);
extern int __get_user_32t_8(void *);
extern int __get_user_8(void *);
extern int __get_user_64t_1(void *);
extern int __get_user_64t_2(void *);
extern int __get_user_64t_4(void *);

#define __get_user_x(__r2, __p, __e, __l, __s)				\
	   __asm__ __volatile__ (					\
		__asmeq("%0", "r0") __asmeq("%1", "r2")			\
		__asmeq("%3", "r1")					\
		"bl	__get_user_" #__s				\
		: "=&r" (__e), "=r" (__r2)				\
		: "0" (__p), "r" (__l)					\
		: "ip", "lr", "cc")

/* narrowing a double-word get into a single 32bit word register: */
#ifdef __ARMEB__
#define __get_user_x_32t(__r2, __p, __e, __l, __s)			\
	__get_user_x(__r2, __p, __e, __l, 32t_8)
#else
#define __get_user_x_32t __get_user_x
#endif

/*
 * storing result into proper least significant word of 64bit target var,
 * different only for big endian case where 64 bit __r2 lsw is r3:
 */
#ifdef __ARMEB__
#define __get_user_x_64t(__r2, __p, __e, __l, __s)		        \
	   __asm__ __volatile__ (					\
		__asmeq("%0", "r0") __asmeq("%1", "r2")			\
		__asmeq("%3", "r1")					\
		"bl	__get_user_64t_" #__s				\
		: "=&r" (__e), "=r" (__r2)				\
		: "0" (__p), "r" (__l)					\
		: "ip", "lr", "cc")
#else
#define __get_user_x_64t __get_user_x
#endif

#define __get_user_check(x, p)						\
	({								\
		unsigned long __limit = TASK_SIZE - 1; \
		register typeof(*(p)) __user *__p asm("r0") = (p);	\
		register __inttype(x) __r2 asm("r2");			\
		register unsigned long __l asm("r1") = __limit;		\
		register int __e asm("r0");				\
		unsigned int __ua_flags = uaccess_save_and_enable();	\
		int __tmp_e;						\
		switch (sizeof(*(__p))) {				\
		case 1:							\
			if (sizeof((x)) >= 8)				\
				__get_user_x_64t(__r2, __p, __e, __l, 1); \
			else						\
				__get_user_x(__r2, __p, __e, __l, 1);	\
			break;						\
		case 2:							\
			if (sizeof((x)) >= 8)				\
				__get_user_x_64t(__r2, __p, __e, __l, 2); \
			else						\
				__get_user_x(__r2, __p, __e, __l, 2);	\
			break;						\
		case 4:							\
			if (sizeof((x)) >= 8)				\
				__get_user_x_64t(__r2, __p, __e, __l, 4); \
			else						\
				__get_user_x(__r2, __p, __e, __l, 4);	\
			break;						\
		case 8:							\
			if (sizeof((x)) < 8)				\
				__get_user_x_32t(__r2, __p, __e, __l, 4); \
			else						\
				__get_user_x(__r2, __p, __e, __l, 8);	\
			break;						\
		default: __e = __get_user_bad(); break;			\
		}							\
		__tmp_e = __e;						\
		uaccess_restore(__ua_flags);				\
		x = (typeof(*(p))) __r2;				\
		__tmp_e;						\
	})

#define get_user(x, p)							\
	({								\
		might_fault();						\
		__get_user_check(x, p);					\
	 })

extern int __put_user_1(void *, unsigned int);
extern int __put_user_2(void *, unsigned int);
extern int __put_user_4(void *, unsigned int);
extern int __put_user_8(void *, unsigned long long);

#define __put_user_check(__pu_val, __ptr, __err, __s)			\
	({								\
		unsigned long __limit = TASK_SIZE - 1; \
		register typeof(__pu_val) __r2 asm("r2") = __pu_val;	\
		register const void __user *__p asm("r0") = __ptr;	\
		register unsigned long __l asm("r1") = __limit;		\
		register int __e asm("r0");				\
		__asm__ __volatile__ (					\
			__asmeq("%0", "r0") __asmeq("%2", "r2")		\
			__asmeq("%3", "r1")				\
			"bl	__put_user_" #__s			\
			: "=&r" (__e)					\
			: "0" (__p), "r" (__r2), "r" (__l)		\
			: "ip", "lr", "cc");				\
		__err = __e;						\
	})

#else /* CONFIG_MMU */

#define __addr_ok(addr)		((void)(addr), 1)
#define __range_ok(addr, size)	((void)(addr), 0)

#define get_user(x, p)	__get_user(x, p)
#define __put_user_check __put_user_nocheck

#endif /* CONFIG_MMU */

#define access_ok(addr, size)	(__range_ok(addr, size) == 0)

#ifdef CONFIG_CPU_SPECTRE
/*
 * When mitigating Spectre variant 1, it is not worth fixing the non-
 * verifying accessors, because we need to add verification of the
 * address space there.  Force these to use the standard get_user()
 * version instead.
 */
#define __get_user(x, ptr) get_user(x, ptr)
#else

/*
 * The "__xxx" versions of the user access functions do not verify the
 * address space - it must have been done previously with a separate
 * "access_ok()" call.
 *
 * The "xxx_error" versions set the third argument to EFAULT if an
 * error occurs, and leave it unchanged on success.  Note that these
 * versions are void (ie, don't return a value as such).
 */
#define __get_user(x, ptr)						\
({									\
	long __gu_err = 0;						\
	__get_user_err((x), (ptr), __gu_err, TUSER());			\
	__gu_err;							\
})

#define __get_user_err(x, ptr, err, __t)				\
do {									\
	unsigned long __gu_addr = (unsigned long)(ptr);			\
	unsigned long __gu_val;						\
	unsigned int __ua_flags;					\
	__chk_user_ptr(ptr);						\
	might_fault();							\
	__ua_flags = uaccess_save_and_enable();				\
	switch (sizeof(*(ptr))) {					\
	case 1:	__get_user_asm_byte(__gu_val, __gu_addr, err, __t); break;	\
	case 2:	__get_user_asm_half(__gu_val, __gu_addr, err, __t); break;	\
	case 4:	__get_user_asm_word(__gu_val, __gu_addr, err, __t); break;	\
	default: (__gu_val) = __get_user_bad();				\
	}								\
	uaccess_restore(__ua_flags);					\
	(x) = (__typeof__(*(ptr)))__gu_val;				\
} while (0)
#endif

#define __get_user_asm(x, addr, err, instr)			\
	__asm__ __volatile__(					\
	"1:	" instr " %1, [%2], #0\n"			\
	"2:\n"							\
	"	.pushsection .text.fixup,\"ax\"\n"		\
	"	.align	2\n"					\
	"3:	mov	%0, %3\n"				\
	"	mov	%1, #0\n"				\
	"	b	2b\n"					\
	"	.popsection\n"					\
	"	.pushsection __ex_table,\"a\"\n"		\
	"	.align	3\n"					\
	"	.long	1b, 3b\n"				\
	"	.popsection"					\
	: "+r" (err), "=&r" (x)					\
	: "r" (addr), "i" (-EFAULT)				\
	: "cc")

#define __get_user_asm_byte(x, addr, err, __t)			\
	__get_user_asm(x, addr, err, "ldrb" __t)

#if __LINUX_ARM_ARCH__ >= 6

#define __get_user_asm_half(x, addr, err, __t)			\
	__get_user_asm(x, addr, err, "ldrh" __t)

#else

#ifndef __ARMEB__
#define __get_user_asm_half(x, __gu_addr, err, __t)		\
({								\
	unsigned long __b1, __b2;				\
	__get_user_asm_byte(__b1, __gu_addr, err, __t);		\
	__get_user_asm_byte(__b2, __gu_addr + 1, err, __t);	\
	(x) = __b1 | (__b2 << 8);				\
})
#else
#define __get_user_asm_half(x, __gu_addr, err, __t)		\
({								\
	unsigned long __b1, __b2;				\
	__get_user_asm_byte(__b1, __gu_addr, err, __t);		\
	__get_user_asm_byte(__b2, __gu_addr + 1, err, __t);	\
	(x) = (__b1 << 8) | __b2;				\
})
#endif

#endif /* __LINUX_ARM_ARCH__ >= 6 */

#define __get_user_asm_word(x, addr, err, __t)			\
	__get_user_asm(x, addr, err, "ldr" __t)

#define __put_user_switch(x, ptr, __err, __fn)				\
	do {								\
		const __typeof__(*(ptr)) __user *__pu_ptr = (ptr);	\
		__typeof__(*(ptr)) __pu_val = (x);			\
		unsigned int __ua_flags;				\
		might_fault();						\
		__ua_flags = uaccess_save_and_enable();			\
		switch (sizeof(*(ptr))) {				\
		case 1: __fn(__pu_val, __pu_ptr, __err, 1); break;	\
		case 2:	__fn(__pu_val, __pu_ptr, __err, 2); break;	\
		case 4:	__fn(__pu_val, __pu_ptr, __err, 4); break;	\
		case 8:	__fn(__pu_val, __pu_ptr, __err, 8); break;	\
		default: __err = __put_user_bad(); break;		\
		}							\
		uaccess_restore(__ua_flags);				\
	} while (0)

#define put_user(x, ptr)						\
({									\
	int __pu_err = 0;						\
	__put_user_switch((x), (ptr), __pu_err, __put_user_check);	\
	__pu_err;							\
})

#ifdef CONFIG_CPU_SPECTRE
/*
 * When mitigating Spectre variant 1.1, all accessors need to include
 * verification of the address space.
 */
#define __put_user(x, ptr) put_user(x, ptr)

#else
#define __put_user(x, ptr)						\
({									\
	long __pu_err = 0;						\
	__put_user_switch((x), (ptr), __pu_err, __put_user_nocheck);	\
	__pu_err;							\
})

#define __put_user_nocheck(x, __pu_ptr, __err, __size)			\
	do {								\
		unsigned long __pu_addr = (unsigned long)__pu_ptr;	\
		__put_user_nocheck_##__size(x, __pu_addr, __err, TUSER());\
	} while (0)

#define __put_user_nocheck_1 __put_user_asm_byte
#define __put_user_nocheck_2 __put_user_asm_half
#define __put_user_nocheck_4 __put_user_asm_word
#define __put_user_nocheck_8 __put_user_asm_dword

#endif /* !CONFIG_CPU_SPECTRE */

#define __put_user_asm(x, __pu_addr, err, instr)		\
	__asm__ __volatile__(					\
	"1:	" instr " %1, [%2], #0\n"		\
	"2:\n"							\
	"	.pushsection .text.fixup,\"ax\"\n"		\
	"	.align	2\n"					\
	"3:	mov	%0, %3\n"				\
	"	b	2b\n"					\
	"	.popsection\n"					\
	"	.pushsection __ex_table,\"a\"\n"		\
	"	.align	3\n"					\
	"	.long	1b, 3b\n"				\
	"	.popsection"					\
	: "+r" (err)						\
	: "r" (x), "r" (__pu_addr), "i" (-EFAULT)		\
	: "cc")

#define __put_user_asm_byte(x, __pu_addr, err, __t)		\
	__put_user_asm(x, __pu_addr, err, "strb" __t)

#if __LINUX_ARM_ARCH__ >= 6

#define __put_user_asm_half(x, __pu_addr, err, __t)		\
	__put_user_asm(x, __pu_addr, err, "strh" __t)

#else

#ifndef __ARMEB__
#define __put_user_asm_half(x, __pu_addr, err, __t)		\
({								\
	unsigned long __temp = (__force unsigned long)(x);	\
	__put_user_asm_byte(__temp, __pu_addr, err, __t);	\
	__put_user_asm_byte(__temp >> 8, __pu_addr + 1, err, __t);\
})
#else
#define __put_user_asm_half(x, __pu_addr, err, __t)		\
({								\
	unsigned long __temp = (__force unsigned long)(x);	\
	__put_user_asm_byte(__temp >> 8, __pu_addr, err, __t);	\
	__put_user_asm_byte(__temp, __pu_addr + 1, err, __t);	\
})
#endif

#endif /* __LINUX_ARM_ARCH__ >= 6 */

#define __put_user_asm_word(x, __pu_addr, err, __t)		\
	__put_user_asm(x, __pu_addr, err, "str" __t)

#ifndef __ARMEB__
#define	__reg_oper0	"%R2"
#define	__reg_oper1	"%Q2"
#else
#define	__reg_oper0	"%Q2"
#define	__reg_oper1	"%R2"
#endif

#define __put_user_asm_dword(x, __pu_addr, err, __t)		\
	__asm__ __volatile__(					\
 ARM(	"1:	str" __t "	" __reg_oper1 ", [%1], #4\n"  ) \
 ARM(	"2:	str" __t "	" __reg_oper0 ", [%1]\n"      ) \
 THUMB(	"1:	str" __t "	" __reg_oper1 ", [%1]\n"      ) \
 THUMB(	"2:	str" __t "	" __reg_oper0 ", [%1, #4]\n"  ) \
	"3:\n"							\
	"	.pushsection .text.fixup,\"ax\"\n"		\
	"	.align	2\n"					\
	"4:	mov	%0, %3\n"				\
	"	b	3b\n"					\
	"	.popsection\n"					\
	"	.pushsection __ex_table,\"a\"\n"		\
	"	.align	3\n"					\
	"	.long	1b, 4b\n"				\
	"	.long	2b, 4b\n"				\
	"	.popsection"					\
	: "+r" (err), "+r" (__pu_addr)				\
	: "r" (x), "i" (-EFAULT)				\
	: "cc")

#define HAVE_GET_KERNEL_NOFAULT

#define __get_kernel_nofault(dst, src, type, err_label)			\
do {									\
	const type *__pk_ptr = (src);					\
	unsigned long __src = (unsigned long)(__pk_ptr);		\
	type __val;							\
	int __err = 0;							\
	switch (sizeof(type)) {						\
	case 1:	__get_user_asm_byte(__val, __src, __err, ""); break;	\
	case 2: __get_user_asm_half(__val, __src, __err, ""); break;	\
	case 4: __get_user_asm_word(__val, __src, __err, ""); break;	\
	case 8: {							\
		u32 *__v32 = (u32*)&__val;				\
		__get_user_asm_word(__v32[0], __src, __err, "");	\
		if (__err)						\
			break;						\
		__get_user_asm_word(__v32[1], __src+4, __err, "");	\
		break;							\
	}								\
	default: __err = __get_user_bad(); break;			\
	}								\
	if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))		\
		put_unaligned(__val, (type *)(dst));			\
	else								\
		*(type *)(dst) = __val; /* aligned by caller */		\
	if (__err)							\
		goto err_label;						\
} while (0)

#define __put_kernel_nofault(dst, src, type, err_label)			\
do {									\
	const type *__pk_ptr = (dst);					\
	unsigned long __dst = (unsigned long)__pk_ptr;			\
	int __err = 0;							\
	type __val = IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)	\
		     ? get_unaligned((type *)(src))			\
		     : *(type *)(src);	/* aligned by caller */		\
	switch (sizeof(type)) {						\
	case 1: __put_user_asm_byte(__val, __dst, __err, ""); break;	\
	case 2:	__put_user_asm_half(__val, __dst, __err, ""); break;	\
	case 4:	__put_user_asm_word(__val, __dst, __err, ""); break;	\
	case 8:	__put_user_asm_dword(__val, __dst, __err, ""); break;	\
	default: __err = __put_user_bad(); break;			\
	}								\
	if (__err)							\
		goto err_label;						\
} while (0)

#ifdef CONFIG_MMU
extern unsigned long __must_check
arm_copy_from_user(void *to, const void __user *from, unsigned long n);

static inline unsigned long __must_check
raw_copy_from_user(void *to, const void __user *from, unsigned long n)
{
	unsigned int __ua_flags;

__ua_flags = uaccess_save_and_enable();
	n = arm_copy_from_user(to, from, n);
	uaccess_restore(__ua_flags);
	return n;
}

extern unsigned long __must_check
arm_copy_to_user(void __user *to, const void *from, unsigned long n);
extern unsigned long __must_check
__copy_to_user_std(void __user *to, const void *from, unsigned long n);

static inline unsigned long __must_check
raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
#ifndef CONFIG_UACCESS_WITH_MEMCPY
	unsigned int __ua_flags;
	__ua_flags = uaccess_save_and_enable();
	n = arm_copy_to_user(to, from, n);
	uaccess_restore(__ua_flags);
	return n;
#else
	return arm_copy_to_user(to, from, n);
#endif
}

extern unsigned long __must_check
arm_clear_user(void __user *addr, unsigned long n);
extern unsigned long __must_check
__clear_user_std(void __user *addr, unsigned long n);

static inline unsigned long __must_check
__clear_user(void __user *addr, unsigned long n)
{
	unsigned int __ua_flags = uaccess_save_and_enable();
	n = arm_clear_user(addr, n);
	uaccess_restore(__ua_flags);
	return n;
}

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

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

/* These are from lib/ code, and use __get_user() and friends */
extern long strncpy_from_user(char *dest, const char __user *src, long count);

extern __must_check long strnlen_user(const char __user *str, long n);

#endif /* _ASMARM_UACCESS_H */

cmd: