[net-next-2.6.git] / arch / microblaze / kernel / sys_microblaze.c

/*
 * Copyright (C) 2007-2009 Michal Simek <monstr@monstr.eu>
 * Copyright (C) 2007-2009 PetaLogix
 * Copyright (C) 2007 John Williams <john.williams@petalogix.com>
 *
 * Copyright (C) 2006 Atmark Techno, Inc.
 *	Yasushi SHOJI <yashi@atmark-techno.com>
 *	Tetsuya OHKAWA <tetsuya@atmark-techno.com>
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License. See the file "COPYING" in the main directory of this archive
 * for more details.
 */

#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/syscalls.h>
#include <linux/sem.h>
#include <linux/msg.h>
#include <linux/shm.h>
#include <linux/stat.h>
#include <linux/mman.h>
#include <linux/sys.h>
#include <linux/ipc.h>
#include <linux/utsname.h>
#include <linux/file.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/fs.h>
#include <linux/semaphore.h>
#include <linux/uaccess.h>
#include <linux/unistd.h>

#include <asm/syscalls.h>
/*
 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 *
 * This is really horribly ugly. This will be remove with new toolchain.
 */
asmlinkage long
sys_ipc(uint call, int first, int second, int third, void *ptr, long fifth)
{
	int version, ret;

	version = call >> 16; /* hack for backward compatibility */
	call &= 0xffff;

	ret = -EINVAL;
	switch (call) {
	case SEMOP:
		ret = sys_semop(first, (struct sembuf *)ptr, second);
		break;
	case SEMGET:
		ret = sys_semget(first, second, third);
		break;
	case SEMCTL:
	{
		union semun fourth;

		if (!ptr)
			break;
		ret = (access_ok(VERIFY_READ, ptr, sizeof(long)) ? 0 : -EFAULT)
				|| (get_user(fourth.__pad, (void **)ptr)) ;
		if (ret)
			break;
		ret = sys_semctl(first, second, third, fourth);
		break;
	}
	case MSGSND:
		ret = sys_msgsnd(first, (struct msgbuf *) ptr, second, third);
		break;
	case MSGRCV:
		switch (version) {
		case 0: {
			struct ipc_kludge tmp;

			if (!ptr)
				break;
			ret = (access_ok(VERIFY_READ, ptr, sizeof(tmp))
				? 0 : -EFAULT) || copy_from_user(&tmp,
				(struct ipc_kludge *) ptr, sizeof(tmp));
			if (ret)
				break;
			ret = sys_msgrcv(first, tmp.msgp, second, tmp.msgtyp,
					third);
			break;
			}
		default:
			ret = sys_msgrcv(first, (struct msgbuf *) ptr,
					second, fifth, third);
			break;
		}
		break;
	case MSGGET:
		ret = sys_msgget((key_t) first, second);
		break;
	case MSGCTL:
		ret = sys_msgctl(first, second, (struct msqid_ds *) ptr);
		break;
	case SHMAT:
		switch (version) {
		default: {
			ulong raddr;
			ret = access_ok(VERIFY_WRITE, (ulong *) third,
					sizeof(ulong)) ? 0 : -EFAULT;
			if (ret)
				break;
			ret = do_shmat(first, (char *) ptr, second, &raddr);
			if (ret)
				break;
			ret = put_user(raddr, (ulong *) third);
			break;
			}
		case 1:	/* iBCS2 emulator entry point */
			if (!segment_eq(get_fs(), get_ds()))
				break;
			ret = do_shmat(first, (char *) ptr, second,
					(ulong *) third);
			break;
		}
		break;
	case SHMDT:
		ret = sys_shmdt((char *)ptr);
		break;
	case SHMGET:
		ret = sys_shmget(first, second, third);
		break;
	case SHMCTL:
		ret = sys_shmctl(first, second, (struct shmid_ds *) ptr);
		break;
	}
	return ret;
}

asmlinkage long microblaze_vfork(struct pt_regs *regs)
{
	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->r1,
						regs, 0, NULL, NULL);
}

asmlinkage long microblaze_clone(int flags, unsigned long stack, struct pt_regs *regs)
{
	if (!stack)
		stack = regs->r1;
	return do_fork(flags, stack, regs, 0, NULL, NULL);
}

asmlinkage long microblaze_execve(char __user *filenamei, char __user *__user *argv,
			char __user *__user *envp, struct pt_regs *regs)
{
	int 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;
}

asmlinkage long
sys_mmap2(unsigned long addr, unsigned long len,
	unsigned long prot, unsigned long flags,
	unsigned long fd, unsigned long pgoff)
{
	struct file *file = NULL;
	int ret = -EBADF;

	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
	if (!(flags & MAP_ANONYMOUS)) {
		file = fget(fd);
		if (!file) {
			printk(KERN_INFO "no fd in mmap\r\n");
			goto out;
		}
	}

	down_write(&current->mm->mmap_sem);
	ret = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
	up_write(&current->mm->mmap_sem);
	if (file)
		fput(file);
out:
	return ret;
}

asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
			unsigned long prot, unsigned long flags,
			unsigned long fd, off_t pgoff)
{
	int err = -EINVAL;

	if (pgoff & ~PAGE_MASK) {
		printk(KERN_INFO "no pagemask in mmap\r\n");
		goto out;
	}

	err = sys_mmap2(addr, len, prot, flags, fd, pgoff >> PAGE_SHIFT);
out:
	return err;
}

/*
 * Do a system call from kernel instead of calling sys_execve so we
 * end up with proper pt_regs.
 */
int kernel_execve(const char *filename, char *const argv[], char *const envp[])
{
	register const char *__a __asm__("r5") = filename;
	register const void *__b __asm__("r6") = argv;
	register const void *__c __asm__("r7") = envp;
	register unsigned long __syscall __asm__("r12") = __NR_execve;
	register unsigned long __ret __asm__("r3");
	__asm__ __volatile__ ("brki r14, 0x8"
			: "=r" (__ret), "=r" (__syscall)
			: "1" (__syscall), "r" (__a), "r" (__b), "r" (__c)
			: "r4", "r8", "r9",
			"r10", "r11", "r14", "cc", "memory");
	return __ret;
}
Commit	Line	Data
7dcbbb2b MS	1	/*
	2	* Copyright (C) 2007-2009 Michal Simek <monstr@monstr.eu>
	3	* Copyright (C) 2007-2009 PetaLogix
	4	* Copyright (C) 2007 John Williams <john.williams@petalogix.com>
	5	*
	6	* Copyright (C) 2006 Atmark Techno, Inc.
	7	* Yasushi SHOJI <yashi@atmark-techno.com>
	8	* Tetsuya OHKAWA <tetsuya@atmark-techno.com>
	9	*
	10	* This file is subject to the terms and conditions of the GNU General Public
	11	* License. See the file "COPYING" in the main directory of this archive
	12	* for more details.
	13	*/
	14
	15	#include <linux/errno.h>
	16	#include <linux/mm.h>
	17	#include <linux/smp.h>
7dcbbb2b MS	18	#include <linux/syscalls.h>
	19	#include <linux/sem.h>
	20	#include <linux/msg.h>
	21	#include <linux/shm.h>
	22	#include <linux/stat.h>
	23	#include <linux/mman.h>
	24	#include <linux/sys.h>
	25	#include <linux/ipc.h>
	26	#include <linux/utsname.h>
	27	#include <linux/file.h>
	28	#include <linux/module.h>
	29	#include <linux/err.h>
	30	#include <linux/fs.h>
7dcbbb2b	31	#include <linux/semaphore.h>
7dcbbb2b MS	32	#include <linux/uaccess.h>
	33	#include <linux/unistd.h>
	34
	35	#include <asm/syscalls.h>
	36	/*
	37	* sys_ipc() is the de-multiplexer for the SysV IPC calls..
	38	*
	39	* This is really horribly ugly. This will be remove with new toolchain.
	40	*/
e513588f	41	asmlinkage long
7dcbbb2b MS	42	sys_ipc(uint call, int first, int second, int third, void *ptr, long fifth)
	43	{
	44	int version, ret;
	45
	46	version = call >> 16; /* hack for backward compatibility */
	47	call &= 0xffff;
	48
	49	ret = -EINVAL;
	50	switch (call) {
	51	case SEMOP:
	52	ret = sys_semop(first, (struct sembuf *)ptr, second);
	53	break;
	54	case SEMGET:
	55	ret = sys_semget(first, second, third);
	56	break;
	57	case SEMCTL:
	58	{
	59	union semun fourth;
	60
	61	if (!ptr)
	62	break;
	63	ret = (access_ok(VERIFY_READ, ptr, sizeof(long)) ? 0 : -EFAULT)
	64	\|\| (get_user(fourth.__pad, (void **)ptr)) ;
	65	if (ret)
	66	break;
	67	ret = sys_semctl(first, second, third, fourth);
	68	break;
	69	}
	70	case MSGSND:
	71	ret = sys_msgsnd(first, (struct msgbuf *) ptr, second, third);
	72	break;
	73	case MSGRCV:
	74	switch (version) {
	75	case 0: {
	76	struct ipc_kludge tmp;
	77
	78	if (!ptr)
	79	break;
	80	ret = (access_ok(VERIFY_READ, ptr, sizeof(tmp))
	81	? 0 : -EFAULT) \|\| copy_from_user(&tmp,
	82	(struct ipc_kludge *) ptr, sizeof(tmp));
	83	if (ret)
	84	break;
	85	ret = sys_msgrcv(first, tmp.msgp, second, tmp.msgtyp,
	86	third);
	87	break;
	88	}
	89	default:
	90	ret = sys_msgrcv(first, (struct msgbuf *) ptr,
	91	second, fifth, third);
	92	break;
	93	}
	94	break;
	95	case MSGGET:
	96	ret = sys_msgget((key_t) first, second);
	97	break;
	98	case MSGCTL:
	99	ret = sys_msgctl(first, second, (struct msqid_ds *) ptr);
	100	break;
	101	case SHMAT:
	102	switch (version) {
	103	default: {
	104	ulong raddr;
	105	ret = access_ok(VERIFY_WRITE, (ulong *) third,
106	sizeof(ulong)) ? 0 : -EFAULT;
107	if (ret)
108	break;
109	ret = do_shmat(first, (char *) ptr, second, &raddr);
110	if (ret)
111	break;
112	ret = put_user(raddr, (ulong *) third);
113	break;
114	}
115	case 1: /* iBCS2 emulator entry point */
116	if (!segment_eq(get_fs(), get_ds()))
117	break;
118	ret = do_shmat(first, (char *) ptr, second,
119	(ulong *) third);
120	break;
121	}
122	break;
123	case SHMDT:
124	ret = sys_shmdt((char *)ptr);
125	break;
126	case SHMGET:
127	ret = sys_shmget(first, second, third);
128	break;
129	case SHMCTL:
130	ret = sys_shmctl(first, second, (struct shmid_ds *) ptr);
131	break;
132	}
c71a7a38	133	return ret;
7dcbbb2b MS	134	}
7dcbbb2b MS	135
e513588f	136	asmlinkage long microblaze_vfork(struct pt_regs *regs)
7dcbbb2b MS	137	{
	138	return do_fork(CLONE_VFORK \| CLONE_VM \| SIGCHLD, regs->r1,
	139	regs, 0, NULL, NULL);
	140	}
	141
