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 }