[deliverable/linux.git] / arch / x86 / kernel / sys_i386_32.c

/*
 * This file contains various random system calls that
 * have a non-standard calling sequence on the Linux/i386
 * platform.
 */

#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/smp.h>
#include <linux/sem.h>
#include <linux/msg.h>
#include <linux/shm.h>
#include <linux/stat.h>
#include <linux/syscalls.h>
#include <linux/mman.h>
#include <linux/file.h>
#include <linux/utsname.h>
#include <linux/ipc.h>

#include <linux/uaccess.h>
#include <linux/unistd.h>

#include <asm/syscalls.h>

asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
			  unsigned long prot, unsigned long flags,
			  unsigned long fd, unsigned long pgoff)
{
	int error = -EBADF;
	struct file *file = NULL;
	struct mm_struct *mm = current->mm;

	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
	if (!(flags & MAP_ANONYMOUS)) {
		file = fget(fd);
		if (!file)
			goto out;
	}

	down_write(&mm->mmap_sem);
	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
	up_write(&mm->mmap_sem);

	if (file)
		fput(file);
out:
	return error;
}

/*
 * Perform the select(nd, in, out, ex, tv) and mmap() system
 * calls. Linux/i386 didn't use to be able to handle more than
 * 4 system call parameters, so these system calls used a memory
 * block for parameter passing..
 */

struct mmap_arg_struct {
	unsigned long addr;
	unsigned long len;
	unsigned long prot;
	unsigned long flags;
	unsigned long fd;
	unsigned long offset;
};

