1/* 2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on 3 * sys_sparc32 4 * 5 * Copyright (C) 2000 VA Linux Co 6 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com> 7 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com> 8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 10 * Copyright (C) 2000 Hewlett-Packard Co. 11 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com> 12 * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port) 13 * 14 * These routines maintain argument size conversion between 32bit and 64bit 15 * environment. In 2.5 most of this should be moved to a generic directory. 16 * 17 * This file assumes that there is a hole at the end of user address space. 18 * 19 * Some of the functions are LE specific currently. These are hopefully all marked. 20 * This should be fixed. 21 */ 22 23#include <linux/kernel.h> 24#include <linux/sched.h> 25#include <linux/fs.h> 26#include <linux/file.h> 27#include <linux/signal.h> 28#include <linux/syscalls.h> 29#include <linux/resource.h> 30#include <linux/times.h> 31#include <linux/utsname.h> 32#include <linux/smp.h> 33#include <linux/smp_lock.h> 34#include <linux/sem.h> 35#include <linux/msg.h> 36#include <linux/mm.h> 37#include <linux/shm.h> 38#include <linux/slab.h> 39#include <linux/uio.h> 40#include <linux/nfs_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/ipc.h> 52#include <linux/rwsem.h> 53#include <linux/binfmts.h> 54#include <linux/init.h> 55#include <linux/aio_abi.h> 56#include <linux/aio.h> 57#include <linux/compat.h> 58#include <linux/vfs.h> 59#include <linux/ptrace.h> 60#include <linux/highuid.h> 61#include <linux/vmalloc.h> 62#include <linux/fsnotify.h> 63#include <linux/sysctl.h> 64#include <asm/mman.h> 65#include <asm/types.h> 66#include <asm/uaccess.h> 67#include <asm/semaphore.h> 68#include <asm/atomic.h> 69#include <asm/ldt.h> 70 71#include <net/scm.h> 72#include <net/sock.h> 73#include <asm/ia32.h> 74 75#define AA(__x) ((unsigned long)(__x)) 76 77int cp_compat_stat(struct kstat *kbuf, struct compat_stat __user *ubuf) 78{ 79 compat_ino_t ino; 80 81 typeof(ubuf->st_uid) uid = 0; 82 typeof(ubuf->st_gid) gid = 0; 83 SET_UID(uid, kbuf->uid); 84 SET_GID(gid, kbuf->gid); 85 if (!old_valid_dev(kbuf->dev) || !old_valid_dev(kbuf->rdev)) 86 return -EOVERFLOW; 87 if (kbuf->size >= 0x7fffffff) 88 return -EOVERFLOW; 89 ino = kbuf->ino; 90 if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino) 91 return -EOVERFLOW; 92 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct compat_stat)) || 93 __put_user (old_encode_dev(kbuf->dev), &ubuf->st_dev) || 94 __put_user (ino, &ubuf->st_ino) || 95 __put_user (kbuf->mode, &ubuf->st_mode) || 96 __put_user (kbuf->nlink, &ubuf->st_nlink) || 97 __put_user (uid, &ubuf->st_uid) || 98 __put_user (gid, &ubuf->st_gid) || 99 __put_user (old_encode_dev(kbuf->rdev), &ubuf->st_rdev) || 100 __put_user (kbuf->size, &ubuf->st_size) || 101 __put_user (kbuf->atime.tv_sec, &ubuf->st_atime) || 102 __put_user (kbuf->atime.tv_nsec, &ubuf->st_atime_nsec) || 103 __put_user (kbuf->mtime.tv_sec, &ubuf->st_mtime) || 104 __put_user (kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec) || 105 __put_user (kbuf->ctime.tv_sec, &ubuf->st_ctime) || 106 __put_user (kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec) || 107 __put_user (kbuf->blksize, &ubuf->st_blksize) || 108 __put_user (kbuf->blocks, &ubuf->st_blocks)) 109 return -EFAULT; 110 return 0; 111} 112 113asmlinkage long 114sys32_truncate64(char __user * filename, unsigned long offset_low, unsigned long offset_high) 115{ 116 return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low); 117} 118 119asmlinkage long 120sys32_ftruncate64(unsigned int fd, unsigned long offset_low, unsigned long offset_high) 121{ 122 return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low); 123} 124 125/* Another set for IA32/LFS -- x86_64 struct stat is different due to 126 support for 64bit inode numbers. */ 127 128static int 129cp_stat64(struct stat64 __user *ubuf, struct kstat *stat) 130{ 131 typeof(ubuf->st_uid) uid = 0; 132 typeof(ubuf->st_gid) gid = 0; 133 SET_UID(uid, stat->uid); 134 SET_GID(gid, stat->gid); 135 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) || 136 __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) || 137 __put_user (stat->ino, &ubuf->__st_ino) || 138 __put_user (stat->ino, &ubuf->st_ino) || 139 __put_user (stat->mode, &ubuf->st_mode) || 140 __put_user (stat->nlink, &ubuf->st_nlink) || 141 __put_user (uid, &ubuf->st_uid) || 142 __put_user (gid, &ubuf->st_gid) || 143 __put_user (huge_encode_dev(stat->rdev), &ubuf->st_rdev) || 144 __put_user (stat->size, &ubuf->st_size) || 145 __put_user (stat->atime.tv_sec, &ubuf->st_atime) || 146 __put_user (stat->atime.tv_nsec, &ubuf->st_atime_nsec) || 147 __put_user (stat->mtime.tv_sec, &ubuf->st_mtime) || 148 __put_user (stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) || 149 __put_user (stat->ctime.tv_sec, &ubuf->st_ctime) || 150 __put_user (stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) || 151 __put_user (stat->blksize, &ubuf->st_blksize) || 152 __put_user (stat->blocks, &ubuf->st_blocks)) 153 return -EFAULT; 154 return 0; 155} 156 157asmlinkage long 158sys32_stat64(char __user * filename, struct stat64 __user *statbuf) 159{ 160 struct kstat stat; 161 int ret = vfs_stat(filename, &stat); 162 if (!ret) 163 ret = cp_stat64(statbuf, &stat); 164 return ret; 165} 166 167asmlinkage long 168sys32_lstat64(char __user * filename, struct stat64 __user *statbuf) 169{ 170 struct kstat stat; 171 int ret = vfs_lstat(filename, &stat); 172 if (!ret) 173 ret = cp_stat64(statbuf, &stat); 174 return ret; 175} 176 177asmlinkage long 178sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf) 179{ 180 struct kstat stat; 181 int ret = vfs_fstat(fd, &stat); 182 if (!ret) 183 ret = cp_stat64(statbuf, &stat); 184 return ret; 185} 186 187asmlinkage long 188sys32_fstatat(unsigned int dfd, char __user *filename, 189 struct stat64 __user* statbuf, int flag) 190{ 191 struct kstat stat; 192 int error = -EINVAL; 193 194 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0) 195 goto out; 196 197 if (flag & AT_SYMLINK_NOFOLLOW) 198 error = vfs_lstat_fd(dfd, filename, &stat); 199 else 200 error = vfs_stat_fd(dfd, filename, &stat); 201 202 if (!error) 203 error = cp_stat64(statbuf, &stat); 204 205out: 206 return error; 207} 208 209/* 210 * Linux/i386 didn't use to be able to handle more than 211 * 4 system call parameters, so these system calls used a memory 212 * block for parameter passing.. 213 */ 214 215struct mmap_arg_struct { 216 unsigned int addr; 217 unsigned int len; 218 unsigned int prot; 219 unsigned int flags; 220 unsigned int fd; 221 unsigned int offset; 222}; 223 224asmlinkage long 225sys32_mmap(struct mmap_arg_struct __user *arg) 226{ 227 struct mmap_arg_struct a; 228 struct file *file = NULL; 229 unsigned long retval; 230 struct mm_struct *mm ; 231 232 if (copy_from_user(&a, arg, sizeof(a))) 233 return -EFAULT; 234 235 if (a.offset & ~PAGE_MASK) 236 return -EINVAL; 237 238 if (!(a.flags & MAP_ANONYMOUS)) { 239 file = fget(a.fd); 240 if (!file) 241 return -EBADF; 242 } 243 244 mm = current->mm; 245 down_write(&mm->mmap_sem); 246 retval = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags, a.offset>>PAGE_SHIFT); 247 if (file) 248 fput(file); 249 250 up_write(&mm->mmap_sem); 251 252 return retval; 253} 254 255asmlinkage long 256sys32_mprotect(unsigned long start, size_t len, unsigned long prot) 257{ 258 return sys_mprotect(start,len,prot); 259} 260 261asmlinkage long 262sys32_pipe(int __user *fd) 263{ 264 int retval; 265 int fds[2]; 266 267 retval = do_pipe(fds); 268 if (retval) 269 goto out; 270 if (copy_to_user(fd, fds, sizeof(fds))) 271 retval = -EFAULT; 272 out: 273 return retval; 274} 275 276asmlinkage long 277sys32_rt_sigaction(int sig, struct sigaction32 __user *act, 278 struct sigaction32 __user *oact, unsigned int sigsetsize) 279{ 280 struct k_sigaction new_ka, old_ka; 281 int ret; 282 compat_sigset_t set32; 283 284 if (sigsetsize != sizeof(compat_sigset_t)) 285 return -EINVAL; 286 287 if (act) { 288 compat_uptr_t handler, restorer; 289 290 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 291 __get_user(handler, &act->sa_handler) || 292 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 293 __get_user(restorer, &act->sa_restorer)|| 294 __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t))) 295 return -EFAULT; 296 new_ka.sa.sa_handler = compat_ptr(handler); 297 new_ka.sa.sa_restorer = compat_ptr(restorer); 298 switch (_NSIG_WORDS) { 299 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] 300 | (((long)set32.sig[7]) << 32); 301 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] 302 | (((long)set32.sig[5]) << 32); 303 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] 304 | (((long)set32.sig[3]) << 32); 305 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] 306 | (((long)set32.sig[1]) << 32); 307 } 308 } 309 310 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 311 312 if (!ret && oact) { 313 switch (_NSIG_WORDS) { 314 case 4: 315 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); 316 set32.sig[6] = old_ka.sa.sa_mask.sig[3]; 317 case 3: 318 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); 319 set32.sig[4] = old_ka.sa.sa_mask.sig[2]; 320 case 2: 321 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); 322 set32.sig[2] = old_ka.sa.sa_mask.sig[1]; 323 case 1: 324 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); 325 set32.sig[0] = old_ka.sa.sa_mask.sig[0]; 326 } 327 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 328 __put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler) || 329 __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer) || 330 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 331 __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t))) 332 return -EFAULT; 333 } 334 335 return ret; 336} 337 338asmlinkage long 339sys32_sigaction (int sig, struct old_sigaction32 __user *act, struct old_sigaction32 __user *oact) 340{ 341 struct k_sigaction new_ka, old_ka; 342 int ret; 343 344 if (act) { 345 compat_old_sigset_t mask; 346 compat_uptr_t handler, restorer; 347 348 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 349 __get_user(handler, &act->sa_handler) || 350 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 351 __get_user(restorer, &act->sa_restorer) || 352 __get_user(mask, &act->sa_mask)) 353 return -EFAULT; 354 355 new_ka.sa.sa_handler = compat_ptr(handler); 356 new_ka.sa.sa_restorer = compat_ptr(restorer); 357 358 siginitset(&new_ka.sa.sa_mask, mask); 359 } 360 361 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 362 363 if (!ret && oact) { 364 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 365 __put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler) || 366 __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer) || 367 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 368 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 369 return -EFAULT; 370 } 371 372 return ret; 373} 374 375asmlinkage long 376sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, 377 compat_sigset_t __user *oset, unsigned int sigsetsize) 378{ 379 sigset_t s; 380 compat_sigset_t s32; 381 int ret; 382 mm_segment_t old_fs = get_fs(); 383 384 if (set) { 385 if (copy_from_user (&s32, set, sizeof(compat_sigset_t))) 386 return -EFAULT; 387 switch (_NSIG_WORDS) { 388 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); 389 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); 390 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); 391 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 392 } 393 } 394 set_fs (KERNEL_DS); 395 ret = sys_rt_sigprocmask(how, 396 set ? (sigset_t __user *)&s : NULL, 397 oset ? (sigset_t __user *)&s : NULL, 398 sigsetsize); 399 set_fs (old_fs); 400 if (ret) return ret; 401 if (oset) { 402 switch (_NSIG_WORDS) { 403 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; 404 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; 405 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; 406 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; 407 } 408 if (copy_to_user (oset, &s32, sizeof(compat_sigset_t))) 409 return -EFAULT; 410 } 411 return 0; 412} 413 414static inline long 415get_tv32(struct timeval *o, struct compat_timeval __user *i) 416{ 417 int err = -EFAULT; 418 if (access_ok(VERIFY_READ, i, sizeof(*i))) { 419 err = __get_user(o->tv_sec, &i->tv_sec); 420 err |= __get_user(o->tv_usec, &i->tv_usec); 421 } 422 return err; 423} 424 425static inline long 426put_tv32(struct compat_timeval __user *o, struct timeval *i) 427{ 428 int err = -EFAULT; 429 if (access_ok(VERIFY_WRITE, o, sizeof(*o))) { 430 err = __put_user(i->tv_sec, &o->tv_sec); 431 err |= __put_user(i->tv_usec, &o->tv_usec); 432 } 433 return err; 434} 435 436extern unsigned int alarm_setitimer(unsigned int seconds); 437 438asmlinkage long 439sys32_alarm(unsigned int seconds) 440{ 441 return alarm_setitimer(seconds); 442} 443 444/* Translations due to time_t size differences. Which affects all 445 sorts of things, like timeval and itimerval. */ 446 447extern struct timezone sys_tz; 448 449asmlinkage long 450sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 451{ 452 if (tv) { 453 struct timeval ktv; 454 do_gettimeofday(&ktv); 455 if (put_tv32(tv, &ktv)) 456 return -EFAULT; 457 } 458 if (tz) { 459 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 460 return -EFAULT; 461 } 462 return 0; 463} 464 465asmlinkage long 466sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 467{ 468 struct timeval ktv; 469 struct timespec kts; 470 struct timezone ktz; 471 472 if (tv) { 473 if (get_tv32(&ktv, tv)) 474 return -EFAULT; 475 kts.tv_sec = ktv.tv_sec; 476 kts.tv_nsec = ktv.tv_usec * NSEC_PER_USEC; 477 } 478 if (tz) { 479 if (copy_from_user(&ktz, tz, sizeof(ktz))) 480 return -EFAULT; 481 } 482 483 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL); 484} 485 486struct sel_arg_struct { 487 unsigned int n; 488 unsigned int inp; 489 unsigned int outp; 490 unsigned int exp; 491 unsigned int tvp; 492}; 493 494asmlinkage long 495sys32_old_select(struct sel_arg_struct __user *arg) 496{ 497 struct sel_arg_struct a; 498 499 if (copy_from_user(&a, arg, sizeof(a))) 500 return -EFAULT; 501 return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp), 502 compat_ptr(a.exp), compat_ptr(a.tvp)); 503} 504 505extern asmlinkage long 506compat_sys_wait4(compat_pid_t pid, compat_uint_t * stat_addr, int options, 507 struct compat_rusage *ru); 508 509asmlinkage long 510sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr, int options) 511{ 512 return compat_sys_wait4(pid, stat_addr, options, NULL); 513} 514 515/* 32-bit timeval and related flotsam. */ 516 517asmlinkage long 518sys32_sysfs(int option, u32 arg1, u32 arg2) 519{ 520 return sys_sysfs(option, arg1, arg2); 521} 522 523asmlinkage long 524sys32_sched_rr_get_interval(compat_pid_t pid, struct compat_timespec __user *interval) 525{ 526 struct timespec t; 527 int ret; 528 mm_segment_t old_fs = get_fs (); 529 530 set_fs (KERNEL_DS); 531 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); 532 set_fs (old_fs); 533 if (put_compat_timespec(&t, interval)) 534 return -EFAULT; 535 return ret; 536} 537 538asmlinkage long 539sys32_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize) 540{ 541 sigset_t s; 542 compat_sigset_t s32; 543 int ret; 544 mm_segment_t old_fs = get_fs(); 545 546 set_fs (KERNEL_DS); 547 ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize); 548 set_fs (old_fs); 549 if (!ret) { 550 switch (_NSIG_WORDS) { 551 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; 552 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; 553 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; 554 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; 555 } 556 if (copy_to_user (set, &s32, sizeof(compat_sigset_t))) 557 return -EFAULT; 558 } 559 return ret; 560} 561 562asmlinkage long 563sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo) 564{ 565 siginfo_t info; 566 int ret; 567 mm_segment_t old_fs = get_fs(); 568 569 if (copy_siginfo_from_user32(&info, uinfo)) 570 return -EFAULT; 571 set_fs (KERNEL_DS); 572 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info); 573 set_fs (old_fs); 574 return ret; 575} 576 577/* These are here just in case some old ia32 binary calls it. */ 578asmlinkage long 579sys32_pause(void) 580{ 581 current->state = TASK_INTERRUPTIBLE; 582 schedule(); 583 return -ERESTARTNOHAND; 584} 585 586 587#ifdef CONFIG_SYSCTL_SYSCALL 588struct sysctl_ia32 { 589 unsigned int name; 590 int nlen; 591 unsigned int oldval; 592 unsigned int oldlenp; 593 unsigned int newval; 594 unsigned int newlen; 595 unsigned int __unused[4]; 596}; 597 598 599asmlinkage long 600sys32_sysctl(struct sysctl_ia32 __user *args32) 601{ 602 struct sysctl_ia32 a32; 603 mm_segment_t old_fs = get_fs (); 604 void __user *oldvalp, *newvalp; 605 size_t oldlen; 606 int __user *namep; 607 long ret; 608 609 if (copy_from_user(&a32, args32, sizeof (a32))) 610 return -EFAULT; 611 612 /* 613 * We need to pre-validate these because we have to disable address checking 614 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the 615 * user specifying bad addresses here. Well, since we're dealing with 32 bit 616 * addresses, we KNOW that access_ok() will always succeed, so this is an 617 * expensive NOP, but so what... 618 */ 619 namep = compat_ptr(a32.name); 620 oldvalp = compat_ptr(a32.oldval); 621 newvalp = compat_ptr(a32.newval); 622 623 if ((oldvalp && get_user(oldlen, (int __user *)compat_ptr(a32.oldlenp))) 624 || !access_ok(VERIFY_WRITE, namep, 0) 625 || !access_ok(VERIFY_WRITE, oldvalp, 0) 626 || !access_ok(VERIFY_WRITE, newvalp, 0)) 627 return -EFAULT; 628 629 set_fs(KERNEL_DS); 630 lock_kernel(); 631 ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *)&oldlen, 632 newvalp, (size_t) a32.newlen); 633 unlock_kernel(); 634 set_fs(old_fs); 635 636 if (oldvalp && put_user (oldlen, (int __user *)compat_ptr(a32.oldlenp))) 637 return -EFAULT; 638 639 return ret; 640} 641#endif 642 643/* warning: next two assume little endian */ 644asmlinkage long 645sys32_pread(unsigned int fd, char __user *ubuf, u32 count, u32 poslo, u32 poshi) 646{ 647 return sys_pread64(fd, ubuf, count, 648 ((loff_t)AA(poshi) << 32) | AA(poslo)); 649} 650 651asmlinkage long 652sys32_pwrite(unsigned int fd, char __user *ubuf, u32 count, u32 poslo, u32 poshi) 653{ 654 return sys_pwrite64(fd, ubuf, count, 655 ((loff_t)AA(poshi) << 32) | AA(poslo)); 656} 657 658 659asmlinkage long 660sys32_personality(unsigned long personality) 661{ 662 int ret; 663 if (personality(current->personality) == PER_LINUX32 && 664 personality == PER_LINUX) 665 personality = PER_LINUX32; 666 ret = sys_personality(personality); 667 if (ret == PER_LINUX32) 668 ret = PER_LINUX; 669 return ret; 670} 671 672asmlinkage long 673sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, s32 count) 674{ 675 mm_segment_t old_fs = get_fs(); 676 int ret; 677 off_t of; 678 679 if (offset && get_user(of, offset)) 680 return -EFAULT; 681 682 set_fs(KERNEL_DS); 683 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, 684 count); 685 set_fs(old_fs); 686 687 if (offset && put_user(of, offset)) 688 return -EFAULT; 689 690 return ret; 691} 692 693asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len, 694 unsigned long prot, unsigned long flags, 695 unsigned long fd, unsigned long pgoff) 696{ 697 struct mm_struct *mm = current->mm; 698 unsigned long error; 699 struct file * file = NULL; 700 701 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); 702 if (!(flags & MAP_ANONYMOUS)) { 703 file = fget(fd); 704 if (!file) 705 return -EBADF; 706 } 707 708 down_write(&mm->mmap_sem); 709 error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); 710 up_write(&mm->mmap_sem); 711 712 if (file) 713 fput(file); 714 return error; 715} 716 717asmlinkage long sys32_olduname(struct oldold_utsname __user * name) 718{ 719 int err; 720 721 if (!name) 722 return -EFAULT; 723 if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname))) 724 return -EFAULT; 725 726 down_read(&uts_sem); 727 728 err = __copy_to_user(&name->sysname,&utsname()->sysname, 729 __OLD_UTS_LEN); 730 err |= __put_user(0,name->sysname+__OLD_UTS_LEN); 731 err |= __copy_to_user(&name->nodename,&utsname()->nodename, 732 __OLD_UTS_LEN); 733 err |= __put_user(0,name->nodename+__OLD_UTS_LEN); 734 err |= __copy_to_user(&name->release,&utsname()->release, 735 __OLD_UTS_LEN); 736 err |= __put_user(0,name->release+__OLD_UTS_LEN); 737 err |= __copy_to_user(&name->version,&utsname()->version, 738 __OLD_UTS_LEN); 739 err |= __put_user(0,name->version+__OLD_UTS_LEN); 740 { 741 char *arch = "x86_64"; 742 if (personality(current->personality) == PER_LINUX32) 743 arch = "i686"; 744 745 err |= __copy_to_user(&name->machine, arch, strlen(arch)+1); 746 } 747 748 up_read(&uts_sem); 749 750 err = err ? -EFAULT : 0; 751 752 return err; 753} 754 755long sys32_uname(struct old_utsname __user * name) 756{ 757 int err; 758 if (!name) 759 return -EFAULT; 760 down_read(&uts_sem); 761 err = copy_to_user(name, utsname(), sizeof (*name)); 762 up_read(&uts_sem); 763 if (personality(current->personality) == PER_LINUX32) 764 err |= copy_to_user(&name->machine, "i686", 5); 765 return err?-EFAULT:0; 766} 767 768long sys32_ustat(unsigned dev, struct ustat32 __user *u32p) 769{ 770 struct ustat u; 771 mm_segment_t seg; 772 int ret; 773 774 seg = get_fs(); 775 set_fs(KERNEL_DS); 776 ret = sys_ustat(dev, (struct ustat __user *)&u); 777 set_fs(seg); 778 if (ret >= 0) { 779 if (!access_ok(VERIFY_WRITE,u32p,sizeof(struct ustat32)) || 780 __put_user((__u32) u.f_tfree, &u32p->f_tfree) || 781 __put_user((__u32) u.f_tinode, &u32p->f_tfree) || 782 __copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) || 783 __copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack))) 784 ret = -EFAULT; 785 } 786 return ret; 787} 788 789asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv, 790 compat_uptr_t __user *envp, struct pt_regs *regs) 791{ 792 long error; 793 char * filename; 794 795 filename = getname(name); 796 error = PTR_ERR(filename); 797 if (IS_ERR(filename)) 798 return error; 799 error = compat_do_execve(filename, argv, envp, regs); 800 if (error == 0) { 801 task_lock(current); 802 current->ptrace &= ~PT_DTRACE; 803 task_unlock(current); 804 } 805 putname(filename); 806 return error; 807} 808 809asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp, 810 struct pt_regs *regs) 811{ 812 void __user *parent_tid = (void __user *)regs->rdx; 813 void __user *child_tid = (void __user *)regs->rdi; 814 if (!newsp) 815 newsp = regs->rsp; 816 return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid); 817} 818 819/* 820 * Some system calls that need sign extended arguments. This could be done by a generic wrapper. 821 */ 822 823long sys32_lseek (unsigned int fd, int offset, unsigned int whence) 824{ 825 return sys_lseek(fd, offset, whence); 826} 827 828long sys32_kill(int pid, int sig) 829{ 830 return sys_kill(pid, sig); 831} 832 833long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high, 834 __u32 len_low, __u32 len_high, int advice) 835{ 836 return sys_fadvise64_64(fd, 837 (((u64)offset_high)<<32) | offset_low, 838 (((u64)len_high)<<32) | len_low, 839 advice); 840} 841 842long sys32_vm86_warning(void) 843{ 844 struct task_struct *me = current; 845 static char lastcomm[sizeof(me->comm)]; 846 if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) { 847 compat_printk(KERN_INFO "%s: vm86 mode not supported on 64 bit kernel\n", 848 me->comm); 849 strncpy(lastcomm, me->comm, sizeof(lastcomm)); 850 } 851 return -ENOSYS; 852} 853 854long sys32_lookup_dcookie(u32 addr_low, u32 addr_high, 855 char __user * buf, size_t len) 856{ 857 return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len); 858} 859 860asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi, size_t count) 861{ 862 return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count); 863} 864 865asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi, 866 unsigned n_low, unsigned n_hi, int flags) 867{ 868 return sys_sync_file_range(fd, 869 ((u64)off_hi << 32) | off_low, 870 ((u64)n_hi << 32) | n_low, flags); 871} 872 873asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi, size_t len, 874 int advice) 875{ 876 return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo, 877 len, advice); 878} 879