arch/ia64/ia32/sys_ia32.c

   1 /*
   2  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Derived from sys_sparc32.c.
   3  *
   4  * Copyright (C) 2000           VA Linux Co
   5  * Copyright (C) 2000           Don Dugger <n0ano@valinux.com>
   6  * Copyright (C) 1999           Arun Sharma <arun.sharma@intel.com>
   7  * Copyright (C) 1997,1998      Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   8  * Copyright (C) 1997           David S. Miller (davem@caip.rutgers.edu)
   9  * Copyright (C) 2000-2003 Hewlett-Packard Co
  10  *      David Mosberger-Tang <davidm@hpl.hp.com>
  11  *
  12  * These routines maintain argument size conversion between 32bit and 64bit
  13  * environment.
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/kernel.h>
  18 #include <linux/syscalls.h>
  19 #include <linux/sysctl.h>
  20 #include <linux/sched.h>
  21 #include <linux/fs.h>
  22 #include <linux/file.h>
  23 #include <linux/signal.h>
  24 #include <linux/resource.h>
  25 #include <linux/times.h>
  26 #include <linux/utsname.h>
  27 #include <linux/timex.h>
  28 #include <linux/smp.h>
  29 #include <linux/smp_lock.h>
  30 #include <linux/sem.h>
  31 #include <linux/msg.h>
  32 #include <linux/mm.h>
  33 #include <linux/shm.h>
  34 #include <linux/slab.h>
  35 #include <linux/uio.h>
  36 #include <linux/nfs_fs.h>
  37 #include <linux/quota.h>
  38 #include <linux/sunrpc/svc.h>
  39 #include <linux/nfsd/nfsd.h>
  40 #include <linux/nfsd/cache.h>
  41 #include <linux/nfsd/xdr.h>
  42 #include <linux/nfsd/syscall.h>
  43 #include <linux/poll.h>
  44 #include <linux/eventpoll.h>
  45 #include <linux/personality.h>
  46 #include <linux/ptrace.h>
  47 #include <linux/stat.h>
  48 #include <linux/ipc.h>
  49 #include <linux/compat.h>
  50 #include <linux/vfs.h>
  51
  52 #include <asm/intrinsics.h>
  53 #include <asm/semaphore.h>
  54 #include <asm/types.h>
  55 #include <asm/uaccess.h>
  56 #include <asm/unistd.h>
  57
  58 #include "ia32priv.h"
  59
  60 #include <net/scm.h>
  61 #include <net/sock.h>
  62
  63 #define DEBUG   0
  64
  65 #if DEBUG
  66 # define DBG(fmt...)    printk(KERN_DEBUG fmt)
  67 #else
  68 # define DBG(fmt...)
  69 #endif
  70
  71 #define A(__x)          ((unsigned long)(__x))
  72 #define AA(__x)         ((unsigned long)(__x))
  73 #define ROUND_UP(x,a)   ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
  74 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  75
  76 #define OFFSET4K(a)             ((a) & 0xfff)
  77 #define PAGE_START(addr)        ((addr) & PAGE_MASK)
  78 #define MINSIGSTKSZ_IA32        2048
  79
  80 #define high2lowuid(uid) ((uid) > 65535 ? 65534 : (uid))
  81 #define high2lowgid(gid) ((gid) > 65535 ? 65534 : (gid))
  82
  83 extern unsigned long arch_get_unmapped_area (struct file *, unsigned long, unsigned long,
  84                                              unsigned long, unsigned long);
  85
  86 /*
  87  * Anything that modifies or inspects ia32 user virtual memory must hold this semaphore
  88  * while doing so.
  89  */
  90 /* XXX make per-mm: */
  91 static DECLARE_MUTEX(ia32_mmap_sem);
  92
  93 static int
  94 nargs (unsigned int arg, char **ap)
  95 {
  96         unsigned int addr;
  97         int n, err;
  98
  99         if (!arg)
 100                 return 0;
 101
 102         n = 0;
 103         do {
 104                 err = get_user(addr, (unsigned int *)A(arg));
 105                 if (err)
 106                         return err;
 107                 if (ap)
 108                         *ap++ = (char *) A(addr);
 109                 arg += sizeof(unsigned int);
 110                 n++;
 111         } while (addr);
 112         return n - 1;
 113 }
 114
 115 asmlinkage long
 116 sys32_execve (char *filename, unsigned int argv, unsigned int envp,
 117               struct pt_regs *regs)
 118 {
 119         unsigned long old_map_base, old_task_size, tssd;
 120         char **av, **ae;
 121         int na, ne, len;
 122         long r;
 123
 124         na = nargs(argv, NULL);
 125         if (na < 0)
 126                 return na;
 127         ne = nargs(envp, NULL);
 128         if (ne < 0)
 129                 return ne;
 130         len = (na + ne + 2) * sizeof(*av);
 131         av = kmalloc(len, GFP_KERNEL);
 132         if (!av)
 133                 return -ENOMEM;
 134
 135         ae = av + na + 1;
 136         av[na] = NULL;
 137         ae[ne] = NULL;
 138
 139         r = nargs(argv, av);
 140         if (r < 0)
 141                 goto out;
 142         r = nargs(envp, ae);
 143         if (r < 0)
 144                 goto out;
 145
 146         old_map_base  = current->thread.map_base;
 147         old_task_size = current->thread.task_size;
 148         tssd = ia64_get_kr(IA64_KR_TSSD);
 149
 150         /* we may be exec'ing a 64-bit process: reset map base, task-size, and io-base: */
 151         current->thread.map_base  = DEFAULT_MAP_BASE;
 152         current->thread.task_size = DEFAULT_TASK_SIZE;
 153         ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
 154         ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
 155
 156         set_fs(KERNEL_DS);
 157         r = sys_execve(filename, av, ae, regs);
 158         if (r < 0) {
 159                 /* oops, execve failed, switch back to old values... */
 160                 ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
 161                 ia64_set_kr(IA64_KR_TSSD, tssd);
 162                 current->thread.map_base  = old_map_base;
 163                 current->thread.task_size = old_task_size;
 164                 set_fs(USER_DS);        /* establish new task-size as the address-limit */
 165         }
 166   out:
 167         kfree(av);
 168         return r;
 169 }
 170
 171 int cp_compat_stat(struct kstat *stat, struct compat_stat *ubuf)
 172 {
 173         int err;
 174
 175         if ((u64) stat->size > MAX_NON_LFS ||
 176             !old_valid_dev(stat->dev) ||
 177             !old_valid_dev(stat->rdev))
 178                 return -EOVERFLOW;
 179
 180         if (clear_user(ubuf, sizeof(*ubuf)))
 181                 return -EFAULT;
 182
 183         err  = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
 184         err |= __put_user(stat->ino, &ubuf->st_ino);
 185         err |= __put_user(stat->mode, &ubuf->st_mode);
 186         err |= __put_user(stat->nlink, &ubuf->st_nlink);
 187         err |= __put_user(high2lowuid(stat->uid), &ubuf->st_uid);
 188         err |= __put_user(high2lowgid(stat->gid), &ubuf->st_gid);
 189         err |= __put_user(old_encode_dev(stat->rdev), &ubuf->st_rdev);
 190         err |= __put_user(stat->size, &ubuf->st_size);
 191         err |= __put_user(stat->atime.tv_sec, &ubuf->st_atime);
 192         err |= __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec);
 193         err |= __put_user(stat->mtime.tv_sec, &ubuf->st_mtime);
 194         err |= __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec);
 195         err |= __put_user(stat->ctime.tv_sec, &ubuf->st_ctime);
 196         err |= __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec);
 197         err |= __put_user(stat->blksize, &ubuf->st_blksize);
 198         err |= __put_user(stat->blocks, &ubuf->st_blocks);
 199         return err;
 200 }
 201
 202 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 203
 204
 205 static int
 206 get_page_prot (struct vm_area_struct *vma, unsigned long addr)
 207 {
 208         int prot = 0;
 209
 210         if (!vma || vma->vm_start > addr)
 211                 return 0;
 212
 213         if (vma->vm_flags & VM_READ)
 214                 prot |= PROT_READ;
 215         if (vma->vm_flags & VM_WRITE)
 216                 prot |= PROT_WRITE;
 217         if (vma->vm_flags & VM_EXEC)
 218                 prot |= PROT_EXEC;
 219         return prot;
 220 }
 221
 222 /*
 223  * Map a subpage by creating an anonymous page that contains the union of the old page and
 224  * the subpage.
 225  */
 226 static unsigned long
 227 mmap_subpage (struct file *file, unsigned long start, unsigned long end, int prot, int flags,
 228               loff_t off)
 229 {
 230         void *page = NULL;
 231         struct inode *inode;
 232         unsigned long ret = 0;
 233         struct vm_area_struct *vma = find_vma(current->mm, start);
 234         int old_prot = get_page_prot(vma, start);
 235
 236         DBG("mmap_subpage(file=%p,start=0x%lx,end=0x%lx,prot=%x,flags=%x,off=0x%llx)\n",
 237             file, start, end, prot, flags, off);
 238
 239
 240         /* Optimize the case where the old mmap and the new mmap are both anonymous */
 241         if ((old_prot & PROT_WRITE) && (flags & MAP_ANONYMOUS) && !vma->vm_file) {
 242                 if (clear_user((void *) start, end - start)) {
 243                         ret = -EFAULT;
 244                         goto out;
 245                 }
 246                 goto skip_mmap;
 247         }
 248
 249         page = (void *) get_zeroed_page(GFP_KERNEL);
 250         if (!page)
 251                 return -ENOMEM;
 252
 253         if (old_prot)
 254                 copy_from_user(page, (void *) PAGE_START(start), PAGE_SIZE);
 255
 256         down_write(&current->mm->mmap_sem);
 257         {
 258                 ret = do_mmap(0, PAGE_START(start), PAGE_SIZE, prot | PROT_WRITE,
 259                               flags | MAP_FIXED | MAP_ANONYMOUS, 0);
 260         }
 261         up_write(&current->mm->mmap_sem);
 262
 263         if (IS_ERR((void *) ret))
 264                 goto out;
 265
 266         if (old_prot) {
 267                 /* copy back the old page contents.  */
 268                 if (offset_in_page(start))
 269                         copy_to_user((void *) PAGE_START(start), page, offset_in_page(start));
 270                 if (offset_in_page(end))
 271                         copy_to_user((void *) end, page + offset_in_page(end),
 272                                      PAGE_SIZE - offset_in_page(end));
 273         }
 274
 275         if (!(flags & MAP_ANONYMOUS)) {
 276                 /* read the file contents */
 277                 inode = file->f_dentry->d_inode;
 278                 if (!inode->i_fop || !file->f_op->read
 279                     || ((*file->f_op->read)(file, (char *) start, end - start, &off) < 0))
 280                 {
 281                         ret = -EINVAL;
 282                         goto out;
 283                 }
 284         }
 285
 286  skip_mmap:
 287         if (!(prot & PROT_WRITE))
 288                 ret = sys_mprotect(PAGE_START(start), PAGE_SIZE, prot | old_prot);
 289   out:
 290         if (page)
 291                 free_page((unsigned long) page);
 292         return ret;
 293 }
 294
 295 static unsigned long
 296 emulate_mmap (struct file *file, unsigned long start, unsigned long len, int prot, int flags,
 297               loff_t off)
 298 {
 299         unsigned long tmp, end, pend, pstart, ret, is_congruent, fudge = 0;
 300         struct inode *inode;
 301         loff_t poff;
 302
 303         end = start + len;
 304         pstart = PAGE_START(start);
 305         pend = PAGE_ALIGN(end);
 306
 307         if (flags & MAP_FIXED) {
 308                 if (start > pstart) {
 309                         if (flags & MAP_SHARED)
 310                                 printk(KERN_INFO
 311                                        "%s(%d): emulate_mmap() can't share head (addr=0x%lx)\n",
 312                                        current->comm, current->pid, start);
 313                         ret = mmap_subpage(file, start, min(PAGE_ALIGN(start), end), prot, flags,
 314                                            off);
 315                         if (IS_ERR((void *) ret))
 316                                 return ret;
 317                         pstart += PAGE_SIZE;
 318                         if (pstart >= pend)
 319                                 return start;   /* done */
 320                 }
 321                 if (end < pend) {
 322                         if (flags & MAP_SHARED)
 323                                 printk(KERN_INFO
 324                                        "%s(%d): emulate_mmap() can't share tail (end=0x%lx)\n",
 325                                        current->comm, current->pid, end);
 326                         ret = mmap_subpage(file, max(start, PAGE_START(end)), end, prot, flags,
 327                                            (off + len) - offset_in_page(end));
 328                         if (IS_ERR((void *) ret))
 329                                 return ret;
 330                         pend -= PAGE_SIZE;
 331                         if (pstart >= pend)
 332                                 return start;   /* done */
 333                 }
 334         } else {
 335                 /*
 336                  * If a start address was specified, use it if the entire rounded out area
 337                  * is available.
 338                  */
 339                 if (start && !pstart)
 340                         fudge = 1;      /* handle case of mapping to range (0,PAGE_SIZE) */
 341                 tmp = arch_get_unmapped_area(file, pstart - fudge, pend - pstart, 0, flags);
 342                 if (tmp != pstart) {
 343                         pstart = tmp;
 344                         start = pstart + offset_in_page(off);   /* make start congruent with off */
 345                         end = start + len;
 346                         pend = PAGE_ALIGN(end);
 347                 }
 348         }
 349
 350         poff = off + (pstart - start);  /* note: (pstart - start) may be negative */
 351         is_congruent = (flags & MAP_ANONYMOUS) || (offset_in_page(poff) == 0);
 352
 353         if ((flags & MAP_SHARED) && !is_congruent)
 354                 printk(KERN_INFO "%s(%d): emulate_mmap() can't share contents of incongruent mmap "
 355                        "(addr=0x%lx,off=0x%llx)\n", current->comm, current->pid, start, off);
 356
 357         DBG("mmap_body: mapping [0x%lx-0x%lx) %s with poff 0x%llx\n", pstart, pend,
 358             is_congruent ? "congruent" : "not congruent", poff);
 359
 360         down_write(&current->mm->mmap_sem);
 361         {
 362                 if (!(flags & MAP_ANONYMOUS) && is_congruent)
 363                         ret = do_mmap(file, pstart, pend - pstart, prot, flags | MAP_FIXED, poff);
 364                 else
 365                         ret = do_mmap(0, pstart, pend - pstart,
 366                                       prot | ((flags & MAP_ANONYMOUS) ? 0 : PROT_WRITE),
 367                                       flags | MAP_FIXED | MAP_ANONYMOUS, 0);
 368         }
 369         up_write(&current->mm->mmap_sem);
 370
 371         if (IS_ERR((void *) ret))
 372                 return ret;
 373
 374         if (!is_congruent) {
 375                 /* read the file contents */
 376                 inode = file->f_dentry->d_inode;
 377                 if (!inode->i_fop || !file->f_op->read
 378                     || ((*file->f_op->read)(file, (char *) pstart, pend - pstart, &poff) < 0))
 379                 {
 380                         sys_munmap(pstart, pend - pstart);
 381                         return -EINVAL;
 382                 }
 383                 if (!(prot & PROT_WRITE) && sys_mprotect(pstart, pend - pstart, prot) < 0)
 384                         return -EINVAL;
 385         }
 386         return start;
 387 }
 388
 389 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
 390
 391 static inline unsigned int
 392 get_prot32 (unsigned int prot)
 393 {
 394         if (prot & PROT_WRITE)
 395                 /* on x86, PROT_WRITE implies PROT_READ which implies PROT_EEC */
 396                 prot |= PROT_READ | PROT_WRITE | PROT_EXEC;
 397         else if (prot & (PROT_READ | PROT_EXEC))
 398                 /* on x86, there is no distinction between PROT_READ and PROT_EXEC */
 399                 prot |= (PROT_READ | PROT_EXEC);
 400
 401         return prot;
 402 }
 403
 404 unsigned long
 405 ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot, int flags,
 406               loff_t offset)
 407 {
 408         DBG("ia32_do_mmap(file=%p,addr=0x%lx,len=0x%lx,prot=%x,flags=%x,offset=0x%llx)\n",
 409             file, addr, len, prot, flags, offset);
 410
 411         if (file && (!file->f_op || !file->f_op->mmap))
 412                 return -ENODEV;
 413
 414         len = IA32_PAGE_ALIGN(len);
 415         if (len == 0)
 416                 return addr;
 417
 418         if (len > IA32_PAGE_OFFSET || addr > IA32_PAGE_OFFSET - len)
 419         {
 420                 if (flags & MAP_FIXED)
 421                         return -ENOMEM;
 422                 else
 423                 return -EINVAL;
 424         }
 425
 426         if (OFFSET4K(offset))
 427                 return -EINVAL;
 428
 429         prot = get_prot32(prot);
 430
 431 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 432         down(&ia32_mmap_sem);
 433         {
 434                 addr = emulate_mmap(file, addr, len, prot, flags, offset);
 435         }
 436         up(&ia32_mmap_sem);
 437 #else
 438         down_write(&current->mm->mmap_sem);
 439         {
 440                 addr = do_mmap(file, addr, len, prot, flags, offset);
 441         }
 442         up_write(&current->mm->mmap_sem);
 443 #endif
 444         DBG("ia32_do_mmap: returning 0x%lx\n", addr);
 445         return addr;
 446 }
 447
 448 /*
 449  * Linux/i386 didn't use to be able to handle more than 4 system call parameters, so these
 450  * system calls used a memory block for parameter passing..
 451  */
 452
 453 struct mmap_arg_struct {
 454         unsigned int addr;
 455         unsigned int len;
 456         unsigned int prot;
 457         unsigned int flags;
 458         unsigned int fd;
 459         unsigned int offset;
 460 };
 461
 462 asmlinkage long
 463 sys32_mmap (struct mmap_arg_struct *arg)
 464 {
 465         struct mmap_arg_struct a;
 466         struct file *file = NULL;
 467         unsigned long addr;
 468         int flags;
 469
 470         if (copy_from_user(&a, arg, sizeof(a)))
 471                 return -EFAULT;
 472
 473         if (OFFSET4K(a.offset))
 474                 return -EINVAL;
 475
 476         flags = a.flags;
 477
 478         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 479         if (!(flags & MAP_ANONYMOUS)) {
 480                 file = fget(a.fd);
 481                 if (!file)
 482                         return -EBADF;
 483         }
 484
 485         addr = ia32_do_mmap(file, a.addr, a.len, a.prot, flags, a.offset);
 486
 487         if (file)
 488                 fput(file);
 489         return addr;
 490 }
 491
 492 asmlinkage long
 493 sys32_mmap2 (unsigned int addr, unsigned int len, unsigned int prot, unsigned int flags,
 494              unsigned int fd, unsigned int pgoff)
 495 {
 496         struct file *file = NULL;
 497         unsigned long retval;
 498
 499         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 500         if (!(flags & MAP_ANONYMOUS)) {
 501                 file = fget(fd);
 502                 if (!file)
 503                         return -EBADF;
 504         }
 505
 506         retval = ia32_do_mmap(file, addr, len, prot, flags,
 507                               (unsigned long) pgoff << IA32_PAGE_SHIFT);
 508
 509         if (file)
 510                 fput(file);
 511         return retval;
 512 }
 513
 514 asmlinkage long
 515 sys32_munmap (unsigned int start, unsigned int len)
 516 {
 517         unsigned int end = start + len;
 518         long ret;
 519
 520 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
 521         ret = sys_munmap(start, end - start);
 522 #else
 523         if (start >= end)
 524                 return -EINVAL;
 525
 526         start = PAGE_ALIGN(start);
 527         end = PAGE_START(end);
 528
 529         if (start >= end)
 530                 return 0;
 531
 532         down(&ia32_mmap_sem);
 533         {
 534                 ret = sys_munmap(start, end - start);
 535         }
 536         up(&ia32_mmap_sem);
 537 #endif
 538         return ret;
 539 }
 540
 541 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 542
 543 /*
 544  * When mprotect()ing a partial page, we set the permission to the union of the old
 545  * settings and the new settings.  In other words, it's only possible to make access to a
 546  * partial page less restrictive.
 547  */
 548 static long
 549 mprotect_subpage (unsigned long address, int new_prot)
 550 {
 551         int old_prot;
 552         struct vm_area_struct *vma;
 553
 554         if (new_prot == PROT_NONE)
 555                 return 0;               /* optimize case where nothing changes... */
 556         vma = find_vma(current->mm, address);
 557         old_prot = get_page_prot(vma, address);
 558         return sys_mprotect(address, PAGE_SIZE, new_prot | old_prot);
 559 }
 560
 561 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
 562
 563 asmlinkage long
 564 sys32_mprotect (unsigned int start, unsigned int len, int prot)
 565 {
 566         unsigned long end = start + len;
 567 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 568         long retval = 0;
 569 #endif
 570
 571         prot = get_prot32(prot);
 572
 573 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
 574         return sys_mprotect(start, end - start, prot);
 575 #else
 576         if (OFFSET4K(start))
 577                 return -EINVAL;
 578
 579         end = IA32_PAGE_ALIGN(end);
 580         if (end < start)
 581                 return -EINVAL;
 582
 583         down(&ia32_mmap_sem);
 584         {
 585                 if (offset_in_page(start)) {
 586                         /* start address is 4KB aligned but not page aligned. */
 587                         retval = mprotect_subpage(PAGE_START(start), prot);
 588                         if (retval < 0)
 589                                 goto out;
 590
 591                         start = PAGE_ALIGN(start);
 592                         if (start >= end)
 593                                 goto out;       /* retval is already zero... */
 594                 }
 595
 596                 if (offset_in_page(end)) {
 597                         /* end address is 4KB aligned but not page aligned. */
 598                         retval = mprotect_subpage(PAGE_START(end), prot);
 599                         if (retval < 0)
 600                                 goto out;
 601
 602                         end = PAGE_START(end);
 603                 }
 604                 retval = sys_mprotect(start, end - start, prot);
 605         }
 606   out:
 607         up(&ia32_mmap_sem);
 608         return retval;
 609 #endif
 610 }
 611
 612 asmlinkage long
 613 sys32_pipe (int *fd)
 614 {
 615         int retval;
 616         int fds[2];
 617
 618         retval = do_pipe(fds);
 619         if (retval)
 620                 goto out;
 621         if (copy_to_user(fd, fds, sizeof(fds)))
 622                 retval = -EFAULT;
 623   out:
 624         return retval;
 625 }
 626
 627 static inline long
 628 get_tv32 (struct timeval *o, struct compat_timeval *i)
 629 {
 630         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
 631                 (__get_user(o->tv_sec, &i->tv_sec) | __get_user(o->tv_usec, &i->tv_usec)));
 632 }
 633
 634 static inline long
 635 put_tv32 (struct compat_timeval *o, struct timeval *i)
 636 {
 637         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 638                 (__put_user(i->tv_sec, &o->tv_sec) | __put_user(i->tv_usec, &o->tv_usec)));
 639 }
 640
 641 asmlinkage unsigned long
 642 sys32_alarm (unsigned int seconds)
 643 {
 644         struct itimerval it_new, it_old;
 645         unsigned int oldalarm;
 646
 647         it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
 648         it_new.it_value.tv_sec = seconds;
 649         it_new.it_value.tv_usec = 0;
 650         do_setitimer(ITIMER_REAL, &it_new, &it_old);
 651         oldalarm = it_old.it_value.tv_sec;
 652         /* ehhh.. We can't return 0 if we have an alarm pending.. */
 653         /* And we'd better return too much than too little anyway */
 654         if (it_old.it_value.tv_usec)
 655                 oldalarm++;
 656         return oldalarm;
 657 }
 658
 659 /* Translations due to time_t size differences.  Which affects all
 660    sorts of things, like timeval and itimerval.  */
 661
 662 extern struct timezone sys_tz;
 663
 664 asmlinkage long
 665 sys32_gettimeofday (struct compat_timeval *tv, struct timezone *tz)
 666 {
 667         if (tv) {
 668                 struct timeval ktv;
 669                 do_gettimeofday(&ktv);
 670                 if (put_tv32(tv, &ktv))
 671                         return -EFAULT;
 672         }
 673         if (tz) {
 674                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 675                         return -EFAULT;
 676         }
 677         return 0;
 678 }
 679
 680 asmlinkage long
 681 sys32_settimeofday (struct compat_timeval *tv, struct timezone *tz)
 682 {
 683         struct timeval ktv;
 684         struct timespec kts;
 685         struct timezone ktz;
 686
 687         if (tv) {
 688                 if (get_tv32(&ktv, tv))
 689                         return -EFAULT;
 690                 kts.tv_sec = ktv.tv_sec;
 691                 kts.tv_nsec = ktv.tv_usec * 1000;
 692         }
 693         if (tz) {
 694                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
 695                         return -EFAULT;
 696         }
 697
 698         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
 699 }
 700
 701 struct getdents32_callback {
 702         struct compat_dirent * current_dir;
 703         struct compat_dirent * previous;
 704         int count;
 705         int error;
 706 };
 707
 708 struct readdir32_callback {
 709         struct old_linux32_dirent * dirent;
 710         int count;
 711 };
 712
 713 static int
 714 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
 715            unsigned int d_type)
 716 {
 717         struct compat_dirent * dirent;
 718         struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
 719         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
 720
 721         buf->error = -EINVAL;   /* only used if we fail.. */
 722         if (reclen > buf->count)
 723                 return -EINVAL;
 724         buf->error = -EFAULT;   /* only used if we fail.. */
 725         dirent = buf->previous;
 726         if (dirent)
 727                 if (put_user(offset, &dirent->d_off))
 728                         return -EFAULT;
 729         dirent = buf->current_dir;
 730         buf->previous = dirent;
 731         if (put_user(ino, &dirent->d_ino)
 732             || put_user(reclen, &dirent->d_reclen)
 733             || copy_to_user(dirent->d_name, name, namlen)
 734             || put_user(0, dirent->d_name + namlen))
 735                 return -EFAULT;
 736         dirent = (struct compat_dirent *) ((char *) dirent + reclen);
 737         buf->current_dir = dirent;
 738         buf->count -= reclen;
 739         return 0;
 740 }
 741
 742 asmlinkage long
 743 sys32_getdents (unsigned int fd, struct compat_dirent *dirent, unsigned int count)
 744 {
 745         struct file * file;
 746         struct compat_dirent * lastdirent;
 747         struct getdents32_callback buf;
 748         int error;
 749
 750         error = -EBADF;
 751         file = fget(fd);
 752         if (!file)
 753                 goto out;
 754
 755         buf.current_dir = dirent;
 756         buf.previous = NULL;
 757         buf.count = count;
 758         buf.error = 0;
 759
 760         error = vfs_readdir(file, filldir32, &buf);
 761         if (error < 0)
 762                 goto out_putf;
 763         error = buf.error;
 764         lastdirent = buf.previous;
 765         if (lastdirent) {
 766                 error = -EINVAL;
 767                 if (put_user(file->f_pos, &lastdirent->d_off))
 768                         goto out_putf;
 769                 error = count - buf.count;
 770         }
 771
 772 out_putf:
 773         fput(file);
 774 out:
 775         return error;
 776 }
 777
 778 static int
 779 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
 780               unsigned int d_type)
 781 {
 782         struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
 783         struct old_linux32_dirent * dirent;
 784
 785         if (buf->count)
 786                 return -EINVAL;
 787         buf->count++;
 788         dirent = buf->dirent;
 789         if (put_user(ino, &dirent->d_ino)
 790             || put_user(offset, &dirent->d_offset)
 791             || put_user(namlen, &dirent->d_namlen)
 792             || copy_to_user(dirent->d_name, name, namlen)
 793             || put_user(0, dirent->d_name + namlen))
 794                 return -EFAULT;
 795         return 0;
 796 }
 797
 798 asmlinkage long
 799 sys32_readdir (unsigned int fd, void *dirent, unsigned int count)
 800 {
 801         int error;
 802         struct file * file;
 803         struct readdir32_callback buf;
 804
 805         error = -EBADF;
 806         file = fget(fd);
 807         if (!file)
 808                 goto out;
 809
 810         buf.count = 0;
 811         buf.dirent = dirent;
 812
 813         error = vfs_readdir(file, fillonedir32, &buf);
 814         if (error >= 0)
 815                 error = buf.count;
 816         fput(file);
 817 out:
 818         return error;
 819 }
 820
 821 /*
 822  * We can actually return ERESTARTSYS instead of EINTR, but I'd
 823  * like to be certain this leads to no problems. So I return
 824  * EINTR just for safety.
 825  *
 826  * Update: ERESTARTSYS breaks at least the xview clock binary, so
 827  * I'm trying ERESTARTNOHAND which restart only when you want to.
 828  */
 829 #define MAX_SELECT_SECONDS \
 830         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 831 #define ROUND_UP_TIME(x,y) (((x)+(y)-1)/(y))
 832
 833 asmlinkage long
 834 sys32_select (int n, fd_set *inp, fd_set *outp, fd_set *exp, struct compat_timeval *tvp32)
 835 {
 836         fd_set_bits fds;
 837         char *bits;
 838         long timeout;
 839         int ret, size;
 840
 841         timeout = MAX_SCHEDULE_TIMEOUT;
 842         if (tvp32) {
 843                 time_t sec, usec;
 844
 845                 ret = -EFAULT;
 846                 if (get_user(sec, &tvp32->tv_sec) || get_user(usec, &tvp32->tv_usec))
 847                         goto out_nofds;
 848
 849                 ret = -EINVAL;
 850                 if (sec < 0 || usec < 0)
 851                         goto out_nofds;
 852
 853                 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
 854                         timeout = ROUND_UP_TIME(usec, 1000000/HZ);
 855                         timeout += sec * (unsigned long) HZ;
 856                 }
 857         }
 858
 859         ret = -EINVAL;
 860         if (n < 0)
 861                 goto out_nofds;
 862
 863         if (n > current->files->max_fdset)
 864                 n = current->files->max_fdset;
 865
 866         /*
 867          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
 868          * since we used fdset we need to allocate memory in units of
 869          * long-words.
 870          */
 871         ret = -ENOMEM;
 872         size = FDS_BYTES(n);
 873         bits = kmalloc(6 * size, GFP_KERNEL);
 874         if (!bits)
 875                 goto out_nofds;
 876         fds.in      = (unsigned long *)  bits;
 877         fds.out     = (unsigned long *) (bits +   size);
 878         fds.ex      = (unsigned long *) (bits + 2*size);
 879         fds.res_in  = (unsigned long *) (bits + 3*size);
 880         fds.res_out = (unsigned long *) (bits + 4*size);
 881         fds.res_ex  = (unsigned long *) (bits + 5*size);
 882
 883         if ((ret = get_fd_set(n, inp, fds.in)) ||
 884             (ret = get_fd_set(n, outp, fds.out)) ||
 885             (ret = get_fd_set(n, exp, fds.ex)))
 886                 goto out;
 887         zero_fd_set(n, fds.res_in);
 888         zero_fd_set(n, fds.res_out);
 889         zero_fd_set(n, fds.res_ex);
 890
 891         ret = do_select(n, &fds, &timeout);
 892
 893         if (tvp32 && !(current->personality & STICKY_TIMEOUTS)) {
 894                 time_t sec = 0, usec = 0;
 895                 if (timeout) {
 896                         sec = timeout / HZ;
 897                         usec = timeout % HZ;
 898                         usec *= (1000000/HZ);
 899                 }
 900                 if (put_user(sec, &tvp32->tv_sec) || put_user(usec, &tvp32->tv_usec)) {
 901                         ret = -EFAULT;
 902                         goto out;
 903                 }
 904         }
 905
 906         if (ret < 0)
 907                 goto out;
 908         if (!ret) {
 909                 ret = -ERESTARTNOHAND;
 910                 if (signal_pending(current))
 911                         goto out;
 912                 ret = 0;
 913         }
 914
 915         set_fd_set(n, inp, fds.res_in);
 916         set_fd_set(n, outp, fds.res_out);
 917         set_fd_set(n, exp, fds.res_ex);
 918
 919 out:
 920         kfree(bits);
 921 out_nofds:
 922         return ret;
 923 }
 924
 925 struct sel_arg_struct {
 926         unsigned int n;
 927         unsigned int inp;
 928         unsigned int outp;
 929         unsigned int exp;
 930         unsigned int tvp;
 931 };
 932
 933 asmlinkage long
 934 sys32_old_select (struct sel_arg_struct *arg)
 935 {
 936         struct sel_arg_struct a;
 937
 938         if (copy_from_user(&a, arg, sizeof(a)))
 939                 return -EFAULT;
 940         return sys32_select(a.n, (fd_set *) A(a.inp), (fd_set *) A(a.outp), (fd_set *) A(a.exp),
 941                             (struct compat_timeval *) A(a.tvp));
 942 }
 943
 944 static struct iovec *
 945 get_compat_iovec (struct compat_iovec *iov32, struct iovec *iov_buf, u32 count, int type)
 946 {
 947         u32 i, buf, len;
 948         struct iovec *ivp, *iov;
 949
 950         /* Get the "struct iovec" from user memory */
 951
 952         if (!count)
 953                 return 0;
 954         if (verify_area(VERIFY_READ, iov32, sizeof(struct compat_iovec)*count))
 955                 return NULL;
 956         if (count > UIO_MAXIOV)
 957                 return NULL;
 958         if (count > UIO_FASTIOV) {
 959                 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
 960                 if (!iov)
 961                         return NULL;
 962         } else
 963                 iov = iov_buf;
 964
 965         ivp = iov;
 966         for (i = 0; i < count; i++) {
 967                 if (__get_user(len, &iov32->iov_len) || __get_user(buf, &iov32->iov_base)) {
 968                         if (iov != iov_buf)
 969                                 kfree(iov);
 970                         return NULL;
 971                 }
 972                 if (verify_area(type, (void *)A(buf), len)) {
 973                         if (iov != iov_buf)
 974                                 kfree(iov);
 975                         return((struct iovec *)0);
 976                 }
 977                 ivp->iov_base = (void *)A(buf);
 978                 ivp->iov_len = (__kernel_size_t) len;
 979                 iov32++;
 980                 ivp++;
 981         }
 982         return iov;
 983 }
 984
 985 asmlinkage long
 986 sys32_readv (int fd, struct compat_iovec *vector, u32 count)
 987 {
 988         struct iovec iovstack[UIO_FASTIOV];
 989         struct iovec *iov;
 990         long ret;
 991         mm_segment_t old_fs = get_fs();
 992
 993         iov = get_compat_iovec(vector, iovstack, count, VERIFY_WRITE);
 994         if (!iov)
 995                 return -EFAULT;
 996         set_fs(KERNEL_DS);
 997         ret = sys_readv(fd, iov, count);
 998         set_fs(old_fs);
 999         if (iov != iovstack)
1000                 kfree(iov);
1001         return ret;
1002 }
1003
1004 asmlinkage long
1005 sys32_writev (int fd, struct compat_iovec *vector, u32 count)
1006 {
1007         struct iovec iovstack[UIO_FASTIOV];
1008         struct iovec *iov;
1009         long ret;
1010         mm_segment_t old_fs = get_fs();
1011
1012         iov = get_compat_iovec(vector, iovstack, count, VERIFY_READ);
1013         if (!iov)
1014                 return -EFAULT;
1015         set_fs(KERNEL_DS);
1016         ret = sys_writev(fd, iov, count);
1017         set_fs(old_fs);
1018         if (iov != iovstack)
1019                 kfree(iov);
1020         return ret;
1021 }
1022
1023 #define SEMOP            1
1024 #define SEMGET           2
1025 #define SEMCTL           3
1026 #define SEMTIMEDOP       4
1027 #define MSGSND          11
1028 #define MSGRCV          12
1029 #define MSGGET          13
1030 #define MSGCTL          14
1031 #define SHMAT           21
1032 #define SHMDT           22
1033 #define SHMGET          23
1034 #define SHMCTL          24
1035
1036 asmlinkage long
1037 sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth)
1038 {
1039         int version;
1040
1041         version = call >> 16; /* hack for backward compatibility */
1042         call &= 0xffff;
1043
1044         switch (call) {
1045               case SEMTIMEDOP:
1046                 if (fifth)
1047                         return compat_sys_semtimedop(first, compat_ptr(ptr),
1048                                 second, compat_ptr(fifth));
1049                 /* else fall through for normal semop() */
1050               case SEMOP:
1051                 /* struct sembuf is the same on 32 and 64bit :)) */
1052                 return sys_semtimedop(first, compat_ptr(ptr), second,
1053                                       NULL);
1054               case SEMGET:
1055                 return sys_semget(first, second, third);
1056               case SEMCTL:
1057                 return compat_sys_semctl(first, second, third, compat_ptr(ptr));
1058
1059               case MSGSND:
1060                 return compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
1061               case MSGRCV:
1062                 return compat_sys_msgrcv(first, second, fifth, third, version, compat_ptr(ptr));
1063               case MSGGET:
1064                 return sys_msgget((key_t) first, second);
1065               case MSGCTL:
1066                 return compat_sys_msgctl(first, second, compat_ptr(ptr));
1067
1068               case SHMAT:
1069                 return compat_sys_shmat(first, second, third, version, compat_ptr(ptr));
1070                 break;
1071               case SHMDT:
1072                 return sys_shmdt(compat_ptr(ptr));
1073               case SHMGET:
1074                 return sys_shmget(first, second, third);
1075               case SHMCTL:
1076                 return compat_sys_shmctl(first, second, compat_ptr(ptr));
1077
1078               default:
1079                 return -ENOSYS;
1080         }
1081         return -EINVAL;
1082 }
1083
1084 /*
1085  * sys_time() can be implemented in user-level using
1086  * sys_gettimeofday().  IA64 did this but i386 Linux did not
1087  * so we have to implement this system call here.
1088  */
1089 asmlinkage long
1090 sys32_time (int *tloc)
1091 {
1092         int i;
1093         struct timeval tv;
1094
1095         do_gettimeofday(&tv);
1096         i = tv.tv_sec;
1097
1098         if (tloc) {
1099                 if (put_user(i, tloc))
1100                         i = -EFAULT;
1101         }
1102         return i;
1103 }
1104
1105 asmlinkage long
1106 compat_sys_wait4 (compat_pid_t pid, compat_uint_t * stat_addr, int options,
1107                  struct compat_rusage *ru);
1108
1109 asmlinkage long
1110 sys32_waitpid (int pid, unsigned int *stat_addr, int options)
1111 {
1112         return compat_sys_wait4(pid, stat_addr, options, NULL);
1113 }
1114
1115 static unsigned int
1116 ia32_peek (struct pt_regs *regs, struct task_struct *child, unsigned long addr, unsigned int *val)
1117 {
1118         size_t copied;
1119         unsigned int ret;
1120
1121         copied = access_process_vm(child, addr, val, sizeof(*val), 0);
1122         return (copied != sizeof(ret)) ? -EIO : 0;
1123 }
1124
1125 static unsigned int
1126 ia32_poke (struct pt_regs *regs, struct task_struct *child, unsigned long addr, unsigned int val)
1127 {
1128
1129         if (access_process_vm(child, addr, &val, sizeof(val), 1) != sizeof(val))
1130                 return -EIO;
1131         return 0;
1132 }
1133
1134 /*
1135  *  The order in which registers are stored in the ptrace regs structure
1136  */
1137 #define PT_EBX  0
1138 #define PT_ECX  1
1139 #define PT_EDX  2
1140 #define PT_ESI  3
1141 #define PT_EDI  4
1142 #define PT_EBP  5
1143 #define PT_EAX  6
1144 #define PT_DS   7
1145 #define PT_ES   8
1146 #define PT_FS   9
1147 #define PT_GS   10
1148 #define PT_ORIG_EAX 11
1149 #define PT_EIP  12
1150 #define PT_CS   13
1151 #define PT_EFL  14
1152 #define PT_UESP 15
1153 #define PT_SS   16
1154
1155 static unsigned int
1156 getreg (struct task_struct *child, int regno)
1157 {
1158         struct pt_regs *child_regs;
1159
1160         child_regs = ia64_task_regs(child);
1161         switch (regno / sizeof(int)) {
1162               case PT_EBX: return child_regs->r11;
1163               case PT_ECX: return child_regs->r9;
1164               case PT_EDX: return child_regs->r10;
1165               case PT_ESI: return child_regs->r14;
1166               case PT_EDI: return child_regs->r15;
1167               case PT_EBP: return child_regs->r13;
1168               case PT_EAX: return child_regs->r8;
1169               case PT_ORIG_EAX: return child_regs->r1; /* see dispatch_to_ia32_handler() */
1170               case PT_EIP: return child_regs->cr_iip;
1171               case PT_UESP: return child_regs->r12;
1172               case PT_EFL: return child->thread.eflag;
1173               case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1174                 return __USER_DS;
1175               case PT_CS: return __USER_CS;
1176               default:
1177                 printk(KERN_ERR "ia32.getreg(): unknown register %d\n", regno);
1178                 break;
1179         }
1180         return 0;
1181 }
1182
1183 static void
1184 putreg (struct task_struct *child, int regno, unsigned int value)
1185 {
1186         struct pt_regs *child_regs;
1187
1188         child_regs = ia64_task_regs(child);
1189         switch (regno / sizeof(int)) {
1190               case PT_EBX: child_regs->r11 = value; break;
1191               case PT_ECX: child_regs->r9 = value; break;
1192               case PT_EDX: child_regs->r10 = value; break;
1193               case PT_ESI: child_regs->r14 = value; break;
1194               case PT_EDI: child_regs->r15 = value; break;
1195               case PT_EBP: child_regs->r13 = value; break;
1196               case PT_EAX: child_regs->r8 = value; break;
1197               case PT_ORIG_EAX: child_regs->r1 = value; break;
1198               case PT_EIP: child_regs->cr_iip = value; break;
1199               case PT_UESP: child_regs->r12 = value; break;
1200               case PT_EFL: child->thread.eflag = value; break;
1201               case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1202                 if (value != __USER_DS)
1203                         printk(KERN_ERR
1204                                "ia32.putreg: attempt to set invalid segment register %d = %x\n",
1205                                regno, value);
1206                 break;
1207               case PT_CS:
1208                 if (value != __USER_CS)
1209                         printk(KERN_ERR
1210                                "ia32.putreg: attempt to to set invalid segment register %d = %x\n",
1211                                regno, value);
1212                 break;
1213               default:
1214                 printk(KERN_ERR "ia32.putreg: unknown register %d\n", regno);
1215                 break;
1216         }
1217 }
1218
1219 static void
1220 put_fpreg (int regno, struct _fpreg_ia32 *reg, struct pt_regs *ptp, struct switch_stack *swp,
1221            int tos)
1222 {
1223         struct _fpreg_ia32 *f;
1224         char buf[32];
1225
1226         f = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
1227         if ((regno += tos) >= 8)
1228                 regno -= 8;
1229         switch (regno) {
1230               case 0:
1231                 ia64f2ia32f(f, &ptp->f8);
1232                 break;
1233               case 1:
1234                 ia64f2ia32f(f, &ptp->f9);
1235                 break;
1236               case 2:
1237                 ia64f2ia32f(f, &ptp->f10);
1238                 break;
1239               case 3:
1240                 ia64f2ia32f(f, &ptp->f11);
1241                 break;
1242               case 4:
1243               case 5:
1244               case 6:
1245               case 7:
1246                 ia64f2ia32f(f, &swp->f12 + (regno - 4));
1247                 break;
1248         }
1249         copy_to_user(reg, f, sizeof(*reg));
1250 }
1251
1252 static void
1253 get_fpreg (int regno, struct _fpreg_ia32 *reg, struct pt_regs *ptp, struct switch_stack *swp,
1254            int tos)
1255 {
1256
1257         if ((regno += tos) >= 8)
1258                 regno -= 8;
1259         switch (regno) {
1260               case 0:
1261                 copy_from_user(&ptp->f8, reg, sizeof(*reg));
1262                 break;
1263               case 1:
1264                 copy_from_user(&ptp->f9, reg, sizeof(*reg));
1265                 break;
1266               case 2:
1267                 copy_from_user(&ptp->f10, reg, sizeof(*reg));
1268                 break;
1269               case 3:
1270                 copy_from_user(&ptp->f11, reg, sizeof(*reg));
1271                 break;
1272               case 4:
1273               case 5:
1274               case 6:
1275               case 7:
1276                 copy_from_user(&swp->f12 + (regno - 4), reg, sizeof(*reg));
1277                 break;
1278         }
1279         return;
1280 }
1281
1282 int
1283 save_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct *save)
1284 {
1285         struct switch_stack *swp;
1286         struct pt_regs *ptp;
1287         int i, tos;
1288
1289         if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1290                 return -EFAULT;
1291
1292         __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1293         __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1294         __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1295         __put_user(tsk->thread.fir, &save->fip);
1296         __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1297         __put_user(tsk->thread.fdr, &save->foo);
1298         __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1299
1300         /*
1301          *  Stack frames start with 16-bytes of temp space
1302          */
1303         swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1304         ptp = ia64_task_regs(tsk);
1305         tos = (tsk->thread.fsr >> 11) & 7;
1306         for (i = 0; i < 8; i++)
1307                 put_fpreg(i, &save->st_space[i], ptp, swp, tos);
1308         return 0;
1309 }
1310
1311 static int
1312 restore_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct *save)
1313 {
1314         struct switch_stack *swp;
1315         struct pt_regs *ptp;
1316         int i, tos;
1317         unsigned int fsrlo, fsrhi, num32;
1318
1319         if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1320                 return(-EFAULT);
1321
1322         __get_user(num32, (unsigned int *)&save->cwd);
1323         tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1324         __get_user(fsrlo, (unsigned int *)&save->swd);
1325         __get_user(fsrhi, (unsigned int *)&save->twd);
1326         num32 = (fsrhi << 16) | fsrlo;
1327         tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1328         __get_user(num32, (unsigned int *)&save->fip);
1329         tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1330         __get_user(num32, (unsigned int *)&save->foo);
1331         tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1332
1333         /*
1334          *  Stack frames start with 16-bytes of temp space
1335          */
1336         swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1337         ptp = ia64_task_regs(tsk);
1338         tos = (tsk->thread.fsr >> 11) & 7;
1339         for (i = 0; i < 8; i++)
1340                 get_fpreg(i, &save->st_space[i], ptp, swp, tos);
1341         return 0;
1342 }
1343
1344 int
1345 save_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct *save)
1346 {
1347         struct switch_stack *swp;
1348         struct pt_regs *ptp;
1349         int i, tos;
1350         unsigned long mxcsr=0;
1351         unsigned long num128[2];
1352
1353         if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1354                 return -EFAULT;
1355
1356         __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1357         __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1358         __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1359         __put_user(tsk->thread.fir, &save->fip);
1360         __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1361         __put_user(tsk->thread.fdr, &save->foo);
1362         __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1363
1364         /*
1365          *  Stack frames start with 16-bytes of temp space
1366          */
1367         swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1368         ptp = ia64_task_regs(tsk);
1369         tos = (tsk->thread.fsr >> 11) & 7;
1370         for (i = 0; i < 8; i++)
1371                 put_fpreg(i, (struct _fpreg_ia32 *)&save->st_space[4*i], ptp, swp, tos);
1372
1373         mxcsr = ((tsk->thread.fcr>>32) & 0xff80) | ((tsk->thread.fsr>>32) & 0x3f);
1374         __put_user(mxcsr & 0xffff, &save->mxcsr);
1375         for (i = 0; i < 8; i++) {
1376                 memcpy(&(num128[0]), &(swp->f16) + i*2, sizeof(unsigned long));
1377                 memcpy(&(num128[1]), &(swp->f17) + i*2, sizeof(unsigned long));
1378                 copy_to_user(&save->xmm_space[0] + 4*i, num128, sizeof(struct _xmmreg_ia32));
1379         }
1380         return 0;
1381 }
1382
1383 static int
1384 restore_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct *save)
1385 {
1386         struct switch_stack *swp;
1387         struct pt_regs *ptp;
1388         int i, tos;
1389         unsigned int fsrlo, fsrhi, num32;
1390         int mxcsr;
1391         unsigned long num64;
1392         unsigned long num128[2];
1393
1394         if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1395                 return(-EFAULT);
1396
1397         __get_user(num32, (unsigned int *)&save->cwd);
1398         tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1399         __get_user(fsrlo, (unsigned int *)&save->swd);
1400         __get_user(fsrhi, (unsigned int *)&save->twd);
1401         num32 = (fsrhi << 16) | fsrlo;
1402         tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1403         __get_user(num32, (unsigned int *)&save->fip);
1404         tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1405         __get_user(num32, (unsigned int *)&save->foo);
1406         tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1407
1408         /*
1409          *  Stack frames start with 16-bytes of temp space
1410          */
1411         swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1412         ptp = ia64_task_regs(tsk);
1413         tos = (tsk->thread.fsr >> 11) & 7;
1414         for (i = 0; i < 8; i++)
1415         get_fpreg(i, (struct _fpreg_ia32 *)&save->st_space[4*i], ptp, swp, tos);
1416
1417         __get_user(mxcsr, (unsigned int *)&save->mxcsr);
1418         num64 = mxcsr & 0xff10;
1419         tsk->thread.fcr = (tsk->thread.fcr & (~0xff1000000000)) | (num64<<32);
1420         num64 = mxcsr & 0x3f;
1421         tsk->thread.fsr = (tsk->thread.fsr & (~0x3f00000000)) | (num64<<32);
1422
1423         for (i = 0; i < 8; i++) {
1424                 copy_from_user(num128, &save->xmm_space[0] + 4*i, sizeof(struct _xmmreg_ia32));
1425                 memcpy(&(swp->f16) + i*2, &(num128[0]), sizeof(unsigned long));
1426                 memcpy(&(swp->f17) + i*2, &(num128[1]), sizeof(unsigned long));
1427         }
1428         return 0;
1429 }
1430
1431 /*
1432  *  Note that the IA32 version of `ptrace' calls the IA64 routine for
1433  *    many of the requests.  This will only work for requests that do
1434  *    not need access to the calling processes `pt_regs' which is located
1435  *    at the address of `stack'.  Once we call the IA64 `sys_ptrace' then
1436  *    the address of `stack' will not be the address of the `pt_regs'.
1437  */
1438 asmlinkage long
1439 sys32_ptrace (int request, pid_t pid, unsigned int addr, unsigned int data,
1440               long arg4, long arg5, long arg6, long arg7, long stack)
1441 {
1442         struct pt_regs *regs = (struct pt_regs *) &stack;
1443         struct task_struct *child;
1444         unsigned int value, tmp;
1445         long i, ret;
1446
1447         lock_kernel();
1448         if (request == PTRACE_TRACEME) {
1449                 ret = sys_ptrace(request, pid, addr, data, arg4, arg5, arg6, arg7, stack);
1450                 goto out;
1451         }
1452
1453         ret = -ESRCH;
1454         read_lock(&tasklist_lock);
1455         child = find_task_by_pid(pid);
1456         if (child)
1457                 get_task_struct(child);
1458         read_unlock(&tasklist_lock);
1459         if (!child)
1460                 goto out;
1461         ret = -EPERM;
1462         if (pid == 1)           /* no messing around with init! */
1463                 goto out_tsk;
1464
1465         if (request == PTRACE_ATTACH) {
1466                 ret = sys_ptrace(request, pid, addr, data, arg4, arg5, arg6, arg7, stack);
1467                 goto out_tsk;
1468         }
1469
1470         ret = ptrace_check_attach(child, request == PTRACE_KILL);
1471         if (ret < 0)
1472                 goto out_tsk;
1473
1474         switch (request) {
1475               case PTRACE_PEEKTEXT:
1476               case PTRACE_PEEKDATA:     /* read word at location addr */
1477                 ret = ia32_peek(regs, child, addr, &value);
1478                 if (ret == 0)
1479                         ret = put_user(value, (unsigned int *) A(data));
1480                 else
1481                         ret = -EIO;
1482                 goto out_tsk;
1483
1484               case PTRACE_POKETEXT:
1485               case PTRACE_POKEDATA:     /* write the word at location addr */
1486                 ret = ia32_poke(regs, child, addr, data);
1487                 goto out_tsk;
1488
1489               case PTRACE_PEEKUSR:      /* read word at addr in USER area */
1490                 ret = -EIO;
1491                 if ((addr & 3) || addr > 17*sizeof(int))
1492                         break;
1493
1494                 tmp = getreg(child, addr);
1495                 if (!put_user(tmp, (unsigned int *) A(data)))
1496                         ret = 0;
1497                 break;
1498
1499               case PTRACE_POKEUSR:      /* write word at addr in USER area */
1500                 ret = -EIO;
1501                 if ((addr & 3) || addr > 17*sizeof(int))
1502                         break;
1503
1504                 putreg(child, addr, data);
1505                 ret = 0;
1506                 break;
1507
1508               case IA32_PTRACE_GETREGS:
1509                 if (!access_ok(VERIFY_WRITE, (int *) A(data), 17*sizeof(int))) {
1510                         ret = -EIO;
1511                         break;
1512                 }
1513                 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1514                         put_user(getreg(child, i), (unsigned int *) A(data));
1515                         data += sizeof(int);
1516                 }
1517                 ret = 0;
1518                 break;
1519
1520               case IA32_PTRACE_SETREGS:
1521                 if (!access_ok(VERIFY_READ, (int *) A(data), 17*sizeof(int))) {
1522                         ret = -EIO;
1523                         break;
1524                 }
1525                 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1526                         get_user(tmp, (unsigned int *) A(data));
1527                         putreg(child, i, tmp);
1528                         data += sizeof(int);
1529                 }
1530                 ret = 0;
1531                 break;
1532
1533               case IA32_PTRACE_GETFPREGS:
1534                 ret = save_ia32_fpstate(child, (struct ia32_user_i387_struct *) A(data));
1535                 break;
1536
1537               case IA32_PTRACE_GETFPXREGS:
1538                 ret = save_ia32_fpxstate(child, (struct ia32_user_fxsr_struct *) A(data));
1539                 break;
1540
1541               case IA32_PTRACE_SETFPREGS:
1542                 ret = restore_ia32_fpstate(child, (struct ia32_user_i387_struct *) A(data));
1543                 break;
1544
1545               case IA32_PTRACE_SETFPXREGS:
1546                 ret = restore_ia32_fpxstate(child, (struct ia32_user_fxsr_struct *) A(data));
1547                 break;
1548
1549               case PTRACE_SYSCALL:      /* continue, stop after next syscall */
1550               case PTRACE_CONT:         /* restart after signal. */
1551               case PTRACE_KILL:
1552               case PTRACE_SINGLESTEP:   /* execute chile for one instruction */
1553               case PTRACE_DETACH:       /* detach a process */
1554                 ret = sys_ptrace(request, pid, addr, data, arg4, arg5, arg6, arg7, stack);
1555                 break;
1556
1557               default:
1558                 ret = ptrace_request(child, request, addr, data);
1559                 break;
1560
1561         }
1562   out_tsk:
1563         put_task_struct(child);
1564   out:
1565         unlock_kernel();
1566         return ret;
1567 }
1568
1569 /*
1570  *  The IA64 maps 4 I/O ports for each 4K page
1571  */
1572 #define IOLEN   ((65536 / 4) * 4096)
1573
1574 asmlinkage long
1575 sys32_iopl (int level)
1576 {
1577         extern unsigned long ia64_iobase;
1578         int fd;
1579         struct file * file;
1580         unsigned int old;
1581         unsigned long addr;
1582         mm_segment_t old_fs = get_fs ();
1583
1584         if (level != 3)
1585                 return(-EINVAL);
1586         /* Trying to gain more privileges? */
1587         old = ia64_getreg(_IA64_REG_AR_EFLAG);
1588         if ((unsigned int) level > ((old >> 12) & 3)) {
1589                 if (!capable(CAP_SYS_RAWIO))
1590                         return -EPERM;
1591         }
1592         set_fs(KERNEL_DS);
1593         fd = sys_open("/dev/mem", O_SYNC | O_RDWR, 0);
1594         set_fs(old_fs);
1595         if (fd < 0)
1596                 return fd;
1597         file = fget(fd);
1598         if (file == NULL) {
1599                 sys_close(fd);
1600                 return(-EFAULT);
1601         }
1602
1603         down_write(&current->mm->mmap_sem);
1604         addr = do_mmap_pgoff(file, IA32_IOBASE,
1605                              IOLEN, PROT_READ|PROT_WRITE, MAP_SHARED,
1606                              (ia64_iobase & ~PAGE_OFFSET) >> PAGE_SHIFT);
1607         up_write(&current->mm->mmap_sem);
1608
1609         if (addr >= 0) {
1610                 old = (old & ~0x3000) | (level << 12);
1611                 ia64_setreg(_IA64_REG_AR_EFLAG, old);
1612         }
1613
1614         fput(file);
1615         sys_close(fd);
1616         return 0;
1617 }
1618
1619 asmlinkage long
1620 sys32_ioperm (unsigned int from, unsigned int num, int on)
1621 {
1622
1623         /*
1624          *  Since IA64 doesn't have permission bits we'd have to go to
1625          *    a lot of trouble to simulate them in software.  There's
1626          *    no point, only trusted programs can make this call so we'll
1627          *    just turn it into an iopl call and let the process have
1628          *    access to all I/O ports.
1629          *
1630          * XXX proper ioperm() support should be emulated by
1631          *      manipulating the page protections...
1632          */
1633         return sys32_iopl(3);
1634 }
1635
1636 typedef struct {
1637         unsigned int    ss_sp;
1638         unsigned int    ss_flags;
1639         unsigned int    ss_size;
1640 } ia32_stack_t;
1641
1642 asmlinkage long
1643 sys32_sigaltstack (ia32_stack_t *uss32, ia32_stack_t *uoss32,
1644                    long arg2, long arg3, long arg4, long arg5, long arg6, long arg7, long stack)
1645 {
1646         struct pt_regs *pt = (struct pt_regs *) &stack;
1647         stack_t uss, uoss;
1648         ia32_stack_t buf32;
1649         int ret;
1650         mm_segment_t old_fs = get_fs();
1651
1652         if (uss32)
1653                 if (copy_from_user(&buf32, uss32, sizeof(ia32_stack_t)))
1654                         return -EFAULT;
1655         uss.ss_sp = (void *) (long) buf32.ss_sp;
1656         uss.ss_flags = buf32.ss_flags;
1657         /* MINSIGSTKSZ is different for ia32 vs ia64. We lie here to pass the
1658            check and set it to the user requested value later */
1659         if ((buf32.ss_flags != SS_DISABLE) && (buf32.ss_size < MINSIGSTKSZ_IA32)) {
1660                 ret = -ENOMEM;
1661                 goto out;
1662         }
1663         uss.ss_size = MINSIGSTKSZ;
1664         set_fs(KERNEL_DS);
1665         ret = do_sigaltstack(uss32 ? &uss : NULL, &uoss, pt->r12);
1666         current->sas_ss_size = buf32.ss_size;
1667         set_fs(old_fs);
1668 out:
1669         if (ret < 0)
1670                 return(ret);
1671         if (uoss32) {
1672                 buf32.ss_sp = (long) uoss.ss_sp;
1673                 buf32.ss_flags = uoss.ss_flags;
1674                 buf32.ss_size = uoss.ss_size;
1675                 if (copy_to_user(uoss32, &buf32, sizeof(ia32_stack_t)))
1676                         return -EFAULT;
1677         }
1678         return ret;
1679 }
1680
1681 asmlinkage int
1682 sys32_pause (void)
1683 {
1684         current->state = TASK_INTERRUPTIBLE;
1685         schedule();
1686         return -ERESTARTNOHAND;
1687 }
1688
1689 asmlinkage int
1690 sys32_msync (unsigned int start, unsigned int len, int flags)
1691 {
1692         unsigned int addr;
1693
1694         if (OFFSET4K(start))
1695                 return -EINVAL;
1696         addr = PAGE_START(start);
1697         return sys_msync(addr, len + (start - addr), flags);
1698 }
1699
1700 struct sysctl32 {
1701         unsigned int    name;
1702         int             nlen;
1703         unsigned int    oldval;
1704         unsigned int    oldlenp;
1705         unsigned int    newval;
1706         unsigned int    newlen;
1707         unsigned int    __unused[4];
1708 };
1709
1710 asmlinkage long
1711 sys32_sysctl (struct sysctl32 *args)
1712 {
1713 #ifdef CONFIG_SYSCTL
1714         struct sysctl32 a32;
1715         mm_segment_t old_fs = get_fs ();
1716         void *oldvalp, *newvalp;
1717         size_t oldlen;
1718         int *namep;
1719         long ret;
1720
1721         if (copy_from_user(&a32, args, sizeof(a32)))
1722                 return -EFAULT;
1723
1724         /*
1725          * We need to pre-validate these because we have to disable address checking
1726          * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
1727          * user specifying bad addresses here.  Well, since we're dealing with 32 bit
1728          * addresses, we KNOW that access_ok() will always succeed, so this is an
1729          * expensive NOP, but so what...
1730          */
1731         namep = (int *) A(a32.name);
1732         oldvalp = (void *) A(a32.oldval);
1733         newvalp = (void *) A(a32.newval);
1734
1735         if ((oldvalp && get_user(oldlen, (int *) A(a32.oldlenp)))
1736             || !access_ok(VERIFY_WRITE, namep, 0)
1737             || !access_ok(VERIFY_WRITE, oldvalp, 0)
1738             || !access_ok(VERIFY_WRITE, newvalp, 0))
1739                 return -EFAULT;
1740
1741         set_fs(KERNEL_DS);
1742         lock_kernel();
1743         ret = do_sysctl(namep, a32.nlen, oldvalp, &oldlen, newvalp, (size_t) a32.newlen);
1744         unlock_kernel();
1745         set_fs(old_fs);
1746
1747         if (oldvalp && put_user (oldlen, (int *) A(a32.oldlenp)))
1748                 return -EFAULT;
1749
1750         return ret;
1751 #else
1752         return -ENOSYS;
1753 #endif
1754 }
1755
1756 asmlinkage long
1757 sys32_newuname (struct new_utsname *name)
1758 {
1759         int ret = sys_newuname(name);
1760
1761         if (!ret)
1762                 if (copy_to_user(name->machine, "i686\0\0\0", 8))
1763                         ret = -EFAULT;
1764         return ret;
1765 }
1766
1767 asmlinkage long
1768 sys32_getresuid16 (u16 *ruid, u16 *euid, u16 *suid)
1769 {
1770         uid_t a, b, c;
1771         int ret;
1772         mm_segment_t old_fs = get_fs();
1773
1774         set_fs(KERNEL_DS);
1775         ret = sys_getresuid(&a, &b, &c);
1776         set_fs(old_fs);
1777
1778         if (put_user(a, ruid) || put_user(b, euid) || put_user(c, suid))
1779                 return -EFAULT;
1780         return ret;
1781 }
1782
1783 asmlinkage long
1784 sys32_getresgid16 (u16 *rgid, u16 *egid, u16 *sgid)
1785 {
1786         gid_t a, b, c;
1787         int ret;
1788         mm_segment_t old_fs = get_fs();
1789
1790         set_fs(KERNEL_DS);
1791         ret = sys_getresgid(&a, &b, &c);
1792         set_fs(old_fs);
1793
1794         if (ret)
1795                 return ret;
1796
1797         return put_user(a, rgid) | put_user(b, egid) | put_user(c, sgid);
1798 }
1799
1800 asmlinkage long
1801 sys32_lseek (unsigned int fd, int offset, unsigned int whence)
1802 {
1803         /* Sign-extension of "offset" is important here... */
1804         return sys_lseek(fd, offset, whence);
1805 }
1806
1807 static int
1808 groups16_to_user(short *grouplist, struct group_info *group_info)
1809 {
1810         int i;
1811         short group;
1812
1813         for (i = 0; i < group_info->ngroups; i++) {
1814                 group = (short)GROUP_AT(group_info, i);
1815                 if (put_user(group, grouplist+i))
1816                         return -EFAULT;
1817         }
1818
1819         return 0;
1820 }
1821
1822 static int
1823 groups16_from_user(struct group_info *group_info, short *grouplist)
1824 {
1825         int i;
1826         short group;
1827
1828         for (i = 0; i < group_info->ngroups; i++) {
1829                 if (get_user(group, grouplist+i))
1830                         return  -EFAULT;
1831                 GROUP_AT(group_info, i) = (gid_t)group;
1832         }
1833
1834         return 0;
1835 }
1836
1837 asmlinkage long
1838 sys32_getgroups16 (int gidsetsize, short *grouplist)
1839 {
1840         int i;
1841
1842         if (gidsetsize < 0)
1843                 return -EINVAL;
1844
1845         get_group_info(current->group_info);
1846         i = current->group_info->ngroups;
1847         if (gidsetsize) {
1848                 if (i > gidsetsize) {
1849                         i = -EINVAL;
1850                         goto out;
1851                 }
1852                 if (groups16_to_user(grouplist, current->group_info)) {
1853                         i = -EFAULT;
1854                         goto out;
1855                 }
1856         }
1857 out:
1858         put_group_info(current->group_info);
1859         return i;
1860 }
1861
1862 asmlinkage long
1863 sys32_setgroups16 (int gidsetsize, short *grouplist)
1864 {
1865         struct group_info *group_info;
1866         int retval;
1867
1868         if (!capable(CAP_SETGID))
1869                 return -EPERM;
1870         if ((unsigned)gidsetsize > NGROUPS_MAX)
1871                 return -EINVAL;
1872
1873         group_info = groups_alloc(gidsetsize);
1874         if (!group_info)
1875                 return -ENOMEM;
1876         retval = groups16_from_user(group_info, grouplist);
1877         if (retval) {
1878                 put_group_info(group_info);
1879                 return retval;
1880         }
1881
1882         retval = set_current_groups(group_info);
1883         put_group_info(group_info);
1884
1885         return retval;
1886 }
1887
1888 asmlinkage long
1889 sys32_truncate64 (unsigned int path, unsigned int len_lo, unsigned int len_hi)
1890 {
1891         return sys_truncate((const char *) A(path), ((unsigned long) len_hi << 32) | len_lo);
1892 }
1893
1894 asmlinkage long
1895 sys32_ftruncate64 (int fd, unsigned int len_lo, unsigned int len_hi)
1896 {
1897         return sys_ftruncate(fd, ((unsigned long) len_hi << 32) | len_lo);
1898 }
1899
1900 static int
1901 putstat64 (struct stat64 *ubuf, struct kstat *kbuf)
1902 {
1903         int err;
1904         u64 hdev;
1905
1906         if (clear_user(ubuf, sizeof(*ubuf)))
1907                 return -EFAULT;
1908
1909         hdev = huge_encode_dev(kbuf->dev);
1910         err  = __put_user(hdev, (u32*)&ubuf->st_dev);
1911         err |= __put_user(hdev >> 32, ((u32*)&ubuf->st_dev) + 1);
1912         err |= __put_user(kbuf->ino, &ubuf->__st_ino);
1913         err |= __put_user(kbuf->ino, &ubuf->st_ino_lo);
1914         err |= __put_user(kbuf->ino >> 32, &ubuf->st_ino_hi);
1915         err |= __put_user(kbuf->mode, &ubuf->st_mode);
1916         err |= __put_user(kbuf->nlink, &ubuf->st_nlink);
1917         err |= __put_user(kbuf->uid, &ubuf->st_uid);
1918         err |= __put_user(kbuf->gid, &ubuf->st_gid);
1919         hdev = huge_encode_dev(kbuf->rdev);
1920         err  = __put_user(hdev, (u32*)&ubuf->st_rdev);
1921         err |= __put_user(hdev >> 32, ((u32*)&ubuf->st_rdev) + 1);
1922         err |= __put_user(kbuf->size, &ubuf->st_size_lo);
1923         err |= __put_user((kbuf->size >> 32), &ubuf->st_size_hi);
1924         err |= __put_user(kbuf->atime.tv_sec, &ubuf->st_atime);
1925         err |= __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec);
1926         err |= __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime);
1927         err |= __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec);
1928         err |= __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime);
1929         err |= __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec);
1930         err |= __put_user(kbuf->blksize, &ubuf->st_blksize);
1931         err |= __put_user(kbuf->blocks, &ubuf->st_blocks);
1932         return err;
1933 }
1934
1935 asmlinkage long
1936 sys32_stat64 (char *filename, struct stat64 *statbuf)
1937 {
1938         struct kstat s;
1939         long ret = vfs_stat(filename, &s);
1940         if (!ret)
1941                 ret = putstat64(statbuf, &s);
1942         return ret;
1943 }
1944
1945 asmlinkage long
1946 sys32_lstat64 (char *filename, struct stat64 *statbuf)
1947 {
1948         struct kstat s;
1949         long ret = vfs_lstat(filename, &s);
1950         if (!ret)
1951                 ret = putstat64(statbuf, &s);
1952         return ret;
1953 }
1954
1955 asmlinkage long
1956 sys32_fstat64 (unsigned int fd, struct stat64 *statbuf)
1957 {
1958         struct kstat s;
1959         long ret = vfs_fstat(fd, &s);
1960         if (!ret)
1961                 ret = putstat64(statbuf, &s);
1962         return ret;
1963 }
1964
1965 struct sysinfo32 {
1966         s32 uptime;
1967         u32 loads[3];
1968         u32 totalram;
1969         u32 freeram;
1970         u32 sharedram;
1971         u32 bufferram;
1972         u32 totalswap;
1973         u32 freeswap;
1974         u16 procs;
1975         u16 pad;
1976         u32 totalhigh;
1977         u32 freehigh;
1978         u32 mem_unit;
1979         char _f[8];
1980 };
1981
1982 asmlinkage long
1983 sys32_sysinfo (struct sysinfo32 *info)
1984 {
1985         struct sysinfo s;
1986         long ret, err;
1987         int bitcount = 0;
1988         mm_segment_t old_fs = get_fs();
1989
1990         set_fs(KERNEL_DS);
1991         ret = sys_sysinfo(&s);
1992         set_fs(old_fs);
1993         /* Check to see if any memory value is too large for 32-bit and
1994          * scale down if needed.
1995          */
1996         if ((s.totalram >> 32) || (s.totalswap >> 32)) {
1997                 while (s.mem_unit < PAGE_SIZE) {
1998                         s.mem_unit <<= 1;
1999                         bitcount++;
2000                 }
2001                 s.totalram >>= bitcount;
2002                 s.freeram >>= bitcount;
2003                 s.sharedram >>= bitcount;
2004                 s.bufferram >>= bitcount;
2005                 s.totalswap >>= bitcount;
2006                 s.freeswap >>= bitcount;
2007                 s.totalhigh >>= bitcount;
2008                 s.freehigh >>= bitcount;
2009         }
2010
2011         if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
2012                 return -EFAULT;
2013
2014         err  = __put_user(s.uptime, &info->uptime);
2015         err |= __put_user(s.loads[0], &info->loads[0]);
2016         err |= __put_user(s.loads[1], &info->loads[1]);
2017         err |= __put_user(s.loads[2], &info->loads[2]);
2018         err |= __put_user(s.totalram, &info->totalram);
2019         err |= __put_user(s.freeram, &info->freeram);
2020         err |= __put_user(s.sharedram, &info->sharedram);
2021         err |= __put_user(s.bufferram, &info->bufferram);
2022         err |= __put_user(s.totalswap, &info->totalswap);
2023         err |= __put_user(s.freeswap, &info->freeswap);
2024         err |= __put_user(s.procs, &info->procs);
2025         err |= __put_user (s.totalhigh, &info->totalhigh);
2026         err |= __put_user (s.freehigh, &info->freehigh);
2027         err |= __put_user (s.mem_unit, &info->mem_unit);
2028         if (err)
2029                 return -EFAULT;
2030         return ret;
2031 }
2032
2033 asmlinkage long
2034 sys32_sched_rr_get_interval (pid_t pid, struct compat_timespec *interval)
2035 {
2036         mm_segment_t old_fs = get_fs();
2037         struct timespec t;
2038         long ret;
2039
2040         set_fs(KERNEL_DS);
2041         ret = sys_sched_rr_get_interval(pid, &t);
2042         set_fs(old_fs);
2043         if (put_compat_timespec(&t, interval))
2044                 return -EFAULT;
2045         return ret;
2046 }
2047
2048 asmlinkage long
2049 sys32_pread (unsigned int fd, void *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
2050 {
2051         return sys_pread64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
2052 }
2053
2054 asmlinkage long
2055 sys32_pwrite (unsigned int fd, void *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
2056 {
2057         return sys_pwrite64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
2058 }
2059
2060 asmlinkage long
2061 sys32_sendfile (int out_fd, int in_fd, int *offset, unsigned int count)
2062 {
2063         mm_segment_t old_fs = get_fs();
2064         long ret;
2065         off_t of;
2066
2067         if (offset && get_user(of, offset))
2068                 return -EFAULT;
2069
2070         set_fs(KERNEL_DS);
2071         ret = sys_sendfile(out_fd, in_fd, offset ? &of : NULL, count);
2072         set_fs(old_fs);
2073
2074         if (!ret && offset && put_user(of, offset))
2075                 return -EFAULT;
2076
2077         return ret;
2078 }
2079
2080 asmlinkage long
2081 sys32_personality (unsigned int personality)
2082 {
2083         long ret;
2084
2085         if (current->personality == PER_LINUX32 && personality == PER_LINUX)
2086                 personality = PER_LINUX32;
2087         ret = sys_personality(personality);
2088         if (ret == PER_LINUX32)
2089                 ret = PER_LINUX;
2090         return ret;
2091 }
2092
2093 asmlinkage unsigned long
2094 sys32_brk (unsigned int brk)
2095 {
2096         unsigned long ret, obrk;
2097         struct mm_struct *mm = current->mm;
2098
2099         obrk = mm->brk;
2100         ret = sys_brk(brk);
2101         if (ret < obrk)
2102                 clear_user((void *) ret, PAGE_ALIGN(ret) - ret);
2103         return ret;
2104 }
2105
2106 /*
2107  * Exactly like fs/open.c:sys_open(), except that it doesn't set the O_LARGEFILE flag.
2108  */
2109 asmlinkage long
2110 sys32_open (const char * filename, int flags, int mode)
2111 {
2112         char * tmp;
2113         int fd, error;
2114
2115         tmp = getname(filename);
2116         fd = PTR_ERR(tmp);
2117         if (!IS_ERR(tmp)) {
2118                 fd = get_unused_fd();
2119                 if (fd >= 0) {
2120                         struct file *f = filp_open(tmp, flags, mode);
2121                         error = PTR_ERR(f);
2122                         if (IS_ERR(f))
2123                                 goto out_error;
2124                         fd_install(fd, f);
2125                 }
2126 out:
2127                 putname(tmp);
2128         }
2129         return fd;
2130
2131 out_error:
2132         put_unused_fd(fd);
2133         fd = error;
2134         goto out;
2135 }
2136
2137 /* Structure for ia32 emulation on ia64 */
2138 struct epoll_event32
2139 {
2140         u32 events;
2141         u32 data[2];
2142 };
2143
2144 asmlinkage long
2145 sys32_epoll_ctl(int epfd, int op, int fd, struct epoll_event32 *event)
2146 {
2147         mm_segment_t old_fs = get_fs();
2148         struct epoll_event event64;
2149         int error = -EFAULT;
2150         u32 data_halfword;
2151
2152         if ((error = verify_area(VERIFY_READ, event,
2153                                  sizeof(struct epoll_event32))))
2154                 return error;
2155
2156         __get_user(event64.events, &event->events);
2157         __get_user(data_halfword, &event->data[0]);
2158         event64.data = data_halfword;
2159         __get_user(data_halfword, &event->data[1]);
2160         event64.data |= (u64)data_halfword << 32;
2161
2162         set_fs(KERNEL_DS);
2163         error = sys_epoll_ctl(epfd, op, fd, &event64);
2164         set_fs(old_fs);
2165
2166         return error;
2167 }
2168
2169 asmlinkage long
2170 sys32_epoll_wait(int epfd, struct epoll_event32 *events, int maxevents,
2171                  int timeout)
2172 {
2173         struct epoll_event *events64 = NULL;
2174         mm_segment_t old_fs = get_fs();
2175         int error, numevents, size;
2176         int evt_idx;
2177         int do_free_pages = 0;
2178
2179         if (maxevents <= 0) {
2180                 return -EINVAL;
2181         }
2182
2183         /* Verify that the area passed by the user is writeable */
2184         if ((error = verify_area(VERIFY_WRITE, events,
2185                                  maxevents * sizeof(struct epoll_event32))))
2186                 return error;
2187
2188         /*
2189          * Allocate space for the intermediate copy.  If the space needed
2190          * is large enough to cause kmalloc to fail, then try again with
2191          * __get_free_pages.
2192          */
2193         size = maxevents * sizeof(struct epoll_event);
2194         events64 = kmalloc(size, GFP_KERNEL);
2195         if (events64 == NULL) {
2196                 events64 = (struct epoll_event *)
2197                                 __get_free_pages(GFP_KERNEL, get_order(size));
2198                 if (events64 == NULL)
2199                         return -ENOMEM;
2200                 do_free_pages = 1;
2201         }
2202
2203         /* Do the system call */
2204         set_fs(KERNEL_DS); /* copy_to/from_user should work on kernel mem*/
2205         numevents = sys_epoll_wait(epfd, events64, maxevents, timeout);
2206         set_fs(old_fs);
2207
2208         /* Don't modify userspace memory if we're returning an error */
2209         if (numevents > 0) {
2210                 /* Translate the 64-bit structures back into the 32-bit
2211                    structures */
2212                 for (evt_idx = 0; evt_idx < numevents; evt_idx++) {
2213                         __put_user(events64[evt_idx].events,
2214                                    &events[evt_idx].events);
2215                         __put_user((u32)events64[evt_idx].data,
2216                                    &events[evt_idx].data[0]);
2217                         __put_user((u32)(events64[evt_idx].data >> 32),
2218                                    &events[evt_idx].data[1]);
2219                 }
2220         }
2221
2222         if (do_free_pages)
2223                 free_pages((unsigned long) events64, get_order(size));
2224         else
2225                 kfree(events64);
2226         return numevents;
2227 }
2228
2229 /*
2230  * Get a yet unused TLS descriptor index.
2231  */
2232 static int
2233 get_free_idx (void)
2234 {
2235         struct thread_struct *t = &current->thread;
2236         int idx;
2237
2238         for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
2239                 if (desc_empty(t->tls_array + idx))
2240                         return idx + GDT_ENTRY_TLS_MIN;
2241         return -ESRCH;
2242 }
2243
2244 /*
2245  * Set a given TLS descriptor:
2246  */
2247 asmlinkage int
2248 sys32_set_thread_area (struct ia32_user_desc *u_info)
2249 {
2250         struct thread_struct *t = &current->thread;
2251         struct ia32_user_desc info;
2252         struct desc_struct *desc;
2253         int cpu, idx;
2254
2255         if (copy_from_user(&info, u_info, sizeof(info)))
2256                 return -EFAULT;
2257         idx = info.entry_number;
2258
2259         /*
2260          * index -1 means the kernel should try to find and allocate an empty descriptor:
2261          */
2262         if (idx == -1) {
2263                 idx = get_free_idx();
2264                 if (idx < 0)
2265                         return idx;
2266                 if (put_user(idx, &u_info->entry_number))
2267                         return -EFAULT;
2268         }
2269
2270         if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
2271                 return -EINVAL;
2272
2273         desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
2274
2275         cpu = smp_processor_id();
2276
2277         if (LDT_empty(&info)) {
2278                 desc->a = 0;
2279                 desc->b = 0;
2280         } else {
2281                 desc->a = LDT_entry_a(&info);
2282                 desc->b = LDT_entry_b(&info);
2283         }
2284         load_TLS(t, cpu);
2285         return 0;
2286 }
2287
2288 /*
2289  * Get the current Thread-Local Storage area:
2290  */
2291
2292 #define GET_BASE(desc) (                        \
2293         (((desc)->a >> 16) & 0x0000ffff) |      \
2294         (((desc)->b << 16) & 0x00ff0000) |      \
2295         ( (desc)->b        & 0xff000000)   )
2296
2297 #define GET_LIMIT(desc) (                       \
2298         ((desc)->a & 0x0ffff) |                 \
2299          ((desc)->b & 0xf0000) )
2300
2301 #define GET_32BIT(desc)         (((desc)->b >> 23) & 1)
2302 #define GET_CONTENTS(desc)      (((desc)->b >> 10) & 3)
2303 #define GET_WRITABLE(desc)      (((desc)->b >>  9) & 1)
2304 #define GET_LIMIT_PAGES(desc)   (((desc)->b >> 23) & 1)
2305 #define GET_PRESENT(desc)       (((desc)->b >> 15) & 1)
2306 #define GET_USEABLE(desc)       (((desc)->b >> 20) & 1)
2307
2308 asmlinkage int
2309 sys32_get_thread_area (struct ia32_user_desc *u_info)
2310 {
2311         struct ia32_user_desc info;
2312         struct desc_struct *desc;
2313         int idx;
2314
2315         if (get_user(idx, &u_info->entry_number))
2316                 return -EFAULT;
2317         if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
2318                 return -EINVAL;
2319
2320         desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
2321
2322         info.entry_number = idx;
2323         info.base_addr = GET_BASE(desc);
2324         info.limit = GET_LIMIT(desc);
2325         info.seg_32bit = GET_32BIT(desc);
2326         info.contents = GET_CONTENTS(desc);
2327         info.read_exec_only = !GET_WRITABLE(desc);
2328         info.limit_in_pages = GET_LIMIT_PAGES(desc);
2329         info.seg_not_present = !GET_PRESENT(desc);
2330         info.useable = GET_USEABLE(desc);
2331
2332         if (copy_to_user(u_info, &info, sizeof(info)))
2333                 return -EFAULT;
2334         return 0;
2335 }
2336
2337 extern asmlinkage long
2338 sys_timer_create(clockid_t which_clock, struct sigevent *timer_event_spec,
2339                  timer_t * created_timer_id);
2340
2341 asmlinkage long
2342 sys32_timer_create(u32 clock, struct sigevent32 *se32, timer_t *timer_id)
2343 {
2344         struct sigevent se;
2345         mm_segment_t oldfs;
2346         timer_t t;
2347         long err;
2348
2349         if (se32 == NULL)
2350                 return sys_timer_create(clock, NULL, timer_id);
2351
2352         memset(&se, 0, sizeof(struct sigevent));
2353         if (get_user(se.sigev_value.sival_int,  &se32->sigev_value.sival_int) ||
2354             __get_user(se.sigev_signo, &se32->sigev_signo) ||
2355             __get_user(se.sigev_notify, &se32->sigev_notify) ||
2356             __copy_from_user(&se._sigev_un._pad, &se32->_sigev_un._pad,
2357             sizeof(se._sigev_un._pad)))
2358                 return -EFAULT;
2359
2360         if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
2361                 return -EFAULT;
2362
2363         oldfs = get_fs();
2364         set_fs(KERNEL_DS);
2365         err = sys_timer_create(clock, &se, &t);
2366         set_fs(oldfs);
2367
2368         if (!err)
2369                 err = __put_user (t, timer_id);
2370
2371         return err;
2372 }
2373
2374 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
2375                         __u32 len_low, __u32 len_high, int advice)
2376 {
2377         return sys_fadvise64_64(fd,
2378                                (((u64)offset_high)<<32) | offset_low,
2379                                (((u64)len_high)<<32) | len_low,
2380                                advice);
2381 }
2382
2383 #ifdef  NOTYET  /* UNTESTED FOR IA64 FROM HERE DOWN */
2384
2385 asmlinkage long sys32_setreuid(compat_uid_t ruid, compat_uid_t euid)
2386 {
2387         uid_t sruid, seuid;
2388
2389         sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
2390         seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
2391         return sys_setreuid(sruid, seuid);
2392 }
2393
2394 asmlinkage long
2395 sys32_setresuid(compat_uid_t ruid, compat_uid_t euid,
2396                 compat_uid_t suid)
2397 {
2398         uid_t sruid, seuid, ssuid;
2399
2400         sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
2401         seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
2402         ssuid = (suid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)suid);
2403         return sys_setresuid(sruid, seuid, ssuid);
2404 }
2405
2406 asmlinkage long
2407 sys32_setregid(compat_gid_t rgid, compat_gid_t egid)
2408 {
2409         gid_t srgid, segid;
2410
2411         srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
2412         segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
2413         return sys_setregid(srgid, segid);
2414 }
2415
2416 asmlinkage long
2417 sys32_setresgid(compat_gid_t rgid, compat_gid_t egid,
2418                 compat_gid_t sgid)
2419 {
2420         gid_t srgid, segid, ssgid;
2421
2422         srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
2423         segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
2424         ssgid = (sgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)sgid);
2425         return sys_setresgid(srgid, segid, ssgid);
2426 }
2427
2428 /* Stuff for NFS server syscalls... */
2429 struct nfsctl_svc32 {
2430         u16                     svc32_port;
2431         s32                     svc32_nthreads;
2432 };
2433
2434 struct nfsctl_client32 {
2435         s8                      cl32_ident[NFSCLNT_IDMAX+1];
2436         s32                     cl32_naddr;
2437         struct in_addr          cl32_addrlist[NFSCLNT_ADDRMAX];
2438         s32                     cl32_fhkeytype;
2439         s32                     cl32_fhkeylen;
2440         u8                      cl32_fhkey[NFSCLNT_KEYMAX];
2441 };
2442
2443 struct nfsctl_export32 {
2444         s8                      ex32_client[NFSCLNT_IDMAX+1];
2445         s8                      ex32_path[NFS_MAXPATHLEN+1];
2446         compat_dev_t    ex32_dev;
2447         compat_ino_t    ex32_ino;
2448         s32                     ex32_flags;
2449         compat_uid_t    ex32_anon_uid;
2450         compat_gid_t    ex32_anon_gid;
2451 };
2452
2453 struct nfsctl_arg32 {
2454         s32                     ca32_version;   /* safeguard */
2455         union {
2456                 struct nfsctl_svc32     u32_svc;
2457                 struct nfsctl_client32  u32_client;
2458                 struct nfsctl_export32  u32_export;
2459                 u32                     u32_debug;
2460         } u;
2461 #define ca32_svc        u.u32_svc
2462 #define ca32_client     u.u32_client
2463 #define ca32_export     u.u32_export
2464 #define ca32_debug      u.u32_debug
2465 };
2466
2467 union nfsctl_res32 {
2468         struct knfs_fh          cr32_getfh;
2469         u32                     cr32_debug;
2470 };
2471
2472 static int
2473 nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2474 {
2475         int err;
2476
2477         err = __get_user(karg->ca_version, &arg32->ca32_version);
2478         err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
2479         err |= __get_user(karg->ca_svc.svc_nthreads,
2480                           &arg32->ca32_svc.svc32_nthreads);
2481         return err;
2482 }
2483
2484 static int
2485 nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2486 {
2487         int err;
2488
2489         err = __get_user(karg->ca_version, &arg32->ca32_version);
2490         err |= copy_from_user(&karg->ca_client.cl_ident[0],
2491                           &arg32->ca32_client.cl32_ident[0],
2492                           NFSCLNT_IDMAX);
2493         err |= __get_user(karg->ca_client.cl_naddr,
2494                           &arg32->ca32_client.cl32_naddr);
2495         err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
2496                           &arg32->ca32_client.cl32_addrlist[0],
2497                           (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
2498         err |= __get_user(karg->ca_client.cl_fhkeytype,
2499                       &arg32->ca32_client.cl32_fhkeytype);
2500         err |= __get_user(karg->ca_client.cl_fhkeylen,
2501                       &arg32->ca32_client.cl32_fhkeylen);
2502         err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
2503                           &arg32->ca32_client.cl32_fhkey[0],
2504                           NFSCLNT_KEYMAX);
2505         return err;
2506 }
2507
2508 static int
2509 nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2510 {
2511         int err;
2512
2513         err = __get_user(karg->ca_version, &arg32->ca32_version);
2514         err |= copy_from_user(&karg->ca_export.ex_client[0],
2515                           &arg32->ca32_export.ex32_client[0],
2516                           NFSCLNT_IDMAX);
2517         err |= copy_from_user(&karg->ca_export.ex_path[0],
2518                           &arg32->ca32_export.ex32_path[0],
2519                           NFS_MAXPATHLEN);
2520         err |= __get_user(karg->ca_export.ex_dev,
2521                       &arg32->ca32_export.ex32_dev);
2522         err |= __get_user(karg->ca_export.ex_ino,
2523                       &arg32->ca32_export.ex32_ino);
2524         err |= __get_user(karg->ca_export.ex_flags,
2525                       &arg32->ca32_export.ex32_flags);
2526         err |= __get_user(karg->ca_export.ex_anon_uid,
2527                       &arg32->ca32_export.ex32_anon_uid);
2528         err |= __get_user(karg->ca_export.ex_anon_gid,
2529                       &arg32->ca32_export.ex32_anon_gid);
2530         return err;
2531 }
2532
2533 static int
2534 nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
2535 {
2536         int err;
2537
2538         err = copy_to_user(&res32->cr32_getfh,
2539                         &kres->cr_getfh,
2540                         sizeof(res32->cr32_getfh));
2541         err |= __put_user(kres->cr_debug, &res32->cr32_debug);
2542         return err;
2543 }
2544
2545 int asmlinkage
2546 sys32_nfsservctl(int cmd, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
2547 {
2548         struct nfsctl_arg *karg = NULL;
2549         union nfsctl_res *kres = NULL;
2550         mm_segment_t oldfs;
2551         int err;
2552
2553         karg = kmalloc(sizeof(*karg), GFP_USER);
2554         if(!karg)
2555                 return -ENOMEM;
2556         if(res32) {
2557                 kres = kmalloc(sizeof(*kres), GFP_USER);
2558                 if(!kres) {
2559                         kfree(karg);
2560                         return -ENOMEM;
2561                 }
2562         }
2563         switch(cmd) {
2564         case NFSCTL_SVC:
2565                 err = nfs_svc32_trans(karg, arg32);
2566                 break;
2567         case NFSCTL_ADDCLIENT:
2568                 err = nfs_clnt32_trans(karg, arg32);
2569                 break;
2570         case NFSCTL_DELCLIENT:
2571                 err = nfs_clnt32_trans(karg, arg32);
2572                 break;
2573         case NFSCTL_EXPORT:
2574                 err = nfs_exp32_trans(karg, arg32);
2575                 break;
2576         default:
2577                 err = -EINVAL;
2578                 break;
2579         }
2580         if(err)
2581                 goto done;
2582         oldfs = get_fs();
2583         set_fs(KERNEL_DS);
2584         err = sys_nfsservctl(cmd, karg, kres);
2585         set_fs(oldfs);
2586
2587         if(!err && cmd == NFSCTL_GETFS)
2588                 err = nfs_getfh32_res_trans(kres, res32);
2589
2590 done:
2591         if(karg)
2592                 kfree(karg);
2593         if(kres)
2594                 kfree(kres);
2595         return err;
2596 }
2597
2598 /* Handle adjtimex compatibility. */
2599
2600 struct timex32 {
2601         u32 modes;
2602         s32 offset, freq, maxerror, esterror;
2603         s32 status, constant, precision, tolerance;
2604         struct compat_timeval time;
2605         s32 tick;
2606         s32 ppsfreq, jitter, shift, stabil;
2607         s32 jitcnt, calcnt, errcnt, stbcnt;
2608         s32  :32; s32  :32; s32  :32; s32  :32;
2609         s32  :32; s32  :32; s32  :32; s32  :32;
2610         s32  :32; s32  :32; s32  :32; s32  :32;
2611 };
2612
2613 extern int do_adjtimex(struct timex *);
2614
2615 asmlinkage long
2616 sys32_adjtimex(struct timex32 *utp)
2617 {
2618         struct timex txc;
2619         int ret;
2620
2621         memset(&txc, 0, sizeof(struct timex));
2622
2623         if(get_user(txc.modes, &utp->modes) ||
2624            __get_user(txc.offset, &utp->offset) ||
2625            __get_user(txc.freq, &utp->freq) ||
2626            __get_user(txc.maxerror, &utp->maxerror) ||
2627            __get_user(txc.esterror, &utp->esterror) ||
2628            __get_user(txc.status, &utp->status) ||
2629            __get_user(txc.constant, &utp->constant) ||
2630            __get_user(txc.precision, &utp->precision) ||
2631            __get_user(txc.tolerance, &utp->tolerance) ||
2632            __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2633            __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2634            __get_user(txc.tick, &utp->tick) ||
2635            __get_user(txc.ppsfreq, &utp->ppsfreq) ||
2636            __get_user(txc.jitter, &utp->jitter) ||
2637            __get_user(txc.shift, &utp->shift) ||
2638            __get_user(txc.stabil, &utp->stabil) ||
2639            __get_user(txc.jitcnt, &utp->jitcnt) ||
2640            __get_user(txc.calcnt, &utp->calcnt) ||
2641            __get_user(txc.errcnt, &utp->errcnt) ||
2642            __get_user(txc.stbcnt, &utp->stbcnt))
2643                 return -EFAULT;
2644
2645         ret = do_adjtimex(&txc);
2646
2647         if(put_user(txc.modes, &utp->modes) ||
2648            __put_user(txc.offset, &utp->offset) ||
2649            __put_user(txc.freq, &utp->freq) ||
2650            __put_user(txc.maxerror, &utp->maxerror) ||
2651            __put_user(txc.esterror, &utp->esterror) ||
2652            __put_user(txc.status, &utp->status) ||
2653            __put_user(txc.constant, &utp->constant) ||
2654            __put_user(txc.precision, &utp->precision) ||
2655            __put_user(txc.tolerance, &utp->tolerance) ||
2656            __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2657            __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2658            __put_user(txc.tick, &utp->tick) ||
2659            __put_user(txc.ppsfreq, &utp->ppsfreq) ||
2660            __put_user(txc.jitter, &utp->jitter) ||
2661            __put_user(txc.shift, &utp->shift) ||
2662            __put_user(txc.stabil, &utp->stabil) ||
2663            __put_user(txc.jitcnt, &utp->jitcnt) ||
2664            __put_user(txc.calcnt, &utp->calcnt) ||
2665            __put_user(txc.errcnt, &utp->errcnt) ||
2666            __put_user(txc.stbcnt, &utp->stbcnt))
2667                 ret = -EFAULT;
2668
2669         return ret;
2670 }
2671 #endif /* NOTYET */