[linux-2.6-block.git] / arch / sparc / kernel / sys_sparc32.c

/* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
 *
 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 * Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
 *
 * These routines maintain argument size conversion between 32bit and 64bit
 * environment.
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/capability.h>
#include <linux/fs.h> 
#include <linux/mm.h> 
#include <linux/file.h> 
#include <linux/signal.h>
#include <linux/resource.h>
#include <linux/times.h>
#include <linux/smp.h>
#include <linux/sem.h>
#include <linux/msg.h>
#include <linux/shm.h>
#include <linux/uio.h>
#include <linux/nfs_fs.h>
#include <linux/quota.h>
#include <linux/poll.h>
#include <linux/personality.h>
#include <linux/stat.h>
#include <linux/filter.h>
#include <linux/highmem.h>
#include <linux/highuid.h>
#include <linux/mman.h>
#include <linux/ipv6.h>
#include <linux/in.h>
#include <linux/icmpv6.h>
#include <linux/syscalls.h>
#include <linux/sysctl.h>
#include <linux/binfmts.h>
#include <linux/dnotify.h>
#include <linux/security.h>
#include <linux/compat.h>
#include <linux/vfs.h>
#include <linux/ptrace.h>
#include <linux/slab.h>

#include <asm/types.h>
#include <asm/uaccess.h>
#include <asm/fpumacro.h>
#include <asm/mmu_context.h>
#include <asm/compat_signal.h>

asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
{
	if ((int)high < 0)
		return -EINVAL;
	else
		return sys_truncate(path, (high << 32) | low);
}

asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
{
	if ((int)high < 0)
		return -EINVAL;
	else
		return sys_ftruncate(fd, (high << 32) | low);
}

static int cp_compat_stat64(struct kstat *stat,
			    struct compat_stat64 __user *statbuf)
{
	int err;

	err  = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev);
	err |= put_user(stat->ino, &statbuf->st_ino);
	err |= put_user(stat->mode, &statbuf->st_mode);
	err |= put_user(stat->nlink, &statbuf->st_nlink);
	err |= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid);
	err |= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid);
	err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev);
	err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]);
	err |= put_user(stat->size, &statbuf->st_size);
	err |= put_user(stat->blksize, &statbuf->st_blksize);
	err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]);
	err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]);
	err |= put_user(stat->blocks, &statbuf->st_blocks);
	err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
	err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
	err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
	err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
	err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
	err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
	err |= put_user(0, &statbuf->__unused4);
	err |= put_user(0, &statbuf->__unused5);

	return err;
}

asmlinkage long compat_sys_stat64(const char __user * filename,
		struct compat_stat64 __user *statbuf)
{
	struct kstat stat;
	int error = vfs_stat(filename, &stat);

	if (!error)
		error = cp_compat_stat64(&stat, statbuf);
	return error;
}

asmlinkage long compat_sys_lstat64(const char __user * filename,
		struct compat_stat64 __user *statbuf)
{
	struct kstat stat;
	int error = vfs_lstat(filename, &stat);

	if (!error)
		error = cp_compat_stat64(&stat, statbuf);
	return error;
}

asmlinkage long compat_sys_fstat64(unsigned int fd,
		struct compat_stat64 __user * statbuf)
{
	struct kstat stat;
	int error = vfs_fstat(fd, &stat);

	if (!error)
		error = cp_compat_stat64(&stat, statbuf);
	return error;
}

asmlinkage long compat_sys_fstatat64(unsigned int dfd,
		const char __user *filename,
		struct compat_stat64 __user * statbuf, int flag)
{
	struct kstat stat;
	int error;

	error = vfs_fstatat(dfd, filename, &stat, flag);
	if (error)
		return error;
	return cp_compat_stat64(&stat, statbuf);
}

COMPAT_SYSCALL_DEFINE3(sparc_sigaction, int, sig,
			struct compat_old_sigaction __user *,act,
			struct compat_old_sigaction __user *,oact)
{
	WARN_ON_ONCE(sig >= 0);
	return compat_sys_sigaction(-sig, act, oact);
}

COMPAT_SYSCALL_DEFINE5(rt_sigaction, int, sig,
			struct compat_sigaction __user *,act,
			struct compat_sigaction __user *,oact,
			void __user *,restorer,
			compat_size_t,sigsetsize)
{
        struct k_sigaction new_ka, old_ka;
        int ret;
	compat_sigset_t set32;

        /* XXX: Don't preclude handling different sized sigset_t's.  */
        if (sigsetsize != sizeof(compat_sigset_t))
                return -EINVAL;

        if (act) {
		u32 u_handler, u_restorer;

		new_ka.ka_restorer = restorer;
		ret = get_user(u_handler, &act->sa_handler);
		new_ka.sa.sa_handler =  compat_ptr(u_handler);
		ret |= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
		sigset_from_compat(&new_ka.sa.sa_mask, &set32);
		ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
		ret |= __get_user(u_restorer, &act->sa_restorer);
		new_ka.sa.sa_restorer = compat_ptr(u_restorer);
                if (ret)
                	return -EFAULT;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		sigset_to_compat(&set32, &old_ka.sa.sa_mask);
		ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
		ret |= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
		ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
		ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
		if (ret)
			ret = -EFAULT;
        }

        return ret;
}

