fs/compat.c

   1 /*
   2  *  linux/fs/compat.c
   3  *
   4  *  Kernel compatibililty routines for e.g. 32 bit syscall support
   5  *  on 64 bit kernels.
   6  *
   7  *  Copyright (C) 2002       Stephen Rothwell, IBM Corporation
   8  *  Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
   9  *  Copyright (C) 1998       Eddie C. Dost  (ecd@skynet.be)
  10  *  Copyright (C) 2001,2002  Andi Kleen, SuSE Labs
  11  *  Copyright (C) 2003       Pavel Machek (pavel@suse.cz)
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License version 2 as
  15  *  published by the Free Software Foundation.
  16  */
  17
  18 #include <linux/linkage.h>
  19 #include <linux/compat.h>
  20 #include <linux/errno.h>
  21 #include <linux/time.h>
  22 #include <linux/fs.h>
  23 #include <linux/fcntl.h>
  24 #include <linux/namei.h>
  25 #include <linux/file.h>
  26 #include <linux/vfs.h>
  27 #include <linux/ioctl32.h>
  28 #include <linux/ioctl.h>
  29 #include <linux/init.h>
  30 #include <linux/sockios.h>      /* for SIOCDEVPRIVATE */
  31 #include <linux/smb.h>
  32 #include <linux/smb_mount.h>
  33 #include <linux/ncp_mount.h>
  34 #include <linux/nfs4_mount.h>
  35 #include <linux/smp_lock.h>
  36 #include <linux/syscalls.h>
  37 #include <linux/ctype.h>
  38 #include <linux/module.h>
  39 #include <linux/dirent.h>
  40 #include <linux/fsnotify.h>
  41 #include <linux/highuid.h>
  42 #include <linux/sunrpc/svc.h>
  43 #include <linux/nfsd/nfsd.h>
  44 #include <linux/nfsd/syscall.h>
  45 #include <linux/personality.h>
  46 #include <linux/rwsem.h>
  47 #include <linux/acct.h>
  48 #include <linux/mm.h>
  49
  50 #include <net/sock.h>           /* siocdevprivate_ioctl */
  51
  52 #include <asm/uaccess.h>
  53 #include <asm/mmu_context.h>
  54 #include <asm/ioctls.h>
  55
  56 /*
  57  * Not all architectures have sys_utime, so implement this in terms
  58  * of sys_utimes.
  59  */
  60 asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t)
  61 {
  62         struct timeval tv[2];
  63
  64         if (t) {
  65                 if (get_user(tv[0].tv_sec, &t->actime) ||
  66                     get_user(tv[1].tv_sec, &t->modtime))
  67                         return -EFAULT;
  68                 tv[0].tv_usec = 0;
  69                 tv[1].tv_usec = 0;
  70         }
  71         return do_utimes(filename, t ? tv : NULL);
  72 }
  73
  74 asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
  75 {
  76         struct timeval tv[2];
  77
  78         if (t) {
  79                 if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
  80                     get_user(tv[0].tv_usec, &t[0].tv_usec) ||
  81                     get_user(tv[1].tv_sec, &t[1].tv_sec) ||
  82                     get_user(tv[1].tv_usec, &t[1].tv_usec))
  83                         return -EFAULT;
  84         }
  85         return do_utimes(filename, t ? tv : NULL);
  86 }
  87
  88 asmlinkage long compat_sys_newstat(char __user * filename,
  89                 struct compat_stat __user *statbuf)
  90 {
  91         struct kstat stat;
  92         int error = vfs_stat(filename, &stat);
  93
  94         if (!error)
  95                 error = cp_compat_stat(&stat, statbuf);
  96         return error;
  97 }
  98
  99 asmlinkage long compat_sys_newlstat(char __user * filename,
 100                 struct compat_stat __user *statbuf)
 101 {
 102         struct kstat stat;
 103         int error = vfs_lstat(filename, &stat);
 104
 105         if (!error)
 106                 error = cp_compat_stat(&stat, statbuf);
 107         return error;
 108 }
 109
 110 asmlinkage long compat_sys_newfstat(unsigned int fd,
 111                 struct compat_stat __user * statbuf)
 112 {
 113         struct kstat stat;
 114         int error = vfs_fstat(fd, &stat);
 115
 116         if (!error)
 117                 error = cp_compat_stat(&stat, statbuf);
 118         return error;
 119 }
 120
 121 static int put_compat_statfs(struct compat_statfs __user *ubuf, struct kstatfs *kbuf)
 122 {
 123
 124         if (sizeof ubuf->f_blocks == 4) {
 125                 if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) &
 126                     0xffffffff00000000ULL)
 127                         return -EOVERFLOW;
 128                 /* f_files and f_ffree may be -1; it's okay
 129                  * to stuff that into 32 bits */
 130                 if (kbuf->f_files != 0xffffffffffffffffULL
 131                  && (kbuf->f_files & 0xffffffff00000000ULL))
 132                         return -EOVERFLOW;
 133                 if (kbuf->f_ffree != 0xffffffffffffffffULL
 134                  && (kbuf->f_ffree & 0xffffffff00000000ULL))
 135                         return -EOVERFLOW;
 136         }
 137         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
 138             __put_user(kbuf->f_type, &ubuf->f_type) ||
 139             __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
 140             __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
 141             __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
 142             __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
 143             __put_user(kbuf->f_files, &ubuf->f_files) ||
 144             __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
 145             __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
 146             __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
 147             __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
 148             __put_user(kbuf->f_frsize, &ubuf->f_frsize) ||
 149             __put_user(0, &ubuf->f_spare[0]) ||
 150             __put_user(0, &ubuf->f_spare[1]) ||
 151             __put_user(0, &ubuf->f_spare[2]) ||
 152             __put_user(0, &ubuf->f_spare[3]) ||
 153             __put_user(0, &ubuf->f_spare[4]))
 154                 return -EFAULT;
 155         return 0;
 156 }
 157
 158 /*
 159  * The following statfs calls are copies of code from fs/open.c and
 160  * should be checked against those from time to time
 161  */
 162 asmlinkage long compat_sys_statfs(const char __user *path, struct compat_statfs __user *buf)
 163 {
 164         struct nameidata nd;
 165         int error;
 166
 167         error = user_path_walk(path, &nd);
 168         if (!error) {
 169                 struct kstatfs tmp;
 170                 error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
 171                 if (!error && put_compat_statfs(buf, &tmp))
 172                         error = -EFAULT;
 173                 path_release(&nd);
 174         }
 175         return error;
 176 }
 177
 178 asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf)
 179 {
 180         struct file * file;
 181         struct kstatfs tmp;
 182         int error;
 183
 184         error = -EBADF;
 185         file = fget(fd);
 186         if (!file)
 187                 goto out;
 188         error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp);
 189         if (!error && put_compat_statfs(buf, &tmp))
 190                 error = -EFAULT;
 191         fput(file);
 192 out:
 193         return error;
 194 }
 195
 196 static int put_compat_statfs64(struct compat_statfs64 __user *ubuf, struct kstatfs *kbuf)
 197 {
 198         if (sizeof ubuf->f_blocks == 4) {
 199                 if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) &
 200                     0xffffffff00000000ULL)
 201                         return -EOVERFLOW;
 202                 /* f_files and f_ffree may be -1; it's okay
 203                  * to stuff that into 32 bits */
 204                 if (kbuf->f_files != 0xffffffffffffffffULL
 205                  && (kbuf->f_files & 0xffffffff00000000ULL))
 206                         return -EOVERFLOW;
 207                 if (kbuf->f_ffree != 0xffffffffffffffffULL
 208                  && (kbuf->f_ffree & 0xffffffff00000000ULL))
 209                         return -EOVERFLOW;
 210         }
 211         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
 212             __put_user(kbuf->f_type, &ubuf->f_type) ||
 213             __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
 214             __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
 215             __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
 216             __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
 217             __put_user(kbuf->f_files, &ubuf->f_files) ||
 218             __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
 219             __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
 220             __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
 221             __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
 222             __put_user(kbuf->f_frsize, &ubuf->f_frsize))
 223                 return -EFAULT;
 224         return 0;
 225 }
 226
 227 asmlinkage long compat_sys_statfs64(const char __user *path, compat_size_t sz, struct compat_statfs64 __user *buf)
 228 {
 229         struct nameidata nd;
 230         int error;
 231
 232         if (sz != sizeof(*buf))
 233                 return -EINVAL;
 234
 235         error = user_path_walk(path, &nd);
 236         if (!error) {
 237                 struct kstatfs tmp;
 238                 error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
 239                 if (!error && put_compat_statfs64(buf, &tmp))
 240                         error = -EFAULT;
 241                 path_release(&nd);
 242         }
 243         return error;
 244 }
 245
 246 asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf)
 247 {
 248         struct file * file;
 249         struct kstatfs tmp;
 250         int error;
 251
 252         if (sz != sizeof(*buf))
 253                 return -EINVAL;
 254
 255         error = -EBADF;
 256         file = fget(fd);
 257         if (!file)
 258                 goto out;
 259         error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp);
 260         if (!error && put_compat_statfs64(buf, &tmp))
 261                 error = -EFAULT;
 262         fput(file);
 263 out:
 264         return error;
 265 }
 266
 267 /* ioctl32 stuff, used by sparc64, parisc, s390x, ppc64, x86_64, MIPS */
 268
 269 #define IOCTL_HASHSIZE 256
 270 static struct ioctl_trans *ioctl32_hash_table[IOCTL_HASHSIZE];
 271 static DECLARE_RWSEM(ioctl32_sem);
 272
 273 extern struct ioctl_trans ioctl_start[];
 274 extern int ioctl_table_size;
 275
 276 static inline unsigned long ioctl32_hash(unsigned long cmd)
 277 {
 278         return (((cmd >> 6) ^ (cmd >> 4) ^ cmd)) % IOCTL_HASHSIZE;
 279 }
 280
 281 static void ioctl32_insert_translation(struct ioctl_trans *trans)
 282 {
 283         unsigned long hash;
 284         struct ioctl_trans *t;
 285
 286         hash = ioctl32_hash (trans->cmd);
 287         if (!ioctl32_hash_table[hash])
 288                 ioctl32_hash_table[hash] = trans;
 289         else {
 290                 t = ioctl32_hash_table[hash];
 291                 while (t->next)
 292                         t = t->next;
 293                 trans->next = NULL;
 294                 t->next = trans;
 295         }
 296 }
 297
 298 static int __init init_sys32_ioctl(void)
 299 {
 300         int i;
 301
 302         for (i = 0; i < ioctl_table_size; i++) {
 303                 if (ioctl_start[i].next != 0) {
 304                         printk("ioctl translation %d bad\n",i);
 305                         return -1;
 306                 }
 307
 308                 ioctl32_insert_translation(&ioctl_start[i]);
 309         }
 310         return 0;
 311 }
 312
 313 __initcall(init_sys32_ioctl);
 314
 315 static void compat_ioctl_error(struct file *filp, unsigned int fd,
 316                 unsigned int cmd, unsigned long arg)
 317 {
 318         char buf[10];
 319         char *fn = "?";
 320         char *path;
 321
 322         /* find the name of the device. */
 323         path = (char *)__get_free_page(GFP_KERNEL);
 324         if (path) {
 325                 fn = d_path(filp->f_dentry, filp->f_vfsmnt, path, PAGE_SIZE);
 326                 if (IS_ERR(fn))
 327                         fn = "?";
 328         }
 329
 330         sprintf(buf,"'%c'", (cmd>>24) & 0x3f);
 331         if (!isprint(buf[1]))
 332                 sprintf(buf, "%02x", buf[1]);
 333         printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
 334                         "cmd(%08x){%s} arg(%08x) on %s\n",
 335                         current->comm, current->pid,
 336                         (int)fd, (unsigned int)cmd, buf,
 337                         (unsigned int)arg, fn);
 338
 339         if (path)
 340                 free_page((unsigned long)path);
 341 }
 342
 343 asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
 344                                 unsigned long arg)
 345 {
 346         struct file *filp;
 347         int error = -EBADF;
 348         struct ioctl_trans *t;
 349         int fput_needed;
 350
 351         filp = fget_light(fd, &fput_needed);
 352         if (!filp)
 353                 goto out;
 354
 355         /* RED-PEN how should LSM module know it's handling 32bit? */
 356         error = security_file_ioctl(filp, cmd, arg);
 357         if (error)
 358                 goto out_fput;
 359
 360         /*
 361          * To allow the compat_ioctl handlers to be self contained
 362          * we need to check the common ioctls here first.
 363          * Just handle them with the standard handlers below.
 364          */
 365         switch (cmd) {
 366         case FIOCLEX:
 367         case FIONCLEX:
 368         case FIONBIO:
 369         case FIOASYNC:
 370         case FIOQSIZE:
 371                 break;
 372
 373         case FIBMAP:
 374         case FIGETBSZ:
 375         case FIONREAD:
 376                 if (S_ISREG(filp->f_dentry->d_inode->i_mode))
 377                         break;
 378                 /*FALL THROUGH*/
 379
 380         default:
 381                 if (filp->f_op && filp->f_op->compat_ioctl) {
 382                         error = filp->f_op->compat_ioctl(filp, cmd, arg);
 383                         if (error != -ENOIOCTLCMD)
 384                                 goto out_fput;
 385                 }
 386
 387                 if (!filp->f_op ||
 388                     (!filp->f_op->ioctl && !filp->f_op->unlocked_ioctl))
 389                         goto do_ioctl;
 390                 break;
 391         }
 392
 393         /* When register_ioctl32_conversion is finally gone remove
 394            this lock! -AK */
 395         down_read(&ioctl32_sem);
 396         for (t = ioctl32_hash_table[ioctl32_hash(cmd)]; t; t = t->next) {
 397                 if (t->cmd == cmd)
 398                         goto found_handler;
 399         }
 400         up_read(&ioctl32_sem);
 401
 402         if (S_ISSOCK(filp->f_dentry->d_inode->i_mode) &&
 403             cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
 404                 error = siocdevprivate_ioctl(fd, cmd, arg);
 405         } else {
 406                 static int count;
 407
 408                 if (++count <= 50)
 409                         compat_ioctl_error(filp, fd, cmd, arg);
 410                 error = -EINVAL;
 411         }
 412
 413         goto out_fput;
 414
 415  found_handler:
 416         if (t->handler) {
 417                 lock_kernel();
 418                 error = t->handler(fd, cmd, arg, filp);
 419                 unlock_kernel();
 420                 up_read(&ioctl32_sem);
 421                 goto out_fput;
 422         }
 423
 424         up_read(&ioctl32_sem);
 425  do_ioctl:
 426         error = vfs_ioctl(filp, fd, cmd, arg);
 427  out_fput:
 428         fput_light(filp, fput_needed);
 429  out:
 430         return error;
 431 }
 432
 433 static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
 434 {
 435         if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
 436             __get_user(kfl->l_type, &ufl->l_type) ||
 437             __get_user(kfl->l_whence, &ufl->l_whence) ||
 438             __get_user(kfl->l_start, &ufl->l_start) ||
 439             __get_user(kfl->l_len, &ufl->l_len) ||
 440             __get_user(kfl->l_pid, &ufl->l_pid))
 441                 return -EFAULT;
 442         return 0;
 443 }
 444
 445 static int put_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
 446 {
 447         if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
 448             __put_user(kfl->l_type, &ufl->l_type) ||
 449             __put_user(kfl->l_whence, &ufl->l_whence) ||
 450             __put_user(kfl->l_start, &ufl->l_start) ||
 451             __put_user(kfl->l_len, &ufl->l_len) ||
 452             __put_user(kfl->l_pid, &ufl->l_pid))
 453                 return -EFAULT;
 454         return 0;
 455 }
 456
 457 #ifndef HAVE_ARCH_GET_COMPAT_FLOCK64
 458 static int get_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
 459 {
 460         if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
 461             __get_user(kfl->l_type, &ufl->l_type) ||
 462             __get_user(kfl->l_whence, &ufl->l_whence) ||
 463             __get_user(kfl->l_start, &ufl->l_start) ||
 464             __get_user(kfl->l_len, &ufl->l_len) ||
 465             __get_user(kfl->l_pid, &ufl->l_pid))
 466                 return -EFAULT;
 467         return 0;
 468 }
 469 #endif
 470
 471 #ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64
 472 static int put_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
 473 {
 474         if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
 475             __put_user(kfl->l_type, &ufl->l_type) ||
 476             __put_user(kfl->l_whence, &ufl->l_whence) ||
 477             __put_user(kfl->l_start, &ufl->l_start) ||
 478             __put_user(kfl->l_len, &ufl->l_len) ||
 479             __put_user(kfl->l_pid, &ufl->l_pid))
 480                 return -EFAULT;
 481         return 0;
 482 }
 483 #endif
 484
 485 asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
 486                 unsigned long arg)
 487 {
 488         mm_segment_t old_fs;
 489         struct flock f;
 490         long ret;
 491
 492         switch (cmd) {
 493         case F_GETLK:
 494         case F_SETLK:
 495         case F_SETLKW:
 496                 ret = get_compat_flock(&f, compat_ptr(arg));
 497                 if (ret != 0)
 498                         break;
 499                 old_fs = get_fs();
 500                 set_fs(KERNEL_DS);
 501                 ret = sys_fcntl(fd, cmd, (unsigned long)&f);
 502                 set_fs(old_fs);
 503                 if (cmd == F_GETLK && ret == 0) {
 504                         if ((f.l_start >= COMPAT_OFF_T_MAX) ||
 505                             ((f.l_start + f.l_len) > COMPAT_OFF_T_MAX))
 506                                 ret = -EOVERFLOW;
 507                         if (ret == 0)
 508                                 ret = put_compat_flock(&f, compat_ptr(arg));
 509                 }
 510                 break;
 511
 512         case F_GETLK64:
 513         case F_SETLK64:
 514         case F_SETLKW64:
 515                 ret = get_compat_flock64(&f, compat_ptr(arg));
 516                 if (ret != 0)
 517                         break;
 518                 old_fs = get_fs();
 519                 set_fs(KERNEL_DS);
 520                 ret = sys_fcntl(fd, (cmd == F_GETLK64) ? F_GETLK :
 521                                 ((cmd == F_SETLK64) ? F_SETLK : F_SETLKW),
 522                                 (unsigned long)&f);
 523                 set_fs(old_fs);
 524                 if (cmd == F_GETLK64 && ret == 0) {
 525                         if ((f.l_start >= COMPAT_LOFF_T_MAX) ||
 526                             ((f.l_start + f.l_len) > COMPAT_LOFF_T_MAX))
 527                                 ret = -EOVERFLOW;
 528                         if (ret == 0)
 529                                 ret = put_compat_flock64(&f, compat_ptr(arg));
 530                 }
 531                 break;
 532
 533         default:
 534                 ret = sys_fcntl(fd, cmd, arg);
 535                 break;
 536         }
 537         return ret;
 538 }
 539
 540 asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
 541                 unsigned long arg)
 542 {
 543         if ((cmd == F_GETLK64) || (cmd == F_SETLK64) || (cmd == F_SETLKW64))
 544                 return -EINVAL;
 545         return compat_sys_fcntl64(fd, cmd, arg);
 546 }
 547
 548 asmlinkage long
 549 compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p)
 550 {
 551         long ret;
 552         aio_context_t ctx64;
 553
 554         mm_segment_t oldfs = get_fs();
 555         if (unlikely(get_user(ctx64, ctx32p)))
 556                 return -EFAULT;
 557
 558         set_fs(KERNEL_DS);
 559         /* The __user pointer cast is valid because of the set_fs() */
 560         ret = sys_io_setup(nr_reqs, (aio_context_t __user *) &ctx64);
 561         set_fs(oldfs);
 562         /* truncating is ok because it's a user address */
 563         if (!ret)
 564                 ret = put_user((u32) ctx64, ctx32p);
 565         return ret;
 566 }
 567
 568 asmlinkage long
 569 compat_sys_io_getevents(aio_context_t ctx_id,
 570                                  unsigned long min_nr,
 571                                  unsigned long nr,
 572                                  struct io_event __user *events,
 573                                  struct compat_timespec __user *timeout)
 574 {
 575         long ret;
 576         struct timespec t;
 577         struct timespec __user *ut = NULL;
 578
 579         ret = -EFAULT;
 580         if (unlikely(!access_ok(VERIFY_WRITE, events,
 581                                 nr * sizeof(struct io_event))))
 582                 goto out;
 583         if (timeout) {
 584                 if (get_compat_timespec(&t, timeout))
 585                         goto out;
 586
 587                 ut = compat_alloc_user_space(sizeof(*ut));
 588                 if (copy_to_user(ut, &t, sizeof(t)) )
 589                         goto out;
 590         }
 591         ret = sys_io_getevents(ctx_id, min_nr, nr, events, ut);
 592 out:
 593         return ret;
 594 }
 595
 596 static inline long
 597 copy_iocb(long nr, u32 __user *ptr32, struct iocb __user * __user *ptr64)
 598 {
 599         compat_uptr_t uptr;
 600         int i;
 601
 602         for (i = 0; i < nr; ++i) {
 603                 if (get_user(uptr, ptr32 + i))
 604                         return -EFAULT;
 605                 if (put_user(compat_ptr(uptr), ptr64 + i))
 606                         return -EFAULT;
 607         }
 608         return 0;
 609 }
 610
 611 #define MAX_AIO_SUBMITS         (PAGE_SIZE/sizeof(struct iocb *))
 612
 613 asmlinkage long
 614 compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb)
 615 {
 616         struct iocb __user * __user *iocb64;
 617         long ret;
 618
 619         if (unlikely(nr < 0))
 620                 return -EINVAL;
 621
 622         if (nr > MAX_AIO_SUBMITS)
 623                 nr = MAX_AIO_SUBMITS;
 624
 625         iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64));
 626         ret = copy_iocb(nr, iocb, iocb64);
 627         if (!ret)
 628                 ret = sys_io_submit(ctx_id, nr, iocb64);
 629         return ret;
 630 }
 631
 632 struct compat_ncp_mount_data {
 633         compat_int_t version;
 634         compat_uint_t ncp_fd;
 635         __compat_uid_t mounted_uid;
 636         compat_pid_t wdog_pid;
 637         unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
 638         compat_uint_t time_out;
 639         compat_uint_t retry_count;
 640         compat_uint_t flags;
 641         __compat_uid_t uid;
 642         __compat_gid_t gid;
 643         compat_mode_t file_mode;
 644         compat_mode_t dir_mode;
 645 };
 646
 647 struct compat_ncp_mount_data_v4 {
 648         compat_int_t version;
 649         compat_ulong_t flags;
 650         compat_ulong_t mounted_uid;
 651         compat_long_t wdog_pid;
 652         compat_uint_t ncp_fd;
 653         compat_uint_t time_out;
 654         compat_uint_t retry_count;
 655         compat_ulong_t uid;
 656         compat_ulong_t gid;
 657         compat_ulong_t file_mode;
 658         compat_ulong_t dir_mode;
 659 };
 660
 661 static void *do_ncp_super_data_conv(void *raw_data)
 662 {
 663         int version = *(unsigned int *)raw_data;
 664
 665         if (version == 3) {
 666                 struct compat_ncp_mount_data *c_n = raw_data;
 667                 struct ncp_mount_data *n = raw_data;
 668
 669                 n->dir_mode = c_n->dir_mode;
 670                 n->file_mode = c_n->file_mode;
 671                 n->gid = c_n->gid;
 672                 n->uid = c_n->uid;
 673                 memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int)));
 674                 n->wdog_pid = c_n->wdog_pid;
 675                 n->mounted_uid = c_n->mounted_uid;
 676         } else if (version == 4) {
 677                 struct compat_ncp_mount_data_v4 *c_n = raw_data;
 678                 struct ncp_mount_data_v4 *n = raw_data;
 679
 680                 n->dir_mode = c_n->dir_mode;
 681                 n->file_mode = c_n->file_mode;
 682                 n->gid = c_n->gid;
 683                 n->uid = c_n->uid;
 684                 n->retry_count = c_n->retry_count;
 685                 n->time_out = c_n->time_out;
 686                 n->ncp_fd = c_n->ncp_fd;
 687                 n->wdog_pid = c_n->wdog_pid;
 688                 n->mounted_uid = c_n->mounted_uid;
 689                 n->flags = c_n->flags;
 690         } else if (version != 5) {
 691                 return NULL;
 692         }
 693
 694         return raw_data;
 695 }
 696
 697 struct compat_smb_mount_data {
 698         compat_int_t version;
 699         __compat_uid_t mounted_uid;
 700         __compat_uid_t uid;
 701         __compat_gid_t gid;
 702         compat_mode_t file_mode;
 703         compat_mode_t dir_mode;
 704 };
 705
 706 static void *do_smb_super_data_conv(void *raw_data)
 707 {
 708         struct smb_mount_data *s = raw_data;
 709         struct compat_smb_mount_data *c_s = raw_data;
 710
 711         if (c_s->version != SMB_MOUNT_OLDVERSION)
 712                 goto out;
 713         s->dir_mode = c_s->dir_mode;
 714         s->file_mode = c_s->file_mode;
 715         s->gid = c_s->gid;
 716         s->uid = c_s->uid;
 717         s->mounted_uid = c_s->mounted_uid;
 718  out:
 719         return raw_data;
 720 }
 721
 722 struct compat_nfs_string {
 723         compat_uint_t len;
 724         compat_uptr_t data;
 725 };
 726
 727 static inline void compat_nfs_string(struct nfs_string *dst,
 728                                      struct compat_nfs_string *src)
 729 {
 730         dst->data = compat_ptr(src->data);
 731         dst->len = src->len;
 732 }
 733
 734 struct compat_nfs4_mount_data_v1 {
 735         compat_int_t version;
 736         compat_int_t flags;
 737         compat_int_t rsize;
 738         compat_int_t wsize;
 739         compat_int_t timeo;
 740         compat_int_t retrans;
 741         compat_int_t acregmin;
 742         compat_int_t acregmax;
 743         compat_int_t acdirmin;
 744         compat_int_t acdirmax;
 745         struct compat_nfs_string client_addr;
 746         struct compat_nfs_string mnt_path;
 747         struct compat_nfs_string hostname;
 748         compat_uint_t host_addrlen;
 749         compat_uptr_t host_addr;
 750         compat_int_t proto;
 751         compat_int_t auth_flavourlen;
 752         compat_uptr_t auth_flavours;
 753 };
 754
 755 static int do_nfs4_super_data_conv(void *raw_data)
 756 {
 757         int version = *(compat_uint_t *) raw_data;
 758
 759         if (version == 1) {
 760                 struct compat_nfs4_mount_data_v1 *raw = raw_data;
 761                 struct nfs4_mount_data *real = raw_data;
 762
 763                 /* copy the fields backwards */
 764                 real->auth_flavours = compat_ptr(raw->auth_flavours);
 765                 real->auth_flavourlen = raw->auth_flavourlen;
 766                 real->proto = raw->proto;
 767                 real->host_addr = compat_ptr(raw->host_addr);
 768                 real->host_addrlen = raw->host_addrlen;
 769                 compat_nfs_string(&real->hostname, &raw->hostname);
 770                 compat_nfs_string(&real->mnt_path, &raw->mnt_path);
 771                 compat_nfs_string(&real->client_addr, &raw->client_addr);
 772                 real->acdirmax = raw->acdirmax;
 773                 real->acdirmin = raw->acdirmin;
 774                 real->acregmax = raw->acregmax;
 775                 real->acregmin = raw->acregmin;
 776                 real->retrans = raw->retrans;
 777                 real->timeo = raw->timeo;
 778                 real->wsize = raw->wsize;
 779                 real->rsize = raw->rsize;
 780                 real->flags = raw->flags;
 781                 real->version = raw->version;
 782         }
 783         else {
 784                 return -EINVAL;
 785         }
 786
 787         return 0;
 788 }
 789
 790 extern int copy_mount_options (const void __user *, unsigned long *);
 791
 792 #define SMBFS_NAME      "smbfs"
 793 #define NCPFS_NAME      "ncpfs"
 794 #define NFS4_NAME       "nfs4"
 795
 796 asmlinkage long compat_sys_mount(char __user * dev_name, char __user * dir_name,
 797                                  char __user * type, unsigned long flags,
 798                                  void __user * data)
 799 {
 800         unsigned long type_page;
 801         unsigned long data_page;
 802         unsigned long dev_page;
 803         char *dir_page;
 804         int retval;
 805
 806         retval = copy_mount_options (type, &type_page);
 807         if (retval < 0)
 808                 goto out;
 809
 810         dir_page = getname(dir_name);
 811         retval = PTR_ERR(dir_page);
 812         if (IS_ERR(dir_page))
 813                 goto out1;
 814
 815         retval = copy_mount_options (dev_name, &dev_page);
 816         if (retval < 0)
 817                 goto out2;
 818
 819         retval = copy_mount_options (data, &data_page);
 820         if (retval < 0)
 821                 goto out3;
 822
 823         retval = -EINVAL;
 824
 825         if (type_page) {
 826                 if (!strcmp((char *)type_page, SMBFS_NAME)) {
 827                         do_smb_super_data_conv((void *)data_page);
 828                 } else if (!strcmp((char *)type_page, NCPFS_NAME)) {
 829                         do_ncp_super_data_conv((void *)data_page);
 830                 } else if (!strcmp((char *)type_page, NFS4_NAME)) {
 831                         if (do_nfs4_super_data_conv((void *) data_page))
 832                                 goto out4;
 833                 }
 834         }
 835
 836         lock_kernel();
 837         retval = do_mount((char*)dev_page, dir_page, (char*)type_page,
 838                         flags, (void*)data_page);
 839         unlock_kernel();
 840
 841  out4:
 842         free_page(data_page);
 843  out3:
 844         free_page(dev_page);
 845  out2:
 846         putname(dir_page);
 847  out1:
 848         free_page(type_page);
 849  out:
 850         return retval;
 851 }
 852
 853 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
 854 #define COMPAT_ROUND_UP(x) (((x)+sizeof(compat_long_t)-1) & \
 855                                 ~(sizeof(compat_long_t)-1))
 856
 857 struct compat_old_linux_dirent {
 858         compat_ulong_t  d_ino;
 859         compat_ulong_t  d_offset;
 860         unsigned short  d_namlen;
 861         char            d_name[1];
 862 };
 863
 864 struct compat_readdir_callback {
 865         struct compat_old_linux_dirent __user *dirent;
 866         int result;
 867 };
 868
 869 static int compat_fillonedir(void *__buf, const char *name, int namlen,
 870                         loff_t offset, ino_t ino, unsigned int d_type)
 871 {
 872         struct compat_readdir_callback *buf = __buf;
 873         struct compat_old_linux_dirent __user *dirent;
 874
 875         if (buf->result)
 876                 return -EINVAL;
 877         buf->result++;
 878         dirent = buf->dirent;
 879         if (!access_ok(VERIFY_WRITE, dirent,
 880                         (unsigned long)(dirent->d_name + namlen + 1) -
 881                                 (unsigned long)dirent))
 882                 goto efault;
 883         if (    __put_user(ino, &dirent->d_ino) ||
 884                 __put_user(offset, &dirent->d_offset) ||
 885                 __put_user(namlen, &dirent->d_namlen) ||
 886                 __copy_to_user(dirent->d_name, name, namlen) ||
 887                 __put_user(0, dirent->d_name + namlen))
 888                 goto efault;
 889         return 0;
 890 efault:
 891         buf->result = -EFAULT;
 892         return -EFAULT;
 893 }
 894
 895 asmlinkage long compat_sys_old_readdir(unsigned int fd,
 896         struct compat_old_linux_dirent __user *dirent, unsigned int count)
 897 {
 898         int error;
 899         struct file *file;
 900         struct compat_readdir_callback buf;
 901
 902         error = -EBADF;
 903         file = fget(fd);
 904         if (!file)
 905                 goto out;
 906
 907         buf.result = 0;
 908         buf.dirent = dirent;
 909
 910         error = vfs_readdir(file, compat_fillonedir, &buf);
 911         if (error >= 0)
 912                 error = buf.result;
 913
 914         fput(file);
 915 out:
 916         return error;
 917 }
 918
 919 struct compat_linux_dirent {
 920         compat_ulong_t  d_ino;
 921         compat_ulong_t  d_off;
 922         unsigned short  d_reclen;
 923         char            d_name[1];
 924 };
 925
 926 struct compat_getdents_callback {
 927         struct compat_linux_dirent __user *current_dir;
 928         struct compat_linux_dirent __user *previous;
 929         int count;
 930         int error;
 931 };
 932
 933 static int compat_filldir(void *__buf, const char *name, int namlen,
 934                 loff_t offset, ino_t ino, unsigned int d_type)
 935 {
 936         struct compat_linux_dirent __user * dirent;
 937         struct compat_getdents_callback *buf = __buf;
 938         int reclen = COMPAT_ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
 939
 940         buf->error = -EINVAL;   /* only used if we fail.. */
 941         if (reclen > buf->count)
 942                 return -EINVAL;
 943         dirent = buf->previous;
 944         if (dirent) {
 945                 if (__put_user(offset, &dirent->d_off))
 946                         goto efault;
 947         }
 948         dirent = buf->current_dir;
 949         if (__put_user(ino, &dirent->d_ino))
 950                 goto efault;
 951         if (__put_user(reclen, &dirent->d_reclen))
 952                 goto efault;
 953         if (copy_to_user(dirent->d_name, name, namlen))
 954                 goto efault;
 955         if (__put_user(0, dirent->d_name + namlen))
 956                 goto efault;
 957         if (__put_user(d_type, (char  __user *) dirent + reclen - 1))
 958                 goto efault;
 959         buf->previous = dirent;
 960         dirent = (void __user *)dirent + reclen;
 961         buf->current_dir = dirent;
 962         buf->count -= reclen;
 963         return 0;
 964 efault:
 965         buf->error = -EFAULT;
 966         return -EFAULT;
 967 }
 968
 969 asmlinkage long compat_sys_getdents(unsigned int fd,
 970                 struct compat_linux_dirent __user *dirent, unsigned int count)
 971 {
 972         struct file * file;
 973         struct compat_linux_dirent __user * lastdirent;
 974         struct compat_getdents_callback buf;
 975         int error;
 976
 977         error = -EFAULT;
 978         if (!access_ok(VERIFY_WRITE, dirent, count))
 979                 goto out;
 980
 981         error = -EBADF;
 982         file = fget(fd);
 983         if (!file)
 984                 goto out;
 985
 986         buf.current_dir = dirent;
 987         buf.previous = NULL;
 988         buf.count = count;
 989         buf.error = 0;
 990
 991         error = vfs_readdir(file, compat_filldir, &buf);
 992         if (error < 0)
 993                 goto out_putf;
 994         error = buf.error;
 995         lastdirent = buf.previous;
 996         if (lastdirent) {
 997                 if (put_user(file->f_pos, &lastdirent->d_off))
 998                         error = -EFAULT;
 999                 else
1000                         error = count - buf.count;
1001         }
1002
1003 out_putf:
1004         fput(file);
1005 out:
1006         return error;
1007 }
1008
1009 #ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
1010 #define COMPAT_ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
1011
1012 struct compat_getdents_callback64 {
1013         struct linux_dirent64 __user *current_dir;
1014         struct linux_dirent64 __user *previous;
1015         int count;
1016         int error;
1017 };
1018
1019 static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
1020                      ino_t ino, unsigned int d_type)
1021 {
1022         struct linux_dirent64 __user *dirent;
1023         struct compat_getdents_callback64 *buf = __buf;
1024         int jj = NAME_OFFSET(dirent);
1025         int reclen = COMPAT_ROUND_UP64(jj + namlen + 1);
1026         u64 off;
1027
1028         buf->error = -EINVAL;   /* only used if we fail.. */
1029         if (reclen > buf->count)
1030                 return -EINVAL;
1031         dirent = buf->previous;
1032
1033         if (dirent) {
1034                 if (__put_user_unaligned(offset, &dirent->d_off))
1035                         goto efault;
1036         }
1037         dirent = buf->current_dir;
1038         if (__put_user_unaligned(ino, &dirent->d_ino))
1039                 goto efault;
1040         off = 0;
1041         if (__put_user_unaligned(off, &dirent->d_off))
1042                 goto efault;
1043         if (__put_user(reclen, &dirent->d_reclen))
1044                 goto efault;
1045         if (__put_user(d_type, &dirent->d_type))
1046                 goto efault;
1047         if (copy_to_user(dirent->d_name, name, namlen))
1048                 goto efault;
1049         if (__put_user(0, dirent->d_name + namlen))
1050                 goto efault;
1051         buf->previous = dirent;
1052         dirent = (void __user *)dirent + reclen;
1053         buf->current_dir = dirent;
1054         buf->count -= reclen;
1055         return 0;
1056 efault:
1057         buf->error = -EFAULT;
1058         return -EFAULT;
1059 }
1060
1061 asmlinkage long compat_sys_getdents64(unsigned int fd,
1062                 struct linux_dirent64 __user * dirent, unsigned int count)
1063 {
1064         struct file * file;
1065         struct linux_dirent64 __user * lastdirent;
1066         struct compat_getdents_callback64 buf;
1067         int error;
1068
1069         error = -EFAULT;
1070         if (!access_ok(VERIFY_WRITE, dirent, count))
1071                 goto out;
1072
1073         error = -EBADF;
1074         file = fget(fd);
1075         if (!file)
1076                 goto out;
1077
1078         buf.current_dir = dirent;
1079         buf.previous = NULL;
1080         buf.count = count;
1081         buf.error = 0;
1082
1083         error = vfs_readdir(file, compat_filldir64, &buf);
1084         if (error < 0)
1085                 goto out_putf;
1086         error = buf.error;
1087         lastdirent = buf.previous;
1088         if (lastdirent) {
1089                 typeof(lastdirent->d_off) d_off = file->f_pos;
1090                 __put_user_unaligned(d_off, &lastdirent->d_off);
1091                 error = count - buf.count;
1092         }
1093
1094 out_putf:
1095         fput(file);
1096 out:
1097         return error;
1098 }
1099 #endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */
1100
1101 static ssize_t compat_do_readv_writev(int type, struct file *file,
1102                                const struct compat_iovec __user *uvector,
1103                                unsigned long nr_segs, loff_t *pos)
1104 {
1105         typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
1106         typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
1107
1108         compat_ssize_t tot_len;
1109         struct iovec iovstack[UIO_FASTIOV];
1110         struct iovec *iov=iovstack, *vector;
1111         ssize_t ret;
1112         int seg;
1113         io_fn_t fn;
1114         iov_fn_t fnv;
1115
1116         /*
1117          * SuS says "The readv() function *may* fail if the iovcnt argument
1118          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
1119          * traditionally returned zero for zero segments, so...
1120          */
1121         ret = 0;
1122         if (nr_segs == 0)
1123                 goto out;
1124
1125         /*
1126          * First get the "struct iovec" from user memory and
1127          * verify all the pointers
1128          */
1129         ret = -EINVAL;
1130         if ((nr_segs > UIO_MAXIOV) || (nr_segs <= 0))
1131                 goto out;
1132         if (!file->f_op)
1133                 goto out;
1134         if (nr_segs > UIO_FASTIOV) {
1135                 ret = -ENOMEM;
1136                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
1137                 if (!iov)
1138                         goto out;
1139         }
1140         ret = -EFAULT;
1141         if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
1142                 goto out;
1143
1144         /*
1145          * Single unix specification:
1146          * We should -EINVAL if an element length is not >= 0 and fitting an
1147          * ssize_t.  The total length is fitting an ssize_t
1148          *
1149          * Be careful here because iov_len is a size_t not an ssize_t
1150          */
1151         tot_len = 0;
1152         vector = iov;
1153         ret = -EINVAL;
1154         for (seg = 0 ; seg < nr_segs; seg++) {
1155                 compat_ssize_t tmp = tot_len;
1156                 compat_ssize_t len;
1157                 compat_uptr_t buf;
1158
1159                 if (__get_user(len, &uvector->iov_len) ||
1160                     __get_user(buf, &uvector->iov_base)) {
1161                         ret = -EFAULT;
1162                         goto out;
1163                 }
1164                 if (len < 0)    /* size_t not fitting an compat_ssize_t .. */
1165                         goto out;
1166                 tot_len += len;
1167                 if (tot_len < tmp) /* maths overflow on the compat_ssize_t */
1168                         goto out;
1169                 vector->iov_base = compat_ptr(buf);
1170                 vector->iov_len = (compat_size_t) len;
1171                 uvector++;
1172                 vector++;
1173         }
1174         if (tot_len == 0) {
1175                 ret = 0;
1176                 goto out;
1177         }
1178
1179         ret = rw_verify_area(type, file, pos, tot_len);
1180         if (ret)
1181                 goto out;
1182
1183         fnv = NULL;
1184         if (type == READ) {
1185                 fn = file->f_op->read;
1186                 fnv = file->f_op->readv;
1187         } else {
1188                 fn = (io_fn_t)file->f_op->write;
1189                 fnv = file->f_op->writev;
1190         }
1191         if (fnv) {
1192                 ret = fnv(file, iov, nr_segs, pos);
1193                 goto out;
1194         }
1195
1196         /* Do it by hand, with file-ops */
1197         ret = 0;
1198         vector = iov;
1199         while (nr_segs > 0) {
1200                 void __user * base;
1201                 size_t len;
1202                 ssize_t nr;
1203
1204                 base = vector->iov_base;
1205                 len = vector->iov_len;
1206                 vector++;
1207                 nr_segs--;
1208
1209                 nr = fn(file, base, len, pos);
1210
1211                 if (nr < 0) {
1212                         if (!ret) ret = nr;
1213                         break;
1214                 }
1215                 ret += nr;
1216                 if (nr != len)
1217                         break;
1218         }
1219 out:
1220         if (iov != iovstack)
1221                 kfree(iov);
1222         if ((ret + (type == READ)) > 0) {
1223                 struct dentry *dentry = file->f_dentry;
1224                 if (type == READ)
1225                         fsnotify_access(dentry);
1226                 else
1227                         fsnotify_modify(dentry);
1228         }
1229         return ret;
1230 }
1231
1232 asmlinkage ssize_t
1233 compat_sys_readv(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen)
1234 {
1235         struct file *file;
1236         ssize_t ret = -EBADF;
1237
1238         file = fget(fd);
1239         if (!file)
1240                 return -EBADF;
1241
1242         if (!(file->f_mode & FMODE_READ))
1243                 goto out;
1244
1245         ret = -EINVAL;
1246         if (!file->f_op || (!file->f_op->readv && !file->f_op->read))
1247                 goto out;
1248
1249         ret = compat_do_readv_writev(READ, file, vec, vlen, &file->f_pos);
1250
1251 out:
1252         fput(file);
1253         return ret;
1254 }
1255
1256 asmlinkage ssize_t
1257 compat_sys_writev(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen)
1258 {
1259         struct file *file;
1260         ssize_t ret = -EBADF;
1261
1262         file = fget(fd);
1263         if (!file)
1264                 return -EBADF;
1265         if (!(file->f_mode & FMODE_WRITE))
1266                 goto out;
1267
1268         ret = -EINVAL;
1269         if (!file->f_op || (!file->f_op->writev && !file->f_op->write))
1270                 goto out;
1271
1272         ret = compat_do_readv_writev(WRITE, file, vec, vlen, &file->f_pos);
1273
1274 out:
1275         fput(file);
1276         return ret;
1277 }
1278
1279 /*
1280  * Exactly like fs/open.c:sys_open(), except that it doesn't set the
1281  * O_LARGEFILE flag.
1282  */
1283 asmlinkage long
1284 compat_sys_open(const char __user *filename, int flags, int mode)
1285 {
1286         return do_sys_open(filename, flags, mode);
1287 }
1288
1289 /*
1290  * compat_count() counts the number of arguments/envelopes. It is basically
1291  * a copy of count() from fs/exec.c, except that it works with 32 bit argv
1292  * and envp pointers.
1293  */
1294 static int compat_count(compat_uptr_t __user *argv, int max)
1295 {
1296         int i = 0;
1297
1298         if (argv != NULL) {
1299                 for (;;) {
1300                         compat_uptr_t p;
1301
1302                         if (get_user(p, argv))
1303                                 return -EFAULT;
1304                         if (!p)
1305                                 break;
1306                         argv++;
1307                         if(++i > max)
1308                                 return -E2BIG;
1309                 }
1310         }
1311         return i;
1312 }
1313
1314 /*
1315  * compat_copy_strings() is basically a copy of copy_strings() from fs/exec.c
1316  * except that it works with 32 bit argv and envp pointers.
1317  */
1318 static int compat_copy_strings(int argc, compat_uptr_t __user *argv,
1319                                 struct linux_binprm *bprm)
1320 {
1321         struct page *kmapped_page = NULL;
1322         char *kaddr = NULL;
1323         int ret;
1324
1325         while (argc-- > 0) {
1326                 compat_uptr_t str;
1327                 int len;
1328                 unsigned long pos;
1329
1330                 if (get_user(str, argv+argc) ||
1331                         !(len = strnlen_user(compat_ptr(str), bprm->p))) {
1332                         ret = -EFAULT;
1333                         goto out;
1334                 }
1335
1336                 if (bprm->p < len)  {
1337                         ret = -E2BIG;
1338                         goto out;
1339                 }
1340
1341                 bprm->p -= len;
1342                 /* XXX: add architecture specific overflow check here. */
1343                 pos = bprm->p;
1344
1345                 while (len > 0) {
1346                         int i, new, err;
1347                         int offset, bytes_to_copy;
1348                         struct page *page;
1349
1350                         offset = pos % PAGE_SIZE;
1351                         i = pos/PAGE_SIZE;
1352                         page = bprm->page[i];
1353                         new = 0;
1354                         if (!page) {
1355                                 page = alloc_page(GFP_HIGHUSER);
1356                                 bprm->page[i] = page;
1357                                 if (!page) {
1358                                         ret = -ENOMEM;
1359                                         goto out;
1360                                 }
1361                                 new = 1;
1362                         }
1363
1364                         if (page != kmapped_page) {
1365                                 if (kmapped_page)
1366                                         kunmap(kmapped_page);
1367                                 kmapped_page = page;
1368                                 kaddr = kmap(kmapped_page);
1369                         }
1370                         if (new && offset)
1371                                 memset(kaddr, 0, offset);
1372                         bytes_to_copy = PAGE_SIZE - offset;
1373                         if (bytes_to_copy > len) {
1374                                 bytes_to_copy = len;
1375                                 if (new)
1376                                         memset(kaddr+offset+len, 0,
1377                                                 PAGE_SIZE-offset-len);
1378                         }
1379                         err = copy_from_user(kaddr+offset, compat_ptr(str),
1380                                                 bytes_to_copy);
1381                         if (err) {
1382                                 ret = -EFAULT;
1383                                 goto out;
1384                         }
1385
1386                         pos += bytes_to_copy;
1387                         str += bytes_to_copy;
1388                         len -= bytes_to_copy;
1389                 }
1390         }
1391         ret = 0;
1392 out:
1393         if (kmapped_page)
1394                 kunmap(kmapped_page);
1395         return ret;
1396 }
1397
1398 #ifdef CONFIG_MMU
1399
1400 #define free_arg_pages(bprm) do { } while (0)
1401
1402 #else
1403
1404 static inline void free_arg_pages(struct linux_binprm *bprm)
1405 {
1406         int i;
1407
1408         for (i = 0; i < MAX_ARG_PAGES; i++) {
1409                 if (bprm->page[i])
1410                         __free_page(bprm->page[i]);
1411                 bprm->page[i] = NULL;
1412         }
1413 }
1414
1415 #endif /* CONFIG_MMU */
1416
1417 /*
1418  * compat_do_execve() is mostly a copy of do_execve(), with the exception
1419  * that it processes 32 bit argv and envp pointers.
1420  */
1421 int compat_do_execve(char * filename,
1422         compat_uptr_t __user *argv,
1423         compat_uptr_t __user *envp,
1424         struct pt_regs * regs)
1425 {
1426         struct linux_binprm *bprm;
1427         struct file *file;
1428         int retval;
1429         int i;
1430
1431         retval = -ENOMEM;
1432         bprm = kmalloc(sizeof(*bprm), GFP_KERNEL);
1433         if (!bprm)
1434                 goto out_ret;
1435         memset(bprm, 0, sizeof(*bprm));
1436
1437         file = open_exec(filename);
1438         retval = PTR_ERR(file);
1439         if (IS_ERR(file))
1440                 goto out_kfree;
1441
1442         sched_exec();
1443
1444         bprm->p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
1445         bprm->file = file;
1446         bprm->filename = filename;
1447         bprm->interp = filename;
1448         bprm->mm = mm_alloc();
1449         retval = -ENOMEM;
1450         if (!bprm->mm)
1451                 goto out_file;
1452
1453         retval = init_new_context(current, bprm->mm);
1454         if (retval < 0)
1455                 goto out_mm;
1456
1457         bprm->argc = compat_count(argv, bprm->p / sizeof(compat_uptr_t));
1458         if ((retval = bprm->argc) < 0)
1459                 goto out_mm;
1460
1461         bprm->envc = compat_count(envp, bprm->p / sizeof(compat_uptr_t));
1462         if ((retval = bprm->envc) < 0)
1463                 goto out_mm;
1464
1465         retval = security_bprm_alloc(bprm);
1466         if (retval)
1467                 goto out;
1468
1469         retval = prepare_binprm(bprm);
1470         if (retval < 0)
1471                 goto out;
1472
1473         retval = copy_strings_kernel(1, &bprm->filename, bprm);
1474         if (retval < 0)
1475                 goto out;
1476
1477         bprm->exec = bprm->p;
1478         retval = compat_copy_strings(bprm->envc, envp, bprm);
1479         if (retval < 0)
1480                 goto out;
1481
1482         retval = compat_copy_strings(bprm->argc, argv, bprm);
1483         if (retval < 0)
1484                 goto out;
1485
1486         retval = search_binary_handler(bprm, regs);
1487         if (retval >= 0) {
1488                 free_arg_pages(bprm);
1489
1490                 /* execve success */
1491                 security_bprm_free(bprm);
1492                 acct_update_integrals(current);
1493                 kfree(bprm);
1494                 return retval;
1495         }
1496
1497 out:
1498         /* Something went wrong, return the inode and free the argument pages*/
1499         for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
1500                 struct page * page = bprm->page[i];
1501                 if (page)
1502                         __free_page(page);
1503         }
1504
1505         if (bprm->security)
1506                 security_bprm_free(bprm);
1507
1508 out_mm:
1509         if (bprm->mm)
1510                 mmdrop(bprm->mm);
1511
1512 out_file:
1513         if (bprm->file) {
1514                 allow_write_access(bprm->file);
1515                 fput(bprm->file);
1516         }
1517
1518 out_kfree:
1519         kfree(bprm);
1520
1521 out_ret:
1522         return retval;
1523 }
1524
1525 #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
1526
1527 #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
1528
1529 /*
1530  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
1531  * 64-bit unsigned longs.
1532  */
1533 static inline
1534 int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1535                         unsigned long *fdset)
1536 {
1537         nr = ROUND_UP(nr, __COMPAT_NFDBITS);
1538         if (ufdset) {
1539                 unsigned long odd;
1540
1541                 if (!access_ok(VERIFY_WRITE, ufdset, nr*sizeof(compat_ulong_t)))
1542                         return -EFAULT;
1543
1544                 odd = nr & 1UL;
1545                 nr &= ~1UL;
1546                 while (nr) {
1547                         unsigned long h, l;
1548                         __get_user(l, ufdset);
1549                         __get_user(h, ufdset+1);
1550                         ufdset += 2;
1551                         *fdset++ = h << 32 | l;
1552                         nr -= 2;
1553                 }
1554                 if (odd)
1555                         __get_user(*fdset, ufdset);
1556         } else {
1557                 /* Tricky, must clear full unsigned long in the
1558                  * kernel fdset at the end, this makes sure that
1559                  * actually happens.
1560                  */
1561                 memset(fdset, 0, ((nr + 1) & ~1)*sizeof(compat_ulong_t));
1562         }
1563         return 0;
1564 }
1565
1566 static inline
1567 void compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1568                         unsigned long *fdset)
1569 {
1570         unsigned long odd;
1571         nr = ROUND_UP(nr, __COMPAT_NFDBITS);
1572
1573         if (!ufdset)
1574                 return;
1575
1576         odd = nr & 1UL;
1577         nr &= ~1UL;
1578         while (nr) {
1579                 unsigned long h, l;
1580                 l = *fdset++;
1581                 h = l >> 32;
1582                 __put_user(l, ufdset);
1583                 __put_user(h, ufdset+1);
1584                 ufdset += 2;
1585                 nr -= 2;
1586         }
1587         if (odd)
1588                 __put_user(*fdset, ufdset);
1589 }
1590
1591
1592 /*
1593  * This is a virtual copy of sys_select from fs/select.c and probably
1594  * should be compared to it from time to time
1595  */
1596 static void *select_bits_alloc(int size)
1597 {
1598         return kmalloc(6 * size, GFP_KERNEL);
1599 }
1600
1601 static void select_bits_free(void *bits, int size)
1602 {
1603         kfree(bits);
1604 }
1605
1606 /*
1607  * We can actually return ERESTARTSYS instead of EINTR, but I'd
1608  * like to be certain this leads to no problems. So I return
1609  * EINTR just for safety.
1610  *
1611  * Update: ERESTARTSYS breaks at least the xview clock binary, so
1612  * I'm trying ERESTARTNOHAND which restart only when you want to.
1613  */
1614 #define MAX_SELECT_SECONDS \
1615         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
1616
1617 asmlinkage long
1618 compat_sys_select(int n, compat_ulong_t __user *inp, compat_ulong_t __user *outp,
1619                 compat_ulong_t __user *exp, struct compat_timeval __user *tvp)
1620 {
1621         fd_set_bits fds;
1622         char *bits;
1623         long timeout;
1624         int size, max_fdset, ret = -EINVAL;
1625         struct fdtable *fdt;
1626
1627         timeout = MAX_SCHEDULE_TIMEOUT;
1628         if (tvp) {
1629                 time_t sec, usec;
1630
1631                 if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
1632                     || __get_user(sec, &tvp->tv_sec)
1633                     || __get_user(usec, &tvp->tv_usec)) {
1634                         ret = -EFAULT;
1635                         goto out_nofds;
1636                 }
1637
1638                 if (sec < 0 || usec < 0)
1639                         goto out_nofds;
1640
1641                 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1642                         timeout = ROUND_UP(usec, 1000000/HZ);
1643                         timeout += sec * (unsigned long) HZ;
1644                 }
1645         }
1646
1647         if (n < 0)
1648                 goto out_nofds;
1649
1650         /* max_fdset can increase, so grab it once to avoid race */
1651         rcu_read_lock();
1652         fdt = files_fdtable(current->files);
1653         max_fdset = fdt->max_fdset;
1654         rcu_read_unlock();
1655         if (n > max_fdset)
1656                 n = max_fdset;
1657
1658         /*
1659          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1660          * since we used fdset we need to allocate memory in units of
1661          * long-words.
1662          */
1663         ret = -ENOMEM;
1664         size = FDS_BYTES(n);
1665         bits = select_bits_alloc(size);
1666         if (!bits)
1667                 goto out_nofds;
1668         fds.in      = (unsigned long *)  bits;
1669         fds.out     = (unsigned long *) (bits +   size);
1670         fds.ex      = (unsigned long *) (bits + 2*size);
1671         fds.res_in  = (unsigned long *) (bits + 3*size);
1672         fds.res_out = (unsigned long *) (bits + 4*size);
1673         fds.res_ex  = (unsigned long *) (bits + 5*size);
1674
1675         if ((ret = compat_get_fd_set(n, inp, fds.in)) ||
1676             (ret = compat_get_fd_set(n, outp, fds.out)) ||
1677             (ret = compat_get_fd_set(n, exp, fds.ex)))
1678                 goto out;
1679         zero_fd_set(n, fds.res_in);
1680         zero_fd_set(n, fds.res_out);
1681         zero_fd_set(n, fds.res_ex);
1682
1683         ret = do_select(n, &fds, &timeout);
1684
1685         if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
1686                 time_t sec = 0, usec = 0;
1687                 if (timeout) {
1688                         sec = timeout / HZ;
1689                         usec = timeout % HZ;
1690                         usec *= (1000000/HZ);
1691                 }
1692                 if (put_user(sec, &tvp->tv_sec) ||
1693                     put_user(usec, &tvp->tv_usec))
1694                         ret = -EFAULT;
1695         }
1696
1697         if (ret < 0)
1698                 goto out;
1699         if (!ret) {
1700                 ret = -ERESTARTNOHAND;
1701                 if (signal_pending(current))
1702                         goto out;
1703                 ret = 0;
1704         }
1705
1706         compat_set_fd_set(n, inp, fds.res_in);
1707         compat_set_fd_set(n, outp, fds.res_out);
1708         compat_set_fd_set(n, exp, fds.res_ex);
1709
1710 out:
1711         select_bits_free(bits, size);
1712 out_nofds:
1713         return ret;
1714 }
1715
1716 #if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)
1717 /* Stuff for NFS server syscalls... */
1718 struct compat_nfsctl_svc {
1719         u16                     svc32_port;
1720         s32                     svc32_nthreads;
1721 };
1722
1723 struct compat_nfsctl_client {
1724         s8                      cl32_ident[NFSCLNT_IDMAX+1];
1725         s32                     cl32_naddr;
1726         struct in_addr          cl32_addrlist[NFSCLNT_ADDRMAX];
1727         s32                     cl32_fhkeytype;
1728         s32                     cl32_fhkeylen;
1729         u8                      cl32_fhkey[NFSCLNT_KEYMAX];
1730 };
1731
1732 struct compat_nfsctl_export {
1733         char            ex32_client[NFSCLNT_IDMAX+1];
1734         char            ex32_path[NFS_MAXPATHLEN+1];
1735         compat_dev_t    ex32_dev;
1736         compat_ino_t    ex32_ino;
1737         compat_int_t    ex32_flags;
1738         __compat_uid_t  ex32_anon_uid;
1739         __compat_gid_t  ex32_anon_gid;
1740 };
1741
1742 struct compat_nfsctl_fdparm {
1743         struct sockaddr         gd32_addr;
1744         s8                      gd32_path[NFS_MAXPATHLEN+1];
1745         compat_int_t            gd32_version;
1746 };
1747
1748 struct compat_nfsctl_fsparm {
1749         struct sockaddr         gd32_addr;
1750         s8                      gd32_path[NFS_MAXPATHLEN+1];
1751         compat_int_t            gd32_maxlen;
1752 };
1753
1754 struct compat_nfsctl_arg {
1755         compat_int_t            ca32_version;   /* safeguard */
1756         union {
1757                 struct compat_nfsctl_svc        u32_svc;
1758                 struct compat_nfsctl_client     u32_client;
1759                 struct compat_nfsctl_export     u32_export;
1760                 struct compat_nfsctl_fdparm     u32_getfd;
1761                 struct compat_nfsctl_fsparm     u32_getfs;
1762         } u;
1763 #define ca32_svc        u.u32_svc
1764 #define ca32_client     u.u32_client
1765 #define ca32_export     u.u32_export
1766 #define ca32_getfd      u.u32_getfd
1767 #define ca32_getfs      u.u32_getfs
1768 };
1769
1770 union compat_nfsctl_res {
1771         __u8                    cr32_getfh[NFS_FHSIZE];
1772         struct knfsd_fh         cr32_getfs;
1773 };
1774
1775 static int compat_nfs_svc_trans(struct nfsctl_arg *karg, struct compat_nfsctl_arg __user *arg)
1776 {
1777         int err;
1778
1779         err = access_ok(VERIFY_READ, &arg->ca32_svc, sizeof(arg->ca32_svc));
1780         err |= get_user(karg->ca_version, &arg->ca32_version);
1781         err |= __get_user(karg->ca_svc.svc_port, &arg->ca32_svc.svc32_port);
1782         err |= __get_user(karg->ca_svc.svc_nthreads, &arg->ca32_svc.svc32_nthreads);
1783         return (err) ? -EFAULT : 0;
1784 }
1785
1786 static int compat_nfs_clnt_trans(struct nfsctl_arg *karg, struct compat_nfsctl_arg __user *arg)
1787 {
1788         int err;
1789
1790         err = access_ok(VERIFY_READ, &arg->ca32_client, sizeof(arg->ca32_client));
1791         err |= get_user(karg->ca_version, &arg->ca32_version);
1792         err |= __copy_from_user(&karg->ca_client.cl_ident[0],
1793                           &arg->ca32_client.cl32_ident[0],
1794                           NFSCLNT_IDMAX);
1795         err |= __get_user(karg->ca_client.cl_naddr, &arg->ca32_client.cl32_naddr);
1796         err |= __copy_from_user(&karg->ca_client.cl_addrlist[0],
1797                           &arg->ca32_client.cl32_addrlist[0],
1798                           (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
1799         err |= __get_user(karg->ca_client.cl_fhkeytype,
1800                       &arg->ca32_client.cl32_fhkeytype);
1801         err |= __get_user(karg->ca_client.cl_fhkeylen,
1802                       &arg->ca32_client.cl32_fhkeylen);
1803         err |= __copy_from_user(&karg->ca_client.cl_fhkey[0],
1804                           &arg->ca32_client.cl32_fhkey[0],
1805                           NFSCLNT_KEYMAX);
1806
1807         return (err) ? -EFAULT : 0;
1808 }
1809
1810 static int compat_nfs_exp_trans(struct nfsctl_arg *karg, struct compat_nfsctl_arg __user *arg)
1811 {
1812         int err;
1813
1814         err = access_ok(VERIFY_READ, &arg->ca32_export, sizeof(arg->ca32_export));
1815         err |= get_user(karg->ca_version, &arg->ca32_version);
1816         err |= __copy_from_user(&karg->ca_export.ex_client[0],
1817                           &arg->ca32_export.ex32_client[0],
1818                           NFSCLNT_IDMAX);
1819         err |= __copy_from_user(&karg->ca_export.ex_path[0],
1820                           &arg->ca32_export.ex32_path[0],
1821                           NFS_MAXPATHLEN);
1822         err |= __get_user(karg->ca_export.ex_dev,
1823                       &arg->ca32_export.ex32_dev);
1824         err |= __get_user(karg->ca_export.ex_ino,
1825                       &arg->ca32_export.ex32_ino);
1826         err |= __get_user(karg->ca_export.ex_flags,
1827                       &arg->ca32_export.ex32_flags);
1828         err |= __get_user(karg->ca_export.ex_anon_uid,
1829                       &arg->ca32_export.ex32_anon_uid);
1830         err |= __get_user(karg->ca_export.ex_anon_gid,
1831                       &arg->ca32_export.ex32_anon_gid);
1832         SET_UID(karg->ca_export.ex_anon_uid, karg->ca_export.ex_anon_uid);
1833         SET_GID(karg->ca_export.ex_anon_gid, karg->ca_export.ex_anon_gid);
1834
1835         return (err) ? -EFAULT : 0;
1836 }
1837
1838 static int compat_nfs_getfd_trans(struct nfsctl_arg *karg, struct compat_nfsctl_arg __user *arg)
1839 {
1840         int err;
1841
1842         err = access_ok(VERIFY_READ, &arg->ca32_getfd, sizeof(arg->ca32_getfd));
1843         err |= get_user(karg->ca_version, &arg->ca32_version);
1844         err |= __copy_from_user(&karg->ca_getfd.gd_addr,
1845                           &arg->ca32_getfd.gd32_addr,
1846                           (sizeof(struct sockaddr)));
1847         err |= __copy_from_user(&karg->ca_getfd.gd_path,
1848                           &arg->ca32_getfd.gd32_path,
1849                           (NFS_MAXPATHLEN+1));
1850         err |= __get_user(karg->ca_getfd.gd_version,
1851                       &arg->ca32_getfd.gd32_version);
1852
1853         return (err) ? -EFAULT : 0;
1854 }
1855
1856 static int compat_nfs_getfs_trans(struct nfsctl_arg *karg, struct compat_nfsctl_arg __user *arg)
1857 {
1858         int err;
1859
1860         err = access_ok(VERIFY_READ, &arg->ca32_getfs, sizeof(arg->ca32_getfs));
1861         err |= get_user(karg->ca_version, &arg->ca32_version);
1862         err |= __copy_from_user(&karg->ca_getfs.gd_addr,
1863                           &arg->ca32_getfs.gd32_addr,
1864                           (sizeof(struct sockaddr)));
1865         err |= __copy_from_user(&karg->ca_getfs.gd_path,
1866                           &arg->ca32_getfs.gd32_path,
1867                           (NFS_MAXPATHLEN+1));
1868         err |= __get_user(karg->ca_getfs.gd_maxlen,
1869                       &arg->ca32_getfs.gd32_maxlen);
1870
1871         return (err) ? -EFAULT : 0;
1872 }
1873
1874 /* This really doesn't need translations, we are only passing
1875  * back a union which contains opaque nfs file handle data.
1876  */
1877 static int compat_nfs_getfh_res_trans(union nfsctl_res *kres, union compat_nfsctl_res __user *res)
1878 {
1879         int err;
1880
1881         err = copy_to_user(res, kres, sizeof(*res));
1882
1883         return (err) ? -EFAULT : 0;
1884 }
1885
1886 asmlinkage long compat_sys_nfsservctl(int cmd, struct compat_nfsctl_arg __user *arg,
1887                                         union compat_nfsctl_res __user *res)
1888 {
1889         struct nfsctl_arg *karg;
1890         union nfsctl_res *kres;
1891         mm_segment_t oldfs;
1892         int err;
1893
1894         karg = kmalloc(sizeof(*karg), GFP_USER);
1895         kres = kmalloc(sizeof(*kres), GFP_USER);
1896         if(!karg || !kres) {
1897                 err = -ENOMEM;
1898                 goto done;
1899         }
1900
1901         switch(cmd) {
1902         case NFSCTL_SVC:
1903                 err = compat_nfs_svc_trans(karg, arg);
1904                 break;
1905
1906         case NFSCTL_ADDCLIENT:
1907                 err = compat_nfs_clnt_trans(karg, arg);
1908                 break;
1909
1910         case NFSCTL_DELCLIENT:
1911                 err = compat_nfs_clnt_trans(karg, arg);
1912                 break;
1913
1914         case NFSCTL_EXPORT:
1915         case NFSCTL_UNEXPORT:
1916                 err = compat_nfs_exp_trans(karg, arg);
1917                 break;
1918
1919         case NFSCTL_GETFD:
1920                 err = compat_nfs_getfd_trans(karg, arg);
1921                 break;
1922
1923         case NFSCTL_GETFS:
1924                 err = compat_nfs_getfs_trans(karg, arg);
1925                 break;
1926
1927         default:
1928                 err = -EINVAL;
1929                 goto done;
1930         }
1931
1932         oldfs = get_fs();
1933         set_fs(KERNEL_DS);
1934         /* The __user pointer casts are valid because of the set_fs() */
1935         err = sys_nfsservctl(cmd, (void __user *) karg, (void __user *) kres);
1936         set_fs(oldfs);
1937
1938         if (err)
1939                 goto done;
1940
1941         if((cmd == NFSCTL_GETFD) ||
1942            (cmd == NFSCTL_GETFS))
1943                 err = compat_nfs_getfh_res_trans(kres, res);
1944
1945 done:
1946         kfree(karg);
1947         kfree(kres);
1948         return err;
1949 }
1950 #else /* !NFSD */
1951 long asmlinkage compat_sys_nfsservctl(int cmd, void *notused, void *notused2)
1952 {
1953         return sys_ni_syscall();
1954 }
1955 #endif