[deliverable/linux.git] / arch / arm64 / kernel / sys.c

/*
 * AArch64-specific system calls implementation
 *
 * Copyright (C) 2012 ARM Ltd.
 * Author: Catalin Marinas <catalin.marinas@arm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/export.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/syscalls.h>

/*
 * Clone a task - this clones the calling program thread.
 */
asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
			  int __user *parent_tidptr, unsigned long tls_val,
			  int __user *child_tidptr, struct pt_regs *regs)
{
	if (!newsp)
		newsp = regs->sp;
	/* 16-byte aligned stack mandatory on AArch64 */
	if (newsp & 15)
		return -EINVAL;
	return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
}

/*
 * sys_execve() executes a new program.
 */
asmlinkage long sys_execve(const char __user *filenamei,
			   const char __user *const __user *argv,
			   const char __user *const __user *envp,
			   struct pt_regs *regs)
{
	long error;
	char * filename;

	filename = getname(filenamei);
	error = PTR_ERR(filename);
	if (IS_ERR(filename))
		goto out;
	error = do_execve(filename, argv, envp, regs);
	putname(filename);
out:
	return error;
}

int kernel_execve(const char *filename,
		  const char *const argv[],
		  const char *const envp[])
{
	struct pt_regs regs;
	int ret;

	memset(&regs, 0, sizeof(struct pt_regs));
	ret = do_execve(filename,
			(const char __user *const __user *)argv,
			(const char __user *const __user *)envp, &regs);
	if (ret < 0)
		goto out;

	/*
	 * Save argc to the register structure for userspace.
	 */
	regs.regs[0] = ret;

	/*
	 * We were successful.  We won't be returning to our caller, but
	 * instead to user space by manipulating the kernel stack.
	 */
	asm(	"add	x0, %0, %1\n\t"
		"mov	x1, %2\n\t"
		"mov	x2, %3\n\t"
		"bl	memmove\n\t"	/* copy regs to top of stack */
		"mov	x27, #0\n\t"	/* not a syscall */
		"mov	x28, %0\n\t"	/* thread structure */
		"mov	sp, x0\n\t"	/* reposition stack pointer */
		"b	ret_to_user"
		:
		: "r" (current_thread_info()),
		  "Ir" (THREAD_START_SP - sizeof(regs)),
		  "r" (&regs),
		  "Ir" (sizeof(regs))
		: "x0", "x1", "x2", "x27", "x28", "x30", "memory");

 out:
	return ret;
}
EXPORT_SYMBOL(kernel_execve);

asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
			 unsigned long prot, unsigned long flags,
			 unsigned long fd, off_t off)
{
	if (offset_in_page(off) != 0)
		return -EINVAL;

	return sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
}

/*
 * Wrappers to pass the pt_regs argument.
 */
#define sys_execve		sys_execve_wrapper
#define sys_clone		sys_clone_wrapper
#define sys_rt_sigreturn	sys_rt_sigreturn_wrapper
#define sys_sigaltstack		sys_sigaltstack_wrapper

#include <asm/syscalls.h>

#undef __SYSCALL
#define __SYSCALL(nr, sym)	[nr] = sym,

/*
 * The sys_call_table array must be 4K aligned to be accessible from
 * kernel/entry.S.
 */
void *sys_call_table[__NR_syscalls] __aligned(4096) = {
	[0 ... __NR_syscalls - 1] = sys_ni_syscall,
#include <asm/unistd.h>
};
Commit	Line	Data
7992d60d CM	1	/*
	2	* AArch64-specific system calls implementation
	3	*
	4	* Copyright (C) 2012 ARM Ltd.
	5	* Author: Catalin Marinas <catalin.marinas@arm.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <linux/compiler.h>
	21	#include <linux/errno.h>
	22	#include <linux/fs.h>
	23	#include <linux/mm.h>
	24	#include <linux/export.h>
	25	#include <linux/sched.h>
	26	#include <linux/slab.h>
	27	#include <linux/syscalls.h>
	28
	29	/*
	30	* Clone a task - this clones the calling program thread.
	31	*/
	32	asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
	33	int __user *parent_tidptr, unsigned long tls_val,
	34	int __user child_tidptr, struct pt_regs regs)
	35	{
	36	if (!newsp)
	37	newsp = regs->sp;
	38	/* 16-byte aligned stack mandatory on AArch64 */
	39	if (newsp & 15)
	40	return -EINVAL;
	41	return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
	42	}
	43
	44	/*
	45	* sys_execve() executes a new program.
	46	*/
	47	asmlinkage long sys_execve(const char __user *filenamei,
	48	const char __user const __user argv,
	49	const char __user const __user envp,
	50	struct pt_regs *regs)
	51	{
	52	long error;
	53	char * filename;
	54
	55	filename = getname(filenamei);
	56	error = PTR_ERR(filename);
	57	if (IS_ERR(filename))
	58	goto out;
	59	error = do_execve(filename, argv, envp, regs);
	60	putname(filename);
	61	out:
	62	return error;
	63	}
	64
65	int kernel_execve(const char *filename,
66	const char *const argv[],
67	const char *const envp[])
68	{
69	struct pt_regs regs;
70	int ret;
71
72	memset(&regs, 0, sizeof(struct pt_regs));
73	ret = do_execve(filename,
74	(const char __user const __user )argv,
75	(const char __user const __user )envp, &regs);
76	if (ret < 0)
77	goto out;
78
79	/*
80	* Save argc to the register structure for userspace.
81	*/
82	regs.regs[0] = ret;
83
84	/*
85	* We were successful. We won't be returning to our caller, but
86	* instead to user space by manipulating the kernel stack.
87	*/
88	asm( "add x0, %0, %1\n\t"
89	"mov x1, %2\n\t"
90	"mov x2, %3\n\t"
91	"bl memmove\n\t" /* copy regs to top of stack */
92	"mov x27, #0\n\t" /* not a syscall */
93	"mov x28, %0\n\t" /* thread structure */
94	"mov sp, x0\n\t" /* reposition stack pointer */
95	"b ret_to_user"
96	:
97	: "r" (current_thread_info()),
98	"Ir" (THREAD_START_SP - sizeof(regs)),
99	"r" (&regs),
100	"Ir" (sizeof(regs))
101	: "x0", "x1", "x2", "x27", "x28", "x30", "memory");
102
103	out:
104	return ret;
105	}
106	EXPORT_SYMBOL(kernel_execve);
107
108	asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
109	unsigned long prot, unsigned long flags,
110	unsigned long fd, off_t off)
111	{
112	if (offset_in_page(off) != 0)
113	return -EINVAL;
114
115	return sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
116	}
117
118	/*
119	* Wrappers to pass the pt_regs argument.
120	*/
121	#define sys_execve sys_execve_wrapper
122	#define sys_clone sys_clone_wrapper
123	#define sys_rt_sigreturn sys_rt_sigreturn_wrapper
124	#define sys_sigaltstack sys_sigaltstack_wrapper
125
126	#include <asm/syscalls.h>
127
128	#undef __SYSCALL
129	#define __SYSCALL(nr, sym) [nr] = sym,
130
131	/*
132	* The sys_call_table array must be 4K aligned to be accessible from
133	* kernel/entry.S.
134	*/
135	void *sys_call_table[__NR_syscalls] __aligned(4096) = {
136	[0 ... __NR_syscalls - 1] = sys_ni_syscall,
137	#include <asm/unistd.h>
138	};