Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 3 | * sys_sparc32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
| 5 | * Copyright (C) 2000 VA Linux Co |
| 6 | * Copyright (C) 2000 Don Dugger <n0ano@valinux.com> |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 7 | * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com> |
| 8 | * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) |
| 9 | * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | * Copyright (C) 2000 Hewlett-Packard Co. |
| 11 | * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com> |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 12 | * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * |
| 14 | * These routines maintain argument size conversion between 32bit and 64bit |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 15 | * environment. In 2.5 most of this should be moved to a generic directory. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | * |
| 17 | * This file assumes that there is a hole at the end of user address space. |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 18 | * |
| 19 | * Some of the functions are LE specific currently. These are |
| 20 | * hopefully all marked. This should be fixed. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | */ |
| 22 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include <linux/kernel.h> |
| 24 | #include <linux/sched.h> |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 25 | #include <linux/fs.h> |
| 26 | #include <linux/file.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <linux/signal.h> |
| 28 | #include <linux/syscalls.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <linux/times.h> |
| 30 | #include <linux/utsname.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/smp_lock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | #include <linux/mm.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | #include <linux/uio.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include <linux/poll.h> |
| 35 | #include <linux/personality.h> |
| 36 | #include <linux/stat.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | #include <linux/rwsem.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | #include <linux/compat.h> |
| 39 | #include <linux/vfs.h> |
| 40 | #include <linux/ptrace.h> |
| 41 | #include <linux/highuid.h> |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 42 | #include <linux/sysctl.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 43 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | #include <asm/mman.h> |
| 45 | #include <asm/types.h> |
| 46 | #include <asm/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | #include <asm/atomic.h> |
Arnaldo Carvalho de Melo | 28d2312 | 2008-02-07 21:03:04 -0200 | [diff] [blame] | 48 | #include <asm/vgtod.h> |
Jaswinder Singh Rajput | 2f06de0 | 2008-12-27 21:37:10 +0530 | [diff] [blame] | 49 | #include <asm/sys_ia32.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | #define AA(__x) ((unsigned long)(__x)) |
| 52 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 54 | asmlinkage long sys32_truncate64(const char __user *filename, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 55 | unsigned long offset_low, |
| 56 | unsigned long offset_high) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | { |
| 58 | return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low); |
| 59 | } |
| 60 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 61 | asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low, |
| 62 | unsigned long offset_high) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | { |
| 64 | return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low); |
| 65 | } |
| 66 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 67 | /* |
| 68 | * Another set for IA32/LFS -- x86_64 struct stat is different due to |
| 69 | * support for 64bit inode numbers. |
| 70 | */ |
| 71 | static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | { |
| 73 | typeof(ubuf->st_uid) uid = 0; |
| 74 | typeof(ubuf->st_gid) gid = 0; |
| 75 | SET_UID(uid, stat->uid); |
| 76 | SET_GID(gid, stat->gid); |
| 77 | if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) || |
| 78 | __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) || |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 79 | __put_user(stat->ino, &ubuf->__st_ino) || |
| 80 | __put_user(stat->ino, &ubuf->st_ino) || |
| 81 | __put_user(stat->mode, &ubuf->st_mode) || |
| 82 | __put_user(stat->nlink, &ubuf->st_nlink) || |
| 83 | __put_user(uid, &ubuf->st_uid) || |
| 84 | __put_user(gid, &ubuf->st_gid) || |
| 85 | __put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) || |
| 86 | __put_user(stat->size, &ubuf->st_size) || |
| 87 | __put_user(stat->atime.tv_sec, &ubuf->st_atime) || |
| 88 | __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) || |
| 89 | __put_user(stat->mtime.tv_sec, &ubuf->st_mtime) || |
| 90 | __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) || |
| 91 | __put_user(stat->ctime.tv_sec, &ubuf->st_ctime) || |
| 92 | __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) || |
| 93 | __put_user(stat->blksize, &ubuf->st_blksize) || |
| 94 | __put_user(stat->blocks, &ubuf->st_blocks)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | return -EFAULT; |
| 96 | return 0; |
| 97 | } |
| 98 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 99 | asmlinkage long sys32_stat64(const char __user *filename, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 100 | struct stat64 __user *statbuf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | { |
| 102 | struct kstat stat; |
| 103 | int ret = vfs_stat(filename, &stat); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 104 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | if (!ret) |
| 106 | ret = cp_stat64(statbuf, &stat); |
| 107 | return ret; |
| 108 | } |
| 109 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 110 | asmlinkage long sys32_lstat64(const char __user *filename, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 111 | struct stat64 __user *statbuf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | { |
| 113 | struct kstat stat; |
| 114 | int ret = vfs_lstat(filename, &stat); |
| 115 | if (!ret) |
| 116 | ret = cp_stat64(statbuf, &stat); |
| 117 | return ret; |
| 118 | } |
| 119 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 120 | asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | { |
| 122 | struct kstat stat; |
| 123 | int ret = vfs_fstat(fd, &stat); |
| 124 | if (!ret) |
| 125 | ret = cp_stat64(statbuf, &stat); |
| 126 | return ret; |
| 127 | } |
| 128 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 129 | asmlinkage long sys32_fstatat(unsigned int dfd, const char __user *filename, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 130 | struct stat64 __user *statbuf, int flag) |
Ulrich Drepper | cff2b76 | 2006-02-11 17:55:47 -0800 | [diff] [blame] | 131 | { |
| 132 | struct kstat stat; |
Oleg Drokin | 0112fc2 | 2009-04-08 20:05:42 +0400 | [diff] [blame] | 133 | int error; |
Ulrich Drepper | cff2b76 | 2006-02-11 17:55:47 -0800 | [diff] [blame] | 134 | |
Oleg Drokin | 0112fc2 | 2009-04-08 20:05:42 +0400 | [diff] [blame] | 135 | error = vfs_fstatat(dfd, filename, &stat, flag); |
| 136 | if (error) |
| 137 | return error; |
| 138 | return cp_stat64(statbuf, &stat); |
Ulrich Drepper | cff2b76 | 2006-02-11 17:55:47 -0800 | [diff] [blame] | 139 | } |
| 140 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | /* |
| 142 | * Linux/i386 didn't use to be able to handle more than |
| 143 | * 4 system call parameters, so these system calls used a memory |
| 144 | * block for parameter passing.. |
| 145 | */ |
| 146 | |
Christoph Hellwig | a467937 | 2010-03-10 15:21:15 -0800 | [diff] [blame] | 147 | struct mmap_arg_struct32 { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | unsigned int addr; |
| 149 | unsigned int len; |
| 150 | unsigned int prot; |
| 151 | unsigned int flags; |
| 152 | unsigned int fd; |
| 153 | unsigned int offset; |
| 154 | }; |
| 155 | |
Christoph Hellwig | a467937 | 2010-03-10 15:21:15 -0800 | [diff] [blame] | 156 | asmlinkage long sys32_mmap(struct mmap_arg_struct32 __user *arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | { |
Christoph Hellwig | a467937 | 2010-03-10 15:21:15 -0800 | [diff] [blame] | 158 | struct mmap_arg_struct32 a; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
| 160 | if (copy_from_user(&a, arg, sizeof(a))) |
| 161 | return -EFAULT; |
| 162 | |
| 163 | if (a.offset & ~PAGE_MASK) |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 164 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | |
Al Viro | f8b7256 | 2009-11-30 17:37:04 -0500 | [diff] [blame] | 166 | return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 167 | a.offset>>PAGE_SHIFT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | } |
| 169 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 170 | asmlinkage long sys32_mprotect(unsigned long start, size_t len, |
| 171 | unsigned long prot) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | { |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 173 | return sys_mprotect(start, len, prot); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | } |
| 175 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 176 | asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act, |
| 177 | struct sigaction32 __user *oact, |
| 178 | unsigned int sigsetsize) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | { |
| 180 | struct k_sigaction new_ka, old_ka; |
| 181 | int ret; |
| 182 | compat_sigset_t set32; |
| 183 | |
| 184 | /* XXX: Don't preclude handling different sized sigset_t's. */ |
| 185 | if (sigsetsize != sizeof(compat_sigset_t)) |
| 186 | return -EINVAL; |
| 187 | |
| 188 | if (act) { |
| 189 | compat_uptr_t handler, restorer; |
| 190 | |
| 191 | if (!access_ok(VERIFY_READ, act, sizeof(*act)) || |
| 192 | __get_user(handler, &act->sa_handler) || |
| 193 | __get_user(new_ka.sa.sa_flags, &act->sa_flags) || |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 194 | __get_user(restorer, &act->sa_restorer) || |
| 195 | __copy_from_user(&set32, &act->sa_mask, |
| 196 | sizeof(compat_sigset_t))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | return -EFAULT; |
| 198 | new_ka.sa.sa_handler = compat_ptr(handler); |
| 199 | new_ka.sa.sa_restorer = compat_ptr(restorer); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 200 | |
| 201 | /* |
| 202 | * FIXME: here we rely on _COMPAT_NSIG_WORS to be >= |
| 203 | * than _NSIG_WORDS << 1 |
| 204 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | switch (_NSIG_WORDS) { |
| 206 | case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] |
| 207 | | (((long)set32.sig[7]) << 32); |
| 208 | case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] |
| 209 | | (((long)set32.sig[5]) << 32); |
| 210 | case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] |
| 211 | | (((long)set32.sig[3]) << 32); |
| 212 | case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] |
| 213 | | (((long)set32.sig[1]) << 32); |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); |
| 218 | |
| 219 | if (!ret && oact) { |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 220 | /* |
| 221 | * FIXME: here we rely on _COMPAT_NSIG_WORS to be >= |
| 222 | * than _NSIG_WORDS << 1 |
| 223 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | switch (_NSIG_WORDS) { |
| 225 | case 4: |
| 226 | set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); |
| 227 | set32.sig[6] = old_ka.sa.sa_mask.sig[3]; |
| 228 | case 3: |
| 229 | set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); |
| 230 | set32.sig[4] = old_ka.sa.sa_mask.sig[2]; |
| 231 | case 2: |
| 232 | set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); |
| 233 | set32.sig[2] = old_ka.sa.sa_mask.sig[1]; |
| 234 | case 1: |
| 235 | set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); |
| 236 | set32.sig[0] = old_ka.sa.sa_mask.sig[0]; |
| 237 | } |
| 238 | if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 239 | __put_user(ptr_to_compat(old_ka.sa.sa_handler), |
| 240 | &oact->sa_handler) || |
| 241 | __put_user(ptr_to_compat(old_ka.sa.sa_restorer), |
| 242 | &oact->sa_restorer) || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 244 | __copy_to_user(&oact->sa_mask, &set32, |
| 245 | sizeof(compat_sigset_t))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | return -EFAULT; |
| 247 | } |
| 248 | |
| 249 | return ret; |
| 250 | } |
| 251 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 252 | asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act, |
| 253 | struct old_sigaction32 __user *oact) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | { |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 255 | struct k_sigaction new_ka, old_ka; |
| 256 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 258 | if (act) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | compat_old_sigset_t mask; |
| 260 | compat_uptr_t handler, restorer; |
| 261 | |
| 262 | if (!access_ok(VERIFY_READ, act, sizeof(*act)) || |
| 263 | __get_user(handler, &act->sa_handler) || |
| 264 | __get_user(new_ka.sa.sa_flags, &act->sa_flags) || |
| 265 | __get_user(restorer, &act->sa_restorer) || |
| 266 | __get_user(mask, &act->sa_mask)) |
| 267 | return -EFAULT; |
| 268 | |
| 269 | new_ka.sa.sa_handler = compat_ptr(handler); |
| 270 | new_ka.sa.sa_restorer = compat_ptr(restorer); |
| 271 | |
| 272 | siginitset(&new_ka.sa.sa_mask, mask); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 273 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 275 | ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | |
| 277 | if (!ret && oact) { |
| 278 | if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 279 | __put_user(ptr_to_compat(old_ka.sa.sa_handler), |
| 280 | &oact->sa_handler) || |
| 281 | __put_user(ptr_to_compat(old_ka.sa.sa_restorer), |
| 282 | &oact->sa_restorer) || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || |
| 284 | __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) |
| 285 | return -EFAULT; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 286 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | |
| 288 | return ret; |
| 289 | } |
| 290 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 291 | asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, |
| 292 | compat_sigset_t __user *oset, |
| 293 | unsigned int sigsetsize) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | { |
| 295 | sigset_t s; |
| 296 | compat_sigset_t s32; |
| 297 | int ret; |
| 298 | mm_segment_t old_fs = get_fs(); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 299 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | if (set) { |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 301 | if (copy_from_user(&s32, set, sizeof(compat_sigset_t))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | return -EFAULT; |
| 303 | switch (_NSIG_WORDS) { |
| 304 | case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); |
| 305 | case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); |
| 306 | case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); |
| 307 | case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); |
| 308 | } |
| 309 | } |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 310 | set_fs(KERNEL_DS); |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 311 | ret = sys_rt_sigprocmask(how, |
| 312 | set ? (sigset_t __user *)&s : NULL, |
| 313 | oset ? (sigset_t __user *)&s : NULL, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 314 | sigsetsize); |
| 315 | set_fs(old_fs); |
| 316 | if (ret) |
| 317 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | if (oset) { |
| 319 | switch (_NSIG_WORDS) { |
| 320 | case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; |
| 321 | case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; |
| 322 | case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; |
| 323 | case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; |
| 324 | } |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 325 | if (copy_to_user(oset, &s32, sizeof(compat_sigset_t))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | return -EFAULT; |
| 327 | } |
| 328 | return 0; |
| 329 | } |
| 330 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 331 | asmlinkage long sys32_alarm(unsigned int seconds) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | { |
Thomas Gleixner | c08b8a4 | 2006-03-25 03:06:33 -0800 | [diff] [blame] | 333 | return alarm_setitimer(seconds); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | } |
| 335 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 336 | asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr, |
| 337 | int options) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | { |
| 339 | return compat_sys_wait4(pid, stat_addr, options, NULL); |
| 340 | } |
| 341 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | /* 32-bit timeval and related flotsam. */ |
| 343 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 344 | asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | { |
| 346 | return sys_sysfs(option, arg1, arg2); |
| 347 | } |
| 348 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 349 | asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid, |
| 350 | struct compat_timespec __user *interval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | { |
| 352 | struct timespec t; |
| 353 | int ret; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 354 | mm_segment_t old_fs = get_fs(); |
| 355 | |
| 356 | set_fs(KERNEL_DS); |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 357 | ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 358 | set_fs(old_fs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | if (put_compat_timespec(&t, interval)) |
| 360 | return -EFAULT; |
| 361 | return ret; |
| 362 | } |
| 363 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 364 | asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set, |
| 365 | compat_size_t sigsetsize) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | { |
| 367 | sigset_t s; |
| 368 | compat_sigset_t s32; |
| 369 | int ret; |
| 370 | mm_segment_t old_fs = get_fs(); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 371 | |
| 372 | set_fs(KERNEL_DS); |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 373 | ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 374 | set_fs(old_fs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | if (!ret) { |
| 376 | switch (_NSIG_WORDS) { |
| 377 | case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; |
| 378 | case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; |
| 379 | case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; |
| 380 | case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; |
| 381 | } |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 382 | if (copy_to_user(set, &s32, sizeof(compat_sigset_t))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | return -EFAULT; |
| 384 | } |
| 385 | return ret; |
| 386 | } |
| 387 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 388 | asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig, |
| 389 | compat_siginfo_t __user *uinfo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | { |
| 391 | siginfo_t info; |
| 392 | int ret; |
| 393 | mm_segment_t old_fs = get_fs(); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 394 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | if (copy_siginfo_from_user32(&info, uinfo)) |
| 396 | return -EFAULT; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 397 | set_fs(KERNEL_DS); |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 398 | ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 399 | set_fs(old_fs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | return ret; |
| 401 | } |
| 402 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 403 | /* warning: next two assume little endian */ |
| 404 | asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count, |
| 405 | u32 poslo, u32 poshi) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | { |
| 407 | return sys_pread64(fd, ubuf, count, |
| 408 | ((loff_t)AA(poshi) << 32) | AA(poslo)); |
| 409 | } |
| 410 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 411 | asmlinkage long sys32_pwrite(unsigned int fd, const char __user *ubuf, |
| 412 | u32 count, u32 poslo, u32 poshi) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | { |
| 414 | return sys_pwrite64(fd, ubuf, count, |
| 415 | ((loff_t)AA(poshi) << 32) | AA(poslo)); |
| 416 | } |
| 417 | |
| 418 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 419 | asmlinkage long sys32_personality(unsigned long personality) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | { |
| 421 | int ret; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 422 | |
| 423 | if (personality(current->personality) == PER_LINUX32 && |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | personality == PER_LINUX) |
| 425 | personality = PER_LINUX32; |
| 426 | ret = sys_personality(personality); |
| 427 | if (ret == PER_LINUX32) |
| 428 | ret = PER_LINUX; |
| 429 | return ret; |
| 430 | } |
| 431 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 432 | asmlinkage long sys32_sendfile(int out_fd, int in_fd, |
| 433 | compat_off_t __user *offset, s32 count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | { |
| 435 | mm_segment_t old_fs = get_fs(); |
| 436 | int ret; |
| 437 | off_t of; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 438 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | if (offset && get_user(of, offset)) |
| 440 | return -EFAULT; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 441 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | set_fs(KERNEL_DS); |
Andi Kleen | ddb15ec | 2006-09-26 10:52:33 +0200 | [diff] [blame] | 443 | ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, |
| 444 | count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | set_fs(old_fs); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 446 | |
Tsuneo.Yoshioka@f-secure.com | 83b942b | 2005-09-12 18:49:24 +0200 | [diff] [blame] | 447 | if (offset && put_user(of, offset)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | return ret; |
| 450 | } |
| 451 | |
David Howells | c788732 | 2010-08-11 11:26:22 +0100 | [diff] [blame] | 452 | asmlinkage long sys32_execve(const char __user *name, compat_uptr_t __user *argv, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | compat_uptr_t __user *envp, struct pt_regs *regs) |
| 454 | { |
| 455 | long error; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 456 | char *filename; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | |
| 458 | filename = getname(name); |
| 459 | error = PTR_ERR(filename); |
| 460 | if (IS_ERR(filename)) |
| 461 | return error; |
| 462 | error = compat_do_execve(filename, argv, envp, regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 463 | putname(filename); |
| 464 | return error; |
| 465 | } |
| 466 | |
| 467 | asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp, |
| 468 | struct pt_regs *regs) |
| 469 | { |
H. Peter Anvin | 65ea5b0 | 2008-01-30 13:30:56 +0100 | [diff] [blame] | 470 | void __user *parent_tid = (void __user *)regs->dx; |
| 471 | void __user *child_tid = (void __user *)regs->di; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 472 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | if (!newsp) |
H. Peter Anvin | 65ea5b0 | 2008-01-30 13:30:56 +0100 | [diff] [blame] | 474 | newsp = regs->sp; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 475 | return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 476 | } |
| 477 | |
| 478 | /* |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 479 | * Some system calls that need sign extended arguments. This could be |
| 480 | * done by a generic wrapper. |
| 481 | */ |
| 482 | long sys32_lseek(unsigned int fd, int offset, unsigned int whence) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | { |
| 484 | return sys_lseek(fd, offset, whence); |
| 485 | } |
| 486 | |
| 487 | long sys32_kill(int pid, int sig) |
| 488 | { |
| 489 | return sys_kill(pid, sig); |
| 490 | } |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 491 | |
| 492 | long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | __u32 len_low, __u32 len_high, int advice) |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 494 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | return sys_fadvise64_64(fd, |
| 496 | (((u64)offset_high)<<32) | offset_low, |
| 497 | (((u64)len_high)<<32) | len_low, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 498 | advice); |
| 499 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | |
| 501 | long sys32_vm86_warning(void) |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 502 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | struct task_struct *me = current; |
| 504 | static char lastcomm[sizeof(me->comm)]; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 505 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) { |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 507 | compat_printk(KERN_INFO |
| 508 | "%s: vm86 mode not supported on 64 bit kernel\n", |
| 509 | me->comm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | strncpy(lastcomm, me->comm, sizeof(lastcomm)); |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 511 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | return -ENOSYS; |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 513 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | |
| 515 | long sys32_lookup_dcookie(u32 addr_low, u32 addr_high, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 516 | char __user *buf, size_t len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 517 | { |
| 518 | return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len); |
| 519 | } |
| 520 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 521 | asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi, |
| 522 | size_t count) |
Andi Kleen | e412ac4 | 2007-06-20 12:23:30 +0200 | [diff] [blame] | 523 | { |
| 524 | return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count); |
| 525 | } |
| 526 | |
| 527 | asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi, |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 528 | unsigned n_low, unsigned n_hi, int flags) |
Andi Kleen | e412ac4 | 2007-06-20 12:23:30 +0200 | [diff] [blame] | 529 | { |
| 530 | return sys_sync_file_range(fd, |
| 531 | ((u64)off_hi << 32) | off_low, |
| 532 | ((u64)n_hi << 32) | n_low, flags); |
| 533 | } |
| 534 | |
Thomas Gleixner | c202f29 | 2008-01-30 13:30:08 +0100 | [diff] [blame] | 535 | asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi, |
| 536 | size_t len, int advice) |
Andi Kleen | e412ac4 | 2007-06-20 12:23:30 +0200 | [diff] [blame] | 537 | { |
| 538 | return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo, |
| 539 | len, advice); |
| 540 | } |
Amit Arora | 97ac735 | 2007-07-17 21:42:44 -0400 | [diff] [blame] | 541 | |
| 542 | asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo, |
| 543 | unsigned offset_hi, unsigned len_lo, |
| 544 | unsigned len_hi) |
| 545 | { |
| 546 | return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo, |
| 547 | ((u64)len_hi << 32) | len_lo); |
| 548 | } |
Eric Paris | bbaa416 | 2009-12-17 21:24:26 -0500 | [diff] [blame] | 549 | |
| 550 | asmlinkage long sys32_fanotify_mark(int fanotify_fd, unsigned int flags, |
| 551 | u32 mask_lo, u32 mask_hi, |
| 552 | int fd, const char __user *pathname) |
| 553 | { |
| 554 | return sys_fanotify_mark(fanotify_fd, flags, |
| 555 | ((u64)mask_hi << 32) | mask_lo, |
| 556 | fd, pathname); |
| 557 | } |