blob: 849813f398e75e8f699b5a5e999efad7df1a76a8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
Thomas Gleixnerc202f292008-01-30 13:30:08 +01003 * sys_sparc32
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Copyright (C) 2000 VA Linux Co
6 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
Thomas Gleixnerc202f292008-01-30 13:30:08 +01007 * 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 Torvalds1da177e2005-04-16 15:20:36 -070010 * Copyright (C) 2000 Hewlett-Packard Co.
11 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
Thomas Gleixnerc202f292008-01-30 13:30:08 +010012 * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
14 * These routines maintain argument size conversion between 32bit and 64bit
Thomas Gleixnerc202f292008-01-30 13:30:08 +010015 * environment. In 2.5 most of this should be moved to a generic directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 *
17 * This file assumes that there is a hole at the end of user address space.
Thomas Gleixnerc202f292008-01-30 13:30:08 +010018 *
19 * Some of the functions are LE specific currently. These are
20 * hopefully all marked. This should be fixed.
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 */
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/kernel.h>
24#include <linux/sched.h>
Thomas Gleixnerc202f292008-01-30 13:30:08 +010025#include <linux/fs.h>
26#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/signal.h>
28#include <linux/syscalls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/times.h>
30#include <linux/utsname.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/uio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/poll.h>
35#include <linux/personality.h>
36#include <linux/stat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/rwsem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/compat.h>
39#include <linux/vfs.h>
40#include <linux/ptrace.h>
41#include <linux/highuid.h>
Andi Kleenddb15ec2006-09-26 10:52:33 +020042#include <linux/sysctl.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <asm/mman.h>
45#include <asm/types.h>
46#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <asm/atomic.h>
Arnaldo Carvalho de Melo28d23122008-02-07 21:03:04 -020048#include <asm/vgtod.h>
Jaswinder Singh Rajput2f06de02008-12-27 21:37:10 +053049#include <asm/sys_ia32.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51#define AA(__x) ((unsigned long)(__x))
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
David Howellsc7887322010-08-11 11:26:22 +010054asmlinkage long sys32_truncate64(const char __user *filename,
Thomas Gleixnerc202f292008-01-30 13:30:08 +010055 unsigned long offset_low,
56 unsigned long offset_high)
Linus Torvalds1da177e2005-04-16 15:20:36 -070057{
58 return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
59}
60
Thomas Gleixnerc202f292008-01-30 13:30:08 +010061asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low,
62 unsigned long offset_high)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063{
64 return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
65}
66
Thomas Gleixnerc202f292008-01-30 13:30:08 +010067/*
68 * Another set for IA32/LFS -- x86_64 struct stat is different due to
69 * support for 64bit inode numbers.
70 */
71static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
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 Gleixnerc202f292008-01-30 13:30:08 +010079 __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 Torvalds1da177e2005-04-16 15:20:36 -070095 return -EFAULT;
96 return 0;
97}
98
David Howellsc7887322010-08-11 11:26:22 +010099asmlinkage long sys32_stat64(const char __user *filename,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100100 struct stat64 __user *statbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 struct kstat stat;
103 int ret = vfs_stat(filename, &stat);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 if (!ret)
106 ret = cp_stat64(statbuf, &stat);
107 return ret;
108}
109
David Howellsc7887322010-08-11 11:26:22 +0100110asmlinkage long sys32_lstat64(const char __user *filename,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100111 struct stat64 __user *statbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
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 Gleixnerc202f292008-01-30 13:30:08 +0100120asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
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 Howellsc7887322010-08-11 11:26:22 +0100129asmlinkage long sys32_fstatat(unsigned int dfd, const char __user *filename,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100130 struct stat64 __user *statbuf, int flag)
Ulrich Dreppercff2b762006-02-11 17:55:47 -0800131{
132 struct kstat stat;
Oleg Drokin0112fc22009-04-08 20:05:42 +0400133 int error;
Ulrich Dreppercff2b762006-02-11 17:55:47 -0800134
Oleg Drokin0112fc22009-04-08 20:05:42 +0400135 error = vfs_fstatat(dfd, filename, &stat, flag);
136 if (error)
137 return error;
138 return cp_stat64(statbuf, &stat);
Ulrich Dreppercff2b762006-02-11 17:55:47 -0800139}
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/*
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 Hellwiga4679372010-03-10 15:21:15 -0800147struct mmap_arg_struct32 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 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 Hellwiga4679372010-03-10 15:21:15 -0800156asmlinkage long sys32_mmap(struct mmap_arg_struct32 __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
Christoph Hellwiga4679372010-03-10 15:21:15 -0800158 struct mmap_arg_struct32 a;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160 if (copy_from_user(&a, arg, sizeof(a)))
161 return -EFAULT;
162
163 if (a.offset & ~PAGE_MASK)
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100164 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Al Virof8b72562009-11-30 17:37:04 -0500166 return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100167 a.offset>>PAGE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100170asmlinkage long sys32_mprotect(unsigned long start, size_t len,
171 unsigned long prot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100173 return sys_mprotect(start, len, prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100176asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act,
177 struct sigaction32 __user *oact,
178 unsigned int sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
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 Gleixnerc202f292008-01-30 13:30:08 +0100194 __get_user(restorer, &act->sa_restorer) ||
195 __copy_from_user(&set32, &act->sa_mask,
196 sizeof(compat_sigset_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return -EFAULT;
198 new_ka.sa.sa_handler = compat_ptr(handler);
199 new_ka.sa.sa_restorer = compat_ptr(restorer);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100200
201 /*
202 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
203 * than _NSIG_WORDS << 1
204 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 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 Gleixnerc202f292008-01-30 13:30:08 +0100220 /*
221 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
222 * than _NSIG_WORDS << 1
223 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 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 Gleixnerc202f292008-01-30 13:30:08 +0100239 __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 Torvalds1da177e2005-04-16 15:20:36 -0700243 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100244 __copy_to_user(&oact->sa_mask, &set32,
245 sizeof(compat_sigset_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return -EFAULT;
247 }
248
249 return ret;
250}
251
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100252asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act,
253 struct old_sigaction32 __user *oact)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100255 struct k_sigaction new_ka, old_ka;
256 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100258 if (act) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 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 Gleixnerc202f292008-01-30 13:30:08 +0100273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100275 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 if (!ret && oact) {
278 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100279 __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 Torvalds1da177e2005-04-16 15:20:36 -0700283 __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 Gleixnerc202f292008-01-30 13:30:08 +0100286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 return ret;
289}
290
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100291asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
292 compat_sigset_t __user *oset,
293 unsigned int sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294{
295 sigset_t s;
296 compat_sigset_t s32;
297 int ret;
298 mm_segment_t old_fs = get_fs();
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 if (set) {
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100301 if (copy_from_user(&s32, set, sizeof(compat_sigset_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 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 Gleixnerc202f292008-01-30 13:30:08 +0100310 set_fs(KERNEL_DS);
Andi Kleenddb15ec2006-09-26 10:52:33 +0200311 ret = sys_rt_sigprocmask(how,
312 set ? (sigset_t __user *)&s : NULL,
313 oset ? (sigset_t __user *)&s : NULL,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100314 sigsetsize);
315 set_fs(old_fs);
316 if (ret)
317 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 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 Gleixnerc202f292008-01-30 13:30:08 +0100325 if (copy_to_user(oset, &s32, sizeof(compat_sigset_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 return -EFAULT;
327 }
328 return 0;
329}
330
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100331asmlinkage long sys32_alarm(unsigned int seconds)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332{
Thomas Gleixnerc08b8a42006-03-25 03:06:33 -0800333 return alarm_setitimer(seconds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100336asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr,
337 int options)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
339 return compat_sys_wait4(pid, stat_addr, options, NULL);
340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342/* 32-bit timeval and related flotsam. */
343
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100344asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
346 return sys_sysfs(option, arg1, arg2);
347}
348
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100349asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
350 struct compat_timespec __user *interval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
352 struct timespec t;
353 int ret;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100354 mm_segment_t old_fs = get_fs();
355
356 set_fs(KERNEL_DS);
Andi Kleenddb15ec2006-09-26 10:52:33 +0200357 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100358 set_fs(old_fs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (put_compat_timespec(&t, interval))
360 return -EFAULT;
361 return ret;
362}
363
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100364asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
365 compat_size_t sigsetsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
367 sigset_t s;
368 compat_sigset_t s32;
369 int ret;
370 mm_segment_t old_fs = get_fs();
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100371
372 set_fs(KERNEL_DS);
Andi Kleenddb15ec2006-09-26 10:52:33 +0200373 ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100374 set_fs(old_fs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 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 Gleixnerc202f292008-01-30 13:30:08 +0100382 if (copy_to_user(set, &s32, sizeof(compat_sigset_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 return -EFAULT;
384 }
385 return ret;
386}
387
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100388asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig,
389 compat_siginfo_t __user *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
391 siginfo_t info;
392 int ret;
393 mm_segment_t old_fs = get_fs();
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (copy_siginfo_from_user32(&info, uinfo))
396 return -EFAULT;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100397 set_fs(KERNEL_DS);
Andi Kleenddb15ec2006-09-26 10:52:33 +0200398 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100399 set_fs(old_fs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return ret;
401}
402
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100403/* warning: next two assume little endian */
404asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
405 u32 poslo, u32 poshi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 return sys_pread64(fd, ubuf, count,
408 ((loff_t)AA(poshi) << 32) | AA(poslo));
409}
410
David Howellsc7887322010-08-11 11:26:22 +0100411asmlinkage long sys32_pwrite(unsigned int fd, const char __user *ubuf,
412 u32 count, u32 poslo, u32 poshi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
414 return sys_pwrite64(fd, ubuf, count,
415 ((loff_t)AA(poshi) << 32) | AA(poslo));
416}
417
418
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100419asmlinkage long sys32_personality(unsigned long personality)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
421 int ret;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100422
423 if (personality(current->personality) == PER_LINUX32 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 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 Gleixnerc202f292008-01-30 13:30:08 +0100432asmlinkage long sys32_sendfile(int out_fd, int in_fd,
433 compat_off_t __user *offset, s32 count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 mm_segment_t old_fs = get_fs();
436 int ret;
437 off_t of;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 if (offset && get_user(of, offset))
440 return -EFAULT;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 set_fs(KERNEL_DS);
Andi Kleenddb15ec2006-09-26 10:52:33 +0200443 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
444 count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 set_fs(old_fs);
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100446
Tsuneo.Yoshioka@f-secure.com83b942b2005-09-12 18:49:24 +0200447 if (offset && put_user(of, offset))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return ret;
450}
451
David Howellsc7887322010-08-11 11:26:22 +0100452asmlinkage long sys32_execve(const char __user *name, compat_uptr_t __user *argv,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 compat_uptr_t __user *envp, struct pt_regs *regs)
454{
455 long error;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100456 char *filename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
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 Torvalds1da177e2005-04-16 15:20:36 -0700463 putname(filename);
464 return error;
465}
466
467asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
468 struct pt_regs *regs)
469{
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100470 void __user *parent_tid = (void __user *)regs->dx;
471 void __user *child_tid = (void __user *)regs->di;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (!newsp)
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100474 newsp = regs->sp;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100475 return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
478/*
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100479 * Some system calls that need sign extended arguments. This could be
480 * done by a generic wrapper.
481 */
482long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
484 return sys_lseek(fd, offset, whence);
485}
486
487long sys32_kill(int pid, int sig)
488{
489 return sys_kill(pid, sig);
490}
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100491
492long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 __u32 len_low, __u32 len_high, int advice)
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100494{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return sys_fadvise64_64(fd,
496 (((u64)offset_high)<<32) | offset_low,
497 (((u64)len_high)<<32) | len_low,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100498 advice);
499}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501long sys32_vm86_warning(void)
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100502{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 struct task_struct *me = current;
504 static char lastcomm[sizeof(me->comm)];
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100507 compat_printk(KERN_INFO
508 "%s: vm86 mode not supported on 64 bit kernel\n",
509 me->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 strncpy(lastcomm, me->comm, sizeof(lastcomm));
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return -ENOSYS;
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100513}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100516 char __user *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
519}
520
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100521asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
522 size_t count)
Andi Kleene412ac42007-06-20 12:23:30 +0200523{
524 return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
525}
526
527asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
Thomas Gleixnerc202f292008-01-30 13:30:08 +0100528 unsigned n_low, unsigned n_hi, int flags)
Andi Kleene412ac42007-06-20 12:23:30 +0200529{
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 Gleixnerc202f292008-01-30 13:30:08 +0100535asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
536 size_t len, int advice)
Andi Kleene412ac42007-06-20 12:23:30 +0200537{
538 return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
539 len, advice);
540}
Amit Arora97ac7352007-07-17 21:42:44 -0400541
542asmlinkage 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 Parisbbaa4162009-12-17 21:24:26 -0500549
550asmlinkage 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}