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