git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/kernel/sys_ppc32.c

   1 /*
   2  * sys_ppc32.c: Conversion between 32bit and 64bit native syscalls.
   3  *
   4  * Copyright (C) 2001 IBM
   5  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   6  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
   7  *
   8  * These routines maintain argument size conversion between 32bit and 64bit
   9  * environment.
  10  *
  11  *      This program is free software; you can redistribute it and/or
  12  *      modify it under the terms of the GNU General Public License
  13  *      as published by the Free Software Foundation; either version
  14  *      2 of the License, or (at your option) any later version.
  15  */
  16
  17 #include <linux/config.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/fs.h>
  21 #include <linux/mm.h>
  22 #include <linux/file.h>
  23 #include <linux/signal.h>
  24 #include <linux/resource.h>
  25 #include <linux/times.h>
  26 #include <linux/utsname.h>
  27 #include <linux/smp.h>
  28 #include <linux/smp_lock.h>
  29 #include <linux/sem.h>
  30 #include <linux/msg.h>
  31 #include <linux/shm.h>
  32 #include <linux/poll.h>
  33 #include <linux/personality.h>
  34 #include <linux/stat.h>
  35 #include <linux/mman.h>
  36 #include <linux/in.h>
  37 #include <linux/syscalls.h>
  38 #include <linux/unistd.h>
  39 #include <linux/sysctl.h>
  40 #include <linux/binfmts.h>
  41 #include <linux/security.h>
  42 #include <linux/compat.h>
  43 #include <linux/ptrace.h>
  44 #include <linux/elf.h>
  45
  46 #include <asm/ptrace.h>
  47 #include <asm/types.h>
  48 #include <asm/ipc.h>
  49 #include <asm/uaccess.h>
  50 #include <asm/unistd.h>
  51 #include <asm/semaphore.h>
  52 #include <asm/time.h>
  53 #include <asm/mmu_context.h>
  54 #include <asm/ppc-pci.h>
  55
  56 /* readdir & getdents */
  57 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
  58 #define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
  59
  60 struct old_linux_dirent32 {
  61         u32             d_ino;
  62         u32             d_offset;
  63         unsigned short  d_namlen;
  64         char            d_name[1];
  65 };
  66
  67 struct readdir_callback32 {
  68         struct old_linux_dirent32 __user * dirent;
  69         int count;
  70 };
  71
  72 static int fillonedir(void * __buf, const char * name, int namlen,
  73                                   off_t offset, ino_t ino, unsigned int d_type)
  74 {
  75         struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
  76         struct old_linux_dirent32 __user * dirent;
  77
  78         if (buf->count)
  79                 return -EINVAL;
  80         buf->count++;
  81         dirent = buf->dirent;
  82         put_user(ino, &dirent->d_ino);
  83         put_user(offset, &dirent->d_offset);
  84         put_user(namlen, &dirent->d_namlen);
  85         copy_to_user(dirent->d_name, name, namlen);
  86         put_user(0, dirent->d_name + namlen);
  87         return 0;
  88 }
  89
  90 asmlinkage int old32_readdir(unsigned int fd, struct old_linux_dirent32 __user *dirent, unsigned int count)
  91 {
  92         int error = -EBADF;
  93         struct file * file;
  94         struct readdir_callback32 buf;
  95
  96         file = fget(fd);
  97         if (!file)
  98                 goto out;
  99
 100         buf.count = 0;
 101         buf.dirent = dirent;
 102
 103         error = vfs_readdir(file, (filldir_t)fillonedir, &buf);
 104         if (error < 0)
 105                 goto out_putf;
 106         error = buf.count;
 107
 108 out_putf:
 109         fput(file);
 110 out:
 111         return error;
 112 }
 113
 114 asmlinkage long ppc32_select(u32 n, compat_ulong_t __user *inp,
 115                 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
 116                 compat_uptr_t tvp_x)
 117 {
 118         /* sign extend n */
 119         return compat_sys_select((int)n, inp, outp, exp, compat_ptr(tvp_x));
 120 }
 121
 122 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 123 {
 124         long err;
 125
 126         if (stat->size > MAX_NON_LFS || !new_valid_dev(stat->dev) ||
 127             !new_valid_dev(stat->rdev))
 128                 return -EOVERFLOW;
 129
 130         err  = access_ok(VERIFY_WRITE, statbuf, sizeof(*statbuf)) ? 0 : -EFAULT;
 131         err |= __put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
 132         err |= __put_user(stat->ino, &statbuf->st_ino);
 133         err |= __put_user(stat->mode, &statbuf->st_mode);
 134         err |= __put_user(stat->nlink, &statbuf->st_nlink);
 135         err |= __put_user(stat->uid, &statbuf->st_uid);
 136         err |= __put_user(stat->gid, &statbuf->st_gid);
 137         err |= __put_user(new_encode_dev(stat->rdev), &statbuf->st_rdev);
 138         err |= __put_user(stat->size, &statbuf->st_size);
 139         err |= __put_user(stat->atime.tv_sec, &statbuf->st_atime);
 140         err |= __put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
 141         err |= __put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
 142         err |= __put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
 143         err |= __put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
 144         err |= __put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
 145         err |= __put_user(stat->blksize, &statbuf->st_blksize);
 146         err |= __put_user(stat->blocks, &statbuf->st_blocks);
 147         err |= __put_user(0, &statbuf->__unused4[0]);
 148         err |= __put_user(0, &statbuf->__unused4[1]);
 149
 150         return err;
 151 }
 152
 153 /* Note: it is necessary to treat option as an unsigned int,
 154  * with the corresponding cast to a signed int to insure that the
 155  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 156  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 157  */
 158 asmlinkage long compat_sys_sysfs(u32 option, u32 arg1, u32 arg2)
 159 {
 160         return sys_sysfs((int)option, arg1, arg2);
 161 }
 162
 163 asmlinkage long compat_sys_pause(void)
 164 {
 165         current->state = TASK_INTERRUPTIBLE;
 166         schedule();
 167
 168         return -ERESTARTNOHAND;
 169 }
 170
 171 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
 172 {
 173         long usec;
 174
 175         if (!access_ok(VERIFY_READ, i, sizeof(*i)))
 176                 return -EFAULT;
 177         if (__get_user(o->tv_sec, &i->tv_sec))
 178                 return -EFAULT;
 179         if (__get_user(usec, &i->tv_usec))
 180                 return -EFAULT;
 181         o->tv_nsec = usec * 1000;
 182         return 0;
 183 }
 184
 185 static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
 186 {
 187         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 188                 (__put_user(i->tv_sec, &o->tv_sec) |
 189                  __put_user(i->tv_usec, &o->tv_usec)));
 190 }
 191
 192 struct sysinfo32 {
 193         s32 uptime;
 194         u32 loads[3];
 195         u32 totalram;
 196         u32 freeram;
 197         u32 sharedram;
 198         u32 bufferram;
 199         u32 totalswap;
 200         u32 freeswap;
 201         unsigned short procs;
 202         unsigned short pad;
 203         u32 totalhigh;
 204         u32 freehigh;
 205         u32 mem_unit;
 206         char _f[20-2*sizeof(int)-sizeof(int)];
 207 };
 208
 209 asmlinkage long compat_sys_sysinfo(struct sysinfo32 __user *info)
 210 {
 211         struct sysinfo s;
 212         int ret, err;
 213         int bitcount=0;
 214         mm_segment_t old_fs = get_fs ();
 215
 216         /* The __user cast is valid due to set_fs() */
 217         set_fs (KERNEL_DS);
 218         ret = sys_sysinfo((struct sysinfo __user *)&s);
 219         set_fs (old_fs);
 220
 221         /* Check to see if any memory value is too large for 32-bit and
 222          * scale down if needed.
 223          */
 224         if ((s.totalram >> 32) || (s.totalswap >> 32)) {
 225             while (s.mem_unit < PAGE_SIZE) {
 226                 s.mem_unit <<= 1;
 227                 bitcount++;
 228             }
 229             s.totalram >>=bitcount;
 230             s.freeram >>= bitcount;
 231             s.sharedram >>= bitcount;
 232             s.bufferram >>= bitcount;
 233             s.totalswap >>= bitcount;
 234             s.freeswap >>= bitcount;
 235             s.totalhigh >>= bitcount;
 236             s.freehigh >>= bitcount;
 237         }
 238
 239         err = put_user (s.uptime, &info->uptime);
 240         err |= __put_user (s.loads[0], &info->loads[0]);
 241         err |= __put_user (s.loads[1], &info->loads[1]);
 242         err |= __put_user (s.loads[2], &info->loads[2]);
 243         err |= __put_user (s.totalram, &info->totalram);
 244         err |= __put_user (s.freeram, &info->freeram);
 245         err |= __put_user (s.sharedram, &info->sharedram);
 246         err |= __put_user (s.bufferram, &info->bufferram);
 247         err |= __put_user (s.totalswap, &info->totalswap);
 248         err |= __put_user (s.freeswap, &info->freeswap);
 249         err |= __put_user (s.procs, &info->procs);
 250         err |= __put_user (s.totalhigh, &info->totalhigh);
 251         err |= __put_user (s.freehigh, &info->freehigh);
 252         err |= __put_user (s.mem_unit, &info->mem_unit);
 253         if (err)
 254                 return -EFAULT;
 255
 256         return ret;
 257 }
 258
 259
 260
 261
 262 /* Translations due to time_t size differences.  Which affects all
 263    sorts of things, like timeval and itimerval.  */
 264 extern struct timezone sys_tz;
 265
 266 asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 267 {
 268         if (tv) {
 269                 struct timeval ktv;
 270                 do_gettimeofday(&ktv);
 271                 if (put_tv32(tv, &ktv))
 272                         return -EFAULT;
 273         }
 274         if (tz) {
 275                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 276                         return -EFAULT;
 277         }
 278
 279         return 0;
 280 }
 281
 282
 283
 284 asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 285 {
 286         struct timespec kts;
 287         struct timezone ktz;
 288
 289         if (tv) {
 290                 if (get_ts32(&kts, tv))
 291                         return -EFAULT;
 292         }
 293         if (tz) {
 294                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
 295                         return -EFAULT;
 296         }
 297
 298         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
 299 }
 300
 301 #ifdef CONFIG_SYSVIPC
 302 long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr,
 303                u32 fifth)
 304 {
 305         int version;
 306
 307         version = call >> 16; /* hack for backward compatibility */
 308         call &= 0xffff;
 309
 310         switch (call) {
 311
 312         case SEMTIMEDOP:
 313                 if (fifth)
 314                         /* sign extend semid */
 315                         return compat_sys_semtimedop((int)first,
 316                                                      compat_ptr(ptr), second,
 317                                                      compat_ptr(fifth));
 318                 /* else fall through for normal semop() */
 319         case SEMOP:
 320                 /* struct sembuf is the same on 32 and 64bit :)) */
 321                 /* sign extend semid */
 322                 return sys_semtimedop((int)first, compat_ptr(ptr), second,
 323                                       NULL);
 324         case SEMGET:
 325                 /* sign extend key, nsems */
 326                 return sys_semget((int)first, (int)second, third);
 327         case SEMCTL:
 328                 /* sign extend semid, semnum */
 329                 return compat_sys_semctl((int)first, (int)second, third,
 330                                          compat_ptr(ptr));
 331
 332         case MSGSND:
 333                 /* sign extend msqid */
 334                 return compat_sys_msgsnd((int)first, (int)second, third,
 335                                          compat_ptr(ptr));
 336         case MSGRCV:
 337                 /* sign extend msqid, msgtyp */
 338                 return compat_sys_msgrcv((int)first, second, (int)fifth,
 339                                          third, version, compat_ptr(ptr));
 340         case MSGGET:
 341                 /* sign extend key */
 342                 return sys_msgget((int)first, second);
 343         case MSGCTL:
 344                 /* sign extend msqid */
 345                 return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
 346
 347         case SHMAT:
 348                 /* sign extend shmid */
 349                 return compat_sys_shmat((int)first, second, third, version,
 350                                         compat_ptr(ptr));
 351         case SHMDT:
 352                 return sys_shmdt(compat_ptr(ptr));
 353         case SHMGET:
 354                 /* sign extend key_t */
 355                 return sys_shmget((int)first, second, third);
 356         case SHMCTL:
 357                 /* sign extend shmid */
 358                 return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
 359
 360         default:
 361                 return -ENOSYS;
 362         }
 363
 364         return -ENOSYS;
 365 }
 366 #endif
 367
 368 /* Note: it is necessary to treat out_fd and in_fd as unsigned ints,
 369  * with the corresponding cast to a signed int to insure that the
 370  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 371  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 372  */
 373 asmlinkage long compat_sys_sendfile(u32 out_fd, u32 in_fd, compat_off_t __user * offset, u32 count)
 374 {
 375         mm_segment_t old_fs = get_fs();
 376         int ret;
 377         off_t of;
 378         off_t __user *up;
 379
 380         if (offset && get_user(of, offset))
 381                 return -EFAULT;
 382
 383         /* The __user pointer cast is valid because of the set_fs() */
 384         set_fs(KERNEL_DS);
 385         up = offset ? (off_t __user *) &of : NULL;
 386         ret = sys_sendfile((int)out_fd, (int)in_fd, up, count);
 387         set_fs(old_fs);
 388
 389         if (offset && put_user(of, offset))
 390                 return -EFAULT;
 391
 392         return ret;
 393 }
 394
 395 asmlinkage int compat_sys_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset, s32 count)
 396 {
 397         mm_segment_t old_fs = get_fs();
 398         int ret;
 399         loff_t lof;
 400         loff_t __user *up;
 401
 402         if (offset && get_user(lof, offset))
 403                 return -EFAULT;
 404
 405         /* The __user pointer cast is valid because of the set_fs() */
 406         set_fs(KERNEL_DS);
 407         up = offset ? (loff_t __user *) &lof : NULL;
 408         ret = sys_sendfile64(out_fd, in_fd, up, count);
 409         set_fs(old_fs);
 410
 411         if (offset && put_user(lof, offset))
 412                 return -EFAULT;
 413
 414         return ret;
 415 }
 416
 417 long compat_sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
 418                   unsigned long a3, unsigned long a4, unsigned long a5,
 419                   struct pt_regs *regs)
 420 {
 421         int error;
 422         char * filename;
 423
 424         filename = getname((char __user *) a0);
 425         error = PTR_ERR(filename);
 426         if (IS_ERR(filename))
 427                 goto out;
 428         flush_fp_to_thread(current);
 429         flush_altivec_to_thread(current);
 430
 431         error = compat_do_execve(filename, compat_ptr(a1), compat_ptr(a2), regs);
 432
 433         if (error == 0) {
 434                 task_lock(current);
 435                 current->ptrace &= ~PT_DTRACE;
 436                 task_unlock(current);
 437         }
 438         putname(filename);
 439
 440 out:
 441         return error;
 442 }
 443
 444 /* Note: it is necessary to treat option as an unsigned int,
 445  * with the corresponding cast to a signed int to insure that the
 446  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 447  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 448  */
 449 asmlinkage long compat_sys_prctl(u32 option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
 450 {
 451         return sys_prctl((int)option,
 452                          (unsigned long) arg2,
 453                          (unsigned long) arg3,
 454                          (unsigned long) arg4,
 455                          (unsigned long) arg5);
 456 }
 457
 458 /* Note: it is necessary to treat pid as an unsigned int,
 459  * with the corresponding cast to a signed int to insure that the
 460  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 461  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 462  */
 463 asmlinkage long compat_sys_sched_rr_get_interval(u32 pid, struct compat_timespec __user *interval)
 464 {
 465         struct timespec t;
 466         int ret;
 467         mm_segment_t old_fs = get_fs ();
 468
 469         /* The __user pointer cast is valid because of the set_fs() */
 470         set_fs (KERNEL_DS);
 471         ret = sys_sched_rr_get_interval((int)pid, (struct timespec __user *) &t);
 472         set_fs (old_fs);
 473         if (put_compat_timespec(&t, interval))
 474                 return -EFAULT;
 475         return ret;
 476 }
 477
 478 /* Note: it is necessary to treat mode as an unsigned int,
 479  * with the corresponding cast to a signed int to insure that the
 480  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 481  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 482  */
 483 asmlinkage long compat_sys_access(const char __user * filename, u32 mode)
 484 {
 485         return sys_access(filename, (int)mode);
 486 }
 487
 488
 489 /* Note: it is necessary to treat mode as an unsigned int,
 490  * with the corresponding cast to a signed int to insure that the
 491  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 492  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 493  */
 494 asmlinkage long compat_sys_creat(const char __user * pathname, u32 mode)
 495 {
 496         return sys_creat(pathname, (int)mode);
 497 }
 498
 499
 500 /* Note: it is necessary to treat pid and options as unsigned ints,
 501  * with the corresponding cast to a signed int to insure that the
 502  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 503  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 504  */
 505 asmlinkage long compat_sys_waitpid(u32 pid, unsigned int __user * stat_addr, u32 options)
 506 {
 507         return sys_waitpid((int)pid, stat_addr, (int)options);
 508 }
 509
 510
 511 /* Note: it is necessary to treat gidsetsize as an unsigned int,
 512  * with the corresponding cast to a signed int to insure that the
 513  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 514  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 515  */
 516 asmlinkage long compat_sys_getgroups(u32 gidsetsize, gid_t __user *grouplist)
 517 {
 518         return sys_getgroups((int)gidsetsize, grouplist);
 519 }
 520
 521
 522 /* Note: it is necessary to treat pid as an unsigned int,
 523  * with the corresponding cast to a signed int to insure that the
 524  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 525  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 526  */
 527 asmlinkage long compat_sys_getpgid(u32 pid)
 528 {
 529         return sys_getpgid((int)pid);
 530 }
 531
 532
 533
 534 /* Note: it is necessary to treat pid as an unsigned int,
 535  * with the corresponding cast to a signed int to insure that the
 536  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 537  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 538  */
 539 asmlinkage long compat_sys_getsid(u32 pid)
 540 {
 541         return sys_getsid((int)pid);
 542 }
 543
 544
 545 /* Note: it is necessary to treat pid and sig as unsigned ints,
 546  * with the corresponding cast to a signed int to insure that the
 547  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 548  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 549  */
 550 asmlinkage long compat_sys_kill(u32 pid, u32 sig)
 551 {
 552         return sys_kill((int)pid, (int)sig);
 553 }
 554
 555
 556 /* Note: it is necessary to treat mode as an unsigned int,
 557  * with the corresponding cast to a signed int to insure that the
 558  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 559  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 560  */
 561 asmlinkage long compat_sys_mkdir(const char __user * pathname, u32 mode)
 562 {
 563         return sys_mkdir(pathname, (int)mode);
 564 }
 565
 566 long compat_sys_nice(u32 increment)
 567 {
 568         /* sign extend increment */
 569         return sys_nice((int)increment);
 570 }
 571
 572 off_t ppc32_lseek(unsigned int fd, u32 offset, unsigned int origin)
 573 {
 574         /* sign extend n */
 575         return sys_lseek(fd, (int)offset, origin);
 576 }
 577
 578 /* Note: it is necessary to treat bufsiz as an unsigned int,
 579  * with the corresponding cast to a signed int to insure that the
 580  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 581  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 582  */
 583 asmlinkage long compat_sys_readlink(const char __user * path, char __user * buf, u32 bufsiz)
 584 {
 585         return sys_readlink(path, buf, (int)bufsiz);
 586 }
 587
 588 /* Note: it is necessary to treat option as an unsigned int,
 589  * with the corresponding cast to a signed int to insure that the
 590  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 591  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 592  */
 593 asmlinkage long compat_sys_sched_get_priority_max(u32 policy)
 594 {
 595         return sys_sched_get_priority_max((int)policy);
 596 }
 597
 598
 599 /* Note: it is necessary to treat policy as an unsigned int,
 600  * with the corresponding cast to a signed int to insure that the
 601  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 602  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 603  */
 604 asmlinkage long compat_sys_sched_get_priority_min(u32 policy)
 605 {
 606         return sys_sched_get_priority_min((int)policy);
 607 }
 608
 609
 610 /* Note: it is necessary to treat pid as an unsigned int,
 611  * with the corresponding cast to a signed int to insure that the
 612  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 613  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 614  */
 615 asmlinkage long compat_sys_sched_getparam(u32 pid, struct sched_param __user *param)
 616 {
 617         return sys_sched_getparam((int)pid, param);
 618 }
 619
 620
 621 /* Note: it is necessary to treat pid as an unsigned int,
 622  * with the corresponding cast to a signed int to insure that the
 623  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 624  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 625  */
 626 asmlinkage long compat_sys_sched_getscheduler(u32 pid)
 627 {
 628         return sys_sched_getscheduler((int)pid);
 629 }
 630
 631
 632 /* Note: it is necessary to treat pid as an unsigned int,
 633  * with the corresponding cast to a signed int to insure that the
 634  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 635  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 636  */
 637 asmlinkage long compat_sys_sched_setparam(u32 pid, struct sched_param __user *param)
 638 {
 639         return sys_sched_setparam((int)pid, param);
 640 }
 641
 642
 643 /* Note: it is necessary to treat pid and policy as unsigned ints,
 644  * with the corresponding cast to a signed int to insure that the
 645  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 646  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 647  */
 648 asmlinkage long compat_sys_sched_setscheduler(u32 pid, u32 policy, struct sched_param __user *param)
 649 {
 650         return sys_sched_setscheduler((int)pid, (int)policy, param);
 651 }
 652
 653
 654 /* Note: it is necessary to treat len as an unsigned int,
 655  * with the corresponding cast to a signed int to insure that the
 656  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 657  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 658  */
 659 asmlinkage long compat_sys_setdomainname(char __user *name, u32 len)
 660 {
 661         return sys_setdomainname(name, (int)len);
 662 }
 663
 664
 665 /* Note: it is necessary to treat gidsetsize as an unsigned int,
 666  * with the corresponding cast to a signed int to insure that the
 667  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 668  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 669  */
 670 asmlinkage long compat_sys_setgroups(u32 gidsetsize, gid_t __user *grouplist)
 671 {
 672         return sys_setgroups((int)gidsetsize, grouplist);
 673 }
 674
 675
 676 asmlinkage long compat_sys_sethostname(char __user *name, u32 len)
 677 {
 678         /* sign extend len */
 679         return sys_sethostname(name, (int)len);
 680 }
 681
 682
 683 /* Note: it is necessary to treat pid and pgid as unsigned ints,
 684  * with the corresponding cast to a signed int to insure that the
 685  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 686  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 687  */
 688 asmlinkage long compat_sys_setpgid(u32 pid, u32 pgid)
 689 {
 690         return sys_setpgid((int)pid, (int)pgid);
 691 }
 692
 693 long compat_sys_getpriority(u32 which, u32 who)
 694 {
 695         /* sign extend which and who */
 696         return sys_getpriority((int)which, (int)who);
 697 }
 698
 699 long compat_sys_setpriority(u32 which, u32 who, u32 niceval)
 700 {
 701         /* sign extend which, who and niceval */
 702         return sys_setpriority((int)which, (int)who, (int)niceval);
 703 }
 704
 705 long compat_sys_ioprio_get(u32 which, u32 who)
 706 {
 707         /* sign extend which and who */
 708         return sys_ioprio_get((int)which, (int)who);
 709 }
 710
 711 long compat_sys_ioprio_set(u32 which, u32 who, u32 ioprio)
 712 {
 713         /* sign extend which, who and ioprio */
 714         return sys_ioprio_set((int)which, (int)who, (int)ioprio);
 715 }
 716
 717 /* Note: it is necessary to treat newmask as an unsigned int,
 718  * with the corresponding cast to a signed int to insure that the
 719  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 720  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 721  */
 722 asmlinkage long compat_sys_ssetmask(u32 newmask)
 723 {
 724         return sys_ssetmask((int) newmask);
 725 }
 726
 727 asmlinkage long compat_sys_syslog(u32 type, char __user * buf, u32 len)
 728 {
 729         /* sign extend len */
 730         return sys_syslog(type, buf, (int)len);
 731 }
 732
 733
 734 /* Note: it is necessary to treat mask as an unsigned int,
 735  * with the corresponding cast to a signed int to insure that the
 736  * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 737  * and the register representation of a signed int (msr in 64-bit mode) is performed.
 738  */
 739 asmlinkage long compat_sys_umask(u32 mask)
 740 {
 741         return sys_umask((int)mask);
 742 }
 743
 744 #ifdef CONFIG_SYSCTL
 745 struct __sysctl_args32 {
 746         u32 name;
 747         int nlen;
 748         u32 oldval;
 749         u32 oldlenp;
 750         u32 newval;
 751         u32 newlen;
 752         u32 __unused[4];
 753 };
 754
 755 asmlinkage long compat_sys_sysctl(struct __sysctl_args32 __user *args)
 756 {
 757         struct __sysctl_args32 tmp;
 758         int error;
 759         size_t oldlen;
 760         size_t __user *oldlenp = NULL;
 761         unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7;
 762
 763         if (copy_from_user(&tmp, args, sizeof(tmp)))
 764                 return -EFAULT;
 765
 766         if (tmp.oldval && tmp.oldlenp) {
 767                 /* Duh, this is ugly and might not work if sysctl_args
 768                    is in read-only memory, but do_sysctl does indirectly
 769                    a lot of uaccess in both directions and we'd have to
 770                    basically copy the whole sysctl.c here, and
 771                    glibc's __sysctl uses rw memory for the structure
 772                    anyway.  */
 773                 oldlenp = (size_t __user *)addr;
 774                 if (get_user(oldlen, (compat_size_t __user *)compat_ptr(tmp.oldlenp)) ||
 775                     put_user(oldlen, oldlenp))
 776                         return -EFAULT;
 777         }
 778
 779         lock_kernel();
 780         error = do_sysctl(compat_ptr(tmp.name), tmp.nlen,
 781                           compat_ptr(tmp.oldval), oldlenp,
 782                           compat_ptr(tmp.newval), tmp.newlen);
 783         unlock_kernel();
 784         if (oldlenp) {
 785                 if (!error) {
 786                         if (get_user(oldlen, oldlenp) ||
 787                             put_user(oldlen, (compat_size_t __user *)compat_ptr(tmp.oldlenp)))
 788                                 error = -EFAULT;
 789                 }
 790                 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
 791         }
 792         return error;
 793 }
 794 #endif
 795
 796 unsigned long compat_sys_mmap2(unsigned long addr, size_t len,
 797                           unsigned long prot, unsigned long flags,
 798                           unsigned long fd, unsigned long pgoff)
 799 {
 800         /* This should remain 12 even if PAGE_SIZE changes */
 801         return sys_mmap(addr, len, prot, flags, fd, pgoff << 12);
 802 }
 803
 804 long compat_sys_tgkill(u32 tgid, u32 pid, int sig)
 805 {
 806         /* sign extend tgid, pid */
 807         return sys_tgkill((int)tgid, (int)pid, sig);
 808 }
 809
 810 /*
 811  * long long munging:
 812  * The 32 bit ABI passes long longs in an odd even register pair.
 813  */
 814
 815 compat_ssize_t compat_sys_pread64(unsigned int fd, char __user *ubuf, compat_size_t count,
 816                              u32 reg6, u32 poshi, u32 poslo)
 817 {
 818         return sys_pread64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
 819 }
 820
 821 compat_ssize_t compat_sys_pwrite64(unsigned int fd, char __user *ubuf, compat_size_t count,
 822                               u32 reg6, u32 poshi, u32 poslo)
 823 {
 824         return sys_pwrite64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
 825 }
 826
 827 compat_ssize_t compat_sys_readahead(int fd, u32 r4, u32 offhi, u32 offlo, u32 count)
 828 {
 829         return sys_readahead(fd, ((loff_t)offhi << 32) | offlo, count);
 830 }
 831
 832 asmlinkage int compat_sys_truncate64(const char __user * path, u32 reg4,
 833                                 unsigned long high, unsigned long low)
 834 {
 835         return sys_truncate(path, (high << 32) | low);
 836 }
 837
 838 asmlinkage int compat_sys_ftruncate64(unsigned int fd, u32 reg4, unsigned long high,
 839                                  unsigned long low)
 840 {
 841         return sys_ftruncate(fd, (high << 32) | low);
 842 }
 843
 844 long ppc32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
 845                           size_t len)
 846 {
 847         return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
 848                                   buf, len);
 849 }
 850
 851 long ppc32_fadvise64(int fd, u32 unused, u32 offset_high, u32 offset_low,
 852                      size_t len, int advice)
 853 {
 854         return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, len,
 855                              advice);
 856 }
 857
 858 asmlinkage long compat_sys_add_key(const char __user *_type,
 859                               const char __user *_description,
 860                               const void __user *_payload,
 861                               u32 plen,
 862                               u32 ringid)
 863 {
 864         return sys_add_key(_type, _description, _payload, plen, ringid);
 865 }
 866
 867 asmlinkage long compat_sys_request_key(const char __user *_type,
 868                                   const char __user *_description,
 869                                   const char __user *_callout_info,
 870                                   u32 destringid)
 871 {
 872         return sys_request_key(_type, _description, _callout_info, destringid);
 873 }
 874