asmlinkage compat_ssize_t sys32_pread64(unsigned int fd,
					char __user *ubuf,
					compat_size_t count,
					unsigned long poshi,
					unsigned long poslo)
{
	return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo);
}

asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd,
					 char __user *ubuf,
					 compat_size_t count,
					 unsigned long poshi,
					 unsigned long poslo)
{
	return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo);
}

asmlinkage long compat_sys_readahead(int fd,
				     unsigned long offhi,
				     unsigned long offlo,
				     compat_size_t count)
{
	return sys_readahead(fd, (offhi << 32) | offlo, count);
}

long compat_sys_fadvise64(int fd,
			  unsigned long offhi,
			  unsigned long offlo,
			  compat_size_t len, int advice)
{
	return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice);
}

long compat_sys_fadvise64_64(int fd,
			     unsigned long offhi, unsigned long offlo,
			     unsigned long lenhi, unsigned long lenlo,
			     int advice)
{
	return sys_fadvise64_64(fd,
				(offhi << 32) | offlo,
				(lenhi << 32) | lenlo,
				advice);
}

long sys32_sync_file_range(unsigned int fd, unsigned long off_high, unsigned long off_low, unsigned long nb_high, unsigned long nb_low, unsigned int flags)
{
	return sys_sync_file_range(fd,
				   (off_high << 32) | off_low,
				   (nb_high << 32) | nb_low,
				   flags);
}

asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo,
				     u32 lenhi, u32 lenlo)
{
	return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo,
			     ((loff_t)lenhi << 32) | lenlo);
}
Commit	Line	Data
bc5a2e64	1	/* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
1da177e4 LT	2	*
1da177e4 LT	3	* Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
bc5a2e64	4	* Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
1da177e4 LT	5	*
	6	* These routines maintain argument size conversion between 32bit and 64bit
	7	* environment.
	8	*/
	9
1da177e4 LT	10	#include <linux/kernel.h>
1da177e4 LT	11	#include <linux/sched.h>
a9415644	12	#include <linux/capability.h>
1da177e4 LT	13	#include <linux/fs.h>
	14	#include <linux/mm.h>
	15	#include <linux/file.h>
	16	#include <linux/signal.h>
	17	#include <linux/resource.h>
	18	#include <linux/times.h>
1da177e4	19	#include <linux/smp.h>
1da177e4 LT	20	#include <linux/sem.h>
	21	#include <linux/msg.h>
	22	#include <linux/shm.h>
1da177e4 LT	23	#include <linux/uio.h>
	24	#include <linux/nfs_fs.h>
	25	#include <linux/quota.h>
1da177e4 LT	26	#include <linux/poll.h>
	27	#include <linux/personality.h>
	28	#include <linux/stat.h>
	29	#include <linux/filter.h>
	30	#include <linux/highmem.h>
	31	#include <linux/highuid.h>
	32	#include <linux/mman.h>
	33	#include <linux/ipv6.h>
	34	#include <linux/in.h>
	35	#include <linux/icmpv6.h>
	36	#include <linux/syscalls.h>
	37	#include <linux/sysctl.h>
	38	#include <linux/binfmts.h>
	39	#include <linux/dnotify.h>
	40	#include <linux/security.h>
	41	#include <linux/compat.h>
	42	#include <linux/vfs.h>
