flag parameters: pipe
[linux-2.6.git] / arch / x86 / ia32 / sys_ia32.c
1 /*
2  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
3  *             sys_sparc32
4  *
5  * Copyright (C) 2000           VA Linux Co
6  * Copyright (C) 2000           Don Dugger <n0ano@valinux.com>
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)
10  * Copyright (C) 2000           Hewlett-Packard Co.
11  * Copyright (C) 2000           David Mosberger-Tang <davidm@hpl.hp.com>
12  * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
13  *
14  * These routines maintain argument size conversion between 32bit and 64bit
15  * environment. In 2.5 most of this should be moved to a generic directory.
16  *
17  * This file assumes that there is a hole at the end of user address space.
18  *
19  * Some of the functions are LE specific currently. These are
20  * hopefully all marked.  This should be fixed.
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/fs.h>
26 #include <linux/file.h>
27 #include <linux/signal.h>
28 #include <linux/syscalls.h>
29 #include <linux/times.h>
30 #include <linux/utsname.h>
31 #include <linux/smp_lock.h>
32 #include <linux/mm.h>
33 #include <linux/uio.h>
34 #include <linux/poll.h>
35 #include <linux/personality.h>
36 #include <linux/stat.h>
37 #include <linux/rwsem.h>
38 #include <linux/compat.h>
39 #include <linux/vfs.h>
40 #include <linux/ptrace.h>
41 #include <linux/highuid.h>
42 #include <linux/sysctl.h>
43 #include <asm/mman.h>
44 #include <asm/types.h>
45 #include <asm/uaccess.h>
46 #include <asm/atomic.h>
47 #include <asm/ia32.h>
48 #include <asm/vgtod.h>
49
50 #define AA(__x)         ((unsigned long)(__x))
51
52 int cp_compat_stat(struct kstat *kbuf, struct compat_stat __user *ubuf)
53 {
54         compat_ino_t ino;
55
56         typeof(ubuf->st_uid) uid = 0;
57         typeof(ubuf->st_gid) gid = 0;
58         SET_UID(uid, kbuf->uid);
59         SET_GID(gid, kbuf->gid);
60         if (!old_valid_dev(kbuf->dev) || !old_valid_dev(kbuf->rdev))
61                 return -EOVERFLOW;
62         if (kbuf->size >= 0x7fffffff)
63                 return -EOVERFLOW;
64         ino = kbuf->ino;
65         if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
66                 return -EOVERFLOW;
67         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct compat_stat)) ||
68             __put_user(old_encode_dev(kbuf->dev), &ubuf->st_dev) ||
69             __put_user(ino, &ubuf->st_ino) ||
70             __put_user(kbuf->mode, &ubuf->st_mode) ||
71             __put_user(kbuf->nlink, &ubuf->st_nlink) ||
72             __put_user(uid, &ubuf->st_uid) ||
73             __put_user(gid, &ubuf->st_gid) ||
74             __put_user(old_encode_dev(kbuf->rdev), &ubuf->st_rdev) ||
75             __put_user(kbuf->size, &ubuf->st_size) ||
76             __put_user(kbuf->atime.tv_sec, &ubuf->st_atime) ||
77             __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec) ||
78             __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime) ||
79             __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
80             __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime) ||
81             __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
82             __put_user(kbuf->blksize, &ubuf->st_blksize) ||
83             __put_user(kbuf->blocks, &ubuf->st_blocks))
84                 return -EFAULT;
85         return 0;
86 }
87
88 asmlinkage long sys32_truncate64(char __user *filename,
89                                  unsigned long offset_low,
90                                  unsigned long offset_high)
91 {
92        return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
93 }
94
95 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low,
96                                   unsigned long offset_high)
97 {
98        return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
99 }
100
101 /*
102  * Another set for IA32/LFS -- x86_64 struct stat is different due to
103  * support for 64bit inode numbers.
104  */
105 static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
106 {
107         typeof(ubuf->st_uid) uid = 0;
108         typeof(ubuf->st_gid) gid = 0;
109         SET_UID(uid, stat->uid);
110         SET_GID(gid, stat->gid);
111         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
112             __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
113             __put_user(stat->ino, &ubuf->__st_ino) ||
114             __put_user(stat->ino, &ubuf->st_ino) ||
115             __put_user(stat->mode, &ubuf->st_mode) ||
116             __put_user(stat->nlink, &ubuf->st_nlink) ||
117             __put_user(uid, &ubuf->st_uid) ||
118             __put_user(gid, &ubuf->st_gid) ||
119             __put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) ||
120             __put_user(stat->size, &ubuf->st_size) ||
121             __put_user(stat->atime.tv_sec, &ubuf->st_atime) ||
122             __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) ||
123             __put_user(stat->mtime.tv_sec, &ubuf->st_mtime) ||
124             __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
125             __put_user(stat->ctime.tv_sec, &ubuf->st_ctime) ||
126             __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
127             __put_user(stat->blksize, &ubuf->st_blksize) ||
128             __put_user(stat->blocks, &ubuf->st_blocks))
129                 return -EFAULT;
130         return 0;
131 }
132
133 asmlinkage long sys32_stat64(char __user *filename,
134                              struct stat64 __user *statbuf)
135 {
136         struct kstat stat;
137         int ret = vfs_stat(filename, &stat);
138
139         if (!ret)
140                 ret = cp_stat64(statbuf, &stat);
141         return ret;
142 }
143
144 asmlinkage long sys32_lstat64(char __user *filename,
145                               struct stat64 __user *statbuf)
146 {
147         struct kstat stat;
148         int ret = vfs_lstat(filename, &stat);
149         if (!ret)
150                 ret = cp_stat64(statbuf, &stat);
151         return ret;
152 }
153
154 asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
155 {
156         struct kstat stat;
157         int ret = vfs_fstat(fd, &stat);
158         if (!ret)
159                 ret = cp_stat64(statbuf, &stat);
160         return ret;
161 }
162
163 asmlinkage long sys32_fstatat(unsigned int dfd, char __user *filename,
164                               struct stat64 __user *statbuf, int flag)
165 {
166         struct kstat stat;
167         int error = -EINVAL;
168
169         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
170                 goto out;
171
172         if (flag & AT_SYMLINK_NOFOLLOW)
173                 error = vfs_lstat_fd(dfd, filename, &stat);
174         else
175                 error = vfs_stat_fd(dfd, filename, &stat);
176
177         if (!error)
178                 error = cp_stat64(statbuf, &stat);
179
180 out:
181         return error;
182 }
183
184 /*
185  * Linux/i386 didn't use to be able to handle more than
186  * 4 system call parameters, so these system calls used a memory
187  * block for parameter passing..
188  */
189
190 struct mmap_arg_struct {
191         unsigned int addr;
192         unsigned int len;
193         unsigned int prot;
194         unsigned int flags;
195         unsigned int fd;
196         unsigned int offset;
197 };
198
199 asmlinkage long sys32_mmap(struct mmap_arg_struct __user *arg)
200 {
201         struct mmap_arg_struct a;
202         struct file *file = NULL;
203         unsigned long retval;
204         struct mm_struct *mm ;
205
206         if (copy_from_user(&a, arg, sizeof(a)))
207                 return -EFAULT;
208
209         if (a.offset & ~PAGE_MASK)
210                 return -EINVAL;
211
212         if (!(a.flags & MAP_ANONYMOUS)) {
213                 file = fget(a.fd);
214                 if (!file)
215                         return -EBADF;
216         }
217
218         mm = current->mm;
219         down_write(&mm->mmap_sem);
220         retval = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags,
221                                a.offset>>PAGE_SHIFT);
222         if (file)
223                 fput(file);
224
225         up_write(&mm->mmap_sem);
226
227         return retval;
228 }
229
230 asmlinkage long sys32_mprotect(unsigned long start, size_t len,
231                                unsigned long prot)
232 {
233         return sys_mprotect(start, len, prot);
234 }
235
236 asmlinkage long sys32_pipe(int __user *fd)
237 {
238         int retval;
239         int fds[2];
240
241         retval = do_pipe_flags(fds, 0);
242         if (retval)
243                 goto out;
244         if (copy_to_user(fd, fds, sizeof(fds)))
245                 retval = -EFAULT;
246 out:
247         return retval;
248 }
249
250 asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act,
251                                    struct sigaction32 __user *oact,
252                                    unsigned int sigsetsize)
253 {
254         struct k_sigaction new_ka, old_ka;
255         int ret;
256         compat_sigset_t set32;
257
258         /* XXX: Don't preclude handling different sized sigset_t's.  */
259         if (sigsetsize != sizeof(compat_sigset_t))
260                 return -EINVAL;
261
262         if (act) {
263                 compat_uptr_t handler, restorer;
264
265                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
266                     __get_user(handler, &act->sa_handler) ||
267                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
268                     __get_user(restorer, &act->sa_restorer) ||
269                     __copy_from_user(&set32, &act->sa_mask,
270                                      sizeof(compat_sigset_t)))
271                         return -EFAULT;
272                 new_ka.sa.sa_handler = compat_ptr(handler);
273                 new_ka.sa.sa_restorer = compat_ptr(restorer);
274
275                 /*
276                  * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
277                  * than _NSIG_WORDS << 1
278                  */
279                 switch (_NSIG_WORDS) {
280                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
281                                 | (((long)set32.sig[7]) << 32);
282                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
283                                 | (((long)set32.sig[5]) << 32);
284                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
285                                 | (((long)set32.sig[3]) << 32);
286                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
287                                 | (((long)set32.sig[1]) << 32);
288                 }
289         }
290
291         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
292
293         if (!ret && oact) {
294                 /*
295                  * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
296                  * than _NSIG_WORDS << 1
297                  */
298                 switch (_NSIG_WORDS) {
299                 case 4:
300                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
301                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
302                 case 3:
303                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
304                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
305                 case 2:
306                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
307                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
308                 case 1:
309                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
310                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
311                 }
312                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
313                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
314                                &oact->sa_handler) ||
315                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
316                                &oact->sa_restorer) ||
317                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
318                     __copy_to_user(&oact->sa_mask, &set32,
319                                    sizeof(compat_sigset_t)))
320                         return -EFAULT;
321         }
322
323         return ret;
324 }
325
326 asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act,
327                                 struct old_sigaction32 __user *oact)
328 {
329         struct k_sigaction new_ka, old_ka;
330         int ret;
331
332         if (act) {
333                 compat_old_sigset_t mask;
334                 compat_uptr_t handler, restorer;
335
336                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
337                     __get_user(handler, &act->sa_handler) ||
338                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
339                     __get_user(restorer, &act->sa_restorer) ||
340                     __get_user(mask, &act->sa_mask))
341                         return -EFAULT;
342
343                 new_ka.sa.sa_handler = compat_ptr(handler);
344                 new_ka.sa.sa_restorer = compat_ptr(restorer);
345
346                 siginitset(&new_ka.sa.sa_mask, mask);
347         }
348
349         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
350
351         if (!ret && oact) {
352                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
353                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
354                                &oact->sa_handler) ||
355                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
356                                &oact->sa_restorer) ||
357                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
358                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
359                         return -EFAULT;
360         }
361
362         return ret;
363 }
364
365 asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
366                                      compat_sigset_t __user *oset,
367                                      unsigned int sigsetsize)
368 {
369         sigset_t s;
370         compat_sigset_t s32;
371         int ret;
372         mm_segment_t old_fs = get_fs();
373
374         if (set) {
375                 if (copy_from_user(&s32, set, sizeof(compat_sigset_t)))
376                         return -EFAULT;
377                 switch (_NSIG_WORDS) {
378                 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
379                 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
380                 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
381                 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
382                 }
383         }
384         set_fs(KERNEL_DS);
385         ret = sys_rt_sigprocmask(how,
386                                  set ? (sigset_t __user *)&s : NULL,
387                                  oset ? (sigset_t __user *)&s : NULL,
388                                  sigsetsize);
389         set_fs(old_fs);
390         if (ret)
391                 return ret;
392         if (oset) {
393                 switch (_NSIG_WORDS) {
394                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
395                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
396                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
397                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
398                 }
399                 if (copy_to_user(oset, &s32, sizeof(compat_sigset_t)))
400                         return -EFAULT;
401         }
402         return 0;
403 }
404
405 static inline long get_tv32(struct timeval *o, struct compat_timeval __user *i)
406 {
407         int err = -EFAULT;
408
409         if (access_ok(VERIFY_READ, i, sizeof(*i))) {
410                 err = __get_user(o->tv_sec, &i->tv_sec);
411                 err |= __get_user(o->tv_usec, &i->tv_usec);
412         }
413         return err;
414 }
415
416 static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
417 {
418         int err = -EFAULT;
419
420         if (access_ok(VERIFY_WRITE, o, sizeof(*o))) {
421                 err = __put_user(i->tv_sec, &o->tv_sec);
422                 err |= __put_user(i->tv_usec, &o->tv_usec);
423         }
424         return err;
425 }
426
427 asmlinkage long sys32_alarm(unsigned int seconds)
428 {
429         return alarm_setitimer(seconds);
430 }
431
432 /*
433  * Translations due to time_t size differences. Which affects all
434  * sorts of things, like timeval and itimerval.
435  */
436 asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv,
437                                    struct timezone __user *tz)
438 {
439         if (tv) {
440                 struct timeval ktv;
441
442                 do_gettimeofday(&ktv);
443                 if (put_tv32(tv, &ktv))
444                         return -EFAULT;
445         }
446         if (tz) {
447                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
448                         return -EFAULT;
449         }
450         return 0;
451 }
452
453 asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv,
454                                    struct timezone __user *tz)
455 {
456         struct timeval ktv;
457         struct timespec kts;
458         struct timezone ktz;
459
460         if (tv) {
461                 if (get_tv32(&ktv, tv))
462                         return -EFAULT;
463                 kts.tv_sec = ktv.tv_sec;
464                 kts.tv_nsec = ktv.tv_usec * NSEC_PER_USEC;
465         }
466         if (tz) {
467                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
468                         return -EFAULT;
469         }
470
471         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
472 }
473
474 struct sel_arg_struct {
475         unsigned int n;
476         unsigned int inp;
477         unsigned int outp;
478         unsigned int exp;
479         unsigned int tvp;
480 };
481
482 asmlinkage long sys32_old_select(struct sel_arg_struct __user *arg)
483 {
484         struct sel_arg_struct a;
485
486         if (copy_from_user(&a, arg, sizeof(a)))
487                 return -EFAULT;
488         return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
489                                  compat_ptr(a.exp), compat_ptr(a.tvp));
490 }
491
492 asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr,
493                               int options)
494 {
495         return compat_sys_wait4(pid, stat_addr, options, NULL);
496 }
497
498 /* 32-bit timeval and related flotsam.  */
499
500 asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2)
501 {
502         return sys_sysfs(option, arg1, arg2);
503 }
504
505 asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
506                                     struct compat_timespec __user *interval)
507 {
508         struct timespec t;
509         int ret;
510         mm_segment_t old_fs = get_fs();
511
512         set_fs(KERNEL_DS);
513         ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
514         set_fs(old_fs);
515         if (put_compat_timespec(&t, interval))
516                 return -EFAULT;
517         return ret;
518 }
519
520 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
521                                     compat_size_t sigsetsize)
522 {
523         sigset_t s;
524         compat_sigset_t s32;
525         int ret;
526         mm_segment_t old_fs = get_fs();
527
528         set_fs(KERNEL_DS);
529         ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize);
530         set_fs(old_fs);
531         if (!ret) {
532                 switch (_NSIG_WORDS) {
533                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
534                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
535                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
536                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
537                 }
538                 if (copy_to_user(set, &s32, sizeof(compat_sigset_t)))
539                         return -EFAULT;
540         }
541         return ret;
542 }
543
544 asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig,
545                                       compat_siginfo_t __user *uinfo)
546 {
547         siginfo_t info;
548         int ret;
549         mm_segment_t old_fs = get_fs();
550
551         if (copy_siginfo_from_user32(&info, uinfo))
552                 return -EFAULT;
553         set_fs(KERNEL_DS);
554         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
555         set_fs(old_fs);
556         return ret;
557 }
558
559 /* These are here just in case some old ia32 binary calls it. */
560 asmlinkage long sys32_pause(void)
561 {
562         current->state = TASK_INTERRUPTIBLE;
563         schedule();
564         return -ERESTARTNOHAND;
565 }
566
567
568 #ifdef CONFIG_SYSCTL_SYSCALL
569 struct sysctl_ia32 {
570         unsigned int    name;
571         int             nlen;
572         unsigned int    oldval;
573         unsigned int    oldlenp;
574         unsigned int    newval;
575         unsigned int    newlen;
576         unsigned int    __unused[4];
577 };
578
579
580 asmlinkage long sys32_sysctl(struct sysctl_ia32 __user *args32)
581 {
582         struct sysctl_ia32 a32;
583         mm_segment_t old_fs = get_fs();
584         void __user *oldvalp, *newvalp;
585         size_t oldlen;
586         int __user *namep;
587         long ret;
588
589         if (copy_from_user(&a32, args32, sizeof(a32)))
590                 return -EFAULT;
591
592         /*
593          * We need to pre-validate these because we have to disable
594          * address checking before calling do_sysctl() because of
595          * OLDLEN but we can't run the risk of the user specifying bad
596          * addresses here.  Well, since we're dealing with 32 bit
597          * addresses, we KNOW that access_ok() will always succeed, so
598          * this is an expensive NOP, but so what...
599          */
600         namep = compat_ptr(a32.name);
601         oldvalp = compat_ptr(a32.oldval);
602         newvalp =  compat_ptr(a32.newval);
603
604         if ((oldvalp && get_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
605             || !access_ok(VERIFY_WRITE, namep, 0)
606             || !access_ok(VERIFY_WRITE, oldvalp, 0)
607             || !access_ok(VERIFY_WRITE, newvalp, 0))
608                 return -EFAULT;
609
610         set_fs(KERNEL_DS);
611         lock_kernel();
612         ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *)&oldlen,
613                         newvalp, (size_t) a32.newlen);
614         unlock_kernel();
615         set_fs(old_fs);
616
617         if (oldvalp && put_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
618                 return -EFAULT;
619
620         return ret;
621 }
622 #endif
623
624 /* warning: next two assume little endian */
625 asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
626                             u32 poslo, u32 poshi)
627 {
628         return sys_pread64(fd, ubuf, count,
629                          ((loff_t)AA(poshi) << 32) | AA(poslo));
630 }
631
632 asmlinkage long sys32_pwrite(unsigned int fd, char __user *ubuf, u32 count,
633                              u32 poslo, u32 poshi)
634 {
635         return sys_pwrite64(fd, ubuf, count,
636                           ((loff_t)AA(poshi) << 32) | AA(poslo));
637 }
638
639
640 asmlinkage long sys32_personality(unsigned long personality)
641 {
642         int ret;
643
644         if (personality(current->personality) == PER_LINUX32 &&
645                 personality == PER_LINUX)
646                 personality = PER_LINUX32;
647         ret = sys_personality(personality);
648         if (ret == PER_LINUX32)
649                 ret = PER_LINUX;
650         return ret;
651 }
652
653 asmlinkage long sys32_sendfile(int out_fd, int in_fd,
654                                compat_off_t __user *offset, s32 count)
655 {
656         mm_segment_t old_fs = get_fs();
657         int ret;
658         off_t of;
659
660         if (offset && get_user(of, offset))
661                 return -EFAULT;
662
663         set_fs(KERNEL_DS);
664         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
665                            count);
666         set_fs(old_fs);
667
668         if (offset && put_user(of, offset))
669                 return -EFAULT;
670         return ret;
671 }
672
673 asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len,
674                             unsigned long prot, unsigned long flags,
675                             unsigned long fd, unsigned long pgoff)
676 {
677         struct mm_struct *mm = current->mm;
678         unsigned long error;
679         struct file *file = NULL;
680
681         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
682         if (!(flags & MAP_ANONYMOUS)) {
683                 file = fget(fd);
684                 if (!file)
685                         return -EBADF;
686         }
687
688         down_write(&mm->mmap_sem);
689         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
690         up_write(&mm->mmap_sem);
691
692         if (file)
693                 fput(file);
694         return error;
695 }
696
697 asmlinkage long sys32_olduname(struct oldold_utsname __user *name)
698 {
699         char *arch = "x86_64";
700         int err;
701
702         if (!name)
703                 return -EFAULT;
704         if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
705                 return -EFAULT;
706
707         down_read(&uts_sem);
708
709         err = __copy_to_user(&name->sysname, &utsname()->sysname,
710                              __OLD_UTS_LEN);
711         err |= __put_user(0, name->sysname+__OLD_UTS_LEN);
712         err |= __copy_to_user(&name->nodename, &utsname()->nodename,
713                               __OLD_UTS_LEN);
714         err |= __put_user(0, name->nodename+__OLD_UTS_LEN);
715         err |= __copy_to_user(&name->release, &utsname()->release,
716                               __OLD_UTS_LEN);
717         err |= __put_user(0, name->release+__OLD_UTS_LEN);
718         err |= __copy_to_user(&name->version, &utsname()->version,
719                               __OLD_UTS_LEN);
720         err |= __put_user(0, name->version+__OLD_UTS_LEN);
721
722         if (personality(current->personality) == PER_LINUX32)
723                 arch = "i686";
724
725         err |= __copy_to_user(&name->machine, arch, strlen(arch) + 1);
726
727         up_read(&uts_sem);
728
729         err = err ? -EFAULT : 0;
730
731         return err;
732 }
733
734 long sys32_uname(struct old_utsname __user *name)
735 {
736         int err;
737
738         if (!name)
739                 return -EFAULT;
740         down_read(&uts_sem);
741         err = copy_to_user(name, utsname(), sizeof(*name));
742         up_read(&uts_sem);
743         if (personality(current->personality) == PER_LINUX32)
744                 err |= copy_to_user(&name->machine, "i686", 5);
745
746         return err ? -EFAULT : 0;
747 }
748
749 long sys32_ustat(unsigned dev, struct ustat32 __user *u32p)
750 {
751         struct ustat u;
752         mm_segment_t seg;
753         int ret;
754
755         seg = get_fs();
756         set_fs(KERNEL_DS);
757         ret = sys_ustat(dev, (struct ustat __user *)&u);
758         set_fs(seg);
759         if (ret < 0)
760                 return ret;
761
762         if (!access_ok(VERIFY_WRITE, u32p, sizeof(struct ustat32)) ||
763             __put_user((__u32) u.f_tfree, &u32p->f_tfree) ||
764             __put_user((__u32) u.f_tinode, &u32p->f_tfree) ||
765             __copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) ||
766             __copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack)))
767                 ret = -EFAULT;
768         return ret;
769 }
770
771 asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv,
772                              compat_uptr_t __user *envp, struct pt_regs *regs)
773 {
774         long error;
775         char *filename;
776
777         filename = getname(name);
778         error = PTR_ERR(filename);
779         if (IS_ERR(filename))
780                 return error;
781         error = compat_do_execve(filename, argv, envp, regs);
782         putname(filename);
783         return error;
784 }
785
786 asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
787                             struct pt_regs *regs)
788 {
789         void __user *parent_tid = (void __user *)regs->dx;
790         void __user *child_tid = (void __user *)regs->di;
791
792         if (!newsp)
793                 newsp = regs->sp;
794         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
795 }
796
797 /*
798  * Some system calls that need sign extended arguments. This could be
799  * done by a generic wrapper.
800  */
801 long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
802 {
803         return sys_lseek(fd, offset, whence);
804 }
805
806 long sys32_kill(int pid, int sig)
807 {
808         return sys_kill(pid, sig);
809 }
810
811 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
812                         __u32 len_low, __u32 len_high, int advice)
813 {
814         return sys_fadvise64_64(fd,
815                                (((u64)offset_high)<<32) | offset_low,
816                                (((u64)len_high)<<32) | len_low,
817                                 advice);
818 }
819
820 long sys32_vm86_warning(void)
821 {
822         struct task_struct *me = current;
823         static char lastcomm[sizeof(me->comm)];
824
825         if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
826                 compat_printk(KERN_INFO
827                               "%s: vm86 mode not supported on 64 bit kernel\n",
828                               me->comm);
829                 strncpy(lastcomm, me->comm, sizeof(lastcomm));
830         }
831         return -ENOSYS;
832 }
833
834 long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
835                           char __user *buf, size_t len)
836 {
837         return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
838 }
839
840 asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
841                                    size_t count)
842 {
843         return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
844 }
845
846 asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
847                                       unsigned n_low, unsigned n_hi,  int flags)
848 {
849         return sys_sync_file_range(fd,
850                                    ((u64)off_hi << 32) | off_low,
851                                    ((u64)n_hi << 32) | n_low, flags);
852 }
853
854 asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
855                                 size_t len, int advice)
856 {
857         return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
858                                 len, advice);
859 }
860
861 asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo,
862                                 unsigned offset_hi, unsigned len_lo,
863                                 unsigned len_hi)
864 {
865         return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
866                              ((u64)len_hi << 32) | len_lo);
867 }