beda4232ce695cc2f42aea28dea84dad02a38235
[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 #ifdef CONFIG_SYSCTL_SYSCALL
560 struct sysctl_ia32 {
561         unsigned int    name;
562         int             nlen;
563         unsigned int    oldval;
564         unsigned int    oldlenp;
565         unsigned int    newval;
566         unsigned int    newlen;
567         unsigned int    __unused[4];
568 };
569
570
571 asmlinkage long sys32_sysctl(struct sysctl_ia32 __user *args32)
572 {
573         struct sysctl_ia32 a32;
574         mm_segment_t old_fs = get_fs();
575         void __user *oldvalp, *newvalp;
576         size_t oldlen;
577         int __user *namep;
578         long ret;
579
580         if (copy_from_user(&a32, args32, sizeof(a32)))
581                 return -EFAULT;
582
583         /*
584          * We need to pre-validate these because we have to disable
585          * address checking before calling do_sysctl() because of
586          * OLDLEN but we can't run the risk of the user specifying bad
587          * addresses here.  Well, since we're dealing with 32 bit
588          * addresses, we KNOW that access_ok() will always succeed, so
589          * this is an expensive NOP, but so what...
590          */
591         namep = compat_ptr(a32.name);
592         oldvalp = compat_ptr(a32.oldval);
593         newvalp =  compat_ptr(a32.newval);
594
595         if ((oldvalp && get_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
596             || !access_ok(VERIFY_WRITE, namep, 0)
597             || !access_ok(VERIFY_WRITE, oldvalp, 0)
598             || !access_ok(VERIFY_WRITE, newvalp, 0))
599                 return -EFAULT;
600
601         set_fs(KERNEL_DS);
602         lock_kernel();
603         ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *)&oldlen,
604                         newvalp, (size_t) a32.newlen);
605         unlock_kernel();
606         set_fs(old_fs);
607
608         if (oldvalp && put_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
609                 return -EFAULT;
610
611         return ret;
612 }
613 #endif
614
615 /* warning: next two assume little endian */
616 asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
617                             u32 poslo, u32 poshi)
618 {
619         return sys_pread64(fd, ubuf, count,
620                          ((loff_t)AA(poshi) << 32) | AA(poslo));
621 }
622
623 asmlinkage long sys32_pwrite(unsigned int fd, char __user *ubuf, u32 count,
624                              u32 poslo, u32 poshi)
625 {
626         return sys_pwrite64(fd, ubuf, count,
627                           ((loff_t)AA(poshi) << 32) | AA(poslo));
628 }
629
630
631 asmlinkage long sys32_personality(unsigned long personality)
632 {
633         int ret;
634
635         if (personality(current->personality) == PER_LINUX32 &&
636                 personality == PER_LINUX)
637                 personality = PER_LINUX32;
638         ret = sys_personality(personality);
639         if (ret == PER_LINUX32)
640                 ret = PER_LINUX;
641         return ret;
642 }
643
644 asmlinkage long sys32_sendfile(int out_fd, int in_fd,
645                                compat_off_t __user *offset, s32 count)
646 {
647         mm_segment_t old_fs = get_fs();
648         int ret;
649         off_t of;
650
651         if (offset && get_user(of, offset))
652                 return -EFAULT;
653
654         set_fs(KERNEL_DS);
655         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
656                            count);
657         set_fs(old_fs);
658
659         if (offset && put_user(of, offset))
660                 return -EFAULT;
661         return ret;
662 }
663
664 asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len,
665                             unsigned long prot, unsigned long flags,
666                             unsigned long fd, unsigned long pgoff)
667 {
668         struct mm_struct *mm = current->mm;
669         unsigned long error;
670         struct file *file = NULL;
671
672         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
673         if (!(flags & MAP_ANONYMOUS)) {
674                 file = fget(fd);
675                 if (!file)
676                         return -EBADF;
677         }
678
679         down_write(&mm->mmap_sem);
680         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
681         up_write(&mm->mmap_sem);
682
683         if (file)
684                 fput(file);
685         return error;
686 }
687
688 asmlinkage long sys32_olduname(struct oldold_utsname __user *name)
689 {
690         char *arch = "x86_64";
691         int err;
692
693         if (!name)
694                 return -EFAULT;
695         if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
696                 return -EFAULT;
697
698         down_read(&uts_sem);
699
700         err = __copy_to_user(&name->sysname, &utsname()->sysname,
701                              __OLD_UTS_LEN);
702         err |= __put_user(0, name->sysname+__OLD_UTS_LEN);
703         err |= __copy_to_user(&name->nodename, &utsname()->nodename,
704                               __OLD_UTS_LEN);
705         err |= __put_user(0, name->nodename+__OLD_UTS_LEN);
706         err |= __copy_to_user(&name->release, &utsname()->release,
707                               __OLD_UTS_LEN);
708         err |= __put_user(0, name->release+__OLD_UTS_LEN);
709         err |= __copy_to_user(&name->version, &utsname()->version,
710                               __OLD_UTS_LEN);
711         err |= __put_user(0, name->version+__OLD_UTS_LEN);
712
713         if (personality(current->personality) == PER_LINUX32)
714                 arch = "i686";
715
716         err |= __copy_to_user(&name->machine, arch, strlen(arch) + 1);
717
718         up_read(&uts_sem);
719
720         err = err ? -EFAULT : 0;
721
722         return err;
723 }
724
725 long sys32_uname(struct old_utsname __user *name)
726 {
727         int err;
728
729         if (!name)
730                 return -EFAULT;
731         down_read(&uts_sem);
732         err = copy_to_user(name, utsname(), sizeof(*name));
733         up_read(&uts_sem);
734         if (personality(current->personality) == PER_LINUX32)
735                 err |= copy_to_user(&name->machine, "i686", 5);
736
737         return err ? -EFAULT : 0;
738 }
739
740 long sys32_ustat(unsigned dev, struct ustat32 __user *u32p)
741 {
742         struct ustat u;
743         mm_segment_t seg;
744         int ret;
745
746         seg = get_fs();
747         set_fs(KERNEL_DS);
748         ret = sys_ustat(dev, (struct ustat __user *)&u);
749         set_fs(seg);
750         if (ret < 0)
751                 return ret;
752
753         if (!access_ok(VERIFY_WRITE, u32p, sizeof(struct ustat32)) ||
754             __put_user((__u32) u.f_tfree, &u32p->f_tfree) ||
755             __put_user((__u32) u.f_tinode, &u32p->f_tfree) ||
756             __copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) ||
757             __copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack)))
758                 ret = -EFAULT;
759         return ret;
760 }
761
762 asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv,
763                              compat_uptr_t __user *envp, struct pt_regs *regs)
764 {
765         long error;
766         char *filename;
767
768         filename = getname(name);
769         error = PTR_ERR(filename);
770         if (IS_ERR(filename))
771                 return error;
772         error = compat_do_execve(filename, argv, envp, regs);
773         putname(filename);
774         return error;
775 }
776
777 asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
778                             struct pt_regs *regs)
779 {
780         void __user *parent_tid = (void __user *)regs->dx;
781         void __user *child_tid = (void __user *)regs->di;
782
783         if (!newsp)
784                 newsp = regs->sp;
785         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
786 }
787
788 /*
789  * Some system calls that need sign extended arguments. This could be
790  * done by a generic wrapper.
791  */
792 long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
793 {
794         return sys_lseek(fd, offset, whence);
795 }
796
797 long sys32_kill(int pid, int sig)
798 {
799         return sys_kill(pid, sig);
800 }
801
802 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
803                         __u32 len_low, __u32 len_high, int advice)
804 {
805         return sys_fadvise64_64(fd,
806                                (((u64)offset_high)<<32) | offset_low,
807                                (((u64)len_high)<<32) | len_low,
808                                 advice);
809 }
810
811 long sys32_vm86_warning(void)
812 {
813         struct task_struct *me = current;
814         static char lastcomm[sizeof(me->comm)];
815
816         if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
817                 compat_printk(KERN_INFO
818                               "%s: vm86 mode not supported on 64 bit kernel\n",
819                               me->comm);
820                 strncpy(lastcomm, me->comm, sizeof(lastcomm));
821         }
822         return -ENOSYS;
823 }
824
825 long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
826                           char __user *buf, size_t len)
827 {
828         return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
829 }
830
831 asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
832                                    size_t count)
833 {
834         return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
835 }
836
837 asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
838                                       unsigned n_low, unsigned n_hi,  int flags)
839 {
840         return sys_sync_file_range(fd,
841                                    ((u64)off_hi << 32) | off_low,
842                                    ((u64)n_hi << 32) | n_low, flags);
843 }
844
845 asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
846                                 size_t len, int advice)
847 {
848         return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
849                                 len, advice);
850 }
851
852 asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo,
853                                 unsigned offset_hi, unsigned len_lo,
854                                 unsigned len_hi)
855 {
856         return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
857                              ((u64)len_hi << 32) | len_lo);
858 }