LoongArch: Add system call support (be769645) · Commits · EulixOS / Software / Kernel

arch/loongarch/include/asm/seccomp.h

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */

		#ifndef _ASM_SECCOMP_H
		#define _ASM_SECCOMP_H

		#include <asm/unistd.h>

		#include <asm-generic/seccomp.h>

		#ifdef CONFIG_32BIT
		# define SECCOMP_ARCH_NATIVE AUDIT_ARCH_LOONGARCH32
		# define SECCOMP_ARCH_NATIVE_NR NR_syscalls
		# define SECCOMP_ARCH_NATIVE_NAME "loongarch32"
		#else
		# define SECCOMP_ARCH_NATIVE AUDIT_ARCH_LOONGARCH64
		# define SECCOMP_ARCH_NATIVE_NR NR_syscalls
		# define SECCOMP_ARCH_NATIVE_NAME "loongarch64"
		#endif

		#endif /* _ASM_SECCOMP_H */

arch/loongarch/include/asm/syscall.h

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0+ */
		/*
		* Author: Hanlu Li <lihanlu@loongson.cn>
		* Huacai Chen <chenhuacai@loongson.cn>
		*
		* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
		*/

		#ifndef __ASM_LOONGARCH_SYSCALL_H
		#define __ASM_LOONGARCH_SYSCALL_H

		#include <linux/compiler.h>
		#include <uapi/linux/audit.h>
		#include <linux/elf-em.h>
		#include <linux/kernel.h>
		#include <linux/sched.h>
		#include <linux/uaccess.h>
		#include <asm/ptrace.h>
		#include <asm/unistd.h>

		extern void *sys_call_table[];

		static inline long syscall_get_nr(struct task_struct *task,
		struct pt_regs *regs)
		{
		return regs->regs[11];
		}

		static inline void syscall_rollback(struct task_struct *task,
		struct pt_regs *regs)
		{
		regs->regs[4] = regs->orig_a0;
		}

		static inline long syscall_get_error(struct task_struct *task,
		struct pt_regs *regs)
		{
		unsigned long error = regs->regs[4];

		return IS_ERR_VALUE(error) ? error : 0;
		}

		static inline long syscall_get_return_value(struct task_struct *task,
		struct pt_regs *regs)
		{
		return regs->regs[4];
		}

		static inline void syscall_set_return_value(struct task_struct *task,
		struct pt_regs *regs,
		int error, long val)
		{
		regs->regs[4] = (long) error ? error : val;
		}

		static inline void syscall_get_arguments(struct task_struct *task,
		struct pt_regs *regs,
		unsigned long *args)
		{
		args[0] = regs->orig_a0;
		memcpy(&args[1], &regs->regs[5], 5 * sizeof(long));
		}

		static inline int syscall_get_arch(struct task_struct *task)
		{
		return AUDIT_ARCH_LOONGARCH64;
		}

		static inline bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs)
		{
		return false;
		}

		#endif /* __ASM_LOONGARCH_SYSCALL_H */

arch/loongarch/include/asm/uaccess.h

0 → 100644

+269 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
		*
		* Derived from MIPS:
		* Copyright (C) 1996, 1997, 1998, 1999, 2000, 03, 04 by Ralf Baechle
		* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
		* Copyright (C) 2007 Maciej W. Rozycki
		* Copyright (C) 2014, Imagination Technologies Ltd.
		*/
		#ifndef _ASM_UACCESS_H
		#define _ASM_UACCESS_H

		#include <linux/kernel.h>
		#include <linux/string.h>
		#include <linux/extable.h>
		#include <asm/pgtable.h>
		#include <asm-generic/extable.h>
		#include <asm-generic/access_ok.h>

		extern u64 __ua_limit;

		#define __UA_ADDR ".dword"
		#define __UA_LA "la.abs"
		#define __UA_LIMIT __ua_limit

		/*
		* get_user: - Get a simple variable from user space.
		* @x: Variable to store result.
		* @ptr: Source address, in user space.
		*
		* Context: User context only. This function may sleep if pagefaults are
		* enabled.
		*
		* This macro copies a single simple variable from user space to kernel
		* space. It supports simple types like char and int, but not larger
		* data types like structures or arrays.
		*
		* @ptr must have pointer-to-simple-variable type, and the result of
		* dereferencing @ptr must be assignable to @x without a cast.
		*
		* Returns zero on success, or -EFAULT on error.
		* On error, the variable @x is set to zero.
		*/
		#define get_user(x, ptr) \
		({ \
		const __typeof__((ptr)) __user __p = (ptr); \
		\
		might_fault(); \
		access_ok(__p, sizeof(*__p)) ? __get_user((x), __p) : \
		((x) = 0, -EFAULT); \
		})

		/*
		* put_user: - Write a simple value into user space.
		* @x: Value to copy to user space.
		* @ptr: Destination address, in user space.
		*
		* Context: User context only. This function may sleep if pagefaults are
		* enabled.
		*
		* This macro copies a single simple value from kernel space to user
		* space. It supports simple types like char and int, but not larger
		* data types like structures or arrays.
		*
		* @ptr must have pointer-to-simple-variable type, and @x must be assignable
		* to the result of dereferencing @ptr.
		*
		* Returns zero on success, or -EFAULT on error.
		*/
		#define put_user(x, ptr) \
		({ \
		__typeof__((ptr)) __user __p = (ptr); \
		\
		might_fault(); \
		access_ok(__p, sizeof(*__p)) ? __put_user((x), __p) : -EFAULT; \
		})

		/*
		* __get_user: - Get a simple variable from user space, with less checking.
		* @x: Variable to store result.
		* @ptr: Source address, in user space.
		*
		* Context: User context only. This function may sleep if pagefaults are
		* enabled.
		*
		* This macro copies a single simple variable from user space to kernel
		* space. It supports simple types like char and int, but not larger
		* data types like structures or arrays.
		*
		* @ptr must have pointer-to-simple-variable type, and the result of
		* dereferencing @ptr must be assignable to @x without a cast.
		*
		* Caller must check the pointer with access_ok() before calling this
		* function.
		*
		* Returns zero on success, or -EFAULT on error.
		* On error, the variable @x is set to zero.
		*/
		#define __get_user(x, ptr) \
		({ \
		int __gu_err = 0; \
		\
		__chk_user_ptr(ptr); \
		__get_user_common((x), sizeof(*(ptr)), ptr); \
		__gu_err; \
		})

		/*
		* __put_user: - Write a simple value into user space, with less checking.
		* @x: Value to copy to user space.
		* @ptr: Destination address, in user space.
		*
		* Context: User context only. This function may sleep if pagefaults are
		* enabled.
		*
		* This macro copies a single simple value from kernel space to user
		* space. It supports simple types like char and int, but not larger
		* data types like structures or arrays.
		*
		* @ptr must have pointer-to-simple-variable type, and @x must be assignable
		* to the result of dereferencing @ptr.
		*
		* Caller must check the pointer with access_ok() before calling this
		* function.
		*
		* Returns zero on success, or -EFAULT on error.
		*/
		#define __put_user(x, ptr) \
		({ \
		int __pu_err = 0; \
		__typeof__(*(ptr)) __pu_val; \
		\
		__pu_val = (x); \
		__chk_user_ptr(ptr); \
		__put_user_common(ptr, sizeof(*(ptr))); \
		__pu_err; \
		})

		struct __large_struct { unsigned long buf[100]; };
		#define __m(x) ((struct __large_struct __user )(x))

		#define __get_user_common(val, size, ptr) \
		do { \
		switch (size) { \
		case 1: __get_data_asm(val, "ld.b", ptr); break; \
		case 2: __get_data_asm(val, "ld.h", ptr); break; \
		case 4: __get_data_asm(val, "ld.w", ptr); break; \
		case 8: __get_data_asm(val, "ld.d", ptr); break; \
		default: BUILD_BUG(); break; \
		} \
		} while (0)

		#define __get_kernel_common(val, size, ptr) __get_user_common(val, size, ptr)

		#define __get_data_asm(val, insn, ptr) \
		{ \
		long __gu_tmp; \
		\
		__asm__ __volatile__( \
		"1: " insn " %1, %2 \n" \
		"2: \n" \
		" .section .fixup,\"ax\" \n" \
		"3: li.w %0, %3 \n" \
		" or %1, $r0, $r0 \n" \
		" b 2b \n" \
		" .previous \n" \
		" .section __ex_table,\"a\" \n" \
		" "__UA_ADDR "\t1b, 3b \n" \
		" .previous \n" \
		: "+r" (__gu_err), "=r" (__gu_tmp) \
		: "m" (__m(ptr)), "i" (-EFAULT)); \
		\
		(val) = (__typeof__(*(ptr))) __gu_tmp; \
		}

		#define __put_user_common(ptr, size) \
		do { \
		switch (size) { \
		case 1: __put_data_asm("st.b", ptr); break; \
		case 2: __put_data_asm("st.h", ptr); break; \
		case 4: __put_data_asm("st.w", ptr); break; \
		case 8: __put_data_asm("st.d", ptr); break; \
		default: BUILD_BUG(); break; \
		} \
		} while (0)

		#define __put_kernel_common(ptr, size) __put_user_common(ptr, size)

		#define __put_data_asm(insn, ptr) \
		{ \
		__asm__ __volatile__( \
		"1: " insn " %z2, %1 # __put_user_asm\n" \
		"2: \n" \
		" .section .fixup,\"ax\" \n" \
		"3: li.w %0, %3 \n" \
		" b 2b \n" \
		" .previous \n" \
		" .section __ex_table,\"a\" \n" \
		" " __UA_ADDR " 1b, 3b \n" \
		" .previous \n" \
		: "+r" (__pu_err), "=m" (__m(ptr)) \
		: "Jr" (__pu_val), "i" (-EFAULT)); \
		}

		#define __get_kernel_nofault(dst, src, type, err_label) \
		do { \
		int __gu_err = 0; \
		\
		__get_kernel_common(((type )(dst)), sizeof(type), \
		(__force type *)(src)); \
		if (unlikely(__gu_err)) \
		goto err_label; \
		} while (0)

		#define __put_kernel_nofault(dst, src, type, err_label) \
		do { \
		type __pu_val; \
		int __pu_err = 0; \
		\
		__pu_val = (__force type )(src); \
		__put_kernel_common(((type *)(dst)), sizeof(type)); \
		if (unlikely(__pu_err)) \
		goto err_label; \
		} while (0)

		extern unsigned long __copy_user(void to, const void from, __kernel_size_t n);

		static inline unsigned long __must_check
		raw_copy_from_user(void to, const void __user from, unsigned long n)
		{
		return __copy_user(to, from, n);
		}

		static inline unsigned long __must_check
		raw_copy_to_user(void __user to, const void from, unsigned long n)
		{
		return __copy_user(to, from, n);
		}

		#define INLINE_COPY_FROM_USER
		#define INLINE_COPY_TO_USER

		/*
		* __clear_user: - Zero a block of memory in user space, with less checking.
		* @addr: Destination address, in user space.
		* @size: Number of bytes to zero.
		*
		* Zero a block of memory in user space. Caller must check
		* the specified block with access_ok() before calling this function.
		*
		* Returns number of bytes that could not be cleared.
		* On success, this will be zero.
		*/
		extern unsigned long __clear_user(void __user *addr, __kernel_size_t size);

		#define clear_user(addr, n) \
		({ \
		void __user *__cl_addr = (addr); \
		unsigned long __cl_size = (n); \
		if (__cl_size && access_ok(__cl_addr, __cl_size)) \
		__cl_size = __clear_user(__cl_addr, __cl_size); \
		__cl_size; \
		})

		extern long strncpy_from_user(char to, const char __user from, long n);
		extern long strnlen_user(const char __user *str, long n);

		#endif /* _ASM_UACCESS_H */

arch/loongarch/include/asm/unistd.h

0 → 100644

+11 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0+ */
		/*
		* Author: Hanlu Li <lihanlu@loongson.cn>
		* Huacai Chen <chenhuacai@loongson.cn>
		*
		* Copyright (C) 2020-2022 Loongson Technology Corporation Limited
		*/

		#include <uapi/asm/unistd.h>

		#define NR_syscalls (__NR_syscalls)

arch/loongarch/include/uapi/asm/unistd.h

0 → 100644

+5 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
		#define __ARCH_WANT_SYS_CLONE
		#define __ARCH_WANT_SYS_CLONE3

		#include <asm-generic/unistd.h>