FM / asm

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

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

Name	Size	Mode	Actions
assembler.h	598	0644	edit dl rm
barrier.h	431	0644	edit dl rm
bitfield.h	47127	0644	edit dl rm
cache.h	276	0644	edit dl rm
cacheflush.h	1986	0644	edit dl rm
cache_info.h	315	0644	edit dl rm
current.h	304	0644	edit dl rm
delay.h	938	0644	edit dl rm
elf.h	6021	0644	edit dl rm
fixmap.h	831	0644	edit dl rm
fpu.h	3195	0644	edit dl rm
fpuemu.h	1272	0644	edit dl rm
ftrace.h	1161	0644	edit dl rm
futex.h	2483	0644	edit dl rm
highmem.h	1624	0644	edit dl rm
io.h	2474	0644	edit dl rm
irqflags.h	848	0644	edit dl rm
Kbuild	194	0644	edit dl rm
l2_cache.h	4791	0644	edit dl rm
linkage.h	264	0644	edit dl rm
memory.h	2713	0644	edit dl rm
mmu.h	213	0644	edit dl rm
mmu_context.h	1409	0644	edit dl rm
nds32.h	2018	0644	edit dl rm
nds32_fpu_inst.h	2510	0644	edit dl rm
page.h	1591	0644	edit dl rm
perf_event.h	445	0644	edit dl rm
pgalloc.h	1419	0644	edit dl rm
pgtable.h	11676	0644	edit dl rm
pmu.h	13350	0644	edit dl rm
proc-fns.h	1668	0644	edit dl rm
processor.h	2405	0644	edit dl rm
ptrace.h	1686	0644	edit dl rm
sfp-machine.h	4463	0644	edit dl rm
shmparam.h	462	0644	edit dl rm
stacktrace.h	884	0644	edit dl rm
string.h	471	0644	edit dl rm
suspend.h	258	0644	edit dl rm
swab.h	810	0644	edit dl rm
syscall.h	5496	0644	edit dl rm
syscalls.h	510	0644	edit dl rm
thread_info.h	2390	0644	edit dl rm
tlb.h	249	0644	edit dl rm
tlbflush.h	1144	0644	edit dl rm
uaccess.h	8272	0644	edit dl rm
unistd.h	156	0644	edit dl rm
vdso.h	429	0644	edit dl rm
vdso_datapage.h	1104	0644	edit dl rm
vdso_timer_info.h	357	0644	edit dl rm
vermagic.h	214	0644	edit dl rm
vmalloc.h	93	0644	edit dl rm

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

/* SPDX-License-Identifier: GPL-2.0 */
// Copyright (C) 2005-2017 Andes Technology Corporation

#ifndef _ASMANDES_UACCESS_H
#define _ASMANDES_UACCESS_H

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

#define __asmeq(x, y)  ".ifnc " x "," y " ; .err ; .endif\n\t"

