2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
|
2008-01-30 05:30:08 -07:00
|
|
|
* sys_sparc32
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 2000 VA Linux Co
|
|
|
|
* Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
|
2008-01-30 05:30:08 -07:00
|
|
|
* Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
|
|
|
|
* Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (C) 2000 Hewlett-Packard Co.
|
|
|
|
* Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
|
2008-01-30 05:30:08 -07:00
|
|
|
* Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* These routines maintain argument size conversion between 32bit and 64bit
|
2008-01-30 05:30:08 -07:00
|
|
|
* environment. In 2.5 most of this should be moved to a generic directory.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This file assumes that there is a hole at the end of user address space.
|
2008-01-30 05:30:08 -07:00
|
|
|
*
|
|
|
|
* Some of the functions are LE specific currently. These are
|
|
|
|
* hopefully all marked. This should be fixed.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
2008-01-30 05:30:08 -07:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/file.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/times.h>
|
|
|
|
#include <linux/utsname.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/uio.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/personality.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/rwsem.h>
|
|
|
|
#include <linux/compat.h>
|
|
|
|
#include <linux/vfs.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/highuid.h>
|
2006-09-26 02:52:33 -06:00
|
|
|
#include <linux/sysctl.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/mman.h>
|
|
|
|
#include <asm/types.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
#include <asm/ia32.h>
|
2008-02-07 16:03:04 -07:00
|
|
|
#include <asm/vgtod.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define AA(__x) ((unsigned long)(__x))
|
|
|
|
|
|
|
|
int cp_compat_stat(struct kstat *kbuf, struct compat_stat __user *ubuf)
|
|
|
|
{
|
2006-10-03 02:13:46 -06:00
|
|
|
compat_ino_t ino;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
typeof(ubuf->st_uid) uid = 0;
|
|
|
|
typeof(ubuf->st_gid) gid = 0;
|
|
|
|
SET_UID(uid, kbuf->uid);
|
|
|
|
SET_GID(gid, kbuf->gid);
|
|
|
|
if (!old_valid_dev(kbuf->dev) || !old_valid_dev(kbuf->rdev))
|
|
|
|
return -EOVERFLOW;
|
|
|
|
if (kbuf->size >= 0x7fffffff)
|
|
|
|
return -EOVERFLOW;
|
2006-10-03 02:13:46 -06:00
|
|
|
ino = kbuf->ino;
|
|
|
|
if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
|
|
|
|
return -EOVERFLOW;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct compat_stat)) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__put_user(old_encode_dev(kbuf->dev), &ubuf->st_dev) ||
|
|
|
|
__put_user(ino, &ubuf->st_ino) ||
|
|
|
|
__put_user(kbuf->mode, &ubuf->st_mode) ||
|
|
|
|
__put_user(kbuf->nlink, &ubuf->st_nlink) ||
|
|
|
|
__put_user(uid, &ubuf->st_uid) ||
|
|
|
|
__put_user(gid, &ubuf->st_gid) ||
|
|
|
|
__put_user(old_encode_dev(kbuf->rdev), &ubuf->st_rdev) ||
|
|
|
|
__put_user(kbuf->size, &ubuf->st_size) ||
|
|
|
|
__put_user(kbuf->atime.tv_sec, &ubuf->st_atime) ||
|
|
|
|
__put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec) ||
|
|
|
|
__put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime) ||
|
|
|
|
__put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
|
|
|
|
__put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime) ||
|
|
|
|
__put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
|
|
|
|
__put_user(kbuf->blksize, &ubuf->st_blksize) ||
|
|
|
|
__put_user(kbuf->blocks, &ubuf->st_blocks))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_truncate64(char __user *filename,
|
|
|
|
unsigned long offset_low,
|
|
|
|
unsigned long offset_high)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low,
|
|
|
|
unsigned long offset_high)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
/*
|
|
|
|
* Another set for IA32/LFS -- x86_64 struct stat is different due to
|
|
|
|
* support for 64bit inode numbers.
|
|
|
|
*/
|
|
|
|
static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
typeof(ubuf->st_uid) uid = 0;
|
|
|
|
typeof(ubuf->st_gid) gid = 0;
|
|
|
|
SET_UID(uid, stat->uid);
|
|
|
|
SET_GID(gid, stat->gid);
|
|
|
|
if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
|
|
|
|
__put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__put_user(stat->ino, &ubuf->__st_ino) ||
|
|
|
|
__put_user(stat->ino, &ubuf->st_ino) ||
|
|
|
|
__put_user(stat->mode, &ubuf->st_mode) ||
|
|
|
|
__put_user(stat->nlink, &ubuf->st_nlink) ||
|
|
|
|
__put_user(uid, &ubuf->st_uid) ||
|
|
|
|
__put_user(gid, &ubuf->st_gid) ||
|
|
|
|
__put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) ||
|
|
|
|
__put_user(stat->size, &ubuf->st_size) ||
|
|
|
|
__put_user(stat->atime.tv_sec, &ubuf->st_atime) ||
|
|
|
|
__put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) ||
|
|
|
|
__put_user(stat->mtime.tv_sec, &ubuf->st_mtime) ||
|
|
|
|
__put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
|
|
|
|
__put_user(stat->ctime.tv_sec, &ubuf->st_ctime) ||
|
|
|
|
__put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
|
|
|
|
__put_user(stat->blksize, &ubuf->st_blksize) ||
|
|
|
|
__put_user(stat->blocks, &ubuf->st_blocks))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_stat64(char __user *filename,
|
|
|
|
struct stat64 __user *statbuf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kstat stat;
|
|
|
|
int ret = vfs_stat(filename, &stat);
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!ret)
|
|
|
|
ret = cp_stat64(statbuf, &stat);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_lstat64(char __user *filename,
|
|
|
|
struct stat64 __user *statbuf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kstat stat;
|
|
|
|
int ret = vfs_lstat(filename, &stat);
|
|
|
|
if (!ret)
|
|
|
|
ret = cp_stat64(statbuf, &stat);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct kstat stat;
|
|
|
|
int ret = vfs_fstat(fd, &stat);
|
|
|
|
if (!ret)
|
|
|
|
ret = cp_stat64(statbuf, &stat);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_fstatat(unsigned int dfd, char __user *filename,
|
|
|
|
struct stat64 __user *statbuf, int flag)
|
2006-02-11 18:55:47 -07:00
|
|
|
{
|
|
|
|
struct kstat stat;
|
|
|
|
int error = -EINVAL;
|
|
|
|
|
|
|
|
if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (flag & AT_SYMLINK_NOFOLLOW)
|
|
|
|
error = vfs_lstat_fd(dfd, filename, &stat);
|
|
|
|
else
|
|
|
|
error = vfs_stat_fd(dfd, filename, &stat);
|
|
|
|
|
|
|
|
if (!error)
|
|
|
|
error = cp_stat64(statbuf, &stat);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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 int addr;
|
|
|
|
unsigned int len;
|
|
|
|
unsigned int prot;
|
|
|
|
unsigned int flags;
|
|
|
|
unsigned int fd;
|
|
|
|
unsigned int offset;
|
|
|
|
};
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_mmap(struct mmap_arg_struct __user *arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct mmap_arg_struct a;
|
|
|
|
struct file *file = NULL;
|
|
|
|
unsigned long retval;
|
|
|
|
struct mm_struct *mm ;
|
|
|
|
|
|
|
|
if (copy_from_user(&a, arg, sizeof(a)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (a.offset & ~PAGE_MASK)
|
2008-01-30 05:30:08 -07:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!(a.flags & MAP_ANONYMOUS)) {
|
|
|
|
file = fget(a.fd);
|
|
|
|
if (!file)
|
|
|
|
return -EBADF;
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
mm = current->mm;
|
|
|
|
down_write(&mm->mmap_sem);
|
|
|
|
retval = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags,
|
|
|
|
a.offset>>PAGE_SHIFT);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (file)
|
|
|
|
fput(file);
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
up_write(&mm->mmap_sem);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_mprotect(unsigned long start, size_t len,
|
|
|
|
unsigned long prot)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-01-30 05:30:08 -07:00
|
|
|
return sys_mprotect(start, len, prot);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_pipe(int __user *fd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
int fds[2];
|
|
|
|
|
2008-07-23 22:29:30 -06:00
|
|
|
retval = do_pipe_flags(fds, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
if (copy_to_user(fd, fds, sizeof(fds)))
|
|
|
|
retval = -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
out:
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act,
|
|
|
|
struct sigaction32 __user *oact,
|
|
|
|
unsigned int sigsetsize)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
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) {
|
|
|
|
compat_uptr_t handler, restorer;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
|
|
|
|
__get_user(handler, &act->sa_handler) ||
|
|
|
|
__get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__get_user(restorer, &act->sa_restorer) ||
|
|
|
|
__copy_from_user(&set32, &act->sa_mask,
|
|
|
|
sizeof(compat_sigset_t)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
new_ka.sa.sa_handler = compat_ptr(handler);
|
|
|
|
new_ka.sa.sa_restorer = compat_ptr(restorer);
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
|
|
|
|
* than _NSIG_WORDS << 1
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
|
|
|
|
| (((long)set32.sig[7]) << 32);
|
|
|
|
case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
|
|
|
|
| (((long)set32.sig[5]) << 32);
|
|
|
|
case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
|
|
|
|
| (((long)set32.sig[3]) << 32);
|
|
|
|
case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
|
|
|
|
| (((long)set32.sig[1]) << 32);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
|
|
|
|
|
|
|
|
if (!ret && oact) {
|
2008-01-30 05:30:08 -07:00
|
|
|
/*
|
|
|
|
* FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
|
|
|
|
* than _NSIG_WORDS << 1
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4:
|
|
|
|
set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
|
|
|
|
set32.sig[6] = old_ka.sa.sa_mask.sig[3];
|
|
|
|
case 3:
|
|
|
|
set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
|
|
|
|
set32.sig[4] = old_ka.sa.sa_mask.sig[2];
|
|
|
|
case 2:
|
|
|
|
set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
|
|
|
|
set32.sig[2] = old_ka.sa.sa_mask.sig[1];
|
|
|
|
case 1:
|
|
|
|
set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
|
|
|
|
set32.sig[0] = old_ka.sa.sa_mask.sig[0];
|
|
|
|
}
|
|
|
|
if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__put_user(ptr_to_compat(old_ka.sa.sa_handler),
|
|
|
|
&oact->sa_handler) ||
|
|
|
|
__put_user(ptr_to_compat(old_ka.sa.sa_restorer),
|
|
|
|
&oact->sa_restorer) ||
|
2005-04-16 16:20:36 -06:00
|
|
|
__put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__copy_to_user(&oact->sa_mask, &set32,
|
|
|
|
sizeof(compat_sigset_t)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act,
|
|
|
|
struct old_sigaction32 __user *oact)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-01-30 05:30:08 -07:00
|
|
|
struct k_sigaction new_ka, old_ka;
|
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
if (act) {
|
2005-04-16 16:20:36 -06:00
|
|
|
compat_old_sigset_t mask;
|
|
|
|
compat_uptr_t handler, restorer;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
|
|
|
|
__get_user(handler, &act->sa_handler) ||
|
|
|
|
__get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
|
|
|
|
__get_user(restorer, &act->sa_restorer) ||
|
|
|
|
__get_user(mask, &act->sa_mask))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
new_ka.sa.sa_handler = compat_ptr(handler);
|
|
|
|
new_ka.sa.sa_restorer = compat_ptr(restorer);
|
|
|
|
|
|
|
|
siginitset(&new_ka.sa.sa_mask, mask);
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!ret && oact) {
|
|
|
|
if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
|
2008-01-30 05:30:08 -07:00
|
|
|
__put_user(ptr_to_compat(old_ka.sa.sa_handler),
|
|
|
|
&oact->sa_handler) ||
|
|
|
|
__put_user(ptr_to_compat(old_ka.sa.sa_restorer),
|
|
|
|
&oact->sa_restorer) ||
|
2005-04-16 16:20:36 -06:00
|
|
|
__put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
|
|
|
|
__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
|
|
|
|
return -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
|
|
|
|
compat_sigset_t __user *oset,
|
|
|
|
unsigned int sigsetsize)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
sigset_t s;
|
|
|
|
compat_sigset_t s32;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (set) {
|
2008-01-30 05:30:08 -07:00
|
|
|
if (copy_from_user(&s32, set, sizeof(compat_sigset_t)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
|
|
|
|
case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
|
|
|
|
case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
|
|
|
|
case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
|
|
|
|
}
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_rt_sigprocmask(how,
|
|
|
|
set ? (sigset_t __user *)&s : NULL,
|
|
|
|
oset ? (sigset_t __user *)&s : NULL,
|
2008-01-30 05:30:08 -07:00
|
|
|
sigsetsize);
|
|
|
|
set_fs(old_fs);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (oset) {
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
|
|
|
|
case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
|
|
|
|
case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
|
|
|
|
case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
if (copy_to_user(oset, &s32, sizeof(compat_sigset_t)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
static inline long get_tv32(struct timeval *o, struct compat_timeval __user *i)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-01-30 05:30:08 -07:00
|
|
|
int err = -EFAULT;
|
|
|
|
|
|
|
|
if (access_ok(VERIFY_READ, i, sizeof(*i))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
err = __get_user(o->tv_sec, &i->tv_sec);
|
|
|
|
err |= __get_user(o->tv_usec, &i->tv_usec);
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err = -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
if (access_ok(VERIFY_WRITE, o, sizeof(*o))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
err = __put_user(i->tv_sec, &o->tv_sec);
|
|
|
|
err |= __put_user(i->tv_usec, &o->tv_usec);
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_alarm(unsigned int seconds)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-25 04:06:33 -07:00
|
|
|
return alarm_setitimer(seconds);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
/*
|
|
|
|
* Translations due to time_t size differences. Which affects all
|
|
|
|
* sorts of things, like timeval and itimerval.
|
|
|
|
*/
|
|
|
|
asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv,
|
|
|
|
struct timezone __user *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (tv) {
|
|
|
|
struct timeval ktv;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
do_gettimeofday(&ktv);
|
|
|
|
if (put_tv32(tv, &ktv))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
if (tz) {
|
|
|
|
if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv,
|
|
|
|
struct timezone __user *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct timeval ktv;
|
|
|
|
struct timespec kts;
|
|
|
|
struct timezone ktz;
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
if (tv) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (get_tv32(&ktv, tv))
|
|
|
|
return -EFAULT;
|
|
|
|
kts.tv_sec = ktv.tv_sec;
|
|
|
|
kts.tv_nsec = ktv.tv_usec * NSEC_PER_USEC;
|
|
|
|
}
|
|
|
|
if (tz) {
|
|
|
|
if (copy_from_user(&ktz, tz, sizeof(ktz)))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct sel_arg_struct {
|
|
|
|
unsigned int n;
|
|
|
|
unsigned int inp;
|
|
|
|
unsigned int outp;
|
|
|
|
unsigned int exp;
|
|
|
|
unsigned int tvp;
|
|
|
|
};
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_old_select(struct sel_arg_struct __user *arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sel_arg_struct a;
|
|
|
|
|
|
|
|
if (copy_from_user(&a, arg, sizeof(a)))
|
|
|
|
return -EFAULT;
|
|
|
|
return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
|
|
|
|
compat_ptr(a.exp), compat_ptr(a.tvp));
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr,
|
|
|
|
int options)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return compat_sys_wait4(pid, stat_addr, options, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 32-bit timeval and related flotsam. */
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_sysfs(option, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
|
|
|
|
struct compat_timespec __user *interval)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct timespec t;
|
|
|
|
int ret;
|
2008-01-30 05:30:08 -07:00
|
|
|
mm_segment_t old_fs = get_fs();
|
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
|
2008-01-30 05:30:08 -07:00
|
|
|
set_fs(old_fs);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (put_compat_timespec(&t, interval))
|
|
|
|
return -EFAULT;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
|
|
|
|
compat_size_t sigsetsize)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
sigset_t s;
|
|
|
|
compat_sigset_t s32;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize);
|
2008-01-30 05:30:08 -07:00
|
|
|
set_fs(old_fs);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!ret) {
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
|
|
|
|
case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
|
|
|
|
case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
|
|
|
|
case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
if (copy_to_user(set, &s32, sizeof(compat_sigset_t)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig,
|
|
|
|
compat_siginfo_t __user *uinfo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
siginfo_t info;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (copy_siginfo_from_user32(&info, uinfo))
|
|
|
|
return -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
|
2008-01-30 05:30:08 -07:00
|
|
|
set_fs(old_fs);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* These are here just in case some old ia32 binary calls it. */
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_pause(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
|
|
schedule();
|
|
|
|
return -ERESTARTNOHAND;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-09-27 02:51:04 -06:00
|
|
|
#ifdef CONFIG_SYSCTL_SYSCALL
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sysctl_ia32 {
|
|
|
|
unsigned int name;
|
|
|
|
int nlen;
|
|
|
|
unsigned int oldval;
|
|
|
|
unsigned int oldlenp;
|
|
|
|
unsigned int newval;
|
|
|
|
unsigned int newlen;
|
|
|
|
unsigned int __unused[4];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_sysctl(struct sysctl_ia32 __user *args32)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sysctl_ia32 a32;
|
2008-01-30 05:30:08 -07:00
|
|
|
mm_segment_t old_fs = get_fs();
|
2005-04-16 16:20:36 -06:00
|
|
|
void __user *oldvalp, *newvalp;
|
|
|
|
size_t oldlen;
|
|
|
|
int __user *namep;
|
|
|
|
long ret;
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
if (copy_from_user(&a32, args32, sizeof(a32)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/*
|
2008-01-30 05:30:08 -07:00
|
|
|
* We need to pre-validate these because we have to disable
|
|
|
|
* address checking before calling do_sysctl() because of
|
|
|
|
* OLDLEN but we can't run the risk of the user specifying bad
|
|
|
|
* addresses here. Well, since we're dealing with 32 bit
|
|
|
|
* addresses, we KNOW that access_ok() will always succeed, so
|
|
|
|
* this is an expensive NOP, but so what...
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
namep = compat_ptr(a32.name);
|
|
|
|
oldvalp = compat_ptr(a32.oldval);
|
|
|
|
newvalp = compat_ptr(a32.newval);
|
|
|
|
|
|
|
|
if ((oldvalp && get_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
|
|
|
|
|| !access_ok(VERIFY_WRITE, namep, 0)
|
|
|
|
|| !access_ok(VERIFY_WRITE, oldvalp, 0)
|
|
|
|
|| !access_ok(VERIFY_WRITE, newvalp, 0))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
lock_kernel();
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *)&oldlen,
|
|
|
|
newvalp, (size_t) a32.newlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
unlock_kernel();
|
|
|
|
set_fs(old_fs);
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
if (oldvalp && put_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
/* warning: next two assume little endian */
|
|
|
|
asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
|
|
|
|
u32 poslo, u32 poshi)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_pread64(fd, ubuf, count,
|
|
|
|
((loff_t)AA(poshi) << 32) | AA(poslo));
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_pwrite(unsigned int fd, char __user *ubuf, u32 count,
|
|
|
|
u32 poslo, u32 poshi)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_pwrite64(fd, ubuf, count,
|
|
|
|
((loff_t)AA(poshi) << 32) | AA(poslo));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_personality(unsigned long personality)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ret;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
if (personality(current->personality) == PER_LINUX32 &&
|
2005-04-16 16:20:36 -06:00
|
|
|
personality == PER_LINUX)
|
|
|
|
personality = PER_LINUX32;
|
|
|
|
ret = sys_personality(personality);
|
|
|
|
if (ret == PER_LINUX32)
|
|
|
|
ret = PER_LINUX;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_sendfile(int out_fd, int in_fd,
|
|
|
|
compat_off_t __user *offset, s32 count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
mm_segment_t old_fs = get_fs();
|
|
|
|
int ret;
|
|
|
|
off_t of;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (offset && get_user(of, offset))
|
|
|
|
return -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
|
|
|
|
count);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_fs(old_fs);
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-09-12 10:49:24 -06:00
|
|
|
if (offset && put_user(of, offset))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len,
|
2008-01-30 05:30:08 -07:00
|
|
|
unsigned long prot, unsigned long flags,
|
|
|
|
unsigned long fd, unsigned long pgoff)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
unsigned long error;
|
2008-01-30 05:30:08 -07:00
|
|
|
struct file *file = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
|
|
|
|
if (!(flags & MAP_ANONYMOUS)) {
|
|
|
|
file = fget(fd);
|
|
|
|
if (!file)
|
|
|
|
return -EBADF;
|
|
|
|
}
|
|
|
|
|
|
|
|
down_write(&mm->mmap_sem);
|
|
|
|
error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
|
|
|
|
up_write(&mm->mmap_sem);
|
|
|
|
|
|
|
|
if (file)
|
|
|
|
fput(file);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_olduname(struct oldold_utsname __user *name)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-01-30 05:30:08 -07:00
|
|
|
char *arch = "x86_64";
|
2006-09-26 02:52:40 -06:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return -EFAULT;
|
2006-10-02 03:18:11 -06:00
|
|
|
if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
down_read(&uts_sem);
|
|
|
|
|
|
|
|
err = __copy_to_user(&name->sysname, &utsname()->sysname,
|
|
|
|
__OLD_UTS_LEN);
|
|
|
|
err |= __put_user(0, name->sysname+__OLD_UTS_LEN);
|
|
|
|
err |= __copy_to_user(&name->nodename, &utsname()->nodename,
|
|
|
|
__OLD_UTS_LEN);
|
|
|
|
err |= __put_user(0, name->nodename+__OLD_UTS_LEN);
|
|
|
|
err |= __copy_to_user(&name->release, &utsname()->release,
|
|
|
|
__OLD_UTS_LEN);
|
|
|
|
err |= __put_user(0, name->release+__OLD_UTS_LEN);
|
|
|
|
err |= __copy_to_user(&name->version, &utsname()->version,
|
|
|
|
__OLD_UTS_LEN);
|
|
|
|
err |= __put_user(0, name->version+__OLD_UTS_LEN);
|
|
|
|
|
|
|
|
if (personality(current->personality) == PER_LINUX32)
|
|
|
|
arch = "i686";
|
|
|
|
|
|
|
|
err |= __copy_to_user(&name->machine, arch, strlen(arch) + 1);
|
2006-10-02 03:18:11 -06:00
|
|
|
|
|
|
|
up_read(&uts_sem);
|
|
|
|
|
|
|
|
err = err ? -EFAULT : 0;
|
|
|
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
long sys32_uname(struct old_utsname __user *name)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!name)
|
|
|
|
return -EFAULT;
|
|
|
|
down_read(&uts_sem);
|
2008-01-30 05:30:08 -07:00
|
|
|
err = copy_to_user(name, utsname(), sizeof(*name));
|
2005-04-16 16:20:36 -06:00
|
|
|
up_read(&uts_sem);
|
2008-01-30 05:30:08 -07:00
|
|
|
if (personality(current->personality) == PER_LINUX32)
|
2005-04-16 16:20:36 -06:00
|
|
|
err |= copy_to_user(&name->machine, "i686", 5);
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
return err ? -EFAULT : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
long sys32_ustat(unsigned dev, struct ustat32 __user *u32p)
|
|
|
|
{
|
|
|
|
struct ustat u;
|
|
|
|
mm_segment_t seg;
|
|
|
|
int ret;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
seg = get_fs();
|
|
|
|
set_fs(KERNEL_DS);
|
2006-09-26 02:52:33 -06:00
|
|
|
ret = sys_ustat(dev, (struct ustat __user *)&u);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_fs(seg);
|
2008-01-30 05:30:08 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_WRITE, u32p, sizeof(struct ustat32)) ||
|
|
|
|
__put_user((__u32) u.f_tfree, &u32p->f_tfree) ||
|
|
|
|
__put_user((__u32) u.f_tinode, &u32p->f_tfree) ||
|
|
|
|
__copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) ||
|
|
|
|
__copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack)))
|
|
|
|
ret = -EFAULT;
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv,
|
|
|
|
compat_uptr_t __user *envp, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
long error;
|
2008-01-30 05:30:08 -07:00
|
|
|
char *filename;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
filename = getname(name);
|
|
|
|
error = PTR_ERR(filename);
|
|
|
|
if (IS_ERR(filename))
|
|
|
|
return error;
|
|
|
|
error = compat_do_execve(filename, argv, envp, regs);
|
|
|
|
putname(filename);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
2008-01-30 05:30:56 -07:00
|
|
|
void __user *parent_tid = (void __user *)regs->dx;
|
|
|
|
void __user *child_tid = (void __user *)regs->di;
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!newsp)
|
2008-01-30 05:30:56 -07:00
|
|
|
newsp = regs->sp;
|
2008-01-30 05:30:08 -07:00
|
|
|
return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-01-30 05:30:08 -07:00
|
|
|
* Some system calls that need sign extended arguments. This could be
|
|
|
|
* done by a generic wrapper.
|
|
|
|
*/
|
|
|
|
long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_lseek(fd, offset, whence);
|
|
|
|
}
|
|
|
|
|
|
|
|
long sys32_kill(int pid, int sig)
|
|
|
|
{
|
|
|
|
return sys_kill(pid, sig);
|
|
|
|
}
|
2008-01-30 05:30:08 -07:00
|
|
|
|
|
|
|
long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
|
2005-04-16 16:20:36 -06:00
|
|
|
__u32 len_low, __u32 len_high, int advice)
|
2008-01-30 05:30:08 -07:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
return sys_fadvise64_64(fd,
|
|
|
|
(((u64)offset_high)<<32) | offset_low,
|
|
|
|
(((u64)len_high)<<32) | len_low,
|
2008-01-30 05:30:08 -07:00
|
|
|
advice);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
long sys32_vm86_warning(void)
|
2008-01-30 05:30:08 -07:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
struct task_struct *me = current;
|
|
|
|
static char lastcomm[sizeof(me->comm)];
|
2008-01-30 05:30:08 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
|
2008-01-30 05:30:08 -07:00
|
|
|
compat_printk(KERN_INFO
|
|
|
|
"%s: vm86 mode not supported on 64 bit kernel\n",
|
|
|
|
me->comm);
|
2005-04-16 16:20:36 -06:00
|
|
|
strncpy(lastcomm, me->comm, sizeof(lastcomm));
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOSYS;
|
2008-01-30 05:30:08 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
|
2008-01-30 05:30:08 -07:00
|
|
|
char __user *buf, size_t len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
|
|
|
|
size_t count)
|
2007-06-20 04:23:30 -06:00
|
|
|
{
|
|
|
|
return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
|
2008-01-30 05:30:08 -07:00
|
|
|
unsigned n_low, unsigned n_hi, int flags)
|
2007-06-20 04:23:30 -06:00
|
|
|
{
|
|
|
|
return sys_sync_file_range(fd,
|
|
|
|
((u64)off_hi << 32) | off_low,
|
|
|
|
((u64)n_hi << 32) | n_low, flags);
|
|
|
|
}
|
|
|
|
|
2008-01-30 05:30:08 -07:00
|
|
|
asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
|
|
|
|
size_t len, int advice)
|
2007-06-20 04:23:30 -06:00
|
|
|
{
|
|
|
|
return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
|
|
|
|
len, advice);
|
|
|
|
}
|
sys_fallocate() implementation on i386, x86_64 and powerpc
fallocate() is a new system call being proposed here which will allow
applications to preallocate space to any file(s) in a file system.
Each file system implementation that wants to use this feature will need
to support an inode operation called ->fallocate().
Applications can use this feature to avoid fragmentation to certain
level and thus get faster access speed. With preallocation, applications
also get a guarantee of space for particular file(s) - even if later the
the system becomes full.
Currently, glibc provides an interface called posix_fallocate() which
can be used for similar cause. Though this has the advantage of working
on all file systems, but it is quite slow (since it writes zeroes to
each block that has to be preallocated). Without a doubt, file systems
can do this more efficiently within the kernel, by implementing
the proposed fallocate() system call. It is expected that
posix_fallocate() will be modified to call this new system call first
and incase the kernel/filesystem does not implement it, it should fall
back to the current implementation of writing zeroes to the new blocks.
ToDos:
1. Implementation on other architectures (other than i386, x86_64,
and ppc). Patches for s390(x) and ia64 are already available from
previous posts, but it was decided that they should be added later
once fallocate is in the mainline. Hence not including those patches
in this take.
2. Changes to glibc,
a) to support fallocate() system call
b) to make posix_fallocate() and posix_fallocate64() call fallocate()
Signed-off-by: Amit Arora <aarora@in.ibm.com>
2007-07-17 19:42:44 -06:00
|
|
|
|
|
|
|
asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo,
|
|
|
|
unsigned offset_hi, unsigned len_lo,
|
|
|
|
unsigned len_hi)
|
|
|
|
{
|
|
|
|
return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
|
|
|
|
((u64)len_hi << 32) | len_lo);
|
|
|
|
}
|