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