1da177e4	43	#include <linux/ptrace.h>
5a0e3ad6	44	#include <linux/slab.h>
1da177e4 LT	45
1da177e4 LT	46	#include <asm/types.h>
1da177e4 LT	47	#include <asm/uaccess.h>
1da177e4 LT	48	#include <asm/fpumacro.h>
1da177e4	49	#include <asm/mmu_context.h>
14cc6aba	50	#include <asm/compat_signal.h>
1da177e4	51
1da177e4 LT	52	asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
	53	{
	54	if ((int)high < 0)
	55	return -EINVAL;
	56	else
	57	return sys_truncate(path, (high << 32) \| low);
	58	}
	59
	60	asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
	61	{
	62	if ((int)high < 0)
	63	return -EINVAL;
	64	else
	65	return sys_ftruncate(fd, (high << 32) \| low);
	66	}
	67
908f5162 AB	68	static int cp_compat_stat64(struct kstat *stat,
908f5162 AB	69	struct compat_stat64 __user *statbuf)
0ba4da03 DM	70	{
	71	int err;
	72
	73	err = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev);
	74	err \|= put_user(stat->ino, &statbuf->st_ino);
	75	err \|= put_user(stat->mode, &statbuf->st_mode);
	76	err \|= put_user(stat->nlink, &statbuf->st_nlink);
a7c1938e EB	77	err \|= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid);
a7c1938e EB	78	err \|= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid);
0ba4da03 DM	79	err \|= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev);
	80	err \|= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]);
	81	err \|= put_user(stat->size, &statbuf->st_size);
	82	err \|= put_user(stat->blksize, &statbuf->st_blksize);
	83	err \|= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]);
	84	err \|= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]);
	85	err \|= put_user(stat->blocks, &statbuf->st_blocks);
	86	err \|= put_user(stat->atime.tv_sec, &statbuf->st_atime);
	87	err \|= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
	88	err \|= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
	89	err \|= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
	90	err \|= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
	91	err \|= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
	92	err \|= put_user(0, &statbuf->__unused4);
	93	err \|= put_user(0, &statbuf->__unused5);
	94
	95	return err;
	96	}
	97
c7887325	98	asmlinkage long compat_sys_stat64(const char __user * filename,
0ba4da03 DM	99	struct compat_stat64 __user *statbuf)
	100	{
	101	struct kstat stat;
	102	int error = vfs_stat(filename, &stat);
	103
	104	if (!error)
	105	error = cp_compat_stat64(&stat, statbuf);
	106	return error;
	107	}
	108
c7887325	109	asmlinkage long compat_sys_lstat64(const char __user * filename,
0ba4da03 DM	110	struct compat_stat64 __user *statbuf)
	111	{
	112	struct kstat stat;
	113	int error = vfs_lstat(filename, &stat);
	114
	115	if (!error)
	116	error = cp_compat_stat64(&stat, statbuf);
	117	return error;
	118	}
	119
	120	asmlinkage long compat_sys_fstat64(unsigned int fd,
	121	struct compat_stat64 __user * statbuf)
	122	{
	123	struct kstat stat;
	124	int error = vfs_fstat(fd, &stat);
	125
	126	if (!error)
	127	error = cp_compat_stat64(&stat, statbuf);
	128	return error;
	129	}
	130
c7887325 DH	131	asmlinkage long compat_sys_fstatat64(unsigned int dfd,
c7887325 DH	132	const char __user *filename,
40ad7a6a DM	133	struct compat_stat64 __user * statbuf, int flag)
	134	{
	135	struct kstat stat;
0112fc22	136	int error;
40ad7a6a	137
0112fc22 OD	138	error = vfs_fstatat(dfd, filename, &stat, flag);
	139	if (error)
	140	return error;
	141	return cp_compat_stat64(&stat, statbuf);
40ad7a6a DM	142	}
40ad7a6a DM	143
a274bd49 AV	144	COMPAT_SYSCALL_DEFINE3(sparc_sigaction, int, sig,
	145	struct compat_old_sigaction __user *,act,
	146	struct compat_old_sigaction __user *,oact)