asmlinkage int old_mmap(struct mmap_arg_struct __user *arg)
{
	struct mmap_arg_struct a;
	int err = -EFAULT;

	if (copy_from_user(&a, arg, sizeof(a)))
		goto out;

	err = -EINVAL;
	if (a.offset & ~PAGE_MASK)
		goto out;

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


struct sel_arg_struct {
	unsigned long n;
	fd_set __user *inp, *outp, *exp;
	struct timeval __user *tvp;
};

asmlinkage int old_select(struct sel_arg_struct __user *arg)
{
	struct sel_arg_struct a;

	if (copy_from_user(&a, arg, sizeof(a)))
		return -EFAULT;
	/* sys_select() does the appropriate kernel locking */
	return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
}

/*
 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 *
 * This is really horribly ugly.
 */
asmlinkage int sys_ipc(uint call, int first, int second,
			int third, void __user *ptr, long fifth)
{
	int version, ret;

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

	switch (call) {
	case SEMOP:
		return sys_semtimedop(first, (struct sembuf __user *)ptr, second, NULL);
	case SEMTIMEDOP:
		return sys_semtimedop(first, (struct sembuf __user *)ptr, second,
					(const struct timespec __user *)fifth);

	case SEMGET:
		return sys_semget(first, second, third);
	case SEMCTL: {
		union semun fourth;
		if (!ptr)
			return -EINVAL;
		if (get_user(fourth.__pad, (void __user * __user *) ptr))
			return -EFAULT;
		return sys_semctl(first, second, third, fourth);
	}

	case MSGSND:
		return sys_msgsnd(first, (struct msgbuf __user *) ptr,
				   second, third);
	case MSGRCV:
		switch (version) {
		case 0: {
			struct ipc_kludge tmp;
			if (!ptr)
				return -EINVAL;

			if (copy_from_user(&tmp,
					   (struct ipc_kludge __user *) ptr,
					   sizeof(tmp)))
				return -EFAULT;
			return sys_msgrcv(first, tmp.msgp, second,
					   tmp.msgtyp, third);
		}
		default:
			return sys_msgrcv(first,
					   (struct msgbuf __user *) ptr,
					   second, fifth, third);
		}
	case MSGGET:
		return sys_msgget((key_t) first, second);
	case MSGCTL:
		return sys_msgctl(first, second, (struct msqid_ds __user *) ptr);

	case SHMAT:
		switch (version) {
		default: {
			ulong raddr;
			ret = do_shmat(first, (char __user *) ptr, second, &raddr);
			if (ret)
				return ret;
			return put_user(raddr, (ulong __user *) third);
		}
		case 1:	/* iBCS2 emulator entry point */
			if (!segment_eq(get_fs(), get_ds()))
				return -EINVAL;
			/* The "(ulong *) third" is valid _only_ because of the kernel segment thing */
			return do_shmat(first, (char __user *) ptr, second, (ulong *) third);
		}
	case SHMDT:
		return sys_shmdt((char __user *)ptr);
	case SHMGET:
		return sys_shmget(first, second, third);
	case SHMCTL:
		return sys_shmctl(first, second,
				   (struct shmid_ds __user *) ptr);
	default:
		return -ENOSYS;
	}
}

/*
 * Old cruft
 */
asmlinkage int sys_uname(struct old_utsname __user *name)
{
	int err;
	if (!name)
		return -EFAULT;
	down_read(&uts_sem);
	err = copy_to_user(name, utsname(), sizeof(*name));
	up_read(&uts_sem);
	return err? -EFAULT:0;
}

asmlinkage int sys_olduname(struct oldold_utsname __user *name)
{
	int error;

	if (!name)
		return -EFAULT;
	if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
		return -EFAULT;

	down_read(&uts_sem);

	error = __copy_to_user(&name->sysname, &utsname()->sysname,
			       __OLD_UTS_LEN);
	error |= __put_user(0, name->sysname + __OLD_UTS_LEN);
	error |= __copy_to_user(&name->nodename, &utsname()->nodename,
				__OLD_UTS_LEN);
	error |= __put_user(0, name->nodename + __OLD_UTS_LEN);
	error |= __copy_to_user(&name->release, &utsname()->release,
				__OLD_UTS_LEN);
	error |= __put_user(0, name->release + __OLD_UTS_LEN);
	error |= __copy_to_user(&name->version, &utsname()->version,
				__OLD_UTS_LEN);
	error |= __put_user(0, name->version + __OLD_UTS_LEN);
	error |= __copy_to_user(&name->machine, &utsname()->machine,
				__OLD_UTS_LEN);
	error |= __put_user(0, name->machine + __OLD_UTS_LEN);

	up_read(&uts_sem);

	error = error ? -EFAULT : 0;

	return error;
}


/*
 * 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[])
{
	long __res;
	asm volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx"
	: "=a" (__res)
	: "0" (__NR_execve), "ri" (filename), "c" (argv), "d" (envp) : "memory");
	return __res;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* This file contains various random system calls that
	3	* have a non-standard calling sequence on the Linux/i386
	4	* platform.
	5	*/
	6
	7	#include <linux/errno.h>
	8	#include <linux/sched.h>
	9	#include <linux/mm.h>
4e950f6f	10	#include <linux/fs.h>
1da177e4	11	#include <linux/smp.h>
1da177e4 LT	12	#include <linux/sem.h>
	13	#include <linux/msg.h>
	14	#include <linux/shm.h>
	15	#include <linux/stat.h>
	16	#include <linux/syscalls.h>
	17	#include <linux/mman.h>
	18	#include <linux/file.h>
	19	#include <linux/utsname.h>
cba4fbbf	20	#include <linux/ipc.h>
1da177e4	21
5b80fe8b PC	22	#include <linux/uaccess.h>
5b80fe8b PC	23	#include <linux/unistd.h>
1da177e4	24
bbc1f698 JS	25	#include <asm/syscalls.h>
bbc1f698 JS	26
a7290ee0 MB	27	asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
	28	unsigned long prot, unsigned long flags,
	29	unsigned long fd, unsigned long pgoff)
1da177e4 LT	30	{
1da177e4 LT	31	int error = -EBADF;
a7290ee0 MB	32	struct file *file = NULL;
a7290ee0 MB	33	struct mm_struct *mm = current->mm;
1da177e4 LT	34
	35	flags &= ~(MAP_EXECUTABLE \| MAP_DENYWRITE);
	36	if (!(flags & MAP_ANONYMOUS)) {
	37	file = fget(fd);
	38	if (!file)
	39	goto out;
	40	}
	41
a7290ee0	42	down_write(&mm->mmap_sem);
1da177e4	43	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
a7290ee0	44	up_write(&mm->mmap_sem);
1da177e4 LT	45
	46	if (file)
	47	fput(file);
	48	out:
	49	return error;
	50	}
	51
