csky: System Call

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __ASM_SYSCALL_H

#define __ASM_SYSCALL_H

#include <linux/sched.h>

#include <linux/err.h>

#include <abi/regdef.h>

static inline int

syscall_get_nr(struct task_struct *task, struct pt_regs *regs)

{

	return regs_syscallid(regs);

}

static inline void

syscall_rollback(struct task_struct *task, struct pt_regs *regs)

{

	regs->a0 = regs->orig_a0;

}

static inline long

syscall_get_error(struct task_struct *task, struct pt_regs *regs)

{

	unsigned long error = regs->a0;

	return IS_ERR_VALUE(error) ? error : 0;

}

static inline long

syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)

{

	return regs->a0;

}

static inline void

syscall_set_return_value(struct task_struct *task, struct pt_regs *regs,

		int error, long val)

{

	regs->a0 = (long) error ?: val;

}

static inline void

syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,

		      unsigned int i, unsigned int n, unsigned long *args)

{

	BUG_ON(i + n > 6);

	if (i == 0) {

		args[0] = regs->orig_a0;

		args++;

		i++;

		n--;

	}

	memcpy(args, &regs->a1 + i * sizeof(regs->a1), n * sizeof(args[0]));

}

static inline void

syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,

		      unsigned int i, unsigned int n, const unsigned long *args)

{

	BUG_ON(i + n > 6);

	if (i == 0) {

		regs->orig_a0 = args[0];

		args++;

		i++;

		n--;

	}

	memcpy(&regs->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0));

}

#endif	/* __ASM_SYSCALL_H */

/* SPDX-License-Identifier: GPL-2.0 */

// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

#ifndef __ASM_CSKY_SYSCALLS_H

#define __ASM_CSKY_SYSCALLS_H

#include <asm-generic/syscalls.h>

long sys_cacheflush(void __user *, unsigned long, int);

long sys_set_thread_area(unsigned long addr);

long sys_csky_fadvise64_64(int fd, int advice, loff_t offset, loff_t len);

#endif /* __ASM_CSKY_SYSCALLS_H */

/* SPDX-License-Identifier: GPL-2.0 */

// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

#define __ARCH_WANT_SYS_CLONE

#include <asm-generic/unistd.h>

#define __NR_set_thread_area	(__NR_arch_specific_syscall + 0)

__SYSCALL(__NR_set_thread_area, sys_set_thread_area)

#define __NR_cacheflush		(__NR_arch_specific_syscall + 1)

__SYSCALL(__NR_cacheflush, sys_cacheflush)

// SPDX-License-Identifier: GPL-2.0

// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

#include <linux/syscalls.h>

SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)

{

	struct thread_info *ti = task_thread_info(current);

	struct pt_regs *reg = current_pt_regs();

	reg->tls = addr;

	ti->tp_value = addr;

	return 0;

}

SYSCALL_DEFINE6(mmap2,

	unsigned long, addr,

	unsigned long, len,

	unsigned long, prot,

	unsigned long, flags,

	unsigned long, fd,

	off_t, offset)

{

	if (unlikely(offset & (~PAGE_MASK >> 12)))

		return -EINVAL;

	return ksys_mmap_pgoff(addr, len, prot, flags, fd,

			       offset >> (PAGE_SHIFT - 12));

}

/*

 * for abiv1 the 64bits args should be even th, So we need mov the advice

 * forward.

 */

SYSCALL_DEFINE4(csky_fadvise64_64,

	int, fd,

	int, advice,

	loff_t, offset,

	loff_t, len)

{

	return ksys_fadvise64_64(fd, offset, len, advice);

}

// SPDX-License-Identifier: GPL-2.0

// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

#include <linux/syscalls.h>

#include <asm/syscalls.h>

#undef __SYSCALL

#define __SYSCALL(nr, call)[nr] = (call),

#define sys_fadvise64_64 sys_csky_fadvise64_64

void * const sys_call_table[__NR_syscalls] __page_aligned_data = {

	[0 ... __NR_syscalls - 1] = sys_ni_syscall,

#include <asm/unistd.h>

};