e513588f	142	asmlinkage long microblaze_clone(int flags, unsigned long stack, struct pt_regs *regs)
7dcbbb2b MS	143	{
	144	if (!stack)
	145	stack = regs->r1;
	146	return do_fork(flags, stack, regs, 0, NULL, NULL);
	147	}
	148
e513588f	149	asmlinkage long microblaze_execve(char __user filenamei, char __user __user *argv,
7dcbbb2b MS	150	char __user __user envp, struct pt_regs *regs)
	151	{
	152	int error;
	153	char *filename;
	154
	155	filename = getname(filenamei);
	156	error = PTR_ERR(filename);
	157	if (IS_ERR(filename))
	158	goto out;
	159	error = do_execve(filename, argv, envp, regs);
	160	putname(filename);
	161	out:
	162	return error;
	163	}
	164
e513588f AB	165	asmlinkage long
e513588f AB	166	sys_mmap2(unsigned long addr, unsigned long len,
7dcbbb2b MS	167	unsigned long prot, unsigned long flags,
	168	unsigned long fd, unsigned long pgoff)
	169	{
	170	struct file *file = NULL;
	171	int ret = -EBADF;
	172
	173	flags &= ~(MAP_EXECUTABLE \| MAP_DENYWRITE);
	174	if (!(flags & MAP_ANONYMOUS)) {
	175	file = fget(fd);
	176	if (!file) {
	177	printk(KERN_INFO "no fd in mmap\r\n");
	178	goto out;
	179	}
	180	}
	181
	182	down_write(&current->mm->mmap_sem);
	183	ret = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
	184	up_write(&current->mm->mmap_sem);
	185	if (file)
	186	fput(file);
	187	out:
	188	return ret;
	189	}
	190
e513588f	191	asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
7dcbbb2b	192	unsigned long prot, unsigned long flags,
e513588f	193	unsigned long fd, off_t pgoff)
7dcbbb2b MS	194	{
	195	int err = -EINVAL;
	196
e513588f	197	if (pgoff & ~PAGE_MASK) {
7dcbbb2b MS	198	printk(KERN_INFO "no pagemask in mmap\r\n");
	199	goto out;
	200	}
	201
e513588f	202	err = sys_mmap2(addr, len, prot, flags, fd, pgoff >> PAGE_SHIFT);
7dcbbb2b MS	203	out:
	204	return err;
	205	}
	206
	207	/*
	208	* Do a system call from kernel instead of calling sys_execve so we
	209	* end up with proper pt_regs.
	210	*/
	211	int kernel_execve(const char filename, char const argv[], char *const envp[])
	212	{
	213	register const char *__a __asm__("r5") = filename;
	214	register const void *__b __asm__("r6") = argv;
	215	register const void *__c __asm__("r7") = envp;
	216	register unsigned long __syscall __asm__("r12") = __NR_execve;
	217	register unsigned long __ret __asm__("r3");
	218	__asm__ __volatile__ ("brki r14, 0x8"
	219	: "=r" (__ret), "=r" (__syscall)
	220	: "1" (__syscall), "r" (__a), "r" (__b), "r" (__c)
	221	: "r4", "r8", "r9",
	222	"r10", "r11", "r14", "cc", "memory");
	223	return __ret;
	224	}