1da177e4 LT	52	/*
	53	* Perform the select(nd, in, out, ex, tv) and mmap() system
	54	* calls. Linux/i386 didn't use to be able to handle more than
	55	* 4 system call parameters, so these system calls used a memory
	56	* block for parameter passing..
	57	*/
	58
	59	struct mmap_arg_struct {
	60	unsigned long addr;
	61	unsigned long len;
	62	unsigned long prot;
	63	unsigned long flags;
	64	unsigned long fd;
	65	unsigned long offset;
	66	};
	67
	68	asmlinkage int old_mmap(struct mmap_arg_struct __user *arg)
	69	{
	70	struct mmap_arg_struct a;
	71	int err = -EFAULT;
	72
	73	if (copy_from_user(&a, arg, sizeof(a)))
	74	goto out;
	75
	76	err = -EINVAL;
	77	if (a.offset & ~PAGE_MASK)
	78	goto out;
	79
a7290ee0 MB	80	err = sys_mmap2(a.addr, a.len, a.prot, a.flags,
a7290ee0 MB	81	a.fd, a.offset >> PAGE_SHIFT);
1da177e4 LT	82	out:
	83	return err;
	84	}
	85
	86
	87	struct sel_arg_struct {
	88	unsigned long n;
	89	fd_set __user inp, outp, *exp;
	90	struct timeval __user *tvp;
	91	};
	92
	93	asmlinkage int old_select(struct sel_arg_struct __user *arg)
	94	{
	95	struct sel_arg_struct a;
	96
	97	if (copy_from_user(&a, arg, sizeof(a)))
	98	return -EFAULT;
	99	/* sys_select() does the appropriate kernel locking */
	100	return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
	101	}
	102
	103	/*
	104	* sys_ipc() is the de-multiplexer for the SysV IPC calls..
	105	*
	106	* This is really horribly ugly.
	107	*/
