arch/s390/kernel/compat_linux.c

   1 /*
   2  *  arch/s390x/kernel/linux32.c
   3  *
   4  *  S390 version
   5  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   6  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
   7  *               Gerhard Tonn (ton@de.ibm.com)
   8  *
   9  *  Conversion between 31bit and 64bit native syscalls.
  10  *
  11  * Heavily inspired by the 32-bit Sparc compat code which is
  12  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  13  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  14  *
  15  */
  16
  17
  18 #include <linux/config.h>
  19 #include <linux/kernel.h>
  20 #include <linux/sched.h>
  21 #include <linux/fs.h>
  22 #include <linux/mm.h>
  23 #include <linux/file.h>
  24 #include <linux/signal.h>
  25 #include <linux/resource.h>
  26 #include <linux/times.h>
  27 #include <linux/utsname.h>
  28 #include <linux/timex.h>
  29 #include <linux/smp.h>
  30 #include <linux/smp_lock.h>
  31 #include <linux/sem.h>
  32 #include <linux/msg.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/smb_fs.h>
  38 #include <linux/smb_mount.h>
  39 #include <linux/ncp_fs.h>
  40 #include <linux/quota.h>
  41 #include <linux/module.h>
  42 #include <linux/sunrpc/svc.h>
  43 #include <linux/nfsd/nfsd.h>
  44 #include <linux/nfsd/cache.h>
  45 #include <linux/nfsd/xdr.h>
  46 #include <linux/nfsd/syscall.h>
  47 #include <linux/poll.h>
  48 #include <linux/personality.h>
  49 #include <linux/stat.h>
  50 #include <linux/filter.h>
  51 #include <linux/highmem.h>
  52 #include <linux/highuid.h>
  53 #include <linux/mman.h>
  54 #include <linux/ipv6.h>
  55 #include <linux/in.h>
  56 #include <linux/icmpv6.h>
  57 #include <linux/sysctl.h>
  58 #include <linux/binfmts.h>
  59 #include <linux/compat.h>
  60 #include <linux/vfs.h>
  61 #include <linux/ptrace.h>
  62
  63 #include <asm/types.h>
  64 #include <asm/ipc.h>
  65 #include <asm/uaccess.h>
  66 #include <asm/semaphore.h>
  67
  68 #include <net/scm.h>
  69 #include <net/sock.h>
  70
  71 #include "compat_linux.h"
  72
  73 extern asmlinkage long sys_chown(const char *, uid_t,gid_t);
  74 extern asmlinkage long sys_lchown(const char *, uid_t,gid_t);
  75 extern asmlinkage long sys_fchown(unsigned int, uid_t,gid_t);
  76 extern asmlinkage long sys_setregid(gid_t, gid_t);
  77 extern asmlinkage long sys_setgid(gid_t);
  78 extern asmlinkage long sys_setreuid(uid_t, uid_t);
  79 extern asmlinkage long sys_setuid(uid_t);
  80 extern asmlinkage long sys_setresuid(uid_t, uid_t, uid_t);
  81 extern asmlinkage long sys_setresgid(gid_t, gid_t, gid_t);
  82 extern asmlinkage long sys_setfsuid(uid_t);
  83 extern asmlinkage long sys_setfsgid(gid_t);
  84
  85 /* For this source file, we want overflow handling. */
  86
  87 #undef high2lowuid
  88 #undef high2lowgid
  89 #undef low2highuid
  90 #undef low2highgid
  91 #undef SET_UID16
  92 #undef SET_GID16
  93 #undef NEW_TO_OLD_UID
  94 #undef NEW_TO_OLD_GID
  95 #undef SET_OLDSTAT_UID
  96 #undef SET_OLDSTAT_GID
  97 #undef SET_STAT_UID
  98 #undef SET_STAT_GID
  99
 100 #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid)
 101 #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid)
 102 #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid)
 103 #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid)
 104 #define SET_UID16(var, uid)     var = high2lowuid(uid)
 105 #define SET_GID16(var, gid)     var = high2lowgid(gid)
 106 #define NEW_TO_OLD_UID(uid)     high2lowuid(uid)
 107 #define NEW_TO_OLD_GID(gid)     high2lowgid(gid)
 108 #define SET_OLDSTAT_UID(stat, uid)      (stat).st_uid = high2lowuid(uid)
 109 #define SET_OLDSTAT_GID(stat, gid)      (stat).st_gid = high2lowgid(gid)
 110 #define SET_STAT_UID(stat, uid)         (stat).st_uid = high2lowuid(uid)
 111 #define SET_STAT_GID(stat, gid)         (stat).st_gid = high2lowgid(gid)
 112
 113 asmlinkage long sys32_chown16(const char * filename, u16 user, u16 group)
 114 {
 115         return sys_chown(filename, low2highuid(user), low2highgid(group));
 116 }
 117
 118 asmlinkage long sys32_lchown16(const char * filename, u16 user, u16 group)
 119 {
 120         return sys_lchown(filename, low2highuid(user), low2highgid(group));
 121 }
 122
 123 asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group)
 124 {
 125         return sys_fchown(fd, low2highuid(user), low2highgid(group));
 126 }
 127
 128 asmlinkage long sys32_setregid16(u16 rgid, u16 egid)
 129 {
 130         return sys_setregid(low2highgid(rgid), low2highgid(egid));
 131 }
 132
 133 asmlinkage long sys32_setgid16(u16 gid)
 134 {
 135         return sys_setgid((gid_t)gid);
 136 }
 137
 138 asmlinkage long sys32_setreuid16(u16 ruid, u16 euid)
 139 {
 140         return sys_setreuid(low2highuid(ruid), low2highuid(euid));
 141 }
 142
 143 asmlinkage long sys32_setuid16(u16 uid)
 144 {
 145         return sys_setuid((uid_t)uid);
 146 }
 147
 148 asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
 149 {
 150         return sys_setresuid(low2highuid(ruid), low2highuid(euid),
 151                 low2highuid(suid));
 152 }
 153
 154 asmlinkage long sys32_getresuid16(u16 *ruid, u16 *euid, u16 *suid)
 155 {
 156         int retval;
 157
 158         if (!(retval = put_user(high2lowuid(current->uid), ruid)) &&
 159             !(retval = put_user(high2lowuid(current->euid), euid)))
 160                 retval = put_user(high2lowuid(current->suid), suid);
 161
 162         return retval;
 163 }
 164
 165 asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
 166 {
 167         return sys_setresgid(low2highgid(rgid), low2highgid(egid),
 168                 low2highgid(sgid));
 169 }
 170
 171 asmlinkage long sys32_getresgid16(u16 *rgid, u16 *egid, u16 *sgid)
 172 {
 173         int retval;
 174
 175         if (!(retval = put_user(high2lowgid(current->gid), rgid)) &&
 176             !(retval = put_user(high2lowgid(current->egid), egid)))
 177                 retval = put_user(high2lowgid(current->sgid), sgid);
 178
 179         return retval;
 180 }
 181
 182 asmlinkage long sys32_setfsuid16(u16 uid)
 183 {
 184         return sys_setfsuid((uid_t)uid);
 185 }
 186
 187 asmlinkage long sys32_setfsgid16(u16 gid)
 188 {
 189         return sys_setfsgid((gid_t)gid);
 190 }
 191
 192 asmlinkage long sys32_getgroups16(int gidsetsize, u16 *grouplist)
 193 {
 194         u16 groups[NGROUPS];
 195         int i,j;
 196
 197         if (gidsetsize < 0)
 198                 return -EINVAL;
 199         i = current->ngroups;
 200         if (gidsetsize) {
 201                 if (i > gidsetsize)
 202                         return -EINVAL;
 203                 for(j=0;j<i;j++)
 204                         groups[j] = current->groups[j];
 205                 if (copy_to_user(grouplist, groups, sizeof(u16)*i))
 206                         return -EFAULT;
 207         }
 208         return i;
 209 }
 210
 211 asmlinkage long sys32_setgroups16(int gidsetsize, u16 *grouplist)
 212 {
 213         u16 groups[NGROUPS];
 214         int i;
 215
 216         if (!capable(CAP_SETGID))
 217                 return -EPERM;
 218         if ((unsigned) gidsetsize > NGROUPS)
 219                 return -EINVAL;
 220         if (copy_from_user(groups, grouplist, gidsetsize * sizeof(u16)))
 221                 return -EFAULT;
 222         for (i = 0 ; i < gidsetsize ; i++)
 223                 current->groups[i] = (gid_t)groups[i];
 224         current->ngroups = gidsetsize;
 225         return 0;
 226 }
 227
 228 asmlinkage long sys32_getuid16(void)
 229 {
 230         return high2lowuid(current->uid);
 231 }
 232
 233 asmlinkage long sys32_geteuid16(void)
 234 {
 235         return high2lowuid(current->euid);
 236 }
 237
 238 asmlinkage long sys32_getgid16(void)
 239 {
 240         return high2lowgid(current->gid);
 241 }
 242
 243 asmlinkage long sys32_getegid16(void)
 244 {
 245         return high2lowgid(current->egid);
 246 }
 247
 248 /* 32-bit timeval and related flotsam.  */
 249
 250 static inline long get_tv32(struct timeval *o, struct compat_timeval *i)
 251 {
 252         return (!access_ok(VERIFY_READ, tv32, sizeof(*tv32)) ||
 253                 (__get_user(o->tv_sec, &i->tv_sec) ||
 254                  __get_user(o->tv_usec, &i->tv_usec)));
 255 }
 256
 257 static inline long put_tv32(struct compat_timeval *o, struct timeval *i)
 258 {
 259         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 260                 (__put_user(i->tv_sec, &o->tv_sec) ||
 261                  __put_user(i->tv_usec, &o->tv_usec)));
 262 }
 263
 264 struct msgbuf32 { s32 mtype; char mtext[1]; };
 265
 266 struct ipc64_perm_ds32
 267 {
 268         __kernel_key_t          key;
 269         __kernel_uid32_t        uid;
 270         __kernel_gid32_t        gid;
 271         __kernel_uid32_t        cuid;
 272         __kernel_gid32_t        cgid;
 273         compat_mode_t       mode;
 274         unsigned short          __pad1;
 275         unsigned short          seq;
 276         unsigned short          __pad2;
 277         unsigned int            __unused1;
 278         unsigned int            __unused2;
 279 };
 280
 281 struct ipc_perm32
 282 {
 283         key_t             key;
 284         compat_uid_t  uid;
 285         compat_gid_t  gid;
 286         compat_uid_t  cuid;
 287         compat_gid_t  cgid;
 288         compat_mode_t mode;
 289         unsigned short  seq;
 290 };
 291
 292 struct semid_ds32 {
 293         struct ipc_perm32 sem_perm;               /* permissions .. see ipc.h */
 294         compat_time_t   sem_otime;              /* last semop time */
 295         compat_time_t   sem_ctime;              /* last change time */
 296         u32 sem_base;              /* ptr to first semaphore in array */
 297         u32 sem_pending;          /* pending operations to be processed */
 298         u32 sem_pending_last;    /* last pending operation */
 299         u32 undo;                  /* undo requests on this array */
 300         unsigned short  sem_nsems;              /* no. of semaphores in array */
 301 };
 302
 303 struct semid64_ds32 {
 304         struct ipc64_perm_ds32 sem_perm;
 305         unsigned int      __pad1;
 306         compat_time_t   sem_otime;
 307         unsigned int      __pad2;
 308         compat_time_t   sem_ctime;
 309         u32 sem_nsems;
 310         u32 __unused1;
 311         u32 __unused2;
 312 };
 313
 314 struct msqid_ds32
 315 {
 316         struct ipc_perm32 msg_perm;
 317         u32 msg_first;
 318         u32 msg_last;
 319         compat_time_t   msg_stime;
 320         compat_time_t   msg_rtime;
 321         compat_time_t   msg_ctime;
 322         u32 wwait;
 323         u32 rwait;
 324         unsigned short msg_cbytes;
 325         unsigned short msg_qnum;
 326         unsigned short msg_qbytes;
 327         compat_ipc_pid_t msg_lspid;
 328         compat_ipc_pid_t msg_lrpid;
 329 };
 330
 331 struct msqid64_ds32 {
 332         struct ipc64_perm_ds32 msg_perm;
 333         unsigned int   __pad1;
 334         compat_time_t msg_stime;
 335         unsigned int   __pad2;
 336         compat_time_t msg_rtime;
 337         unsigned int   __pad3;
 338         compat_time_t msg_ctime;
 339         unsigned int  msg_cbytes;
 340         unsigned int  msg_qnum;
 341         unsigned int  msg_qbytes;
 342         compat_pid_t msg_lspid;
 343         compat_pid_t msg_lrpid;
 344         unsigned int  __unused1;
 345         unsigned int  __unused2;
 346 };
 347
 348
 349 struct shmid_ds32 {
 350         struct ipc_perm32       shm_perm;
 351         int                     shm_segsz;
 352         compat_time_t         shm_atime;
 353         compat_time_t         shm_dtime;
 354         compat_time_t         shm_ctime;
 355         compat_ipc_pid_t    shm_cpid;
 356         compat_ipc_pid_t    shm_lpid;
 357         unsigned short          shm_nattch;
 358 };
 359
 360 struct shmid64_ds32 {
 361         struct ipc64_perm_ds32  shm_perm;
 362         compat_size_t   shm_segsz;
 363         compat_time_t   shm_atime;
 364         unsigned int            __unused1;
 365         compat_time_t   shm_dtime;
 366         unsigned int            __unused2;
 367         compat_time_t   shm_ctime;
 368         unsigned int            __unused3;
 369         compat_pid_t    shm_cpid;
 370         compat_pid_t    shm_lpid;
 371         unsigned int            shm_nattch;
 372         unsigned int            __unused4;
 373         unsigned int            __unused5;
 374 };
 375
 376 extern int sem_ctls[];
 377 #define sc_semopm       (sem_ctls[2])
 378 #define SEMOPM_FAST     64  /* ~ 372 bytes on stack */
 379
 380 static long
 381 do_sys32_semtimedop (int semid, struct sembuf *tsops, int nsops,
 382                      struct compat_timespec *timeout32)
 383 {
 384         struct sembuf *sops, fast_sops[SEMOPM_FAST];
 385         struct timespec t;
 386         mm_segment_t oldfs;
 387         long ret;
 388
 389         /* parameter checking precedence should mirror sys_semtimedop() */
 390         if (nsops < 1 || semid < 0)
 391                 return -EINVAL;
 392         if (nsops > sc_semopm)
 393                 return -E2BIG;
 394         if (nsops <= SEMOPM_FAST)
 395                 sops = fast_sops;
 396         else {
 397                 sops = kmalloc(nsops * sizeof(*sops), GFP_KERNEL);
 398                 if (sops == NULL)
 399                         return -ENOMEM;
 400         }
 401         if (copy_from_user(sops, tsops, nsops * sizeof(*tsops)) ||
 402             get_compat_timespec(&t, timeout32))
 403                 ret = -EFAULT;
 404         else {
 405                 oldfs = get_fs();
 406                 set_fs(KERNEL_DS);
 407                 ret = sys_semtimedop(semid, sops, nsops, &t);
 408                 set_fs(oldfs);
 409         }
 410         if (sops != fast_sops)
 411                 kfree(sops);
 412         return ret;
 413 }
 414
 415 #define IPCOP_MASK(__x) (1UL << (__x))
 416 static int do_sys32_semctl(int first, int second, int third, void *uptr)
 417 {
 418         union semun fourth;
 419         u32 pad;
 420         int err = -EINVAL;
 421
 422         if (!uptr)
 423                 goto out;
 424         err = -EFAULT;
 425         if (get_user (pad, (u32 *)uptr))
 426                 goto out;
 427         if(third == SETVAL)
 428                 fourth.val = (int)pad;
 429         else
 430                 fourth.__pad = (void *)A(pad);
 431         if (IPCOP_MASK (third) &
 432             (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SEM_INFO) | IPCOP_MASK (GETVAL) |
 433              IPCOP_MASK (GETPID) | IPCOP_MASK (GETNCNT) | IPCOP_MASK (GETZCNT) |
 434              IPCOP_MASK (GETALL) | IPCOP_MASK (SETALL) | IPCOP_MASK (IPC_RMID))) {
 435                 err = sys_semctl (first, second, third, fourth);
 436         } else if (third & IPC_64) {
 437                 struct semid64_ds s;
 438                 struct semid64_ds32 *usp = (struct semid64_ds32 *)A(pad);
 439                 mm_segment_t old_fs;
 440                 int need_back_translation;
 441
 442                 if (third == (IPC_SET|IPC_64)) {
 443                         err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
 444                         err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
 445                         err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
 446                         if (err)
 447                                 goto out;
 448                         fourth.__pad = &s;
 449                 }
 450                 need_back_translation =
 451                         (IPCOP_MASK (third) &
 452                          (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
 453                 if (need_back_translation)
 454                         fourth.__pad = &s;
 455                 old_fs = get_fs ();
 456                 set_fs (KERNEL_DS);
 457                 err = sys_semctl (first, second, third, fourth);
 458                 set_fs (old_fs);
 459                 if (need_back_translation) {
 460                         int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
 461                         err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
 462                         err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
 463                         err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
 464                         err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
 465                         err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
 466                         err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
 467                         err2 |= __put_user (s.sem_otime, &usp->sem_otime);
 468                         err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
 469                         err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
 470                         if (err2) err = -EFAULT;
 471                 }
 472         } else {
 473                 struct semid_ds s;
 474                 struct semid_ds32 *usp = (struct semid_ds32 *)A(pad);
 475                 mm_segment_t old_fs;
 476                 int need_back_translation;
 477
 478                 if (third == IPC_SET) {
 479                         err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
 480                         err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
 481                         err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
 482                         if (err)
 483                                 goto out;
 484                         fourth.__pad = &s;
 485                 }
 486                 need_back_translation =
 487                         (IPCOP_MASK (third) &
 488                          (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
 489                 if (need_back_translation)
 490                         fourth.__pad = &s;
 491                 old_fs = get_fs ();
 492                 set_fs (KERNEL_DS);
 493                 err = sys_semctl (first, second, third, fourth);
 494                 set_fs (old_fs);
 495                 if (need_back_translation) {
 496                         int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
 497                         err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
 498                         err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
 499                         err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
 500                         err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
 501                         err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
 502                         err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
 503                         err2 |= __put_user (s.sem_otime, &usp->sem_otime);
 504                         err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
 505                         err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
 506                         if (err2) err = -EFAULT;
 507                 }
 508         }
 509 out:
 510         return err;
 511 }
 512
 513 static int do_sys32_msgsnd (int first, int second, int third, void *uptr)
 514 {
 515         struct msgbuf *p = kmalloc (second + sizeof (struct msgbuf), GFP_USER);
 516         struct msgbuf32 *up = (struct msgbuf32 *)uptr;
 517         mm_segment_t old_fs;
 518         int err;
 519
 520         if (!p)
 521                 return -ENOMEM;
 522
 523         err = -EINVAL;
 524         if (second > MSGMAX || first < 0 || second < 0)
 525                 goto out;
 526
 527         err = -EFAULT;
 528         if (!uptr)
 529                 goto out;
 530         if (get_user (p->mtype, &up->mtype) ||
 531             __copy_from_user (p->mtext, &up->mtext, second))
 532                 goto out;
 533         old_fs = get_fs ();
 534         set_fs (KERNEL_DS);
 535         err = sys_msgsnd (first, p, second, third);
 536         set_fs (old_fs);
 537 out:
 538         kfree (p);
 539         return err;
 540 }
 541
 542 static int do_sys32_msgrcv (int first, int second, int msgtyp, int third,
 543                             int version, void *uptr)
 544 {
 545         struct msgbuf32 *up;
 546         struct msgbuf *p;
 547         mm_segment_t old_fs;
 548         int err;
 549
 550         if (first < 0 || second < 0)
 551                 return -EINVAL;
 552
 553         if (!version) {
 554                 struct ipc_kludge_32 *uipck = (struct ipc_kludge_32 *)uptr;
 555                 struct ipc_kludge_32 ipck;
 556
 557                 err = -EINVAL;
 558                 if (!uptr)
 559                         goto out;
 560                 err = -EFAULT;
 561                 if (copy_from_user (&ipck, uipck, sizeof (struct ipc_kludge_32)))
 562                         goto out;
 563                 uptr = (void *)A(ipck.msgp);
 564                 msgtyp = ipck.msgtyp;
 565         }
 566         err = -ENOMEM;
 567         p = kmalloc (second + sizeof (struct msgbuf), GFP_USER);
 568         if (!p)
 569                 goto out;
 570         old_fs = get_fs ();
 571         set_fs (KERNEL_DS);
 572         err = sys_msgrcv (first, p, second, msgtyp, third);
 573         set_fs (old_fs);
 574         if (err < 0)
 575                 goto free_then_out;
 576         up = (struct msgbuf32 *)uptr;
 577         if (put_user (p->mtype, &up->mtype) ||
 578             __copy_to_user (&up->mtext, p->mtext, err))
 579                 err = -EFAULT;
 580 free_then_out:
 581         kfree (p);
 582 out:
 583         return err;
 584 }
 585
 586 static int do_sys32_msgctl (int first, int second, void *uptr)
 587 {
 588         int err;
 589
 590         if (IPCOP_MASK (second) &
 591             (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (MSG_INFO) |
 592              IPCOP_MASK (IPC_RMID))) {
 593                 err = sys_msgctl (first, second, (struct msqid_ds *)uptr);
 594         } else if (second & IPC_64) {
 595                 struct msqid64_ds m;
 596                 struct msqid64_ds32 *up = (struct msqid64_ds32 *)uptr;
 597                 mm_segment_t old_fs;
 598
 599                 if (second == (IPC_SET|IPC_64)) {
 600                         err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
 601                         err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
 602                         err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
 603                         err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
 604                         if (err)
 605                                 goto out;
 606                 }
 607                 old_fs = get_fs ();
 608                 set_fs (KERNEL_DS);
 609                 err = sys_msgctl (first, second, (struct msqid_ds *)&m);
 610                 set_fs (old_fs);
 611                 if (IPCOP_MASK (second) &
 612                     (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
 613                         int err2 = put_user (m.msg_perm.key, &up->msg_perm.key);
 614                         err2 |= __put_user (high2lowuid(m.msg_perm.uid), &up->msg_perm.uid);
 615                         err2 |= __put_user (high2lowgid(m.msg_perm.gid), &up->msg_perm.gid);
 616                         err2 |= __put_user (high2lowuid(m.msg_perm.cuid), &up->msg_perm.cuid);
 617                         err2 |= __put_user (high2lowgid(m.msg_perm.cgid), &up->msg_perm.cgid);
 618                         err2 |= __put_user (m.msg_perm.mode, &up->msg_perm.mode);
 619                         err2 |= __put_user (m.msg_perm.seq, &up->msg_perm.seq);
 620                         err2 |= __put_user (m.msg_stime, &up->msg_stime);
 621                         err2 |= __put_user (m.msg_rtime, &up->msg_rtime);
 622                         err2 |= __put_user (m.msg_ctime, &up->msg_ctime);
 623                         err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
 624                         err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
 625                         err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
 626                         err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
 627                         err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
 628                         if (err2)
 629                                 err = -EFAULT;
 630                 }
 631         } else {
 632                 struct msqid_ds m;
 633                 struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;
 634                 mm_segment_t old_fs;
 635
 636                 if (second == IPC_SET) {
 637                         err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
 638                         err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
 639                         err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
 640                         err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
 641                         if (err)
 642                                 goto out;
 643                 }
 644                 old_fs = get_fs ();
 645                 set_fs (KERNEL_DS);
 646                 err = sys_msgctl (first, second, &m);
 647                 set_fs (old_fs);
 648                 if (IPCOP_MASK (second) &
 649                     (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
 650                         int err2 = put_user (m.msg_perm.key, &up->msg_perm.key);
 651                         err2 |= __put_user (high2lowuid(m.msg_perm.uid), &up->msg_perm.uid);
 652                         err2 |= __put_user (high2lowgid(m.msg_perm.gid), &up->msg_perm.gid);
 653                         err2 |= __put_user (high2lowuid(m.msg_perm.cuid), &up->msg_perm.cuid);
 654                         err2 |= __put_user (high2lowgid(m.msg_perm.cgid), &up->msg_perm.cgid);
 655                         err2 |= __put_user (m.msg_perm.mode, &up->msg_perm.mode);
 656                         err2 |= __put_user (m.msg_perm.seq, &up->msg_perm.seq);
 657                         err2 |= __put_user (m.msg_stime, &up->msg_stime);
 658                         err2 |= __put_user (m.msg_rtime, &up->msg_rtime);
 659                         err2 |= __put_user (m.msg_ctime, &up->msg_ctime);
 660                         err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
 661                         err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
 662                         err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
 663                         err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
 664                         err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
 665                         if (err2)
 666                                 err = -EFAULT;
 667                 }
 668         }
 669
 670 out:
 671         return err;
 672 }
 673
 674 static int do_sys32_shmat (int first, int second, int third, int version, void *uptr)
 675 {
 676         unsigned long raddr;
 677         u32 *uaddr = (u32 *)A((u32)third);
 678         int err = -EINVAL;
 679
 680         if (version == 1)
 681                 goto out;
 682         err = sys_shmat (first, uptr, second, &raddr);
 683         if (err)
 684                 goto out;
 685         err = put_user (raddr, uaddr);
 686 out:
 687         return err;
 688 }
 689
 690 static int do_sys32_shmctl (int first, int second, void *uptr)
 691 {
 692         int err;
 693
 694         if (IPCOP_MASK (second) &
 695             (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SHM_LOCK) | IPCOP_MASK (SHM_UNLOCK) |
 696              IPCOP_MASK (IPC_RMID))) {
 697                 if (second == (IPC_INFO|IPC_64))
 698                         second = IPC_INFO; /* So that we don't have to translate it */
 699                 err = sys_shmctl (first, second, (struct shmid_ds *)uptr);
 700         } else if ((second & IPC_64) && second != (SHM_INFO|IPC_64)) {
 701                 struct shmid64_ds s;
 702                 struct shmid64_ds32 *up = (struct shmid64_ds32 *)uptr;
 703                 mm_segment_t old_fs;
 704
 705                 if (second == (IPC_SET|IPC_64)) {
 706                         err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
 707                         err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
 708                         err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
 709                         if (err)
 710                                 goto out;
 711                 }
 712                 old_fs = get_fs ();
 713                 set_fs (KERNEL_DS);
 714                 err = sys_shmctl (first, second, (struct shmid_ds *)&s);
 715                 set_fs (old_fs);
 716                 if (err < 0)
 717                         goto out;
 718
 719                 /* Mask it even in this case so it becomes a CSE. */
 720                 if (IPCOP_MASK (second) &
 721                     (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
 722                         int err2 = put_user (s.shm_perm.key, &up->shm_perm.key);
 723                         err2 |= __put_user (high2lowuid(s.shm_perm.uid), &up->shm_perm.uid);
 724                         err2 |= __put_user (high2lowgid(s.shm_perm.gid), &up->shm_perm.gid);
 725                         err2 |= __put_user (high2lowuid(s.shm_perm.cuid), &up->shm_perm.cuid);
 726                         err2 |= __put_user (high2lowgid(s.shm_perm.cgid), &up->shm_perm.cgid);
 727                         err2 |= __put_user (s.shm_perm.mode, &up->shm_perm.mode);
 728                         err2 |= __put_user (s.shm_perm.seq, &up->shm_perm.seq);
 729                         err2 |= __put_user (s.shm_atime, &up->shm_atime);
 730                         err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
 731                         err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
 732                         err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
 733                         err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
 734                         err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
 735                         err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
 736                         if (err2)
 737                                 err = -EFAULT;
 738                 }
 739         } else {
 740                 struct shmid_ds s;
 741                 struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
 742                 mm_segment_t old_fs;
 743
 744                 second &= ~IPC_64;
 745                 if (second == IPC_SET) {
 746                         err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
 747                         err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
 748                         err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
 749                         if (err)
 750                                 goto out;
 751                 }
 752                 old_fs = get_fs ();
 753                 set_fs (KERNEL_DS);
 754                 err = sys_shmctl (first, second, &s);
 755                 set_fs (old_fs);
 756                 if (err < 0)
 757                         goto out;
 758
 759                 /* Mask it even in this case so it becomes a CSE. */
 760                 if (second == SHM_INFO) {
 761                         struct shm_info32 {
 762                                 int used_ids;
 763                                 u32 shm_tot, shm_rss, shm_swp;
 764                                 u32 swap_attempts, swap_successes;
 765                         } *uip = (struct shm_info32 *)uptr;
 766                         struct shm_info *kp = (struct shm_info *)&s;
 767                         int err2 = put_user (kp->used_ids, &uip->used_ids);
 768                         err2 |= __put_user (kp->shm_tot, &uip->shm_tot);
 769                         err2 |= __put_user (kp->shm_rss, &uip->shm_rss);
 770                         err2 |= __put_user (kp->shm_swp, &uip->shm_swp);
 771                         err2 |= __put_user (kp->swap_attempts, &uip->swap_attempts);
 772                         err2 |= __put_user (kp->swap_successes, &uip->swap_successes);
 773                         if (err2)
 774                                 err = -EFAULT;
 775                 } else if (IPCOP_MASK (second) &
 776                            (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
 777                         int err2 = put_user (s.shm_perm.key, &up->shm_perm.key);
 778                         err2 |= __put_user (high2lowuid(s.shm_perm.uid), &up->shm_perm.uid);
 779                         err2 |= __put_user (high2lowgid(s.shm_perm.gid), &up->shm_perm.gid);
 780                         err2 |= __put_user (high2lowuid(s.shm_perm.cuid), &up->shm_perm.cuid);
 781                         err2 |= __put_user (high2lowgid(s.shm_perm.cgid), &up->shm_perm.cgid);
 782                         err2 |= __put_user (s.shm_perm.mode, &up->shm_perm.mode);
 783                         err2 |= __put_user (s.shm_perm.seq, &up->shm_perm.seq);
 784                         err2 |= __put_user (s.shm_atime, &up->shm_atime);
 785                         err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
 786                         err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
 787                         err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
 788                         err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
 789                         err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
 790                         err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
 791                         if (err2)
 792                                 err = -EFAULT;
 793                 }
 794         }
 795 out:
 796         return err;
 797 }
 798
 799 /*
 800  * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation.
 801  *
 802  * This is really horribly ugly.
 803  */
 804 asmlinkage int sys32_ipc (u32 call, int first, int second, int third, u32 ptr)
 805 {
 806         int version, err;
 807
 808         version = call >> 16; /* hack for backward compatibility */
 809         call &= 0xffff;
 810
 811         if(version)
 812                 return -EINVAL;
 813
 814         if (call <= SEMTIMEDOP)
 815                 switch (call) {
 816                 case SEMTIMEDOP:
 817                         if (third) {
 818                                 err = do_sys32_semtimedop(first,
 819                                         (struct sembuf *)AA(ptr),
 820                                         second,
 821                                         (struct compat_timespec *)
 822                                                 AA((u32)third));
 823                                 goto out;
 824                         }
 825                         /* else fall through for normal semop() */
 826                 case SEMOP:
 827                         /* struct sembuf is the same on 32 and 64bit :)) */
 828                         err = sys_semtimedop (first, (struct sembuf *)AA(ptr),
 829                                               second, NULL);
 830                         goto out;
 831                 case SEMGET:
 832                         err = sys_semget (first, second, third);
 833                         goto out;
 834                 case SEMCTL:
 835                         err = do_sys32_semctl (first, second, third, (void *)AA(ptr));
 836                         goto out;
 837                 default:
 838                         err = -EINVAL;
 839                         goto out;
 840                 };
 841         if (call <= MSGCTL)
 842                 switch (call) {
 843                 case MSGSND:
 844                         err = do_sys32_msgsnd (first, second, third, (void *)AA(ptr));
 845                         goto out;
 846                 case MSGRCV:
 847                         err = do_sys32_msgrcv (first, second, 0, third,
 848                                                version, (void *)AA(ptr));
 849                         goto out;
 850                 case MSGGET:
 851                         err = sys_msgget ((key_t) first, second);
 852                         goto out;
 853                 case MSGCTL:
 854                         err = do_sys32_msgctl (first, second, (void *)AA(ptr));
 855                         goto out;
 856                 default:
 857                         err = -EINVAL;
 858                         goto out;
 859                 }
 860         if (call <= SHMCTL)
 861                 switch (call) {
 862                 case SHMAT:
 863                         err = do_sys32_shmat (first, second, third,
 864                                               version, (void *)AA(ptr));
 865                         goto out;
 866                 case SHMDT:
 867                         err = sys_shmdt ((char *)AA(ptr));
 868                         goto out;
 869                 case SHMGET:
 870                         err = sys_shmget (first, second, third);
 871                         goto out;
 872                 case SHMCTL:
 873                         err = do_sys32_shmctl (first, second, (void *)AA(ptr));
 874                         goto out;
 875                 default:
 876                         err = -EINVAL;
 877                         goto out;
 878                 }
 879
 880         err = -EINVAL;
 881
 882 out:
 883         return err;
 884 }
 885
 886 extern asmlinkage long sys_truncate(const char * path, unsigned long length);
 887 extern asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
 888
 889 asmlinkage int sys32_truncate64(const char * path, unsigned long high, unsigned long low)
 890 {
 891         if ((int)high < 0)
 892                 return -EINVAL;
 893         else
 894                 return sys_truncate(path, (high << 32) | low);
 895 }
 896
 897 asmlinkage int sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
 898 {
 899         if ((int)high < 0)
 900                 return -EINVAL;
 901         else
 902                 return sys_ftruncate(fd, (high << 32) | low);
 903 }
 904
 905 typedef ssize_t (*io_fn_t)(struct file *, char *, size_t, loff_t *);
 906 typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
 907
 908 static long do_readv_writev32(int type, struct file *file,
 909                               const struct compat_iovec *vector, u32 count)
 910 {
 911         unsigned long tot_len;
 912         struct iovec iovstack[UIO_FASTIOV];
 913         struct iovec *iov=iovstack, *ivp;
 914         struct inode *inode;
 915         long retval, i;
 916         io_fn_t fn;
 917         iov_fn_t fnv;
 918
 919         /* First get the "struct iovec" from user memory and
 920          * verify all the pointers
 921          */
 922         if (!count)
 923                 return 0;
 924         if (verify_area(VERIFY_READ, vector, sizeof(struct compat_iovec)*count))
 925                 return -EFAULT;
 926         if (count > UIO_MAXIOV)
 927                 return -EINVAL;
 928         if (count > UIO_FASTIOV) {
 929                 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
 930                 if (!iov)
 931                         return -ENOMEM;
 932         }
 933
 934         tot_len = 0;
 935         i = count;
 936         ivp = iov;
 937         while(i > 0) {
 938                 u32 len;
 939                 u32 buf;
 940
 941                 __get_user(len, &vector->iov_len);
 942                 __get_user(buf, &vector->iov_base);
 943                 tot_len += len;
 944                 ivp->iov_base = (void *)A(buf);
 945                 ivp->iov_len = (__kernel_size_t) len;
 946                 vector++;
 947                 ivp++;
 948                 i--;
 949         }
 950
 951         inode = file->f_dentry->d_inode;
 952         /* VERIFY_WRITE actually means a read, as we write to user space */
 953         retval = locks_verify_area((type == VERIFY_WRITE
 954                                     ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
 955                                    inode, file, file->f_pos, tot_len);
 956         if (retval)
 957                 goto out;
 958
 959         /* VERIFY_WRITE actually means a read, as we write to user space */
 960         fnv = (type == VERIFY_WRITE ? file->f_op->readv : file->f_op->writev);
 961         if (fnv) {
 962                 retval = fnv(file, iov, count, &file->f_pos);
 963                 goto out;
 964         }
 965
 966         fn = (type == VERIFY_WRITE ? file->f_op->read :
 967               (io_fn_t) file->f_op->write);
 968
 969         ivp = iov;
 970         while (count > 0) {
 971                 void * base;
 972                 int len, nr;
 973
 974                 base = ivp->iov_base;
 975                 len = ivp->iov_len;
 976                 ivp++;
 977                 count--;
 978                 nr = fn(file, base, len, &file->f_pos);
 979                 if (nr < 0) {
 980                         if (!retval)
 981                                 retval = nr;
 982                         break;
 983                 }
 984                 retval += nr;
 985                 if (nr != len)
 986                         break;
 987         }
 988 out:
 989         if (iov != iovstack)
 990                 kfree(iov);
 991
 992         return retval;
 993 }
 994
 995 asmlinkage long sys32_readv(int fd, struct compat_iovec *vector, u32 count)
 996 {
 997         struct file *file;
 998         long ret = -EBADF;
 999
1000         file = fget(fd);
1001         if(!file)
1002                 goto bad_file;
1003
1004         if (file->f_op && (file->f_mode & FMODE_READ) &&
1005             (file->f_op->readv || file->f_op->read))
1006                 ret = do_readv_writev32(VERIFY_WRITE, file, vector, count);
1007         fput(file);
1008
1009 bad_file:
1010         return ret;
1011 }
1012
1013 asmlinkage long sys32_writev(int fd, struct compat_iovec *vector, u32 count)
1014 {
1015         struct file *file;
1016         int ret = -EBADF;
1017
1018         file = fget(fd);
1019         if(!file)
1020                 goto bad_file;
1021         if (file->f_op && (file->f_mode & FMODE_WRITE) &&
1022             (file->f_op->writev || file->f_op->write))
1023                 ret = do_readv_writev32(VERIFY_READ, file, vector, count);
1024         fput(file);
1025
1026 bad_file:
1027         return ret;
1028 }
1029
1030 /* readdir & getdents */
1031
1032 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
1033 #define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
1034
1035 struct old_linux_dirent32 {
1036         u32             d_ino;
1037         u32             d_offset;
1038         unsigned short  d_namlen;
1039         char            d_name[1];
1040 };
1041
1042 struct readdir_callback32 {
1043         struct old_linux_dirent32 * dirent;
1044         int count;
1045 };
1046
1047 static int fillonedir(void * __buf, const char * name, int namlen,
1048                       loff_t offset, ino_t ino, unsigned int d_type)
1049 {
1050         struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
1051         struct old_linux_dirent32 * dirent;
1052
1053         if (buf->count)
1054                 return -EINVAL;
1055         buf->count++;
1056         dirent = buf->dirent;
1057         put_user(ino, &dirent->d_ino);
1058         put_user(offset, &dirent->d_offset);
1059         put_user(namlen, &dirent->d_namlen);
1060         copy_to_user(dirent->d_name, name, namlen);
1061         put_user(0, dirent->d_name + namlen);
1062         return 0;
1063 }
1064
1065 asmlinkage int old32_readdir(unsigned int fd, struct old_linux_dirent32 *dirent, unsigned int count)
1066 {
1067         int error = -EBADF;
1068         struct file * file;
1069         struct readdir_callback32 buf;
1070
1071         file = fget(fd);
1072         if (!file)
1073                 goto out;
1074
1075         buf.count = 0;
1076         buf.dirent = dirent;
1077
1078         error = vfs_readdir(file, fillonedir, &buf);
1079         if (error < 0)
1080                 goto out_putf;
1081         error = buf.count;
1082
1083 out_putf:
1084         fput(file);
1085 out:
1086         return error;
1087 }
1088
1089 struct linux_dirent32 {
1090         u32             d_ino;
1091         u32             d_off;
1092         unsigned short  d_reclen;
1093         char            d_name[1];
1094 };
1095
1096 struct getdents_callback32 {
1097         struct linux_dirent32 * current_dir;
1098         struct linux_dirent32 * previous;
1099         int count;
1100         int error;
1101 };
1102
1103 static int filldir(void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
1104                    unsigned int d_type)
1105 {
1106         struct linux_dirent32 * dirent;
1107         struct getdents_callback32 * buf = (struct getdents_callback32 *) __buf;
1108         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
1109
1110         buf->error = -EINVAL;   /* only used if we fail.. */
1111         if (reclen > buf->count)
1112                 return -EINVAL;
1113         dirent = buf->previous;
1114         if (dirent)
1115                 put_user(offset, &dirent->d_off);
1116         dirent = buf->current_dir;
1117         buf->previous = dirent;
1118         put_user(ino, &dirent->d_ino);
1119         put_user(reclen, &dirent->d_reclen);
1120         copy_to_user(dirent->d_name, name, namlen);
1121         put_user(0, dirent->d_name + namlen);
1122         ((char *) dirent) += reclen;
1123         buf->current_dir = dirent;
1124         buf->count -= reclen;
1125         return 0;
1126 }
1127
1128 asmlinkage int sys32_getdents(unsigned int fd, struct linux_dirent32 *dirent, unsigned int count)
1129 {
1130         struct file * file;
1131         struct linux_dirent32 * lastdirent;
1132         struct getdents_callback32 buf;
1133         int error = -EBADF;
1134
1135         file = fget(fd);
1136         if (!file)
1137                 goto out;
1138
1139         buf.current_dir = dirent;
1140         buf.previous = NULL;
1141         buf.count = count;
1142         buf.error = 0;
1143
1144         error = vfs_readdir(file, filldir, &buf);
1145         if (error < 0)
1146                 goto out_putf;
1147         lastdirent = buf.previous;
1148         error = buf.error;
1149         if(lastdirent) {
1150                 put_user(file->f_pos, &lastdirent->d_off);
1151                 error = count - buf.count;
1152         }
1153 out_putf:
1154         fput(file);
1155 out:
1156         return error;
1157 }
1158
1159 /* end of readdir & getdents */
1160
1161 /*
1162  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
1163  * 64-bit unsigned longs.
1164  */
1165
1166 static inline int
1167 get_fd_set32(unsigned long n, unsigned long *fdset, u32 *ufdset)
1168 {
1169         if (ufdset) {
1170                 unsigned long odd;
1171
1172                 if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32)))
1173                         return -EFAULT;
1174
1175                 odd = n & 1UL;
1176                 n &= ~1UL;
1177                 while (n) {
1178                         unsigned long h, l;
1179                         __get_user(l, ufdset);
1180                         __get_user(h, ufdset+1);
1181                         ufdset += 2;
1182                         *fdset++ = h << 32 | l;
1183                         n -= 2;
1184                 }
1185                 if (odd)
1186                         __get_user(*fdset, ufdset);
1187         } else {
1188                 /* Tricky, must clear full unsigned long in the
1189                  * kernel fdset at the end, this makes sure that
1190                  * actually happens.
1191                  */
1192                 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
1193         }
1194         return 0;
1195 }
1196
1197 static inline void
1198 set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
1199 {
1200         unsigned long odd;
1201
1202         if (!ufdset)
1203                 return;
1204
1205         odd = n & 1UL;
1206         n &= ~1UL;
1207         while (n) {
1208                 unsigned long h, l;
1209                 l = *fdset++;
1210                 h = l >> 32;
1211                 __put_user(l, ufdset);
1212                 __put_user(h, ufdset+1);
1213                 ufdset += 2;
1214                 n -= 2;
1215         }
1216         if (odd)
1217                 __put_user(*fdset, ufdset);
1218 }
1219
1220 #define MAX_SELECT_SECONDS \
1221         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
1222
1223 asmlinkage int sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, u32 tvp_x)
1224 {
1225         fd_set_bits fds;
1226         struct compat_timeval *tvp = (struct compat_timeval *)AA(tvp_x);
1227         char *bits;
1228         unsigned long nn;
1229         long timeout;
1230         int ret, size;
1231
1232         timeout = MAX_SCHEDULE_TIMEOUT;
1233         if (tvp) {
1234                 int sec, usec;
1235
1236                 if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
1237                     || (ret = __get_user(sec, &tvp->tv_sec))
1238                     || (ret = __get_user(usec, &tvp->tv_usec)))
1239                         goto out_nofds;
1240
1241                 ret = -EINVAL;
1242                 if(sec < 0 || usec < 0)
1243                         goto out_nofds;
1244
1245                 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1246                         timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
1247                         timeout += sec * (unsigned long) HZ;
1248                 }
1249         }
1250
1251         ret = -EINVAL;
1252         if (n < 0)
1253                 goto out_nofds;
1254         if (n > current->files->max_fdset)
1255                 n = current->files->max_fdset;
1256
1257         /*
1258          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1259          * since we used fdset we need to allocate memory in units of
1260          * long-words.
1261          */
1262         ret = -ENOMEM;
1263         size = FDS_BYTES(n);
1264         bits = kmalloc(6 * size, GFP_KERNEL);
1265         if (!bits)
1266                 goto out_nofds;
1267         fds.in      = (unsigned long *)  bits;
1268         fds.out     = (unsigned long *) (bits +   size);
1269         fds.ex      = (unsigned long *) (bits + 2*size);
1270         fds.res_in  = (unsigned long *) (bits + 3*size);
1271         fds.res_out = (unsigned long *) (bits + 4*size);
1272         fds.res_ex  = (unsigned long *) (bits + 5*size);
1273
1274         nn = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
1275         if ((ret = get_fd_set32(nn, fds.in, inp)) ||
1276             (ret = get_fd_set32(nn, fds.out, outp)) ||
1277             (ret = get_fd_set32(nn, fds.ex, exp)))
1278                 goto out;
1279         zero_fd_set(n, fds.res_in);
1280         zero_fd_set(n, fds.res_out);
1281         zero_fd_set(n, fds.res_ex);
1282
1283         ret = do_select(n, &fds, &timeout);
1284
1285         if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
1286                 int sec = 0, usec = 0;
1287                 if (timeout) {
1288                         sec = timeout / HZ;
1289                         usec = timeout % HZ;
1290                         usec *= (1000000/HZ);
1291                 }
1292                 put_user(sec, &tvp->tv_sec);
1293                 put_user(usec, &tvp->tv_usec);
1294         }
1295
1296         if (ret < 0)
1297                 goto out;
1298         if (!ret) {
1299                 ret = -ERESTARTNOHAND;
1300                 if (signal_pending(current))
1301                         goto out;
1302                 ret = 0;
1303         }
1304
1305         set_fd_set32(nn, inp, fds.res_in);
1306         set_fd_set32(nn, outp, fds.res_out);
1307         set_fd_set32(nn, exp, fds.res_ex);
1308
1309 out:
1310         kfree(bits);
1311 out_nofds:
1312         return ret;
1313 }
1314
1315 int cp_compat_stat(struct kstat *stat, struct compat_stat *statbuf)
1316 {
1317         int err;
1318
1319         err = put_user(stat->dev, &statbuf->st_dev);
1320         err |= put_user(stat->ino, &statbuf->st_ino);
1321         err |= put_user(stat->mode, &statbuf->st_mode);
1322         err |= put_user(stat->nlink, &statbuf->st_nlink);
1323         err |= put_user(high2lowuid(stat->uid), &statbuf->st_uid);
1324         err |= put_user(high2lowgid(stat->gid), &statbuf->st_gid);
1325         err |= put_user(stat->rdev, &statbuf->st_rdev);
1326         err |= put_user(stat->size, &statbuf->st_size);
1327         err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
1328         err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
1329         err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
1330         err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
1331         err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
1332         err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
1333         err |= put_user(stat->blksize, &statbuf->st_blksize);
1334         err |= put_user(stat->blocks, &statbuf->st_blocks);
1335 /* fixme
1336         err |= put_user(0, &statbuf->__unused4[0]);
1337         err |= put_user(0, &statbuf->__unused4[1]);
1338 */
1339         return err;
1340 }
1341
1342 extern asmlinkage int sys_sysfs(int option, unsigned long arg1, unsigned long arg2);
1343
1344 asmlinkage int sys32_sysfs(int option, u32 arg1, u32 arg2)
1345 {
1346         return sys_sysfs(option, arg1, arg2);
1347 }
1348
1349 struct ncp_mount_data32 {
1350         int version;
1351         unsigned int ncp_fd;
1352         compat_uid_t mounted_uid;
1353         compat_pid_t wdog_pid;
1354         unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
1355         unsigned int time_out;
1356         unsigned int retry_count;
1357         unsigned int flags;
1358         compat_uid_t uid;
1359         compat_gid_t gid;
1360         compat_mode_t file_mode;
1361         compat_mode_t dir_mode;
1362 };
1363
1364 static void *do_ncp_super_data_conv(void *raw_data)
1365 {
1366         struct ncp_mount_data *n = (struct ncp_mount_data *)raw_data;
1367         struct ncp_mount_data32 *n32 = (struct ncp_mount_data32 *)raw_data;
1368
1369         n->dir_mode = n32->dir_mode;
1370         n->file_mode = n32->file_mode;
1371         n->gid = low2highgid(n32->gid);
1372         n->uid = low2highuid(n32->uid);
1373         memmove (n->mounted_vol, n32->mounted_vol, (sizeof (n32->mounted_vol) + 3 * sizeof (unsigned int)));
1374         n->wdog_pid = n32->wdog_pid;
1375         n->mounted_uid = low2highuid(n32->mounted_uid);
1376         return raw_data;
1377 }
1378
1379 struct smb_mount_data32 {
1380         int version;
1381         compat_uid_t mounted_uid;
1382         compat_uid_t uid;
1383         compat_gid_t gid;
1384         compat_mode_t file_mode;
1385         compat_mode_t dir_mode;
1386 };
1387
1388 static void *do_smb_super_data_conv(void *raw_data)
1389 {
1390         struct smb_mount_data *s = (struct smb_mount_data *)raw_data;
1391         struct smb_mount_data32 *s32 = (struct smb_mount_data32 *)raw_data;
1392
1393         if (s32->version != SMB_MOUNT_OLDVERSION)
1394                 goto out;
1395         s->version = s32->version;
1396         s->mounted_uid = low2highuid(s32->mounted_uid);
1397         s->uid = low2highuid(s32->uid);
1398         s->gid = low2highgid(s32->gid);
1399         s->file_mode = s32->file_mode;
1400         s->dir_mode = s32->dir_mode;
1401 out:
1402         return raw_data;
1403 }
1404
1405 static int copy_mount_stuff_to_kernel(const void *user, unsigned long *kernel)
1406 {
1407         int i;
1408         unsigned long page;
1409         struct vm_area_struct *vma;
1410
1411         *kernel = 0;
1412         if(!user)
1413                 return 0;
1414         vma = find_vma(current->mm, (unsigned long)user);
1415         if(!vma || (unsigned long)user < vma->vm_start)
1416                 return -EFAULT;
1417         if(!(vma->vm_flags & VM_READ))
1418                 return -EFAULT;
1419         i = vma->vm_end - (unsigned long) user;
1420         if(PAGE_SIZE <= (unsigned long) i)
1421                 i = PAGE_SIZE - 1;
1422         if(!(page = __get_free_page(GFP_KERNEL)))
1423                 return -ENOMEM;
1424         if(copy_from_user((void *) page, user, i)) {
1425                 free_page(page);
1426                 return -EFAULT;
1427         }
1428         *kernel = page;
1429         return 0;
1430 }
1431
1432 #define SMBFS_NAME      "smbfs"
1433 #define NCPFS_NAME      "ncpfs"
1434
1435 asmlinkage int sys32_mount(char *dev_name, char *dir_name, char *type, unsigned long new_flags, u32 data)
1436 {
1437         unsigned long type_page = 0;
1438         unsigned long data_page = 0;
1439         unsigned long dev_page = 0;
1440         unsigned long dir_page = 0;
1441         int err, is_smb, is_ncp;
1442
1443         is_smb = is_ncp = 0;
1444
1445         err = copy_mount_stuff_to_kernel((const void *)type, &type_page);
1446         if (err)
1447                 goto out;
1448
1449         if (!type_page) {
1450                 err = -EINVAL;
1451                 goto out;
1452         }
1453
1454         is_smb = !strcmp((char *)type_page, SMBFS_NAME);
1455         is_ncp = !strcmp((char *)type_page, NCPFS_NAME);
1456
1457         err = copy_mount_stuff_to_kernel((const void *)AA(data), &data_page);
1458         if (err)
1459                 goto type_out;
1460
1461         err = copy_mount_stuff_to_kernel(dev_name, &dev_page);
1462         if (err)
1463                 goto data_out;
1464
1465         err = copy_mount_stuff_to_kernel(dir_name, &dir_page);
1466         if (err)
1467                 goto dev_out;
1468
1469         if (!is_smb && !is_ncp) {
1470                 lock_kernel();
1471                 err = do_mount((char*)dev_page, (char*)dir_page,
1472                                 (char*)type_page, new_flags, (char*)data_page);
1473                 unlock_kernel();
1474         } else {
1475                 if (is_ncp)
1476                         do_ncp_super_data_conv((void *)data_page);
1477                 else
1478                         do_smb_super_data_conv((void *)data_page);
1479
1480                 lock_kernel();
1481                 err = do_mount((char*)dev_page, (char*)dir_page,
1482                                 (char*)type_page, new_flags, (char*)data_page);
1483                 unlock_kernel();
1484         }
1485         free_page(dir_page);
1486
1487 dev_out:
1488         free_page(dev_page);
1489
1490 data_out:
1491         free_page(data_page);
1492
1493 type_out:
1494         free_page(type_page);
1495
1496 out:
1497         return err;
1498 }
1499
1500 struct rusage32 {
1501         struct compat_timeval ru_utime;
1502         struct compat_timeval ru_stime;
1503         s32    ru_maxrss;
1504         s32    ru_ixrss;
1505         s32    ru_idrss;
1506         s32    ru_isrss;
1507         s32    ru_minflt;
1508         s32    ru_majflt;
1509         s32    ru_nswap;
1510         s32    ru_inblock;
1511         s32    ru_oublock;
1512         s32    ru_msgsnd;
1513         s32    ru_msgrcv;
1514         s32    ru_nsignals;
1515         s32    ru_nvcsw;
1516         s32    ru_nivcsw;
1517 };
1518
1519 static int put_rusage (struct rusage32 *ru, struct rusage *r)
1520 {
1521         int err;
1522
1523         err = put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec);
1524         err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec);
1525         err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec);
1526         err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec);
1527         err |= __put_user (r->ru_maxrss, &ru->ru_maxrss);
1528         err |= __put_user (r->ru_ixrss, &ru->ru_ixrss);
1529         err |= __put_user (r->ru_idrss, &ru->ru_idrss);
1530         err |= __put_user (r->ru_isrss, &ru->ru_isrss);
1531         err |= __put_user (r->ru_minflt, &ru->ru_minflt);
1532         err |= __put_user (r->ru_majflt, &ru->ru_majflt);
1533         err |= __put_user (r->ru_nswap, &ru->ru_nswap);
1534         err |= __put_user (r->ru_inblock, &ru->ru_inblock);
1535         err |= __put_user (r->ru_oublock, &ru->ru_oublock);
1536         err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd);
1537         err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv);
1538         err |= __put_user (r->ru_nsignals, &ru->ru_nsignals);
1539         err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw);
1540         err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw);
1541         return err;
1542 }
1543
1544 struct sysinfo32 {
1545         s32 uptime;
1546         u32 loads[3];
1547         u32 totalram;
1548         u32 freeram;
1549         u32 sharedram;
1550         u32 bufferram;
1551         u32 totalswap;
1552         u32 freeswap;
1553         unsigned short procs;
1554         char _f[22];
1555 };
1556
1557 extern asmlinkage int sys_sysinfo(struct sysinfo *info);
1558
1559 asmlinkage int sys32_sysinfo(struct sysinfo32 *info)
1560 {
1561         struct sysinfo s;
1562         int ret, err;
1563         mm_segment_t old_fs = get_fs ();
1564
1565         set_fs (KERNEL_DS);
1566         ret = sys_sysinfo(&s);
1567         set_fs (old_fs);
1568         err = put_user (s.uptime, &info->uptime);
1569         err |= __put_user (s.loads[0], &info->loads[0]);
1570         err |= __put_user (s.loads[1], &info->loads[1]);
1571         err |= __put_user (s.loads[2], &info->loads[2]);
1572         err |= __put_user (s.totalram, &info->totalram);
1573         err |= __put_user (s.freeram, &info->freeram);
1574         err |= __put_user (s.sharedram, &info->sharedram);
1575         err |= __put_user (s.bufferram, &info->bufferram);
1576         err |= __put_user (s.totalswap, &info->totalswap);
1577         err |= __put_user (s.freeswap, &info->freeswap);
1578         err |= __put_user (s.procs, &info->procs);
1579         if (err)
1580                 return -EFAULT;
1581         return ret;
1582 }
1583
1584 extern asmlinkage int sys_sched_rr_get_interval(pid_t pid, struct timespec *interval);
1585
1586 asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid,
1587                 struct compat_timespec *interval)
1588 {
1589         struct timespec t;
1590         int ret;
1591         mm_segment_t old_fs = get_fs ();
1592
1593         set_fs (KERNEL_DS);
1594         ret = sys_sched_rr_get_interval(pid, &t);
1595         set_fs (old_fs);
1596         if (put_compat_timespec(&t, interval))
1597                 return -EFAULT;
1598         return ret;
1599 }
1600
1601 extern asmlinkage int sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset, size_t sigsetsize);
1602
1603 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set, compat_sigset_t *oset, compat_size_t sigsetsize)
1604 {
1605         sigset_t s;
1606         compat_sigset_t s32;
1607         int ret;
1608         mm_segment_t old_fs = get_fs();
1609
1610         if (set) {
1611                 if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
1612                         return -EFAULT;
1613                 switch (_NSIG_WORDS) {
1614                 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
1615                 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
1616                 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
1617                 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
1618                 }
1619         }
1620         set_fs (KERNEL_DS);
1621         ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sigsetsize);
1622         set_fs (old_fs);
1623         if (ret) return ret;
1624         if (oset) {
1625                 switch (_NSIG_WORDS) {
1626                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
1627                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
1628                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
1629                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
1630                 }
1631                 if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
1632                         return -EFAULT;
1633         }
1634         return 0;
1635 }
1636
1637 extern asmlinkage int sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
1638
1639 asmlinkage int sys32_rt_sigpending(compat_sigset_t *set, compat_size_t sigsetsize)
1640 {
1641         sigset_t s;
1642         compat_sigset_t s32;
1643         int ret;
1644         mm_segment_t old_fs = get_fs();
1645
1646         set_fs (KERNEL_DS);
1647         ret = sys_rt_sigpending(&s, sigsetsize);
1648         set_fs (old_fs);
1649         if (!ret) {
1650                 switch (_NSIG_WORDS) {
1651                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
1652                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
1653                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
1654                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
1655                 }
1656                 if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
1657                         return -EFAULT;
1658         }
1659         return ret;
1660 }
1661
1662 extern int
1663 copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from);
1664
1665 asmlinkage int
1666 sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
1667                       struct compat_timespec *uts, compat_size_t sigsetsize)
1668 {
1669         int ret, sig;
1670         sigset_t these;
1671         compat_sigset_t these32;
1672         struct timespec ts;
1673         siginfo_t info;
1674         long timeout = 0;
1675
1676         /* XXX: Don't preclude handling different sized sigset_t's.  */
1677         if (sigsetsize != sizeof(sigset_t))
1678                 return -EINVAL;
1679
1680         if (copy_from_user (&these32, uthese, sizeof(compat_sigset_t)))
1681                 return -EFAULT;
1682
1683         switch (_NSIG_WORDS) {
1684         case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
1685         case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
1686         case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
1687         case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
1688         }
1689
1690         /*
1691          * Invert the set of allowed signals to get those we
1692          * want to block.
1693          */
1694         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
1695         signotset(&these);
1696
1697         if (uts) {
1698                 if (get_compat_timespec(&ts, uts))
1699                         return -EINVAL;
1700                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
1701                     || ts.tv_sec < 0)
1702                         return -EINVAL;
1703         }
1704
1705         spin_lock_irq(&current->sighand->siglock);
1706         sig = dequeue_signal(current, &these, &info);
1707         if (!sig) {
1708                 /* None ready -- temporarily unblock those we're interested
1709                    in so that we'll be awakened when they arrive.  */
1710                 current->real_blocked = current->blocked;
1711                 sigandsets(&current->blocked, &current->blocked, &these);
1712                 recalc_sigpending();
1713                 spin_unlock_irq(&current->sighand->siglock);
1714
1715                 timeout = MAX_SCHEDULE_TIMEOUT;
1716                 if (uts)
1717                         timeout = (timespec_to_jiffies(&ts)
1718                                    + (ts.tv_sec || ts.tv_nsec));
1719
1720                 current->state = TASK_INTERRUPTIBLE;
1721                 timeout = schedule_timeout(timeout);
1722
1723                 spin_lock_irq(&current->sighand->siglock);
1724                 sig = dequeue_signal(current, &these, &info);
1725                 current->blocked = current->real_blocked;
1726                 siginitset(&current->real_blocked, 0);
1727                 recalc_sigpending();
1728         }
1729         spin_unlock_irq(&current->sighand->siglock);
1730
1731         if (sig) {
1732                 ret = sig;
1733                 if (uinfo) {
1734                         if (copy_siginfo_to_user32(uinfo, &info))
1735                                 ret = -EFAULT;
1736                 }
1737         } else {
1738                 ret = -EAGAIN;
1739                 if (timeout)
1740                         ret = -EINTR;
1741         }
1742
1743         return ret;
1744 }
1745
1746 extern asmlinkage int
1747 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
1748
1749 asmlinkage int
1750 sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
1751 {
1752         siginfo_t info;
1753         int ret;
1754         mm_segment_t old_fs = get_fs();
1755
1756         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
1757             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
1758                 return -EFAULT;
1759         set_fs (KERNEL_DS);
1760         ret = sys_rt_sigqueueinfo(pid, sig, &info);
1761         set_fs (old_fs);
1762         return ret;
1763 }
1764
1765 extern void check_pending(int signum);
1766
1767 /*
1768  * count32() counts the number of arguments/envelopes
1769  */
1770 static int count32(u32 * argv)
1771 {
1772         int i = 0;
1773
1774         if (argv != NULL) {
1775                 for (;;) {
1776                         u32 p; int error;
1777
1778                         error = get_user(p,argv);
1779                         if (error) return error;
1780                         if (!p) break;
1781                         argv++; i++;
1782                 }
1783         }
1784         return i;
1785 }
1786
1787 /*
1788  * 'copy_string32()' copies argument/envelope strings from user
1789  * memory to free pages in kernel mem. These are in a format ready
1790  * to be put directly into the top of new user memory.
1791  */
1792 static int copy_strings32(int argc, u32 * argv, struct linux_binprm *bprm)
1793 {
1794         while (argc-- > 0) {
1795                 u32 str;
1796                 int len;
1797                 unsigned long pos;
1798
1799                 if (get_user(str, argv + argc) ||
1800                     !str ||
1801                     !(len = strnlen_user((char *)A(str), bprm->p)))
1802                         return -EFAULT;
1803
1804                 if (bprm->p < len)
1805                         return -E2BIG;
1806
1807                 bprm->p -= len;
1808
1809                 pos = bprm->p;
1810                 while (len) {
1811                         char *kaddr;
1812                         struct page *page;
1813                         int offset, bytes_to_copy, new, err;
1814
1815                         offset = pos % PAGE_SIZE;
1816                         page = bprm->page[pos / PAGE_SIZE];
1817                         new = 0;
1818                         if (!page) {
1819                                 page = alloc_page(GFP_USER);
1820                                 bprm->page[pos / PAGE_SIZE] = page;
1821                                 if (!page)
1822                                         return -ENOMEM;
1823                                 new = 1;
1824                         }
1825                         kaddr = (char *)kmap(page);
1826
1827                         if (new && offset)
1828                                 memset(kaddr, 0, offset);
1829                         bytes_to_copy = PAGE_SIZE - offset;
1830                         if (bytes_to_copy > len) {
1831                                 bytes_to_copy = len;
1832                                 if (new)
1833                                         memset(kaddr+offset+len, 0,
1834                                                PAGE_SIZE-offset-len);
1835                         }
1836
1837                         err = copy_from_user(kaddr + offset, (char *)A(str),
1838                                              bytes_to_copy);
1839                         kunmap(page);
1840
1841                         if (err)
1842                                 return -EFAULT;
1843
1844                         pos += bytes_to_copy;
1845                         str += bytes_to_copy;
1846                         len -= bytes_to_copy;
1847                 }
1848         }
1849         return 0;
1850 }
1851
1852 /*
1853  * sys32_execve() executes a new program.
1854  */
1855 static inline int
1856 do_execve32(char * filename, u32 * argv, u32 * envp, struct pt_regs * regs)
1857 {
1858         struct linux_binprm bprm;
1859         struct file * file;
1860         int retval;
1861         int i;
1862
1863         sched_balance_exec();
1864
1865         file = open_exec(filename);
1866
1867         retval = PTR_ERR(file);
1868         if (IS_ERR(file))
1869                 return retval;
1870
1871         bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
1872         memset(bprm.page, 0, MAX_ARG_PAGES * sizeof(bprm.page[0]));
1873
1874         bprm.file = file;
1875         bprm.filename = filename;
1876         bprm.sh_bang = 0;
1877         bprm.loader = 0;
1878         bprm.exec = 0;
1879         bprm.mm = mm_alloc();
1880         retval = -ENOMEM;
1881         if (!bprm.mm)
1882                 goto out_file;
1883
1884         /* init_new_context is empty for s390x. */
1885
1886         bprm.argc = count32(argv);
1887         if ((retval = bprm.argc) < 0)
1888                 goto out_mm;
1889
1890         bprm.envc = count32(envp);
1891         if ((retval = bprm.envc) < 0)
1892                 goto out_mm;
1893
1894         retval = security_bprm_alloc(&bprm);
1895         if (retval)
1896                 goto out;
1897
1898         retval = prepare_binprm(&bprm);
1899         if (retval < 0)
1900                 goto out;
1901
1902         retval = copy_strings_kernel(1, &bprm.filename, &bprm);
1903         if (retval < 0)
1904                 goto out;
1905
1906         bprm.exec = bprm.p;
1907         retval = copy_strings32(bprm.envc, envp, &bprm);
1908         if (retval < 0)
1909                 goto out;
1910
1911         retval = copy_strings32(bprm.argc, argv, &bprm);
1912         if (retval < 0)
1913                 goto out;
1914
1915         retval = search_binary_handler(&bprm, regs);
1916         if (retval >= 0) {
1917                 /* execve success */
1918                 security_bprm_free(&bprm);
1919                 return retval;
1920         }
1921
1922 out:
1923         /* Something went wrong, return the inode and free the argument pages*/
1924         for (i=0 ; i<MAX_ARG_PAGES ; i++) {
1925                 struct page * page = bprm.page[i];
1926                 if (page)
1927                         __free_page(page);
1928         }
1929
1930         if (bprm.security)
1931                 security_bprm_free(&bprm);
1932
1933 out_mm:
1934         mmdrop(bprm.mm);
1935
1936 out_file:
1937         if (bprm.file) {
1938                 allow_write_access(bprm.file);
1939                 fput(bprm.file);
1940         }
1941
1942         return retval;
1943 }
1944
1945 /*
1946  * sys32_execve() executes a new program after the asm stub has set
1947  * things up for us.  This should basically do what I want it to.
1948  */
1949 asmlinkage int
1950 sys32_execve(struct pt_regs regs)
1951 {
1952         int error;
1953         char * filename;
1954
1955         filename = getname((char *)A(regs.orig_gpr2));
1956         error = PTR_ERR(filename);
1957         if (IS_ERR(filename))
1958                 goto out;
1959         error = do_execve32(filename, (u32 *)A(regs.gprs[3]), (u32 *)A(regs.gprs[4]), &regs);
1960         if (error == 0)
1961         {
1962                 current->ptrace &= ~PT_DTRACE;
1963                 current->thread.fp_regs.fpc=0;
1964                 __asm__ __volatile__
1965                         ("sr  0,0\n\t"
1966                          "sfpc 0,0\n\t"
1967                          : : :"0");
1968         }
1969         putname(filename);
1970 out:
1971         return error;
1972 }
1973
1974
1975 #ifdef CONFIG_MODULES
1976
1977 extern asmlinkage int sys_init_module(const char *name_user, struct module *mod_user);
1978
1979 /* Hey, when you're trying to init module, take time and prepare us a nice 64bit
1980  * module structure, even if from 32bit modutils... Why to pollute kernel... :))
1981  */
1982 asmlinkage int sys32_init_module(const char *name_user, struct module *mod_user)
1983 {
1984         return sys_init_module(name_user, mod_user);
1985 }
1986
1987 extern asmlinkage int sys_delete_module(const char *name_user);
1988
1989 asmlinkage int sys32_delete_module(const char *name_user)
1990 {
1991         return sys_delete_module(name_user);
1992 }
1993
1994 struct module_info32 {
1995         u32 addr;
1996         u32 size;
1997         u32 flags;
1998         s32 usecount;
1999 };
2000
2001 #else /* CONFIG_MODULES */
2002
2003 asmlinkage int
2004 sys32_init_module(const char *name_user, struct module *mod_user)
2005 {
2006         return -ENOSYS;
2007 }
2008
2009 asmlinkage int
2010 sys32_delete_module(const char *name_user)
2011 {
2012         return -ENOSYS;
2013 }
2014
2015 #endif  /* CONFIG_MODULES */
2016
2017 /* Stuff for NFS server syscalls... */
2018 struct nfsctl_svc32 {
2019         u16                     svc32_port;
2020         s32                     svc32_nthreads;
2021 };
2022
2023 struct nfsctl_client32 {
2024         s8                      cl32_ident[NFSCLNT_IDMAX+1];
2025         s32                     cl32_naddr;
2026         struct in_addr          cl32_addrlist[NFSCLNT_ADDRMAX];
2027         s32                     cl32_fhkeytype;
2028         s32                     cl32_fhkeylen;
2029         u8                      cl32_fhkey[NFSCLNT_KEYMAX];
2030 };
2031
2032 struct nfsctl_export32 {
2033         s8                      ex32_client[NFSCLNT_IDMAX+1];
2034         s8                      ex32_path[NFS_MAXPATHLEN+1];
2035         compat_dev_t    ex32_dev;
2036         compat_ino_t    ex32_ino;
2037         s32                     ex32_flags;
2038         compat_uid_t    ex32_anon_uid;
2039         compat_gid_t    ex32_anon_gid;
2040 };
2041
2042 struct nfsctl_fdparm32 {
2043         struct sockaddr         gd32_addr;
2044         s8                      gd32_path[NFS_MAXPATHLEN+1];
2045         s32                     gd32_version;
2046 };
2047
2048 struct nfsctl_fsparm32 {
2049         struct sockaddr         gd32_addr;
2050         s8                      gd32_path[NFS_MAXPATHLEN+1];
2051         s32                     gd32_maxlen;
2052 };
2053
2054 struct nfsctl_arg32 {
2055         s32                     ca32_version;   /* safeguard */
2056         union {
2057                 struct nfsctl_svc32     u32_svc;
2058                 struct nfsctl_client32  u32_client;
2059                 struct nfsctl_export32  u32_export;
2060                 struct nfsctl_fdparm32  u32_getfd;
2061                 struct nfsctl_fsparm32  u32_getfs;
2062         } u;
2063 #define ca32_svc        u.u32_svc
2064 #define ca32_client     u.u32_client
2065 #define ca32_export     u.u32_export
2066 #define ca32_getfd      u.u32_getfd
2067 #define ca32_getfs      u.u32_getfs
2068 #define ca32_authd      u.u32_authd
2069 };
2070
2071 union nfsctl_res32 {
2072         __u8                    cr32_getfh[NFS_FHSIZE];
2073         struct knfsd_fh         cr32_getfs;
2074 };
2075
2076 static int nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2077 {
2078         int err;
2079
2080         err = __get_user(karg->ca_version, &arg32->ca32_version);
2081         err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
2082         err |= __get_user(karg->ca_svc.svc_nthreads, &arg32->ca32_svc.svc32_nthreads);
2083         return err;
2084 }
2085
2086 static int nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2087 {
2088         int err;
2089
2090         err = __get_user(karg->ca_version, &arg32->ca32_version);
2091         err |= copy_from_user(&karg->ca_client.cl_ident[0],
2092                           &arg32->ca32_client.cl32_ident[0],
2093                           NFSCLNT_IDMAX);
2094         err |= __get_user(karg->ca_client.cl_naddr, &arg32->ca32_client.cl32_naddr);
2095         err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
2096                           &arg32->ca32_client.cl32_addrlist[0],
2097                           (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
2098         err |= __get_user(karg->ca_client.cl_fhkeytype,
2099                       &arg32->ca32_client.cl32_fhkeytype);
2100         err |= __get_user(karg->ca_client.cl_fhkeylen,
2101                       &arg32->ca32_client.cl32_fhkeylen);
2102         err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
2103                           &arg32->ca32_client.cl32_fhkey[0],
2104                           NFSCLNT_KEYMAX);
2105         return err;
2106 }
2107
2108 static int nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2109 {
2110         int err;
2111
2112         err = __get_user(karg->ca_version, &arg32->ca32_version);
2113         err |= copy_from_user(&karg->ca_export.ex_client[0],
2114                           &arg32->ca32_export.ex32_client[0],
2115                           NFSCLNT_IDMAX);
2116         err |= copy_from_user(&karg->ca_export.ex_path[0],
2117                           &arg32->ca32_export.ex32_path[0],
2118                           NFS_MAXPATHLEN);
2119         err |= __get_user(karg->ca_export.ex_dev,
2120                       &arg32->ca32_export.ex32_dev);
2121         err |= __get_user(karg->ca_export.ex_ino,
2122                       &arg32->ca32_export.ex32_ino);
2123         err |= __get_user(karg->ca_export.ex_flags,
2124                       &arg32->ca32_export.ex32_flags);
2125         err |= __get_user(karg->ca_export.ex_anon_uid,
2126                       &arg32->ca32_export.ex32_anon_uid);
2127         err |= __get_user(karg->ca_export.ex_anon_gid,
2128                       &arg32->ca32_export.ex32_anon_gid);
2129         karg->ca_export.ex_anon_uid = high2lowuid(karg->ca_export.ex_anon_uid);
2130         karg->ca_export.ex_anon_gid = high2lowgid(karg->ca_export.ex_anon_gid);
2131         return err;
2132 }
2133
2134 static int nfs_getfd32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2135 {
2136         int err;
2137
2138         err = __get_user(karg->ca_version, &arg32->ca32_version);
2139         err |= copy_from_user(&karg->ca_getfd.gd_addr,
2140                           &arg32->ca32_getfd.gd32_addr,
2141                           (sizeof(struct sockaddr)));
2142         err |= copy_from_user(&karg->ca_getfd.gd_path,
2143                           &arg32->ca32_getfd.gd32_path,
2144                           (NFS_MAXPATHLEN+1));
2145         err |= __get_user(karg->ca_getfd.gd_version,
2146                       &arg32->ca32_getfd.gd32_version);
2147         return err;
2148 }
2149
2150 static int nfs_getfs32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2151 {
2152         int err;
2153
2154         err = __get_user(karg->ca_version, &arg32->ca32_version);
2155         err |= copy_from_user(&karg->ca_getfs.gd_addr,
2156                           &arg32->ca32_getfs.gd32_addr,
2157                           (sizeof(struct sockaddr)));
2158         err |= copy_from_user(&karg->ca_getfs.gd_path,
2159                           &arg32->ca32_getfs.gd32_path,
2160                           (NFS_MAXPATHLEN+1));
2161         err |= __get_user(karg->ca_getfs.gd_maxlen,
2162                       &arg32->ca32_getfs.gd32_maxlen);
2163         return err;
2164 }
2165
2166 /* This really doesn't need translations, we are only passing
2167  * back a union which contains opaque nfs file handle data.
2168  */
2169 static int nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
2170 {
2171         return copy_to_user(res32, kres, sizeof(*res32)) ? -EFAULT : 0;
2172 }
2173
2174 /*
2175 asmlinkage long sys_ni_syscall(void);
2176 */
2177
2178 int asmlinkage sys32_nfsservctl(int cmd, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
2179 {
2180         struct nfsctl_arg *karg = NULL;
2181         union nfsctl_res *kres = NULL;
2182         mm_segment_t oldfs;
2183         int err;
2184
2185         karg = kmalloc(sizeof(*karg), GFP_USER);
2186         if(!karg)
2187                 return -ENOMEM;
2188         if(res32) {
2189                 kres = kmalloc(sizeof(*kres), GFP_USER);
2190                 if(!kres) {
2191                         kfree(karg);
2192                         return -ENOMEM;
2193                 }
2194         }
2195         switch(cmd) {
2196         case NFSCTL_SVC:
2197                 err = nfs_svc32_trans(karg, arg32);
2198                 break;
2199         case NFSCTL_ADDCLIENT:
2200                 err = nfs_clnt32_trans(karg, arg32);
2201                 break;
2202         case NFSCTL_DELCLIENT:
2203                 err = nfs_clnt32_trans(karg, arg32);
2204                 break;
2205         case NFSCTL_EXPORT:
2206         case NFSCTL_UNEXPORT:
2207                 err = nfs_exp32_trans(karg, arg32);
2208                 break;
2209         case NFSCTL_GETFD:
2210                 err = nfs_getfd32_trans(karg, arg32);
2211                 break;
2212         case NFSCTL_GETFS:
2213                 err = nfs_getfs32_trans(karg, arg32);
2214                 break;
2215         default:
2216                 err = -EINVAL;
2217                 break;
2218         }
2219         if(err)
2220                 goto done;
2221         oldfs = get_fs();
2222         set_fs(KERNEL_DS);
2223         err = sys_nfsservctl(cmd, karg, kres);
2224         set_fs(oldfs);
2225
2226         if (err)
2227                 goto done;
2228
2229         if((cmd == NFSCTL_GETFD) ||
2230            (cmd == NFSCTL_GETFS))
2231                 err = nfs_getfh32_res_trans(kres, res32);
2232
2233 done:
2234         if(karg)
2235                 kfree(karg);
2236         if(kres)
2237                 kfree(kres);
2238         return err;
2239 }
2240
2241 /* Translations due to time_t size differences.  Which affects all
2242    sorts of things, like timeval and itimerval.  */
2243
2244 extern struct timezone sys_tz;
2245
2246 asmlinkage int sys32_gettimeofday(struct compat_timeval *tv, struct timezone *tz)
2247 {
2248         if (tv) {
2249                 struct timeval ktv;
2250                 do_gettimeofday(&ktv);
2251                 if (put_tv32(tv, &ktv))
2252                         return -EFAULT;
2253         }
2254         if (tz) {
2255                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
2256                         return -EFAULT;
2257         }
2258         return 0;
2259 }
2260
2261 static inline long get_ts32(struct timespec *o, struct compat_timeval *i)
2262 {
2263         long usec;
2264
2265         if (!access_ok(VERIFY_READ, i, sizeof(*i)))
2266                 return -EFAULT;
2267         if (__get_user(o->tv_sec, &i->tv_sec))
2268                 return -EFAULT;
2269         if (__get_user(usec, &i->tv_usec))
2270                 return -EFAULT;
2271         o->tv_nsec = usec * 1000;
2272         return 0;
2273 }
2274
2275 asmlinkage int sys32_settimeofday(struct compat_timeval *tv, struct timezone *tz)
2276 {
2277         struct timespec kts;
2278         struct timezone ktz;
2279
2280         if (tv) {
2281                 if (get_ts32(&kts, tv))
2282                         return -EFAULT;
2283         }
2284         if (tz) {
2285                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
2286                         return -EFAULT;
2287         }
2288
2289         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
2290 }
2291
2292 asmlinkage int sys_utimes(char *, struct timeval *);
2293
2294 asmlinkage int sys32_utimes(char *filename, struct compat_timeval *tvs)
2295 {
2296         char *kfilename;
2297         struct timeval ktvs[2];
2298         mm_segment_t old_fs;
2299         int ret;
2300
2301         kfilename = getname(filename);
2302         ret = PTR_ERR(kfilename);
2303         if (!IS_ERR(kfilename)) {
2304                 if (tvs) {
2305                         if (get_tv32(&ktvs[0], tvs) ||
2306                             get_tv32(&ktvs[1], 1+tvs))
2307                                 return -EFAULT;
2308                 }
2309
2310                 old_fs = get_fs();
2311                 set_fs(KERNEL_DS);
2312                 ret = sys_utimes(kfilename, &ktvs[0]);
2313                 set_fs(old_fs);
2314
2315                 putname(kfilename);
2316         }
2317         return ret;
2318 }
2319
2320 /* These are here just in case some old sparc32 binary calls it. */
2321 asmlinkage int sys32_pause(void)
2322 {
2323         current->state = TASK_INTERRUPTIBLE;
2324         schedule();
2325         return -ERESTARTNOHAND;
2326 }
2327
2328 extern asmlinkage int sys_prctl(int option, unsigned long arg2, unsigned long arg3,
2329                                 unsigned long arg4, unsigned long arg5);
2330
2331 asmlinkage int sys32_prctl(int option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
2332 {
2333         return sys_prctl(option,
2334                          (unsigned long) arg2,
2335                          (unsigned long) arg3,
2336                          (unsigned long) arg4,
2337                          (unsigned long) arg5);
2338 }
2339
2340
2341 extern asmlinkage ssize_t sys_pread64(unsigned int fd, char * buf,
2342                                     size_t count, loff_t pos);
2343
2344 extern asmlinkage ssize_t sys_pwrite64(unsigned int fd, const char * buf,
2345                                      size_t count, loff_t pos);
2346
2347 asmlinkage compat_ssize_t sys32_pread64(unsigned int fd, char *ubuf,
2348                                  compat_size_t count, u32 poshi, u32 poslo)
2349 {
2350         if ((compat_ssize_t) count < 0)
2351                 return -EINVAL;
2352         return sys_pread64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
2353 }
2354
2355 asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd, char *ubuf,
2356                                   compat_size_t count, u32 poshi, u32 poslo)
2357 {
2358         if ((compat_ssize_t) count < 0)
2359                 return -EINVAL;
2360         return sys_pwrite64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
2361 }
2362
2363 extern asmlinkage ssize_t sys_readahead(int fd, loff_t offset, size_t count);
2364
2365 asmlinkage compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 count)
2366 {
2367         return sys_readahead(fd, ((loff_t)AA(offhi) << 32) | AA(offlo), count);
2368 }
2369
2370 extern asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
2371
2372 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t *offset, s32 count)
2373 {
2374         mm_segment_t old_fs = get_fs();
2375         int ret;
2376         off_t of;
2377
2378         if (offset && get_user(of, offset))
2379                 return -EFAULT;
2380
2381         set_fs(KERNEL_DS);
2382         ret = sys_sendfile(out_fd, in_fd, offset ? &of : NULL, count);
2383         set_fs(old_fs);
2384
2385         if (!ret && offset && put_user(of, offset))
2386                 return -EFAULT;
2387
2388         return ret;
2389 }
2390
2391 extern asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd,
2392                                          loff_t *offset, size_t count);
2393
2394 asmlinkage int sys32_sendfile64(int out_fd, int in_fd,
2395                                 compat_loff_t *offset, s32 count)
2396 {
2397         mm_segment_t old_fs = get_fs();
2398         int ret;
2399         loff_t lof;
2400
2401         if (offset && get_user(lof, offset))
2402                 return -EFAULT;
2403
2404         set_fs(KERNEL_DS);
2405         ret = sys_sendfile64(out_fd, in_fd, offset ? &lof : NULL, count);
2406         set_fs(old_fs);
2407
2408         if (offset && put_user(lof, offset))
2409                 return -EFAULT;
2410
2411         return ret;
2412 }
2413
2414 /* Handle adjtimex compatibility. */
2415
2416 struct timex32 {
2417         u32 modes;
2418         s32 offset, freq, maxerror, esterror;
2419         s32 status, constant, precision, tolerance;
2420         struct compat_timeval time;
2421         s32 tick;
2422         s32 ppsfreq, jitter, shift, stabil;
2423         s32 jitcnt, calcnt, errcnt, stbcnt;
2424         s32  :32; s32  :32; s32  :32; s32  :32;
2425         s32  :32; s32  :32; s32  :32; s32  :32;
2426         s32  :32; s32  :32; s32  :32; s32  :32;
2427 };
2428
2429 extern int do_adjtimex(struct timex *);
2430
2431 asmlinkage int sys32_adjtimex(struct timex32 *utp)
2432 {
2433         struct timex txc;
2434         int ret;
2435
2436         memset(&txc, 0, sizeof(struct timex));
2437
2438         if(get_user(txc.modes, &utp->modes) ||
2439            __get_user(txc.offset, &utp->offset) ||
2440            __get_user(txc.freq, &utp->freq) ||
2441            __get_user(txc.maxerror, &utp->maxerror) ||
2442            __get_user(txc.esterror, &utp->esterror) ||
2443            __get_user(txc.status, &utp->status) ||
2444            __get_user(txc.constant, &utp->constant) ||
2445            __get_user(txc.precision, &utp->precision) ||
2446            __get_user(txc.tolerance, &utp->tolerance) ||
2447            __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2448            __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2449            __get_user(txc.tick, &utp->tick) ||
2450            __get_user(txc.ppsfreq, &utp->ppsfreq) ||
2451            __get_user(txc.jitter, &utp->jitter) ||
2452            __get_user(txc.shift, &utp->shift) ||
2453            __get_user(txc.stabil, &utp->stabil) ||
2454            __get_user(txc.jitcnt, &utp->jitcnt) ||
2455            __get_user(txc.calcnt, &utp->calcnt) ||
2456            __get_user(txc.errcnt, &utp->errcnt) ||
2457            __get_user(txc.stbcnt, &utp->stbcnt))
2458                 return -EFAULT;
2459
2460         ret = do_adjtimex(&txc);
2461
2462         if(put_user(txc.modes, &utp->modes) ||
2463            __put_user(txc.offset, &utp->offset) ||
2464            __put_user(txc.freq, &utp->freq) ||
2465            __put_user(txc.maxerror, &utp->maxerror) ||
2466            __put_user(txc.esterror, &utp->esterror) ||
2467            __put_user(txc.status, &utp->status) ||
2468            __put_user(txc.constant, &utp->constant) ||
2469            __put_user(txc.precision, &utp->precision) ||
2470            __put_user(txc.tolerance, &utp->tolerance) ||
2471            __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2472            __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2473            __put_user(txc.tick, &utp->tick) ||
2474            __put_user(txc.ppsfreq, &utp->ppsfreq) ||
2475            __put_user(txc.jitter, &utp->jitter) ||
2476            __put_user(txc.shift, &utp->shift) ||
2477            __put_user(txc.stabil, &utp->stabil) ||
2478            __put_user(txc.jitcnt, &utp->jitcnt) ||
2479            __put_user(txc.calcnt, &utp->calcnt) ||
2480            __put_user(txc.errcnt, &utp->errcnt) ||
2481            __put_user(txc.stbcnt, &utp->stbcnt))
2482                 ret = -EFAULT;
2483
2484         return ret;
2485 }
2486
2487 extern asmlinkage long sys_setpriority(int which, int who, int niceval);
2488
2489 asmlinkage int sys_setpriority32(u32 which, u32 who, u32 niceval)
2490 {
2491         return sys_setpriority((int) which,
2492                                (int) who,
2493                                (int) niceval);
2494 }
2495
2496 struct __sysctl_args32 {
2497         u32 name;
2498         int nlen;
2499         u32 oldval;
2500         u32 oldlenp;
2501         u32 newval;
2502         u32 newlen;
2503         u32 __unused[4];
2504 };
2505
2506 extern asmlinkage long sys32_sysctl(struct __sysctl_args32 *args)
2507 {
2508         struct __sysctl_args32 tmp;
2509         int error;
2510         size_t oldlen, *oldlenp = NULL;
2511         unsigned long addr = (((long)&args->__unused[0]) + 7) & ~7;
2512
2513         if (copy_from_user(&tmp, args, sizeof(tmp)))
2514                 return -EFAULT;
2515
2516         if (tmp.oldval && tmp.oldlenp) {
2517                 /* Duh, this is ugly and might not work if sysctl_args
2518                    is in read-only memory, but do_sysctl does indirectly
2519                    a lot of uaccess in both directions and we'd have to
2520                    basically copy the whole sysctl.c here, and
2521                    glibc's __sysctl uses rw memory for the structure
2522                    anyway.  */
2523                 if (get_user(oldlen, (u32 *)A(tmp.oldlenp)) ||
2524                     put_user(oldlen, (size_t *)addr))
2525                         return -EFAULT;
2526                 oldlenp = (size_t *)addr;
2527         }
2528
2529         lock_kernel();
2530         error = do_sysctl((int *)A(tmp.name), tmp.nlen, (void *)A(tmp.oldval),
2531                           oldlenp, (void *)A(tmp.newval), tmp.newlen);
2532         unlock_kernel();
2533         if (oldlenp) {
2534                 if (!error) {
2535                         if (get_user(oldlen, (size_t *)addr) ||
2536                             put_user(oldlen, (u32 *)A(tmp.oldlenp)))
2537                                 error = -EFAULT;
2538                 }
2539                 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
2540         }
2541         return error;
2542 }
2543
2544 struct stat64_emu31 {
2545         unsigned char   __pad0[6];
2546         unsigned short  st_dev;
2547         unsigned int    __pad1;
2548 #define STAT64_HAS_BROKEN_ST_INO        1
2549         u32             __st_ino;
2550         unsigned int    st_mode;
2551         unsigned int    st_nlink;
2552         u32             st_uid;
2553         u32             st_gid;
2554         unsigned char   __pad2[6];
2555         unsigned short  st_rdev;
2556         unsigned int    __pad3;
2557         long            st_size;
2558         u32             st_blksize;
2559         unsigned char   __pad4[4];
2560         u32             __pad5;     /* future possible st_blocks high bits */
2561         u32             st_blocks;  /* Number 512-byte blocks allocated. */
2562         u32             st_atime;
2563         u32             __pad6;
2564         u32             st_mtime;
2565         u32             __pad7;
2566         u32             st_ctime;
2567         u32             __pad8;     /* will be high 32 bits of ctime someday */
2568         unsigned long   st_ino;
2569 };
2570
2571 static inline int
2572 putstat64 (struct stat64_emu31 *ubuf, struct stat *kbuf)
2573 {
2574     struct stat64_emu31 tmp;
2575
2576     memset(&tmp, 0, sizeof(tmp));
2577
2578     tmp.st_dev = (unsigned short)kbuf->st_dev;
2579     tmp.st_ino = kbuf->st_ino;
2580     tmp.__st_ino = (u32)kbuf->st_ino;
2581     tmp.st_mode = kbuf->st_mode;
2582     tmp.st_nlink = (unsigned int)kbuf->st_nlink;
2583     tmp.st_uid = kbuf->st_uid;
2584     tmp.st_gid = kbuf->st_gid;
2585     tmp.st_rdev = (unsigned short)kbuf->st_rdev;
2586     tmp.st_size = kbuf->st_size;
2587     tmp.st_blksize = (u32)kbuf->st_blksize;
2588     tmp.st_blocks = (u32)kbuf->st_blocks;
2589     tmp.st_atime = (u32)kbuf->st_atime;
2590     tmp.st_mtime = (u32)kbuf->st_mtime;
2591     tmp.st_ctime = (u32)kbuf->st_ctime;
2592
2593     return copy_to_user(ubuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
2594 }
2595
2596 extern asmlinkage long sys_newstat(char * filename, struct stat * statbuf);
2597
2598 asmlinkage long sys32_stat64(char * filename, struct stat64_emu31 * statbuf, long flags)
2599 {
2600     int ret;
2601     struct stat s;
2602     char * tmp;
2603     int err;
2604     mm_segment_t old_fs = get_fs();
2605
2606     tmp = getname(filename);
2607     err = PTR_ERR(tmp);
2608     if (IS_ERR(tmp))
2609             return err;
2610
2611     set_fs (KERNEL_DS);
2612     ret = sys_newstat(tmp, &s);
2613     set_fs (old_fs);
2614     putname(tmp);
2615     if (putstat64 (statbuf, &s))
2616             return -EFAULT;
2617     return ret;
2618 }
2619
2620 extern asmlinkage long sys_newlstat(char * filename, struct stat * statbuf);
2621
2622 asmlinkage long sys32_lstat64(char * filename, struct stat64_emu31 * statbuf, long flags)
2623 {
2624     int ret;
2625     struct stat s;
2626     char * tmp;
2627     int err;
2628     mm_segment_t old_fs = get_fs();
2629
2630     tmp = getname(filename);
2631     err = PTR_ERR(tmp);
2632     if (IS_ERR(tmp))
2633             return err;
2634
2635     set_fs (KERNEL_DS);
2636     ret = sys_newlstat(tmp, &s);
2637     set_fs (old_fs);
2638     putname(tmp);
2639     if (putstat64 (statbuf, &s))
2640             return -EFAULT;
2641     return ret;
2642 }
2643
2644 extern asmlinkage long sys_newfstat(unsigned int fd, struct stat * statbuf);
2645
2646 asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 * statbuf, long flags)
2647 {
2648     int ret;
2649     struct stat s;
2650     mm_segment_t old_fs = get_fs();
2651
2652     set_fs (KERNEL_DS);
2653     ret = sys_newfstat(fd, &s);
2654     set_fs (old_fs);
2655     if (putstat64 (statbuf, &s))
2656             return -EFAULT;
2657     return ret;
2658 }
2659
2660 /*
2661  * Linux/i386 didn't use to be able to handle more than
2662  * 4 system call parameters, so these system calls used a memory
2663  * block for parameter passing..
2664  */
2665
2666 struct mmap_arg_struct_emu31 {
2667         u32     addr;
2668         u32     len;
2669         u32     prot;
2670         u32     flags;
2671         u32     fd;
2672         u32     offset;
2673 };
2674
2675 /* common code for old and new mmaps */
2676 static inline long do_mmap2(
2677         unsigned long addr, unsigned long len,
2678         unsigned long prot, unsigned long flags,
2679         unsigned long fd, unsigned long pgoff)
2680 {
2681         struct file * file = NULL;
2682         unsigned long error = -EBADF;
2683
2684         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
2685         if (!(flags & MAP_ANONYMOUS)) {
2686                 file = fget(fd);
2687                 if (!file)
2688                         goto out;
2689         }
2690
2691         down_write(&current->mm->mmap_sem);
2692         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
2693         if (!IS_ERR((void *) error) && error + len >= 0x80000000ULL) {
2694                 /* Result is out of bounds.  */
2695                 do_munmap(current->mm, addr, len);
2696                 error = -ENOMEM;
2697         }
2698         up_write(&current->mm->mmap_sem);
2699
2700         if (file)
2701                 fput(file);
2702 out:
2703         return error;
2704 }
2705
2706
2707 asmlinkage unsigned long
2708 old32_mmap(struct mmap_arg_struct_emu31 *arg)
2709 {
2710         struct mmap_arg_struct_emu31 a;
2711         int error = -EFAULT;
2712
2713         if (copy_from_user(&a, arg, sizeof(a)))
2714                 goto out;
2715
2716         error = -EINVAL;
2717         if (a.offset & ~PAGE_MASK)
2718                 goto out;
2719
2720         error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);
2721 out:
2722         return error;
2723 }
2724
2725 asmlinkage long
2726 sys32_mmap2(struct mmap_arg_struct_emu31 *arg)
2727 {
2728         struct mmap_arg_struct_emu31 a;
2729         int error = -EFAULT;
2730
2731         if (copy_from_user(&a, arg, sizeof(a)))
2732                 goto out;
2733         error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);
2734 out:
2735         return error;
2736 }
2737
2738 extern asmlinkage int sys_sched_setaffinity(pid_t pid, unsigned int len,
2739                                             unsigned long *user_mask_ptr);
2740
2741 asmlinkage int sys32_sched_setaffinity(compat_pid_t pid, unsigned int len,
2742                                        u32 *user_mask_ptr)
2743 {
2744         unsigned long kernel_mask;
2745         mm_segment_t old_fs;
2746         int ret;
2747
2748         if (get_user(kernel_mask, user_mask_ptr))
2749                 return -EFAULT;
2750
2751         old_fs = get_fs();
2752         set_fs(KERNEL_DS);
2753         ret = sys_sched_setaffinity(pid,
2754                                     /* XXX Nice api... */
2755                                     sizeof(kernel_mask),
2756                                     &kernel_mask);
2757         set_fs(old_fs);
2758
2759         return ret;
2760 }
2761
2762 extern asmlinkage int sys_sched_getaffinity(pid_t pid, unsigned int len,
2763                                             unsigned long *user_mask_ptr);
2764
2765 asmlinkage int sys32_sched_getaffinity(compat_pid_t pid, unsigned int len,
2766                                        u32 *user_mask_ptr)
2767 {
2768         unsigned long kernel_mask;
2769         mm_segment_t old_fs;
2770         int ret;
2771
2772         old_fs = get_fs();
2773         set_fs(KERNEL_DS);
2774         ret = sys_sched_getaffinity(pid,
2775                                     /* XXX Nice api... */
2776                                     sizeof(kernel_mask),
2777                                     &kernel_mask);
2778         set_fs(old_fs);
2779
2780         if (ret == 0) {
2781                 if (put_user(kernel_mask, user_mask_ptr))
2782                         ret = -EFAULT;
2783         }
2784
2785         return ret;
2786 }
2787
2788 asmlinkage ssize_t sys_read(unsigned int fd, char * buf, size_t count);
2789
2790 asmlinkage compat_ssize_t sys32_read(unsigned int fd, char * buf, size_t count)
2791 {
2792         if ((compat_ssize_t) count < 0)
2793                 return -EINVAL;
2794
2795         return sys_read(fd, buf, count);
2796 }
2797
2798 asmlinkage ssize_t sys_write(unsigned int fd, const char * buf, size_t count);
2799
2800 asmlinkage compat_ssize_t sys32_write(unsigned int fd, char * buf, size_t count)
2801 {
2802         if ((compat_ssize_t) count < 0)
2803                 return -EINVAL;
2804
2805         return sys_write(fd, buf, count);
2806 }
2807
2808 asmlinkage int sys32_clone(struct pt_regs regs)
2809 {
2810         unsigned long clone_flags;
2811         unsigned long newsp;
2812         struct task_struct *p;
2813         int *parent_tidptr, *child_tidptr;
2814
2815         clone_flags = regs.gprs[3] & 0xffffffffUL;
2816         newsp = regs.orig_gpr2 & 0x7fffffffUL;
2817         parent_tidptr = (int *) (regs.gprs[4] & 0x7fffffffUL);
2818         child_tidptr = (int *) (regs.gprs[5] & 0x7fffffffUL);
2819         if (!newsp)
2820                 newsp = regs.gprs[15];
2821         p = do_fork(clone_flags & ~CLONE_IDLETASK, newsp, &regs, 0,
2822                     parent_tidptr, child_tidptr);
2823         return IS_ERR(p) ? PTR_ERR(p) : p->pid;
2824 }