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 ([email protected]), 7 * Gerhard Tonn ([email protected]) 8 * Thomas Spatzier ([email protected]) 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 ([email protected]) 14 * Copyright (C) 1997 David S. Miller ([email protected]) 15 * 16 */ 17 18 19 #include <linux/kernel.h> 20 #include <linux/sched.h> 21 #include <linux/fs.h> 22 #include <linux/mm.h> 23 #include <linux/file.h> 24 #include <linux/signal.h> 25 #include <linux/resource.h> 26 #include <linux/times.h> 27 #include <linux/utsname.h> 28 #include <linux/smp.h> 29 #include <linux/smp_lock.h> 30 #include <linux/sem.h> 31 #include <linux/msg.h> 32 #include <linux/shm.h> 33 #include <linux/slab.h> 34 #include <linux/uio.h> 35 #include <linux/nfs_fs.h> 36 #include <linux/quota.h> 37 #include <linux/module.h> 38 #include <linux/sunrpc/svc.h> 39 #include <linux/nfsd/nfsd.h> 40 #include <linux/nfsd/cache.h> 41 #include <linux/nfsd/xdr.h> 42 #include <linux/nfsd/syscall.h> 43 #include <linux/poll.h> 44 #include <linux/personality.h> 45 #include <linux/stat.h> 46 #include <linux/filter.h> 47 #include <linux/highmem.h> 48 #include <linux/highuid.h> 49 #include <linux/mman.h> 50 #include <linux/ipv6.h> 51 #include <linux/in.h> 52 #include <linux/icmpv6.h> 53 #include <linux/syscalls.h> 54 #include <linux/sysctl.h> 55 #include <linux/binfmts.h> 56 #include <linux/capability.h> 57 #include <linux/compat.h> 58 #include <linux/vfs.h> 59 #include <linux/ptrace.h> 60 #include <linux/fadvise.h> 61 #include <linux/ipc.h> 62 63 #include <asm/types.h> 64 #include <asm/uaccess.h> 65 66 #include <net/scm.h> 67 #include <net/sock.h> 68 69 #include "compat_linux.h" 70 71 long psw_user32_bits = (PSW_BASE32_BITS | PSW_MASK_DAT | PSW_ASC_HOME | 72 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK | 73 PSW_MASK_PSTATE | PSW_DEFAULT_KEY); 74 long psw32_user_bits = (PSW32_BASE_BITS | PSW32_MASK_DAT | PSW32_ASC_HOME | 75 PSW32_MASK_IO | PSW32_MASK_EXT | PSW32_MASK_MCHECK | 76 PSW32_MASK_PSTATE); 77 78 /* For this source file, we want overflow handling. */ 79 80 #undef high2lowuid 81 #undef high2lowgid 82 #undef low2highuid 83 #undef low2highgid 84 #undef SET_UID16 85 #undef SET_GID16 86 #undef NEW_TO_OLD_UID 87 #undef NEW_TO_OLD_GID 88 #undef SET_OLDSTAT_UID 89 #undef SET_OLDSTAT_GID 90 #undef SET_STAT_UID 91 #undef SET_STAT_GID 92 93 #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid) 94 #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid) 95 #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid) 96 #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid) 97 #define SET_UID16(var, uid) var = high2lowuid(uid) 98 #define SET_GID16(var, gid) var = high2lowgid(gid) 99 #define NEW_TO_OLD_UID(uid) high2lowuid(uid) 100 #define NEW_TO_OLD_GID(gid) high2lowgid(gid) 101 #define SET_OLDSTAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid) 102 #define SET_OLDSTAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid) 103 #define SET_STAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid) 104 #define SET_STAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid) 105 106 asmlinkage long sys32_chown16(const char __user * filename, u16 user, u16 group) 107 { 108 return sys_chown(filename, low2highuid(user), low2highgid(group)); 109 } 110 111 asmlinkage long sys32_lchown16(const char __user * filename, u16 user, u16 group) 112 { 113 return sys_lchown(filename, low2highuid(user), low2highgid(group)); 114 } 115 116 asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group) 117 { 118 return sys_fchown(fd, low2highuid(user), low2highgid(group)); 119 } 120 121 asmlinkage long sys32_setregid16(u16 rgid, u16 egid) 122 { 123 return sys_setregid(low2highgid(rgid), low2highgid(egid)); 124 } 125 126 asmlinkage long sys32_setgid16(u16 gid) 127 { 128 return sys_setgid((gid_t)gid); 129 } 130 131 asmlinkage long sys32_setreuid16(u16 ruid, u16 euid) 132 { 133 return sys_setreuid(low2highuid(ruid), low2highuid(euid)); 134 } 135 136 asmlinkage long sys32_setuid16(u16 uid) 137 { 138 return sys_setuid((uid_t)uid); 139 } 140 141 asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid) 142 { 143 return sys_setresuid(low2highuid(ruid), low2highuid(euid), 144 low2highuid(suid)); 145 } 146 147 asmlinkage long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid) 148 { 149 int retval; 150 151 if (!(retval = put_user(high2lowuid(current->cred->uid), ruid)) && 152 !(retval = put_user(high2lowuid(current->cred->euid), euid))) 153 retval = put_user(high2lowuid(current->cred->suid), suid); 154 155 return retval; 156 } 157 158 asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid) 159 { 160 return sys_setresgid(low2highgid(rgid), low2highgid(egid), 161 low2highgid(sgid)); 162 } 163 164 asmlinkage long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid) 165 { 166 int retval; 167 168 if (!(retval = put_user(high2lowgid(current->cred->gid), rgid)) && 169 !(retval = put_user(high2lowgid(current->cred->egid), egid))) 170 retval = put_user(high2lowgid(current->cred->sgid), sgid); 171 172 return retval; 173 } 174 175 asmlinkage long sys32_setfsuid16(u16 uid) 176 { 177 return sys_setfsuid((uid_t)uid); 178 } 179 180 asmlinkage long sys32_setfsgid16(u16 gid) 181 { 182 return sys_setfsgid((gid_t)gid); 183 } 184 185 static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info) 186 { 187 int i; 188 u16 group; 189 190 for (i = 0; i < group_info->ngroups; i++) { 191 group = (u16)GROUP_AT(group_info, i); 192 if (put_user(group, grouplist+i)) 193 return -EFAULT; 194 } 195 196 return 0; 197 } 198 199 static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist) 200 { 201 int i; 202 u16 group; 203 204 for (i = 0; i < group_info->ngroups; i++) { 205 if (get_user(group, grouplist+i)) 206 return -EFAULT; 207 GROUP_AT(group_info, i) = (gid_t)group; 208 } 209 210 return 0; 211 } 212 213 asmlinkage long sys32_getgroups16(int gidsetsize, u16 __user *grouplist) 214 { 215 int i; 216 217 if (gidsetsize < 0) 218 return -EINVAL; 219 220 get_group_info(current->cred->group_info); 221 i = current->cred->group_info->ngroups; 222 if (gidsetsize) { 223 if (i > gidsetsize) { 224 i = -EINVAL; 225 goto out; 226 } 227 if (groups16_to_user(grouplist, current->cred->group_info)) { 228 i = -EFAULT; 229 goto out; 230 } 231 } 232 out: 233 put_group_info(current->cred->group_info); 234 return i; 235 } 236 237 asmlinkage long sys32_setgroups16(int gidsetsize, u16 __user *grouplist) 238 { 239 struct group_info *group_info; 240 int retval; 241 242 if (!capable(CAP_SETGID)) 243 return -EPERM; 244 if ((unsigned)gidsetsize > NGROUPS_MAX) 245 return -EINVAL; 246 247 group_info = groups_alloc(gidsetsize); 248 if (!group_info) 249 return -ENOMEM; 250 retval = groups16_from_user(group_info, grouplist); 251 if (retval) { 252 put_group_info(group_info); 253 return retval; 254 } 255 256 retval = set_current_groups(group_info); 257 put_group_info(group_info); 258 259 return retval; 260 } 261 262 asmlinkage long sys32_getuid16(void) 263 { 264 return high2lowuid(current->cred->uid); 265 } 266 267 asmlinkage long sys32_geteuid16(void) 268 { 269 return high2lowuid(current->cred->euid); 270 } 271 272 asmlinkage long sys32_getgid16(void) 273 { 274 return high2lowgid(current->cred->gid); 275 } 276 277 asmlinkage long sys32_getegid16(void) 278 { 279 return high2lowgid(current->cred->egid); 280 } 281 282 /* 283 * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation. 284 * 285 * This is really horribly ugly. 286 */ 287 #ifdef CONFIG_SYSVIPC 288 asmlinkage long sys32_ipc(u32 call, int first, int second, int third, u32 ptr) 289 { 290 if (call >> 16) /* hack for backward compatibility */ 291 return -EINVAL; 292 293 call &= 0xffff; 294 295 switch (call) { 296 case SEMTIMEDOP: 297 return compat_sys_semtimedop(first, compat_ptr(ptr), 298 second, compat_ptr(third)); 299 case SEMOP: 300 /* struct sembuf is the same on 32 and 64bit :)) */ 301 return sys_semtimedop(first, compat_ptr(ptr), 302 second, NULL); 303 case SEMGET: 304 return sys_semget(first, second, third); 305 case SEMCTL: 306 return compat_sys_semctl(first, second, third, 307 compat_ptr(ptr)); 308 case MSGSND: 309 return compat_sys_msgsnd(first, second, third, 310 compat_ptr(ptr)); 311 case MSGRCV: 312 return compat_sys_msgrcv(first, second, 0, third, 313 0, compat_ptr(ptr)); 314 case MSGGET: 315 return sys_msgget((key_t) first, second); 316 case MSGCTL: 317 return compat_sys_msgctl(first, second, compat_ptr(ptr)); 318 case SHMAT: 319 return compat_sys_shmat(first, second, third, 320 0, compat_ptr(ptr)); 321 case SHMDT: 322 return sys_shmdt(compat_ptr(ptr)); 323 case SHMGET: 324 return sys_shmget(first, (unsigned)second, third); 325 case SHMCTL: 326 return compat_sys_shmctl(first, second, compat_ptr(ptr)); 327 } 328 329 return -ENOSYS; 330 } 331 #endif 332 333 asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low) 334 { 335 if ((int)high < 0) 336 return -EINVAL; 337 else 338 return sys_truncate(path, (high << 32) | low); 339 } 340 341 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low) 342 { 343 if ((int)high < 0) 344 return -EINVAL; 345 else 346 return sys_ftruncate(fd, (high << 32) | low); 347 } 348 349 asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid, 350 struct compat_timespec __user *interval) 351 { 352 struct timespec t; 353 int ret; 354 mm_segment_t old_fs = get_fs (); 355 356 set_fs (KERNEL_DS); 357 ret = sys_sched_rr_get_interval(pid, 358 (struct timespec __force __user *) &t); 359 set_fs (old_fs); 360 if (put_compat_timespec(&t, interval)) 361 return -EFAULT; 362 return ret; 363 } 364 365 asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, 366 compat_sigset_t __user *oset, size_t sigsetsize) 367 { 368 sigset_t s; 369 compat_sigset_t s32; 370 int ret; 371 mm_segment_t old_fs = get_fs(); 372 373 if (set) { 374 if (copy_from_user (&s32, set, sizeof(compat_sigset_t))) 375 return -EFAULT; 376 switch (_NSIG_WORDS) { 377 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); 378 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); 379 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); 380 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 381 } 382 } 383 set_fs (KERNEL_DS); 384 ret = sys_rt_sigprocmask(how, 385 set ? (sigset_t __force __user *) &s : NULL, 386 oset ? (sigset_t __force __user *) &s : NULL, 387 sigsetsize); 388 set_fs (old_fs); 389 if (ret) return ret; 390 if (oset) { 391 switch (_NSIG_WORDS) { 392 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; 393 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; 394 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; 395 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; 396 } 397 if (copy_to_user (oset, &s32, sizeof(compat_sigset_t))) 398 return -EFAULT; 399 } 400 return 0; 401 } 402 403 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set, 404 size_t sigsetsize) 405 { 406 sigset_t s; 407 compat_sigset_t s32; 408 int ret; 409 mm_segment_t old_fs = get_fs(); 410 411 set_fs (KERNEL_DS); 412 ret = sys_rt_sigpending((sigset_t __force __user *) &s, sigsetsize); 413 set_fs (old_fs); 414 if (!ret) { 415 switch (_NSIG_WORDS) { 416 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; 417 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; 418 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; 419 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; 420 } 421 if (copy_to_user (set, &s32, sizeof(compat_sigset_t))) 422 return -EFAULT; 423 } 424 return ret; 425 } 426 427 asmlinkage long 428 sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo) 429 { 430 siginfo_t info; 431 int ret; 432 mm_segment_t old_fs = get_fs(); 433 434 if (copy_siginfo_from_user32(&info, uinfo)) 435 return -EFAULT; 436 set_fs (KERNEL_DS); 437 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __force __user *) &info); 438 set_fs (old_fs); 439 return ret; 440 } 441 442 /* 443 * sys32_execve() executes a new program after the asm stub has set 444 * things up for us. This should basically do what I want it to. 445 */ 446 asmlinkage long sys32_execve(void) 447 { 448 struct pt_regs *regs = task_pt_regs(current); 449 char *filename; 450 unsigned long result; 451 int rc; 452 453 filename = getname(compat_ptr(regs->orig_gpr2)); 454 if (IS_ERR(filename)) { 455 result = PTR_ERR(filename); 456 goto out; 457 } 458 rc = compat_do_execve(filename, compat_ptr(regs->gprs[3]), 459 compat_ptr(regs->gprs[4]), regs); 460 if (rc) { 461 result = rc; 462 goto out_putname; 463 } 464 current->thread.fp_regs.fpc=0; 465 asm volatile("sfpc %0,0" : : "d" (0)); 466 result = regs->gprs[2]; 467 out_putname: 468 putname(filename); 469 out: 470 return result; 471 } 472 473 474 #ifdef CONFIG_MODULES 475 476 asmlinkage long 477 sys32_init_module(void __user *umod, unsigned long len, 478 const char __user *uargs) 479 { 480 return sys_init_module(umod, len, uargs); 481 } 482 483 asmlinkage long 484 sys32_delete_module(const char __user *name_user, unsigned int flags) 485 { 486 return sys_delete_module(name_user, flags); 487 } 488 489 #else /* CONFIG_MODULES */ 490 491 asmlinkage long 492 sys32_init_module(void __user *umod, unsigned long len, 493 const char __user *uargs) 494 { 495 return -ENOSYS; 496 } 497 498 asmlinkage long 499 sys32_delete_module(const char __user *name_user, unsigned int flags) 500 { 501 return -ENOSYS; 502 } 503 504 #endif /* CONFIG_MODULES */ 505 506 asmlinkage long sys32_pread64(unsigned int fd, char __user *ubuf, 507 size_t count, u32 poshi, u32 poslo) 508 { 509 if ((compat_ssize_t) count < 0) 510 return -EINVAL; 511 return sys_pread64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo)); 512 } 513 514 asmlinkage long sys32_pwrite64(unsigned int fd, const char __user *ubuf, 515 size_t count, u32 poshi, u32 poslo) 516 { 517 if ((compat_ssize_t) count < 0) 518 return -EINVAL; 519 return sys_pwrite64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo)); 520 } 521 522 asmlinkage compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 count) 523 { 524 return sys_readahead(fd, ((loff_t)AA(offhi) << 32) | AA(offlo), count); 525 } 526 527 asmlinkage long sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, size_t count) 528 { 529 mm_segment_t old_fs = get_fs(); 530 int ret; 531 off_t of; 532 533 if (offset && get_user(of, offset)) 534 return -EFAULT; 535 536 set_fs(KERNEL_DS); 537 ret = sys_sendfile(out_fd, in_fd, 538 offset ? (off_t __force __user *) &of : NULL, count); 539 set_fs(old_fs); 540 541 if (offset && put_user(of, offset)) 542 return -EFAULT; 543 544 return ret; 545 } 546 547 asmlinkage long sys32_sendfile64(int out_fd, int in_fd, 548 compat_loff_t __user *offset, s32 count) 549 { 550 mm_segment_t old_fs = get_fs(); 551 int ret; 552 loff_t lof; 553 554 if (offset && get_user(lof, offset)) 555 return -EFAULT; 556 557 set_fs(KERNEL_DS); 558 ret = sys_sendfile64(out_fd, in_fd, 559 offset ? (loff_t __force __user *) &lof : NULL, 560 count); 561 set_fs(old_fs); 562 563 if (offset && put_user(lof, offset)) 564 return -EFAULT; 565 566 return ret; 567 } 568 569 #ifdef CONFIG_SYSCTL_SYSCALL 570 struct __sysctl_args32 { 571 u32 name; 572 int nlen; 573 u32 oldval; 574 u32 oldlenp; 575 u32 newval; 576 u32 newlen; 577 u32 __unused[4]; 578 }; 579 580 asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args) 581 { 582 struct __sysctl_args32 tmp; 583 int error; 584 size_t oldlen; 585 size_t __user *oldlenp = NULL; 586 unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7; 587 588 if (copy_from_user(&tmp, args, sizeof(tmp))) 589 return -EFAULT; 590 591 if (tmp.oldval && tmp.oldlenp) { 592 /* Duh, this is ugly and might not work if sysctl_args 593 is in read-only memory, but do_sysctl does indirectly 594 a lot of uaccess in both directions and we'd have to 595 basically copy the whole sysctl.c here, and 596 glibc's __sysctl uses rw memory for the structure 597 anyway. */ 598 if (get_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp)) || 599 put_user(oldlen, (size_t __user *)addr)) 600 return -EFAULT; 601 oldlenp = (size_t __user *)addr; 602 } 603 604 lock_kernel(); 605 error = do_sysctl(compat_ptr(tmp.name), tmp.nlen, compat_ptr(tmp.oldval), 606 oldlenp, compat_ptr(tmp.newval), tmp.newlen); 607 unlock_kernel(); 608 if (oldlenp) { 609 if (!error) { 610 if (get_user(oldlen, (size_t __user *)addr) || 611 put_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp))) 612 error = -EFAULT; 613 } 614 if (copy_to_user(args->__unused, tmp.__unused, 615 sizeof(tmp.__unused))) 616 error = -EFAULT; 617 } 618 return error; 619 } 620 #endif 621 622 struct stat64_emu31 { 623 unsigned long long st_dev; 624 unsigned int __pad1; 625 #define STAT64_HAS_BROKEN_ST_INO 1 626 u32 __st_ino; 627 unsigned int st_mode; 628 unsigned int st_nlink; 629 u32 st_uid; 630 u32 st_gid; 631 unsigned long long st_rdev; 632 unsigned int __pad3; 633 long st_size; 634 u32 st_blksize; 635 unsigned char __pad4[4]; 636 u32 __pad5; /* future possible st_blocks high bits */ 637 u32 st_blocks; /* Number 512-byte blocks allocated. */ 638 u32 st_atime; 639 u32 __pad6; 640 u32 st_mtime; 641 u32 __pad7; 642 u32 st_ctime; 643 u32 __pad8; /* will be high 32 bits of ctime someday */ 644 unsigned long st_ino; 645 }; 646 647 static int cp_stat64(struct stat64_emu31 __user *ubuf, struct kstat *stat) 648 { 649 struct stat64_emu31 tmp; 650 651 memset(&tmp, 0, sizeof(tmp)); 652 653 tmp.st_dev = huge_encode_dev(stat->dev); 654 tmp.st_ino = stat->ino; 655 tmp.__st_ino = (u32)stat->ino; 656 tmp.st_mode = stat->mode; 657 tmp.st_nlink = (unsigned int)stat->nlink; 658 tmp.st_uid = stat->uid; 659 tmp.st_gid = stat->gid; 660 tmp.st_rdev = huge_encode_dev(stat->rdev); 661 tmp.st_size = stat->size; 662 tmp.st_blksize = (u32)stat->blksize; 663 tmp.st_blocks = (u32)stat->blocks; 664 tmp.st_atime = (u32)stat->atime.tv_sec; 665 tmp.st_mtime = (u32)stat->mtime.tv_sec; 666 tmp.st_ctime = (u32)stat->ctime.tv_sec; 667 668 return copy_to_user(ubuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 669 } 670 671 asmlinkage long sys32_stat64(char __user * filename, struct stat64_emu31 __user * statbuf) 672 { 673 struct kstat stat; 674 int ret = vfs_stat(filename, &stat); 675 if (!ret) 676 ret = cp_stat64(statbuf, &stat); 677 return ret; 678 } 679 680 asmlinkage long sys32_lstat64(char __user * filename, struct stat64_emu31 __user * statbuf) 681 { 682 struct kstat stat; 683 int ret = vfs_lstat(filename, &stat); 684 if (!ret) 685 ret = cp_stat64(statbuf, &stat); 686 return ret; 687 } 688 689 asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 __user * statbuf) 690 { 691 struct kstat stat; 692 int ret = vfs_fstat(fd, &stat); 693 if (!ret) 694 ret = cp_stat64(statbuf, &stat); 695 return ret; 696 } 697 698 asmlinkage long sys32_fstatat64(unsigned int dfd, char __user *filename, 699 struct stat64_emu31 __user* statbuf, int flag) 700 { 701 struct kstat stat; 702 int error; 703 704 error = vfs_fstatat(dfd, filename, &stat, flag); 705 if (error) 706 return error; 707 return cp_stat64(statbuf, &stat); 708 } 709 710 /* 711 * Linux/i386 didn't use to be able to handle more than 712 * 4 system call parameters, so these system calls used a memory 713 * block for parameter passing.. 714 */ 715 716 struct mmap_arg_struct_emu31 { 717 u32 addr; 718 u32 len; 719 u32 prot; 720 u32 flags; 721 u32 fd; 722 u32 offset; 723 }; 724 725 /* common code for old and new mmaps */ 726 static inline long do_mmap2( 727 unsigned long addr, unsigned long len, 728 unsigned long prot, unsigned long flags, 729 unsigned long fd, unsigned long pgoff) 730 { 731 struct file * file = NULL; 732 unsigned long error = -EBADF; 733 734 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); 735 if (!(flags & MAP_ANONYMOUS)) { 736 file = fget(fd); 737 if (!file) 738 goto out; 739 } 740 741 down_write(¤t->mm->mmap_sem); 742 error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); 743 if (!IS_ERR((void *) error) && error + len >= 0x80000000ULL) { 744 /* Result is out of bounds. */ 745 do_munmap(current->mm, addr, len); 746 error = -ENOMEM; 747 } 748 up_write(¤t->mm->mmap_sem); 749 750 if (file) 751 fput(file); 752 out: 753 return error; 754 } 755 756 757 asmlinkage unsigned long 758 old32_mmap(struct mmap_arg_struct_emu31 __user *arg) 759 { 760 struct mmap_arg_struct_emu31 a; 761 int error = -EFAULT; 762 763 if (copy_from_user(&a, arg, sizeof(a))) 764 goto out; 765 766 error = -EINVAL; 767 if (a.offset & ~PAGE_MASK) 768 goto out; 769 770 error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT); 771 out: 772 return error; 773 } 774 775 asmlinkage long 776 sys32_mmap2(struct mmap_arg_struct_emu31 __user *arg) 777 { 778 struct mmap_arg_struct_emu31 a; 779 int error = -EFAULT; 780 781 if (copy_from_user(&a, arg, sizeof(a))) 782 goto out; 783 error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset); 784 out: 785 return error; 786 } 787 788 asmlinkage long sys32_read(unsigned int fd, char __user * buf, size_t count) 789 { 790 if ((compat_ssize_t) count < 0) 791 return -EINVAL; 792 793 return sys_read(fd, buf, count); 794 } 795 796 asmlinkage long sys32_write(unsigned int fd, char __user * buf, size_t count) 797 { 798 if ((compat_ssize_t) count < 0) 799 return -EINVAL; 800 801 return sys_write(fd, buf, count); 802 } 803 804 asmlinkage long sys32_clone(void) 805 { 806 struct pt_regs *regs = task_pt_regs(current); 807 unsigned long clone_flags; 808 unsigned long newsp; 809 int __user *parent_tidptr, *child_tidptr; 810 811 clone_flags = regs->gprs[3] & 0xffffffffUL; 812 newsp = regs->orig_gpr2 & 0x7fffffffUL; 813 parent_tidptr = compat_ptr(regs->gprs[4]); 814 child_tidptr = compat_ptr(regs->gprs[5]); 815 if (!newsp) 816 newsp = regs->gprs[15]; 817 return do_fork(clone_flags, newsp, regs, 0, 818 parent_tidptr, child_tidptr); 819 } 820 821 /* 822 * 31 bit emulation wrapper functions for sys_fadvise64/fadvise64_64. 823 * These need to rewrite the advise values for POSIX_FADV_{DONTNEED,NOREUSE} 824 * because the 31 bit values differ from the 64 bit values. 825 */ 826 827 asmlinkage long 828 sys32_fadvise64(int fd, loff_t offset, size_t len, int advise) 829 { 830 if (advise == 4) 831 advise = POSIX_FADV_DONTNEED; 832 else if (advise == 5) 833 advise = POSIX_FADV_NOREUSE; 834 return sys_fadvise64(fd, offset, len, advise); 835 } 836 837 struct fadvise64_64_args { 838 int fd; 839 long long offset; 840 long long len; 841 int advice; 842 }; 843 844 asmlinkage long 845 sys32_fadvise64_64(struct fadvise64_64_args __user *args) 846 { 847 struct fadvise64_64_args a; 848 849 if ( copy_from_user(&a, args, sizeof(a)) ) 850 return -EFAULT; 851 if (a.advice == 4) 852 a.advice = POSIX_FADV_DONTNEED; 853 else if (a.advice == 5) 854 a.advice = POSIX_FADV_NOREUSE; 855 return sys_fadvise64_64(a.fd, a.offset, a.len, a.advice); 856 } 857