5b80fe8b	108	asmlinkage int sys_ipc(uint call, int first, int second,
1da177e4 LT	109	int third, void __user *ptr, long fifth)
	110	{
	111	int version, ret;
	112
	113	version = call >> 16; /* hack for backward compatibility */
	114	call &= 0xffff;
	115
	116	switch (call) {
	117	case SEMOP:
5b80fe8b	118	return sys_semtimedop(first, (struct sembuf __user *)ptr, second, NULL);
1da177e4 LT	119	case SEMTIMEDOP:
	120	return sys_semtimedop(first, (struct sembuf __user *)ptr, second,
	121	(const struct timespec __user *)fifth);
	122
	123	case SEMGET:
5b80fe8b	124	return sys_semget(first, second, third);
1da177e4 LT	125	case SEMCTL: {
	126	union semun fourth;
	127	if (!ptr)
	128	return -EINVAL;
	129	if (get_user(fourth.__pad, (void __user * __user *) ptr))
	130	return -EFAULT;
5b80fe8b	131	return sys_semctl(first, second, third, fourth);
1da177e4 LT	132	}
	133
	134	case MSGSND:
5b80fe8b	135	return sys_msgsnd(first, (struct msgbuf __user *) ptr,
1da177e4 LT	136	second, third);
	137	case MSGRCV:
	138	switch (version) {
	139	case 0: {
	140	struct ipc_kludge tmp;
	141	if (!ptr)
	142	return -EINVAL;
5b80fe8b	143
1da177e4	144	if (copy_from_user(&tmp,
5b80fe8b PC	145	(struct ipc_kludge __user *) ptr,
5b80fe8b PC	146	sizeof(tmp)))
1da177e4	147	return -EFAULT;
5b80fe8b	148	return sys_msgrcv(first, tmp.msgp, second,
1da177e4 LT	149	tmp.msgtyp, third);
	150	}
	151	default:
5b80fe8b	152	return sys_msgrcv(first,
1da177e4 LT	153	(struct msgbuf __user *) ptr,
	154	second, fifth, third);
	155	}
	156	case MSGGET:
5b80fe8b	157	return sys_msgget((key_t) first, second);
1da177e4	158	case MSGCTL:
5b80fe8b	159	return sys_msgctl(first, second, (struct msqid_ds __user *) ptr);
1da177e4 LT	160
	161	case SHMAT:
	162	switch (version) {
	163	default: {
	164	ulong raddr;
5b80fe8b	165	ret = do_shmat(first, (char __user *) ptr, second, &raddr);
1da177e4 LT	166	if (ret)
1da177e4 LT	167	return ret;
5b80fe8b	168	return put_user(raddr, (ulong __user *) third);
1da177e4 LT	169	}
	170	case 1: /* iBCS2 emulator entry point */
	171	if (!segment_eq(get_fs(), get_ds()))
	172	return -EINVAL;
	173	/* The "(ulong ) third" is valid _only_ because of the kernel segment thing /
5b80fe8b	174	return do_shmat(first, (char __user ) ptr, second, (ulong ) third);
1da177e4	175	}
5b80fe8b PC	176	case SHMDT:
5b80fe8b PC	177	return sys_shmdt((char __user *)ptr);
1da177e4	178	case SHMGET:
5b80fe8b	179	return sys_shmget(first, second, third);
1da177e4	180	case SHMCTL:
5b80fe8b	181	return sys_shmctl(first, second,
1da177e4 LT	182	(struct shmid_ds __user *) ptr);
	183	default:
	184	return -ENOSYS;
	185	}
	186	}
	187
	188	/*
	189	* Old cruft
	190	*/
5b80fe8b	191	asmlinkage int sys_uname(struct old_utsname __user *name)
1da177e4 LT	192	{
	193	int err;
	194	if (!name)
	195	return -EFAULT;
	196	down_read(&uts_sem);
5b80fe8b	197	err = copy_to_user(name, utsname(), sizeof(*name));
1da177e4	198	up_read(&uts_sem);
5b80fe8b	199	return err? -EFAULT:0;
1da177e4 LT	200	}
1da177e4 LT	201
5b80fe8b	202	asmlinkage int sys_olduname(struct oldold_utsname __user *name)
1da177e4 LT	203	{
	204	int error;
	205
	206	if (!name)
	207	return -EFAULT;
5b80fe8b	208	if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
1da177e4	209	return -EFAULT;
5b80fe8b PC	210
	211	down_read(&uts_sem);
	212
e9ff3990 SH	213	error = __copy_to_user(&name->sysname, &utsname()->sysname,
	214	__OLD_UTS_LEN);
	215	error \|= __put_user(0, name->sysname + __OLD_UTS_LEN);
	216	error \|= __copy_to_user(&name->nodename, &utsname()->nodename,
	217	__OLD_UTS_LEN);
	218	error \|= __put_user(0, name->nodename + __OLD_UTS_LEN);
	219	error \|= __copy_to_user(&name->release, &utsname()->release,
	220	__OLD_UTS_LEN);
	221	error \|= __put_user(0, name->release + __OLD_UTS_LEN);
	222	error \|= __copy_to_user(&name->version, &utsname()->version,
	223	__OLD_UTS_LEN);
	224	error \|= __put_user(0, name->version + __OLD_UTS_LEN);
	225	error \|= __copy_to_user(&name->machine, &utsname()->machine,
	226	__OLD_UTS_LEN);
	227	error \|= __put_user(0, name->machine + __OLD_UTS_LEN);
5b80fe8b	228
1da177e4	229	up_read(&uts_sem);
5b80fe8b	230
1da177e4 LT	231	error = error ? -EFAULT : 0;
	232
	233	return error;
	234	}
fe74290d AB	235
	236
	237	/*
	238	* Do a system call from kernel instead of calling sys_execve so we
	239	* end up with proper pt_regs.
	240	*/
	241	int kernel_execve(const char filename, char const argv[], char *const envp[])
	242	{
	243	long __res;
	244	asm volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx"
	245	: "=a" (__res)
5b80fe8b	246	: "0" (__NR_execve), "ri" (filename), "c" (argv), "d" (envp) : "memory");
fe74290d AB	247	return __res;
fe74290d AB	248	}