1da177e4	147	{
5526b7e4	148	WARN_ON_ONCE(sig >= 0);
a274bd49	149	return compat_sys_sigaction(-sig, act, oact);
1da177e4 LT	150	}
1da177e4 LT	151
bdc40abf AV	152	COMPAT_SYSCALL_DEFINE5(rt_sigaction, int, sig,
	153	struct compat_sigaction __user *,act,
	154	struct compat_sigaction __user *,oact,
	155	void __user *,restorer,
	156	compat_size_t,sigsetsize)
1da177e4 LT	157	{
	158	struct k_sigaction new_ka, old_ka;
	159	int ret;
	160	compat_sigset_t set32;
	161
	162	/* XXX: Don't preclude handling different sized sigset_t's. */
	163	if (sigsetsize != sizeof(compat_sigset_t))
	164	return -EINVAL;
	165
1da177e4 LT	166	if (act) {
	167	u32 u_handler, u_restorer;
	168
	169	new_ka.ka_restorer = restorer;
	170	ret = get_user(u_handler, &act->sa_handler);
	171	new_ka.sa.sa_handler = compat_ptr(u_handler);
	172	ret \|= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
bdc40abf	173	sigset_from_compat(&new_ka.sa.sa_mask, &set32);
1da177e4 LT	174	ret \|= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
	175	ret \|= __get_user(u_restorer, &act->sa_restorer);
	176	new_ka.sa.sa_restorer = compat_ptr(u_restorer);
	177	if (ret)
	178	return -EFAULT;
	179	}
	180
	181	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	182
	183	if (!ret && oact) {
bdc40abf	184	sigset_to_compat(&set32, &old_ka.sa.sa_mask);
1da177e4 LT	185	ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
	186	ret \|= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
	187	ret \|= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	188	ret \|= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
	189	if (ret)
	190	ret = -EFAULT;
	191	}
	192
	193	return ret;
	194	}
	195
1da177e4 LT	196	asmlinkage compat_ssize_t sys32_pread64(unsigned int fd,
	197	char __user *ubuf,
	198	compat_size_t count,
	199	unsigned long poshi,
	200	unsigned long poslo)
	201	{
	202	return sys_pread64(fd, ubuf, count, (poshi << 32) \| poslo);
	203	}
	204
	205	asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd,
	206	char __user *ubuf,
	207	compat_size_t count,
	208	unsigned long poshi,
	209	unsigned long poslo)
	210	{
	211	return sys_pwrite64(fd, ubuf, count, (poshi << 32) \| poslo);
	212	}
	213
	214	asmlinkage long compat_sys_readahead(int fd,
	215	unsigned long offhi,
	216	unsigned long offlo,
	217	compat_size_t count)
	218	{
	219	return sys_readahead(fd, (offhi << 32) \| offlo, count);
	220	}
	221
	222	long compat_sys_fadvise64(int fd,
	223	unsigned long offhi,
	224	unsigned long offlo,
	225	compat_size_t len, int advice)
	226	{
	227	return sys_fadvise64_64(fd, (offhi << 32) \| offlo, len, advice);
	228	}
	229
	230	long compat_sys_fadvise64_64(int fd,
	231	unsigned long offhi, unsigned long offlo,
	232	unsigned long lenhi, unsigned long lenlo,
	233	int advice)
	234	{
	235	return sys_fadvise64_64(fd,
	236	(offhi << 32) \| offlo,
	237	(lenhi << 32) \| lenlo,
	238	advice);
	239	}
	240
2ae80c43	241	long sys32_sync_file_range(unsigned int fd, unsigned long off_high, unsigned long off_low, unsigned long nb_high, unsigned long nb_low, unsigned int flags)
289eee6f DM	242	{
	243	return sys_sync_file_range(fd,
	244	(off_high << 32) \| off_low,
	245	(nb_high << 32) \| nb_low,
	246	flags);
	247	}
bc5a2e64 DM	248
	249	asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo,
	250	u32 lenhi, u32 lenlo)
	251	{
	252	return sys_fallocate(fd, mode, ((loff_t)offhi << 32) \| offlo,
	253	((loff_t)lenhi << 32) \| lenlo);
	254	}