1 /* 2 * Conversion between 32-bit and 64-bit native system calls. 3 * 4 * Copyright (C) 2000 Silicon Graphics, Inc. 5 * Written by Ulf Carlsson (ulfc@engr.sgi.com) 6 * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com) 7 */ 8 #include <linux/compiler.h> 9 #include <linux/mm.h> 10 #include <linux/errno.h> 11 #include <linux/file.h> 12 #include <linux/smp_lock.h> 13 #include <linux/highuid.h> 14 #include <linux/dirent.h> 15 #include <linux/resource.h> 16 #include <linux/highmem.h> 17 #include <linux/time.h> 18 #include <linux/times.h> 19 #include <linux/poll.h> 20 #include <linux/slab.h> 21 #include <linux/skbuff.h> 22 #include <linux/filter.h> 23 #include <linux/shm.h> 24 #include <linux/sem.h> 25 #include <linux/msg.h> 26 #include <linux/icmpv6.h> 27 #include <linux/syscalls.h> 28 #include <linux/sysctl.h> 29 #include <linux/utime.h> 30 #include <linux/utsname.h> 31 #include <linux/personality.h> 32 #include <linux/dnotify.h> 33 #include <linux/module.h> 34 #include <linux/binfmts.h> 35 #include <linux/security.h> 36 #include <linux/compat.h> 37 #include <linux/vfs.h> 38 39 #include <net/sock.h> 40 #include <net/scm.h> 41 42 #include <asm/compat-signal.h> 43 #include <asm/ipc.h> 44 #include <asm/sim.h> 45 #include <asm/uaccess.h> 46 #include <asm/mmu_context.h> 47 #include <asm/mman.h> 48 49 /* Use this to get at 32-bit user passed pointers. */ 50 /* A() macro should be used for places where you e.g. 51 have some internal variable u32 and just want to get 52 rid of a compiler warning. AA() has to be used in 53 places where you want to convert a function argument 54 to 32bit pointer or when you e.g. access pt_regs 55 structure and want to consider 32bit registers only. 56 */ 57 #define A(__x) ((unsigned long)(__x)) 58 #define AA(__x) ((unsigned long)((int)__x)) 59 60 #ifdef __MIPSEB__ 61 #define merge_64(r1,r2) ((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL)) 62 #endif 63 #ifdef __MIPSEL__ 64 #define merge_64(r1,r2) ((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL)) 65 #endif 66 67 /* 68 * Revalidate the inode. This is required for proper NFS attribute caching. 69 */ 70 71 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf) 72 { 73 struct compat_stat tmp; 74 75 if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev)) 76 return -EOVERFLOW; 77 78 memset(&tmp, 0, sizeof(tmp)); 79 tmp.st_dev = new_encode_dev(stat->dev); 80 tmp.st_ino = stat->ino; 81 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 82 return -EOVERFLOW; 83 tmp.st_mode = stat->mode; 84 tmp.st_nlink = stat->nlink; 85 SET_UID(tmp.st_uid, stat->uid); 86 SET_GID(tmp.st_gid, stat->gid); 87 tmp.st_rdev = new_encode_dev(stat->rdev); 88 tmp.st_size = stat->size; 89 tmp.st_atime = stat->atime.tv_sec; 90 tmp.st_mtime = stat->mtime.tv_sec; 91 tmp.st_ctime = stat->ctime.tv_sec; 92 #ifdef STAT_HAVE_NSEC 93 tmp.st_atime_nsec = stat->atime.tv_nsec; 94 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 95 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 96 #endif 97 tmp.st_blocks = stat->blocks; 98 tmp.st_blksize = stat->blksize; 99 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 100 } 101 102 asmlinkage unsigned long 103 sys32_mmap2(unsigned long addr, unsigned long len, unsigned long prot, 104 unsigned long flags, unsigned long fd, unsigned long pgoff) 105 { 106 struct file * file = NULL; 107 unsigned long error; 108 109 error = -EINVAL; 110 if (pgoff & (~PAGE_MASK >> 12)) 111 goto out; 112 pgoff >>= PAGE_SHIFT-12; 113 114 if (!(flags & MAP_ANONYMOUS)) { 115 error = -EBADF; 116 file = fget(fd); 117 if (!file) 118 goto out; 119 } 120 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); 121 122 down_write(¤t->mm->mmap_sem); 123 error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); 124 up_write(¤t->mm->mmap_sem); 125 if (file) 126 fput(file); 127 128 out: 129 return error; 130 } 131 132 133 asmlinkage int sys_truncate64(const char __user *path, unsigned int high, 134 unsigned int low) 135 { 136 if ((int)high < 0) 137 return -EINVAL; 138 return sys_truncate(path, ((long) high << 32) | low); 139 } 140 141 asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high, 142 unsigned int low) 143 { 144 if ((int)high < 0) 145 return -EINVAL; 146 return sys_ftruncate(fd, ((long) high << 32) | low); 147 } 148 149 /* 150 * sys_execve() executes a new program. 151 */ 152 asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs) 153 { 154 int error; 155 char * filename; 156 157 filename = getname(compat_ptr(regs.regs[4])); 158 error = PTR_ERR(filename); 159 if (IS_ERR(filename)) 160 goto out; 161 error = compat_do_execve(filename, compat_ptr(regs.regs[5]), 162 compat_ptr(regs.regs[6]), ®s); 163 putname(filename); 164 165 out: 166 return error; 167 } 168 169 asmlinkage long 170 sysn32_waitid(int which, compat_pid_t pid, 171 siginfo_t __user *uinfo, int options, 172 struct compat_rusage __user *uru) 173 { 174 struct rusage ru; 175 long ret; 176 mm_segment_t old_fs = get_fs(); 177 int si_signo; 178 179 if (!access_ok(VERIFY_WRITE, uinfo, sizeof(*uinfo))) 180 return -EFAULT; 181 182 set_fs (KERNEL_DS); 183 ret = sys_waitid(which, pid, uinfo, options, 184 uru ? (struct rusage __user *) &ru : NULL); 185 set_fs (old_fs); 186 187 if (__get_user(si_signo, &uinfo->si_signo)) 188 return -EFAULT; 189 if (ret < 0 || si_signo == 0) 190 return ret; 191 192 if (uru) 193 ret = put_compat_rusage(&ru, uru); 194 return ret; 195 } 196 197 #define RLIM_INFINITY32 0x7fffffff 198 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x) 199 200 struct rlimit32 { 201 int rlim_cur; 202 int rlim_max; 203 }; 204 205 #ifdef __MIPSEB__ 206 asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy, 207 int length_hi, int length_lo) 208 #endif 209 #ifdef __MIPSEL__ 210 asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy, 211 int length_lo, int length_hi) 212 #endif 213 { 214 loff_t length; 215 216 length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo; 217 218 return sys_truncate(path, length); 219 } 220 221 #ifdef __MIPSEB__ 222 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy, 223 int length_hi, int length_lo) 224 #endif 225 #ifdef __MIPSEL__ 226 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy, 227 int length_lo, int length_hi) 228 #endif 229 { 230 loff_t length; 231 232 length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo; 233 234 return sys_ftruncate(fd, length); 235 } 236 237 static inline long 238 get_tv32(struct timeval *o, struct compat_timeval __user *i) 239 { 240 return (!access_ok(VERIFY_READ, i, sizeof(*i)) || 241 (__get_user(o->tv_sec, &i->tv_sec) | 242 __get_user(o->tv_usec, &i->tv_usec))); 243 } 244 245 static inline long 246 put_tv32(struct compat_timeval __user *o, struct timeval *i) 247 { 248 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) || 249 (__put_user(i->tv_sec, &o->tv_sec) | 250 __put_user(i->tv_usec, &o->tv_usec))); 251 } 252 253 extern struct timezone sys_tz; 254 255 asmlinkage int 256 sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 257 { 258 if (tv) { 259 struct timeval ktv; 260 do_gettimeofday(&ktv); 261 if (put_tv32(tv, &ktv)) 262 return -EFAULT; 263 } 264 if (tz) { 265 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 266 return -EFAULT; 267 } 268 return 0; 269 } 270 271 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i) 272 { 273 long usec; 274 275 if (!access_ok(VERIFY_READ, i, sizeof(*i))) 276 return -EFAULT; 277 if (__get_user(o->tv_sec, &i->tv_sec)) 278 return -EFAULT; 279 if (__get_user(usec, &i->tv_usec)) 280 return -EFAULT; 281 o->tv_nsec = usec * 1000; 282 return 0; 283 } 284 285 asmlinkage int 286 sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 287 { 288 struct timespec kts; 289 struct timezone ktz; 290 291 if (tv) { 292 if (get_ts32(&kts, tv)) 293 return -EFAULT; 294 } 295 if (tz) { 296 if (copy_from_user(&ktz, tz, sizeof(ktz))) 297 return -EFAULT; 298 } 299 300 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL); 301 } 302 303 asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high, 304 unsigned int offset_low, loff_t __user * result, 305 unsigned int origin) 306 { 307 return sys_llseek(fd, offset_high, offset_low, result, origin); 308 } 309 310 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op + 311 lseek back to original location. They fail just like lseek does on 312 non-seekable files. */ 313 314 asmlinkage ssize_t sys32_pread(unsigned int fd, char __user * buf, 315 size_t count, u32 unused, u64 a4, u64 a5) 316 { 317 return sys_pread64(fd, buf, count, merge_64(a4, a5)); 318 } 319 320 asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char __user * buf, 321 size_t count, u32 unused, u64 a4, u64 a5) 322 { 323 return sys_pwrite64(fd, buf, count, merge_64(a4, a5)); 324 } 325 326 asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid, 327 struct compat_timespec __user *interval) 328 { 329 struct timespec t; 330 int ret; 331 mm_segment_t old_fs = get_fs (); 332 333 set_fs (KERNEL_DS); 334 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); 335 set_fs (old_fs); 336 if (put_user (t.tv_sec, &interval->tv_sec) || 337 __put_user (t.tv_nsec, &interval->tv_nsec)) 338 return -EFAULT; 339 return ret; 340 } 341 342 asmlinkage long 343 sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth) 344 { 345 int version, err; 346 347 version = call >> 16; /* hack for backward compatibility */ 348 call &= 0xffff; 349 350 switch (call) { 351 case SEMOP: 352 /* struct sembuf is the same on 32 and 64bit :)) */ 353 err = sys_semtimedop(first, compat_ptr(ptr), second, NULL); 354 break; 355 case SEMTIMEDOP: 356 err = compat_sys_semtimedop(first, compat_ptr(ptr), second, 357 compat_ptr(fifth)); 358 break; 359 case SEMGET: 360 err = sys_semget(first, second, third); 361 break; 362 case SEMCTL: 363 err = compat_sys_semctl(first, second, third, compat_ptr(ptr)); 364 break; 365 case MSGSND: 366 err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr)); 367 break; 368 case MSGRCV: 369 err = compat_sys_msgrcv(first, second, fifth, third, 370 version, compat_ptr(ptr)); 371 break; 372 case MSGGET: 373 err = sys_msgget((key_t) first, second); 374 break; 375 case MSGCTL: 376 err = compat_sys_msgctl(first, second, compat_ptr(ptr)); 377 break; 378 case SHMAT: 379 err = compat_sys_shmat(first, second, third, version, 380 compat_ptr(ptr)); 381 break; 382 case SHMDT: 383 err = sys_shmdt(compat_ptr(ptr)); 384 break; 385 case SHMGET: 386 err = sys_shmget(first, (unsigned)second, third); 387 break; 388 case SHMCTL: 389 err = compat_sys_shmctl(first, second, compat_ptr(ptr)); 390 break; 391 default: 392 err = -EINVAL; 393 break; 394 } 395 396 return err; 397 } 398 399 #ifdef CONFIG_MIPS32_N32 400 asmlinkage long sysn32_semctl(int semid, int semnum, int cmd, u32 arg) 401 { 402 /* compat_sys_semctl expects a pointer to union semun */ 403 u32 __user *uptr = compat_alloc_user_space(sizeof(u32)); 404 if (put_user(arg, uptr)) 405 return -EFAULT; 406 return compat_sys_semctl(semid, semnum, cmd, uptr); 407 } 408 409 asmlinkage long sysn32_msgsnd(int msqid, u32 msgp, unsigned msgsz, int msgflg) 410 { 411 return compat_sys_msgsnd(msqid, msgsz, msgflg, compat_ptr(msgp)); 412 } 413 414 asmlinkage long sysn32_msgrcv(int msqid, u32 msgp, size_t msgsz, int msgtyp, 415 int msgflg) 416 { 417 return compat_sys_msgrcv(msqid, msgsz, msgtyp, msgflg, IPC_64, 418 compat_ptr(msgp)); 419 } 420 #endif 421 422 struct sysctl_args32 423 { 424 compat_caddr_t name; 425 int nlen; 426 compat_caddr_t oldval; 427 compat_caddr_t oldlenp; 428 compat_caddr_t newval; 429 compat_size_t newlen; 430 unsigned int __unused[4]; 431 }; 432 433 #ifdef CONFIG_SYSCTL_SYSCALL 434 435 asmlinkage long sys32_sysctl(struct sysctl_args32 __user *args) 436 { 437 struct sysctl_args32 tmp; 438 int error; 439 size_t oldlen; 440 size_t __user *oldlenp = NULL; 441 unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7; 442 443 if (copy_from_user(&tmp, args, sizeof(tmp))) 444 return -EFAULT; 445 446 if (tmp.oldval && tmp.oldlenp) { 447 /* Duh, this is ugly and might not work if sysctl_args 448 is in read-only memory, but do_sysctl does indirectly 449 a lot of uaccess in both directions and we'd have to 450 basically copy the whole sysctl.c here, and 451 glibc's __sysctl uses rw memory for the structure 452 anyway. */ 453 if (get_user(oldlen, (u32 __user *)A(tmp.oldlenp)) || 454 put_user(oldlen, (size_t __user *)addr)) 455 return -EFAULT; 456 oldlenp = (size_t __user *)addr; 457 } 458 459 lock_kernel(); 460 error = do_sysctl((int __user *)A(tmp.name), tmp.nlen, (void __user *)A(tmp.oldval), 461 oldlenp, (void __user *)A(tmp.newval), tmp.newlen); 462 unlock_kernel(); 463 if (oldlenp) { 464 if (!error) { 465 if (get_user(oldlen, (size_t __user *)addr) || 466 put_user(oldlen, (u32 __user *)A(tmp.oldlenp))) 467 error = -EFAULT; 468 } 469 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)); 470 } 471 return error; 472 } 473 474 #endif /* CONFIG_SYSCTL_SYSCALL */ 475 476 asmlinkage long sys32_newuname(struct new_utsname __user * name) 477 { 478 int ret = 0; 479 480 down_read(&uts_sem); 481 if (copy_to_user(name, utsname(), sizeof *name)) 482 ret = -EFAULT; 483 up_read(&uts_sem); 484 485 if (current->personality == PER_LINUX32 && !ret) 486 if (copy_to_user(name->machine, "mips\0\0\0", 8)) 487 ret = -EFAULT; 488 489 return ret; 490 } 491 492 asmlinkage int sys32_personality(unsigned long personality) 493 { 494 int ret; 495 personality &= 0xffffffff; 496 if (personality(current->personality) == PER_LINUX32 && 497 personality == PER_LINUX) 498 personality = PER_LINUX32; 499 ret = sys_personality(personality); 500 if (ret == PER_LINUX32) 501 ret = PER_LINUX; 502 return ret; 503 } 504 505 /* ustat compatibility */ 506 struct ustat32 { 507 compat_daddr_t f_tfree; 508 compat_ino_t f_tinode; 509 char f_fname[6]; 510 char f_fpack[6]; 511 }; 512 513 extern asmlinkage long sys_ustat(dev_t dev, struct ustat __user * ubuf); 514 515 asmlinkage int sys32_ustat(dev_t dev, struct ustat32 __user * ubuf32) 516 { 517 int err; 518 struct ustat tmp; 519 struct ustat32 tmp32; 520 mm_segment_t old_fs = get_fs(); 521 522 set_fs(KERNEL_DS); 523 err = sys_ustat(dev, (struct ustat __user *)&tmp); 524 set_fs (old_fs); 525 526 if (err) 527 goto out; 528 529 memset(&tmp32,0,sizeof(struct ustat32)); 530 tmp32.f_tfree = tmp.f_tfree; 531 tmp32.f_tinode = tmp.f_tinode; 532 533 err = copy_to_user(ubuf32,&tmp32,sizeof(struct ustat32)) ? -EFAULT : 0; 534 535 out: 536 return err; 537 } 538 539 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, 540 s32 count) 541 { 542 mm_segment_t old_fs = get_fs(); 543 int ret; 544 off_t of; 545 546 if (offset && get_user(of, offset)) 547 return -EFAULT; 548 549 set_fs(KERNEL_DS); 550 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count); 551 set_fs(old_fs); 552 553 if (offset && put_user(of, offset)) 554 return -EFAULT; 555 556 return ret; 557 } 558 559 asmlinkage ssize_t sys32_readahead(int fd, u32 pad0, u64 a2, u64 a3, 560 size_t count) 561 { 562 return sys_readahead(fd, merge_64(a2, a3), count); 563 } 564 565 asmlinkage long sys32_sync_file_range(int fd, int __pad, 566 unsigned long a2, unsigned long a3, 567 unsigned long a4, unsigned long a5, 568 int flags) 569 { 570 return sys_sync_file_range(fd, 571 merge_64(a2, a3), merge_64(a4, a5), 572 flags); 573 } 574 575 /* Argument list sizes for sys_socketcall */ 576 #define AL(x) ((x) * sizeof(unsigned int)) 577 static unsigned char socketcall_nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 578 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 579 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)}; 580 #undef AL 581 582 /* 583 * System call vectors. 584 * 585 * Argument checking cleaned up. Saved 20% in size. 586 * This function doesn't need to set the kernel lock because 587 * it is set by the callees. 588 */ 589 590 asmlinkage long sys32_socketcall(int call, unsigned int __user *args32) 591 { 592 unsigned int a[6]; 593 unsigned int a0,a1; 594 int err; 595 596 extern asmlinkage long sys_socket(int family, int type, int protocol); 597 extern asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen); 598 extern asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen); 599 extern asmlinkage long sys_listen(int fd, int backlog); 600 extern asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen); 601 extern asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len); 602 extern asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len); 603 extern asmlinkage long sys_socketpair(int family, int type, int protocol, int __user *usockvec); 604 extern asmlinkage long sys_send(int fd, void __user * buff, size_t len, unsigned flags); 605 extern asmlinkage long sys_sendto(int fd, void __user * buff, size_t len, unsigned flags, 606 struct sockaddr __user *addr, int addr_len); 607 extern asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags); 608 extern asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags, 609 struct sockaddr __user *addr, int __user *addr_len); 610 extern asmlinkage long sys_shutdown(int fd, int how); 611 extern asmlinkage long sys_setsockopt(int fd, int level, int optname, char __user *optval, int optlen); 612 extern asmlinkage long sys_getsockopt(int fd, int level, int optname, char __user *optval, int __user *optlen); 613 extern asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags); 614 extern asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned int flags); 615 616 617 if(call<1||call>SYS_RECVMSG) 618 return -EINVAL; 619 620 /* copy_from_user should be SMP safe. */ 621 if (copy_from_user(a, args32, socketcall_nargs[call])) 622 return -EFAULT; 623 624 a0=a[0]; 625 a1=a[1]; 626 627 switch(call) 628 { 629 case SYS_SOCKET: 630 err = sys_socket(a0,a1,a[2]); 631 break; 632 case SYS_BIND: 633 err = sys_bind(a0,(struct sockaddr __user *)A(a1), a[2]); 634 break; 635 case SYS_CONNECT: 636 err = sys_connect(a0, (struct sockaddr __user *)A(a1), a[2]); 637 break; 638 case SYS_LISTEN: 639 err = sys_listen(a0,a1); 640 break; 641 case SYS_ACCEPT: 642 err = sys_accept(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2])); 643 break; 644 case SYS_GETSOCKNAME: 645 err = sys_getsockname(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2])); 646 break; 647 case SYS_GETPEERNAME: 648 err = sys_getpeername(a0, (struct sockaddr __user *)A(a1), (int __user *)A(a[2])); 649 break; 650 case SYS_SOCKETPAIR: 651 err = sys_socketpair(a0,a1, a[2], (int __user *)A(a[3])); 652 break; 653 case SYS_SEND: 654 err = sys_send(a0, (void __user *)A(a1), a[2], a[3]); 655 break; 656 case SYS_SENDTO: 657 err = sys_sendto(a0,(void __user *)A(a1), a[2], a[3], 658 (struct sockaddr __user *)A(a[4]), a[5]); 659 break; 660 case SYS_RECV: 661 err = sys_recv(a0, (void __user *)A(a1), a[2], a[3]); 662 break; 663 case SYS_RECVFROM: 664 err = sys_recvfrom(a0, (void __user *)A(a1), a[2], a[3], 665 (struct sockaddr __user *)A(a[4]), (int __user *)A(a[5])); 666 break; 667 case SYS_SHUTDOWN: 668 err = sys_shutdown(a0,a1); 669 break; 670 case SYS_SETSOCKOPT: 671 err = sys_setsockopt(a0, a1, a[2], (char __user *)A(a[3]), a[4]); 672 break; 673 case SYS_GETSOCKOPT: 674 err = sys_getsockopt(a0, a1, a[2], (char __user *)A(a[3]), (int __user *)A(a[4])); 675 break; 676 case SYS_SENDMSG: 677 err = sys_sendmsg(a0, (struct msghdr __user *) A(a1), a[2]); 678 break; 679 case SYS_RECVMSG: 680 err = sys_recvmsg(a0, (struct msghdr __user *) A(a1), a[2]); 681 break; 682 default: 683 err = -EINVAL; 684 break; 685 } 686 return err; 687 } 688 689 struct sigevent32 { 690 u32 sigev_value; 691 u32 sigev_signo; 692 u32 sigev_notify; 693 u32 payload[(64 / 4) - 3]; 694 }; 695 696 extern asmlinkage long 697 sys_timer_create(clockid_t which_clock, 698 struct sigevent __user *timer_event_spec, 699 timer_t __user * created_timer_id); 700 701 long 702 sys32_timer_create(u32 clock, struct sigevent32 __user *se32, timer_t __user *timer_id) 703 { 704 struct sigevent __user *p = NULL; 705 if (se32) { 706 struct sigevent se; 707 p = compat_alloc_user_space(sizeof(struct sigevent)); 708 memset(&se, 0, sizeof(struct sigevent)); 709 if (get_user(se.sigev_value.sival_int, &se32->sigev_value) || 710 __get_user(se.sigev_signo, &se32->sigev_signo) || 711 __get_user(se.sigev_notify, &se32->sigev_notify) || 712 __copy_from_user(&se._sigev_un._pad, &se32->payload, 713 sizeof(se32->payload)) || 714 copy_to_user(p, &se, sizeof(se))) 715 return -EFAULT; 716 } 717 return sys_timer_create(clock, p, timer_id); 718 } 719 720 save_static_function(sys32_clone); 721 __attribute_used__ noinline static int 722 _sys32_clone(nabi_no_regargs struct pt_regs regs) 723 { 724 unsigned long clone_flags; 725 unsigned long newsp; 726 int __user *parent_tidptr, *child_tidptr; 727 728 clone_flags = regs.regs[4]; 729 newsp = regs.regs[5]; 730 if (!newsp) 731 newsp = regs.regs[29]; 732 parent_tidptr = (int __user *) regs.regs[6]; 733 734 /* Use __dummy4 instead of getting it off the stack, so that 735 syscall() works. */ 736 child_tidptr = (int __user *) __dummy4; 737 return do_fork(clone_flags, newsp, ®s, 0, 738 parent_tidptr, child_tidptr); 739 } 740 741 /* 742 * Implement the event wait interface for the eventpoll file. It is the kernel 743 * part of the user space epoll_pwait(2). 744 */ 745 asmlinkage long compat_sys_epoll_pwait(int epfd, 746 struct epoll_event __user *events, int maxevents, int timeout, 747 const compat_sigset_t __user *sigmask, size_t sigsetsize) 748 { 749 int error; 750 sigset_t ksigmask, sigsaved; 751 752 /* 753 * If the caller wants a certain signal mask to be set during the wait, 754 * we apply it here. 755 */ 756 if (sigmask) { 757 if (sigsetsize != sizeof(sigset_t)) 758 return -EINVAL; 759 if (!access_ok(VERIFY_READ, sigmask, sizeof(ksigmask))) 760 return -EFAULT; 761 if (__copy_conv_sigset_from_user(&ksigmask, sigmask)) 762 return -EFAULT; 763 sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 764 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved); 765 } 766 767 error = sys_epoll_wait(epfd, events, maxevents, timeout); 768 769 /* 770 * If we changed the signal mask, we need to restore the original one. 771 * In case we've got a signal while waiting, we do not restore the 772 * signal mask yet, and we allow do_signal() to deliver the signal on 773 * the way back to userspace, before the signal mask is restored. 774 */ 775 if (sigmask) { 776 if (error == -EINTR) { 777 memcpy(¤t->saved_sigmask, &sigsaved, 778 sizeof(sigsaved)); 779 set_thread_flag(TIF_RESTORE_SIGMASK); 780 } else 781 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 782 } 783 784 return error; 785 } 786