[linux-2.6-block.git] / arch / powerpc / platforms / cell / spu_callbacks.c

/*
 * System call callback functions for SPUs
 */

#undef DEBUG

#include <linux/kallsyms.h>
#include <linux/export.h>
#include <linux/syscalls.h>

#include <asm/spu.h>
#include <asm/syscalls.h>
#include <asm/unistd.h>

/*
 * This table defines the system calls that an SPU can call.
 * It is currently a subset of the 64 bit powerpc system calls,
 * with the exact semantics.
 *
 * The reasons for disabling some of the system calls are:
 * 1. They interact with the way SPU syscalls are handled
 *    and we can't let them execute ever:
 *	restart_syscall, exit, for, execve, ptrace, ...
 * 2. They are deprecated and replaced by other means:
 *	uselib, pciconfig_*, sysfs, ...
 * 3. They are somewhat interacting with the system in a way
 *    we don't want an SPU to:
 *	reboot, init_module, mount, kexec_load
 * 4. They are optional and we can't rely on them being
 *    linked into the kernel. Unfortunately, the cond_syscall
 *    helper does not work here as it does not add the necessary
 *    opd symbols:
 *	mbind, mq_open, ipc, ...
 */

static void *spu_syscall_table[] = {
#define SYSCALL(func)		sys_ni_syscall,
#define COMPAT_SYS(func)	sys_ni_syscall,
#define PPC_SYS(func)		sys_ni_syscall,
#define OLDSYS(func)		sys_ni_syscall,
#define SYS32ONLY(func)		sys_ni_syscall,
#define PPC64ONLY(func)		sys_ni_syscall,
#define SYSX(f, f3264, f32)	sys_ni_syscall,

#define SYSCALL_SPU(func)	sys_##func,
#define COMPAT_SYS_SPU(func)	sys_##func,
#define PPC_SYS_SPU(func)	ppc_##func,
#define SYSX_SPU(f, f3264, f32)	f,

#include <asm/systbl.h>
};

long spu_sys_callback(struct spu_syscall_block *s)
{
	long (*syscall)(u64 a1, u64 a2, u64 a3, u64 a4, u64 a5, u64 a6);

	if (s->nr_ret >= ARRAY_SIZE(spu_syscall_table)) {
		pr_debug("%s: invalid syscall #%lld", __func__, s->nr_ret);
		return -ENOSYS;
	}

	syscall = spu_syscall_table[s->nr_ret];

	pr_debug("SPU-syscall "
		 "%pSR:syscall%lld(%llx, %llx, %llx, %llx, %llx, %llx)\n",
		 syscall,
		 s->nr_ret,
		 s->parm[0], s->parm[1], s->parm[2],
		 s->parm[3], s->parm[4], s->parm[5]);

	return syscall(s->parm[0], s->parm[1], s->parm[2],
		       s->parm[3], s->parm[4], s->parm[5]);
}
EXPORT_SYMBOL_GPL(spu_sys_callback);
Commit	Line	Data
2dd14934 AB	1	/*
	2	* System call callback functions for SPUs
	3	*/
	4
c70d4ca5	5	#undef DEBUG
2dd14934 AB	6
2dd14934 AB	7	#include <linux/kallsyms.h>
4b16f8e2	8	#include <linux/export.h>
2dd14934 AB	9	#include <linux/syscalls.h>
	10
	11	#include <asm/spu.h>
	12	#include <asm/syscalls.h>
	13	#include <asm/unistd.h>
	14
	15	/*
	16	* This table defines the system calls that an SPU can call.
	17	* It is currently a subset of the 64 bit powerpc system calls,
	18	* with the exact semantics.
	19	*
	20	* The reasons for disabling some of the system calls are:
	21	* 1. They interact with the way SPU syscalls are handled
	22	* and we can't let them execute ever:
	23	* restart_syscall, exit, for, execve, ptrace, ...
	24	* 2. They are deprecated and replaced by other means:
	25	* uselib, pciconfig_*, sysfs, ...
	26	* 3. They are somewhat interacting with the system in a way
	27	* we don't want an SPU to:
	28	* reboot, init_module, mount, kexec_load
	29	* 4. They are optional and we can't rely on them being
	30	* linked into the kernel. Unfortunately, the cond_syscall
	31	* helper does not work here as it does not add the necessary
	32	* opd symbols:
	33	* mbind, mq_open, ipc, ...
	34	*/
	35
1238819a	36	static void *spu_syscall_table[] = {
72abd540 AS	37	#define SYSCALL(func) sys_ni_syscall,
	38	#define COMPAT_SYS(func) sys_ni_syscall,
	39	#define PPC_SYS(func) sys_ni_syscall,
	40	#define OLDSYS(func) sys_ni_syscall,
	41	#define SYS32ONLY(func) sys_ni_syscall,
529d235a	42	#define PPC64ONLY(func) sys_ni_syscall,
72abd540 AS	43	#define SYSX(f, f3264, f32) sys_ni_syscall,
	44
	45	#define SYSCALL_SPU(func) sys_##func,
	46	#define COMPAT_SYS_SPU(func) sys_##func,
	47	#define PPC_SYS_SPU(func) ppc_##func,
	48	#define SYSX_SPU(f, f3264, f32) f,
	49
	50	#include <asm/systbl.h>
2dd14934 AB	51	};
	52
	53	long spu_sys_callback(struct spu_syscall_block *s)
	54	{
	55	long (*syscall)(u64 a1, u64 a2, u64 a3, u64 a4, u64 a5, u64 a6);
	56
23b2527d	57	if (s->nr_ret >= ARRAY_SIZE(spu_syscall_table)) {
fe333321	58	pr_debug("%s: invalid syscall #%lld", __func__, s->nr_ret);
2dd14934 AB	59	return -ENOSYS;
	60	}
	61
b471f554 DW	62	syscall = spu_syscall_table[s->nr_ret];
b471f554 DW	63
03743716 JP	64	pr_debug("SPU-syscall "
	65	"%pSR:syscall%lld(%llx, %llx, %llx, %llx, %llx, %llx)\n",
	66	syscall,
	67	s->nr_ret,
	68	s->parm[0], s->parm[1], s->parm[2],
	69	s->parm[3], s->parm[4], s->parm[5]);
2dd14934 AB	70
	71	return syscall(s->parm[0], s->parm[1], s->parm[2],
	72	s->parm[3], s->parm[4], s->parm[5]);
	73	}
	74	EXPORT_SYMBOL_GPL(spu_sys_callback);