/*
 * 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;
};

extern int fixup_exception(struct pt_regs *regs);

#define KERNEL_DS 	((mm_segment_t) { ~0UL })
#define USER_DS		((mm_segment_t) {TASK_SIZE - 1})

#define get_fs()	(current_thread_info()->addr_limit)
#define user_addr_max	get_fs

static inline void set_fs(mm_segment_t fs)
{
	current_thread_info()->addr_limit = fs;
}

#define uaccess_kernel()	(get_fs() == KERNEL_DS)

#define __range_ok(addr, size) (size <= get_fs() && addr <= (get_fs() -size))

#define access_ok(addr, size)	\
	__range_ok((unsigned long)addr, (unsigned long)size)
/*
 * 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.
 *
 * 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_check((x), (ptr), __gu_err);				\
	__gu_err;							\
})

#define __get_user_error(x, ptr, err)					\
({									\
	__get_user_check((x), (ptr), (err));				\
	(void)0;							\
})

#define __get_user(x, ptr)						\
({									\
	long __gu_err = 0;						\
	const __typeof__(*(ptr)) __user *__p = (ptr);			\
	__get_user_err((x), __p, (__gu_err));				\
	__gu_err;							\
})

#define __get_user_check(x, ptr, err)					\
({									\
	const __typeof__(*(ptr)) __user *__p = (ptr);			\
	might_fault();							\
	if (access_ok(__p, sizeof(*__p))) {		\
		__get_user_err((x), __p, (err));			\
	} else {							\
		(x) = 0; (err) = -EFAULT;				\
	}								\
})

#define __get_user_err(x, ptr, err)					\
do {									\
	unsigned long __gu_val;						\
	__chk_user_ptr(ptr);						\
	switch (sizeof(*(ptr))) {					\
	case 1:								\
		__get_user_asm("lbi", __gu_val, (ptr), (err));		\
		break;							\
	case 2:								\
		__get_user_asm("lhi", __gu_val, (ptr), (err));		\
		break;							\
	case 4:								\
		__get_user_asm("lwi", __gu_val, (ptr), (err));		\
		break;							\
	case 8:								\
		__get_user_asm_dword(__gu_val, (ptr), (err));		\
		break;							\
	default:							\
		BUILD_BUG(); 						\
		break;							\
	}								\
	(x) = (__force __typeof__(*(ptr)))__gu_val;			\
} while (0)

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

#ifdef __NDS32_EB__
#define __gu_reg_oper0 "%H1"
#define __gu_reg_oper1 "%L1"
#else
#define __gu_reg_oper0 "%L1"
#define __gu_reg_oper1 "%H1"
#endif

#define __get_user_asm_dword(x, addr, err) 				\
	__asm__ __volatile__ (						\
		"\n1:\tlwi " __gu_reg_oper0 ",[%2]\n"			\
		"\n2:\tlwi " __gu_reg_oper1 ",[%2+4]\n"			\
		"3:\n"							\
		"	.section .fixup,\"ax\"\n"			\
		"	.align	2\n"					\
		"4:	move	%0, %3\n"				\
		"	b	3b\n"					\
		"	.previous\n"					\
		"	.section __ex_table,\"a\"\n"			\
		"	.align	3\n"					\
		"	.long	1b, 4b\n"				\
		"	.long	2b, 4b\n"				\
		"	.previous"					\
		: "+r"(err), "=&r"(x)					\
		: "r"(addr), "i"(-EFAULT)				\
		: "cc")

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

#define __put_user(x, ptr)						\
({									\
	long __pu_err = 0;						\
	__typeof__(*(ptr)) __user *__p = (ptr);				\
	__put_user_err((x), __p, __pu_err);				\
	__pu_err;							\
})

#define __put_user_error(x, ptr, err)					\
({									\
	__put_user_err((x), (ptr), (err));				\
	(void)0;							\
})

#define __put_user_check(x, ptr, err)					\
({									\
	__typeof__(*(ptr)) __user *__p = (ptr);				\
	might_fault();							\
	if (access_ok(__p, sizeof(*__p))) {		\
		__put_user_err((x), __p, (err));			\
	} else	{							\
		(err) = -EFAULT;					\
	}								\
})

#define __put_user_err(x, ptr, err)					\
do {									\
	__typeof__(*(ptr)) __pu_val = (x);				\
	__chk_user_ptr(ptr);						\
	switch (sizeof(*(ptr))) {					\
	case 1:								\
		__put_user_asm("sbi", __pu_val, (ptr), (err));		\
		break;							\
	case 2: 							\
		__put_user_asm("shi", __pu_val, (ptr), (err));		\
		break;							\
	case 4: 							\
		__put_user_asm("swi", __pu_val, (ptr), (err));		\
		break;							\
	case 8:								\
		__put_user_asm_dword(__pu_val, (ptr), (err));		\
		break;							\
	default:							\
		BUILD_BUG(); 						\
		break;							\
	}								\
} while (0)

#define __put_user_asm(inst, x, addr, err)				\
	__asm__ __volatile__ (						\
		"1:	"inst"	%1,[%2]\n"				\
		"2:\n"							\
		"	.section .fixup,\"ax\"\n"			\
		"	.align	2\n"					\
		"3:	move	%0, %3\n"				\
		"	b	2b\n"					\
		"	.previous\n"					\
		"	.section __ex_table,\"a\"\n"			\
		"	.align	3\n"					\
		"	.long	1b, 3b\n"				\
		"	.previous"					\
		: "+r" (err)						\
		: "r" (x), "r" (addr), "i" (-EFAULT)			\
		: "cc")

#ifdef __NDS32_EB__
#define __pu_reg_oper0 "%H2"
#define __pu_reg_oper1 "%L2"
#else
#define __pu_reg_oper0 "%L2"
#define __pu_reg_oper1 "%H2"
#endif

#define __put_user_asm_dword(x, addr, err) 				\
	__asm__ __volatile__ (						\
		"\n1:\tswi " __pu_reg_oper0 ",[%1]\n"			\
		"\n2:\tswi " __pu_reg_oper1 ",[%1+4]\n"			\
		"3:\n"							\
		"	.section .fixup,\"ax\"\n"			\
		"	.align	2\n"					\
		"4:	move	%0, %3\n"				\
		"	b	3b\n"					\
		"	.previous\n"					\
		"	.section __ex_table,\"a\"\n"			\
		"	.align	3\n"					\
		"	.long	1b, 4b\n"				\
		"	.long	2b, 4b\n"				\
		"	.previous"					\
		: "+r"(err)						\
		: "r"(addr), "r"(x), "i"(-EFAULT)			\
		: "cc")

extern unsigned long __arch_clear_user(void __user * addr, unsigned long n);
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);
extern unsigned long __arch_copy_from_user(void *to, const void __user * from,
                                           unsigned long n);
extern unsigned long __arch_copy_to_user(void __user * to, const void *from,
                                         unsigned long n);

#define raw_copy_from_user __arch_copy_from_user
#define raw_copy_to_user __arch_copy_to_user

#define INLINE_COPY_FROM_USER
#define INLINE_COPY_TO_USER
static inline unsigned long clear_user(void __user * to, unsigned long n)
{
	if (access_ok(to, n))
		n = __arch_clear_user(to, n);
	return n;
}

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

#endif /* _ASMNDS32_UACCESS_H */

cmd: