1 /* 2 * Linux syscalls 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 #define _ATFILE_SOURCE 20 #include "qemu/osdep.h" 21 #include "qemu/cutils.h" 22 #include "qemu/path.h" 23 #include "qemu/memfd.h" 24 #include "qemu/queue.h" 25 #include <elf.h> 26 #include <endian.h> 27 #include <grp.h> 28 #include <sys/ipc.h> 29 #include <sys/msg.h> 30 #include <sys/wait.h> 31 #include <sys/mount.h> 32 #include <sys/file.h> 33 #include <sys/fsuid.h> 34 #include <sys/personality.h> 35 #include <sys/prctl.h> 36 #include <sys/resource.h> 37 #include <sys/swap.h> 38 #include <linux/capability.h> 39 #include <sched.h> 40 #include <sys/timex.h> 41 #include <sys/socket.h> 42 #include <linux/sockios.h> 43 #include <sys/un.h> 44 #include <sys/uio.h> 45 #include <poll.h> 46 #include <sys/times.h> 47 #include <sys/shm.h> 48 #include <sys/sem.h> 49 #include <sys/statfs.h> 50 #include <utime.h> 51 #include <sys/sysinfo.h> 52 #include <sys/signalfd.h> 53 //#include <sys/user.h> 54 #include <netinet/in.h> 55 #include <netinet/ip.h> 56 #include <netinet/tcp.h> 57 #include <netinet/udp.h> 58 #include <linux/wireless.h> 59 #include <linux/icmp.h> 60 #include <linux/icmpv6.h> 61 #include <linux/if_tun.h> 62 #include <linux/in6.h> 63 #include <linux/errqueue.h> 64 #include <linux/random.h> 65 #ifdef CONFIG_TIMERFD 66 #include <sys/timerfd.h> 67 #endif 68 #ifdef CONFIG_EVENTFD 69 #include <sys/eventfd.h> 70 #endif 71 #ifdef CONFIG_EPOLL 72 #include <sys/epoll.h> 73 #endif 74 #ifdef CONFIG_ATTR 75 #include "qemu/xattr.h" 76 #endif 77 #ifdef CONFIG_SENDFILE 78 #include <sys/sendfile.h> 79 #endif 80 #ifdef HAVE_SYS_KCOV_H 81 #include <sys/kcov.h> 82 #endif 83 84 #define termios host_termios 85 #define winsize host_winsize 86 #define termio host_termio 87 #define sgttyb host_sgttyb /* same as target */ 88 #define tchars host_tchars /* same as target */ 89 #define ltchars host_ltchars /* same as target */ 90 91 #include <linux/termios.h> 92 #include <linux/unistd.h> 93 #include <linux/cdrom.h> 94 #include <linux/hdreg.h> 95 #include <linux/soundcard.h> 96 #include <linux/kd.h> 97 #include <linux/mtio.h> 98 #include <linux/fs.h> 99 #include <linux/fd.h> 100 #if defined(CONFIG_FIEMAP) 101 #include <linux/fiemap.h> 102 #endif 103 #include <linux/fb.h> 104 #if defined(CONFIG_USBFS) 105 #include <linux/usbdevice_fs.h> 106 #include <linux/usb/ch9.h> 107 #endif 108 #include <linux/vt.h> 109 #include <linux/dm-ioctl.h> 110 #include <linux/reboot.h> 111 #include <linux/route.h> 112 #include <linux/filter.h> 113 #include <linux/blkpg.h> 114 #include <netpacket/packet.h> 115 #include <linux/netlink.h> 116 #include <linux/if_alg.h> 117 #include <linux/rtc.h> 118 #include <sound/asound.h> 119 #ifdef HAVE_BTRFS_H 120 #include <linux/btrfs.h> 121 #endif 122 #ifdef HAVE_DRM_H 123 #include <libdrm/drm.h> 124 #include <libdrm/i915_drm.h> 125 #endif 126 #include "linux_loop.h" 127 #include "uname.h" 128 129 #include "qemu.h" 130 #include "strace.h" 131 #include "signal-common.h" 132 #include "loader.h" 133 #include "user-mmap.h" 134 #include "safe-syscall.h" 135 #include "qemu/guest-random.h" 136 #include "qemu/selfmap.h" 137 #include "user/syscall-trace.h" 138 #include "qapi/error.h" 139 #include "fd-trans.h" 140 #include "tcg/tcg.h" 141 142 #ifndef CLONE_IO 143 #define CLONE_IO 0x80000000 /* Clone io context */ 144 #endif 145 146 /* We can't directly call the host clone syscall, because this will 147 * badly confuse libc (breaking mutexes, for example). So we must 148 * divide clone flags into: 149 * * flag combinations that look like pthread_create() 150 * * flag combinations that look like fork() 151 * * flags we can implement within QEMU itself 152 * * flags we can't support and will return an error for 153 */ 154 /* For thread creation, all these flags must be present; for 155 * fork, none must be present. 156 */ 157 #define CLONE_THREAD_FLAGS \ 158 (CLONE_VM | CLONE_FS | CLONE_FILES | \ 159 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM) 160 161 /* These flags are ignored: 162 * CLONE_DETACHED is now ignored by the kernel; 163 * CLONE_IO is just an optimisation hint to the I/O scheduler 164 */ 165 #define CLONE_IGNORED_FLAGS \ 166 (CLONE_DETACHED | CLONE_IO) 167 168 /* Flags for fork which we can implement within QEMU itself */ 169 #define CLONE_OPTIONAL_FORK_FLAGS \ 170 (CLONE_SETTLS | CLONE_PARENT_SETTID | \ 171 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID) 172 173 /* Flags for thread creation which we can implement within QEMU itself */ 174 #define CLONE_OPTIONAL_THREAD_FLAGS \ 175 (CLONE_SETTLS | CLONE_PARENT_SETTID | \ 176 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT) 177 178 #define CLONE_INVALID_FORK_FLAGS \ 179 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS)) 180 181 #define CLONE_INVALID_THREAD_FLAGS \ 182 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \ 183 CLONE_IGNORED_FLAGS)) 184 185 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits 186 * have almost all been allocated. We cannot support any of 187 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC, 188 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED. 189 * The checks against the invalid thread masks above will catch these. 190 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.) 191 */ 192 193 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted 194 * once. This exercises the codepaths for restart. 195 */ 196 //#define DEBUG_ERESTARTSYS 197 198 //#include <linux/msdos_fs.h> 199 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2]) 200 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2]) 201 202 #undef _syscall0 203 #undef _syscall1 204 #undef _syscall2 205 #undef _syscall3 206 #undef _syscall4 207 #undef _syscall5 208 #undef _syscall6 209 210 #define _syscall0(type,name) \ 211 static type name (void) \ 212 { \ 213 return syscall(__NR_##name); \ 214 } 215 216 #define _syscall1(type,name,type1,arg1) \ 217 static type name (type1 arg1) \ 218 { \ 219 return syscall(__NR_##name, arg1); \ 220 } 221 222 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 223 static type name (type1 arg1,type2 arg2) \ 224 { \ 225 return syscall(__NR_##name, arg1, arg2); \ 226 } 227 228 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 229 static type name (type1 arg1,type2 arg2,type3 arg3) \ 230 { \ 231 return syscall(__NR_##name, arg1, arg2, arg3); \ 232 } 233 234 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 235 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \ 236 { \ 237 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \ 238 } 239 240 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 241 type5,arg5) \ 242 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \ 243 { \ 244 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \ 245 } 246 247 248 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 249 type5,arg5,type6,arg6) \ 250 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \ 251 type6 arg6) \ 252 { \ 253 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \ 254 } 255 256 257 #define __NR_sys_uname __NR_uname 258 #define __NR_sys_getcwd1 __NR_getcwd 259 #define __NR_sys_getdents __NR_getdents 260 #define __NR_sys_getdents64 __NR_getdents64 261 #define __NR_sys_getpriority __NR_getpriority 262 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo 263 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo 264 #define __NR_sys_syslog __NR_syslog 265 #if defined(__NR_futex) 266 # define __NR_sys_futex __NR_futex 267 #endif 268 #if defined(__NR_futex_time64) 269 # define __NR_sys_futex_time64 __NR_futex_time64 270 #endif 271 #define __NR_sys_inotify_init __NR_inotify_init 272 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch 273 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch 274 #define __NR_sys_statx __NR_statx 275 276 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__) 277 #define __NR__llseek __NR_lseek 278 #endif 279 280 /* Newer kernel ports have llseek() instead of _llseek() */ 281 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek) 282 #define TARGET_NR__llseek TARGET_NR_llseek 283 #endif 284 285 /* some platforms need to mask more bits than just TARGET_O_NONBLOCK */ 286 #ifndef TARGET_O_NONBLOCK_MASK 287 #define TARGET_O_NONBLOCK_MASK TARGET_O_NONBLOCK 288 #endif 289 290 #define __NR_sys_gettid __NR_gettid 291 _syscall0(int, sys_gettid) 292 293 /* For the 64-bit guest on 32-bit host case we must emulate 294 * getdents using getdents64, because otherwise the host 295 * might hand us back more dirent records than we can fit 296 * into the guest buffer after structure format conversion. 297 * Otherwise we emulate getdents with getdents if the host has it. 298 */ 299 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS 300 #define EMULATE_GETDENTS_WITH_GETDENTS 301 #endif 302 303 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS) 304 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count); 305 #endif 306 #if (defined(TARGET_NR_getdents) && \ 307 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \ 308 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64)) 309 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count); 310 #endif 311 #if defined(TARGET_NR__llseek) && defined(__NR_llseek) 312 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, 313 loff_t *, res, uint, wh); 314 #endif 315 _syscall3(int, sys_rt_sigqueueinfo, pid_t, pid, int, sig, siginfo_t *, uinfo) 316 _syscall4(int, sys_rt_tgsigqueueinfo, pid_t, pid, pid_t, tid, int, sig, 317 siginfo_t *, uinfo) 318 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len) 319 #ifdef __NR_exit_group 320 _syscall1(int,exit_group,int,error_code) 321 #endif 322 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) 323 _syscall1(int,set_tid_address,int *,tidptr) 324 #endif 325 #if defined(__NR_futex) 326 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val, 327 const struct timespec *,timeout,int *,uaddr2,int,val3) 328 #endif 329 #if defined(__NR_futex_time64) 330 _syscall6(int,sys_futex_time64,int *,uaddr,int,op,int,val, 331 const struct timespec *,timeout,int *,uaddr2,int,val3) 332 #endif 333 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity 334 _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len, 335 unsigned long *, user_mask_ptr); 336 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity 337 _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len, 338 unsigned long *, user_mask_ptr); 339 #define __NR_sys_getcpu __NR_getcpu 340 _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); 341 _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, 342 void *, arg); 343 _syscall2(int, capget, struct __user_cap_header_struct *, header, 344 struct __user_cap_data_struct *, data); 345 _syscall2(int, capset, struct __user_cap_header_struct *, header, 346 struct __user_cap_data_struct *, data); 347 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get) 348 _syscall2(int, ioprio_get, int, which, int, who) 349 #endif 350 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set) 351 _syscall3(int, ioprio_set, int, which, int, who, int, ioprio) 352 #endif 353 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom) 354 _syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags) 355 #endif 356 357 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp) 358 _syscall5(int, kcmp, pid_t, pid1, pid_t, pid2, int, type, 359 unsigned long, idx1, unsigned long, idx2) 360 #endif 361 362 /* 363 * It is assumed that struct statx is architecture independent. 364 */ 365 #if defined(TARGET_NR_statx) && defined(__NR_statx) 366 _syscall5(int, sys_statx, int, dirfd, const char *, pathname, int, flags, 367 unsigned int, mask, struct target_statx *, statxbuf) 368 #endif 369 #if defined(TARGET_NR_membarrier) && defined(__NR_membarrier) 370 _syscall2(int, membarrier, int, cmd, int, flags) 371 #endif 372 373 static const bitmask_transtbl fcntl_flags_tbl[] = { 374 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, }, 375 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, }, 376 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, }, 377 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, }, 378 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, }, 379 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, }, 380 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, }, 381 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, }, 382 { TARGET_O_SYNC, TARGET_O_DSYNC, O_SYNC, O_DSYNC, }, 383 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, }, 384 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, }, 385 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, }, 386 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, }, 387 #if defined(O_DIRECT) 388 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, }, 389 #endif 390 #if defined(O_NOATIME) 391 { TARGET_O_NOATIME, TARGET_O_NOATIME, O_NOATIME, O_NOATIME }, 392 #endif 393 #if defined(O_CLOEXEC) 394 { TARGET_O_CLOEXEC, TARGET_O_CLOEXEC, O_CLOEXEC, O_CLOEXEC }, 395 #endif 396 #if defined(O_PATH) 397 { TARGET_O_PATH, TARGET_O_PATH, O_PATH, O_PATH }, 398 #endif 399 #if defined(O_TMPFILE) 400 { TARGET_O_TMPFILE, TARGET_O_TMPFILE, O_TMPFILE, O_TMPFILE }, 401 #endif 402 /* Don't terminate the list prematurely on 64-bit host+guest. */ 403 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0 404 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, }, 405 #endif 406 { 0, 0, 0, 0 } 407 }; 408 409 _syscall2(int, sys_getcwd1, char *, buf, size_t, size) 410 411 #if defined(TARGET_NR_utimensat) || defined(TARGET_NR_utimensat_time64) 412 #if defined(__NR_utimensat) 413 #define __NR_sys_utimensat __NR_utimensat 414 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname, 415 const struct timespec *,tsp,int,flags) 416 #else 417 static int sys_utimensat(int dirfd, const char *pathname, 418 const struct timespec times[2], int flags) 419 { 420 errno = ENOSYS; 421 return -1; 422 } 423 #endif 424 #endif /* TARGET_NR_utimensat */ 425 426 #ifdef TARGET_NR_renameat2 427 #if defined(__NR_renameat2) 428 #define __NR_sys_renameat2 __NR_renameat2 429 _syscall5(int, sys_renameat2, int, oldfd, const char *, old, int, newfd, 430 const char *, new, unsigned int, flags) 431 #else 432 static int sys_renameat2(int oldfd, const char *old, 433 int newfd, const char *new, int flags) 434 { 435 if (flags == 0) { 436 return renameat(oldfd, old, newfd, new); 437 } 438 errno = ENOSYS; 439 return -1; 440 } 441 #endif 442 #endif /* TARGET_NR_renameat2 */ 443 444 #ifdef CONFIG_INOTIFY 445 #include <sys/inotify.h> 446 447 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init) 448 static int sys_inotify_init(void) 449 { 450 return (inotify_init()); 451 } 452 #endif 453 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch) 454 static int sys_inotify_add_watch(int fd,const char *pathname, int32_t mask) 455 { 456 return (inotify_add_watch(fd, pathname, mask)); 457 } 458 #endif 459 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch) 460 static int sys_inotify_rm_watch(int fd, int32_t wd) 461 { 462 return (inotify_rm_watch(fd, wd)); 463 } 464 #endif 465 #ifdef CONFIG_INOTIFY1 466 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1) 467 static int sys_inotify_init1(int flags) 468 { 469 return (inotify_init1(flags)); 470 } 471 #endif 472 #endif 473 #else 474 /* Userspace can usually survive runtime without inotify */ 475 #undef TARGET_NR_inotify_init 476 #undef TARGET_NR_inotify_init1 477 #undef TARGET_NR_inotify_add_watch 478 #undef TARGET_NR_inotify_rm_watch 479 #endif /* CONFIG_INOTIFY */ 480 481 #if defined(TARGET_NR_prlimit64) 482 #ifndef __NR_prlimit64 483 # define __NR_prlimit64 -1 484 #endif 485 #define __NR_sys_prlimit64 __NR_prlimit64 486 /* The glibc rlimit structure may not be that used by the underlying syscall */ 487 struct host_rlimit64 { 488 uint64_t rlim_cur; 489 uint64_t rlim_max; 490 }; 491 _syscall4(int, sys_prlimit64, pid_t, pid, int, resource, 492 const struct host_rlimit64 *, new_limit, 493 struct host_rlimit64 *, old_limit) 494 #endif 495 496 497 #if defined(TARGET_NR_timer_create) 498 /* Maximum of 32 active POSIX timers allowed at any one time. */ 499 static timer_t g_posix_timers[32] = { 0, } ; 500 501 static inline int next_free_host_timer(void) 502 { 503 int k ; 504 /* FIXME: Does finding the next free slot require a lock? */ 505 for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) { 506 if (g_posix_timers[k] == 0) { 507 g_posix_timers[k] = (timer_t) 1; 508 return k; 509 } 510 } 511 return -1; 512 } 513 #endif 514 515 static inline int host_to_target_errno(int host_errno) 516 { 517 switch (host_errno) { 518 #define E(X) case X: return TARGET_##X; 519 #include "errnos.c.inc" 520 #undef E 521 default: 522 return host_errno; 523 } 524 } 525 526 static inline int target_to_host_errno(int target_errno) 527 { 528 switch (target_errno) { 529 #define E(X) case TARGET_##X: return X; 530 #include "errnos.c.inc" 531 #undef E 532 default: 533 return target_errno; 534 } 535 } 536 537 static inline abi_long get_errno(abi_long ret) 538 { 539 if (ret == -1) 540 return -host_to_target_errno(errno); 541 else 542 return ret; 543 } 544 545 const char *target_strerror(int err) 546 { 547 if (err == TARGET_ERESTARTSYS) { 548 return "To be restarted"; 549 } 550 if (err == TARGET_QEMU_ESIGRETURN) { 551 return "Successful exit from sigreturn"; 552 } 553 554 return strerror(target_to_host_errno(err)); 555 } 556 557 #define safe_syscall0(type, name) \ 558 static type safe_##name(void) \ 559 { \ 560 return safe_syscall(__NR_##name); \ 561 } 562 563 #define safe_syscall1(type, name, type1, arg1) \ 564 static type safe_##name(type1 arg1) \ 565 { \ 566 return safe_syscall(__NR_##name, arg1); \ 567 } 568 569 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \ 570 static type safe_##name(type1 arg1, type2 arg2) \ 571 { \ 572 return safe_syscall(__NR_##name, arg1, arg2); \ 573 } 574 575 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 576 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \ 577 { \ 578 return safe_syscall(__NR_##name, arg1, arg2, arg3); \ 579 } 580 581 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \ 582 type4, arg4) \ 583 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \ 584 { \ 585 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \ 586 } 587 588 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \ 589 type4, arg4, type5, arg5) \ 590 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 591 type5 arg5) \ 592 { \ 593 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \ 594 } 595 596 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \ 597 type4, arg4, type5, arg5, type6, arg6) \ 598 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 599 type5 arg5, type6 arg6) \ 600 { \ 601 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \ 602 } 603 604 safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count) 605 safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count) 606 safe_syscall4(int, openat, int, dirfd, const char *, pathname, \ 607 int, flags, mode_t, mode) 608 #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid) 609 safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \ 610 struct rusage *, rusage) 611 #endif 612 safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \ 613 int, options, struct rusage *, rusage) 614 safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp) 615 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \ 616 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64) 617 safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \ 618 fd_set *, exceptfds, struct timespec *, timeout, void *, sig) 619 #endif 620 #if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64) 621 safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds, 622 struct timespec *, tsp, const sigset_t *, sigmask, 623 size_t, sigsetsize) 624 #endif 625 safe_syscall6(int, epoll_pwait, int, epfd, struct epoll_event *, events, 626 int, maxevents, int, timeout, const sigset_t *, sigmask, 627 size_t, sigsetsize) 628 #if defined(__NR_futex) 629 safe_syscall6(int,futex,int *,uaddr,int,op,int,val, \ 630 const struct timespec *,timeout,int *,uaddr2,int,val3) 631 #endif 632 #if defined(__NR_futex_time64) 633 safe_syscall6(int,futex_time64,int *,uaddr,int,op,int,val, \ 634 const struct timespec *,timeout,int *,uaddr2,int,val3) 635 #endif 636 safe_syscall2(int, rt_sigsuspend, sigset_t *, newset, size_t, sigsetsize) 637 safe_syscall2(int, kill, pid_t, pid, int, sig) 638 safe_syscall2(int, tkill, int, tid, int, sig) 639 safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig) 640 safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt) 641 safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt) 642 safe_syscall5(ssize_t, preadv, int, fd, const struct iovec *, iov, int, iovcnt, 643 unsigned long, pos_l, unsigned long, pos_h) 644 safe_syscall5(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt, 645 unsigned long, pos_l, unsigned long, pos_h) 646 safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr, 647 socklen_t, addrlen) 648 safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len, 649 int, flags, const struct sockaddr *, addr, socklen_t, addrlen) 650 safe_syscall6(ssize_t, recvfrom, int, fd, void *, buf, size_t, len, 651 int, flags, struct sockaddr *, addr, socklen_t *, addrlen) 652 safe_syscall3(ssize_t, sendmsg, int, fd, const struct msghdr *, msg, int, flags) 653 safe_syscall3(ssize_t, recvmsg, int, fd, struct msghdr *, msg, int, flags) 654 safe_syscall2(int, flock, int, fd, int, operation) 655 #if defined(TARGET_NR_rt_sigtimedwait) || defined(TARGET_NR_rt_sigtimedwait_time64) 656 safe_syscall4(int, rt_sigtimedwait, const sigset_t *, these, siginfo_t *, uinfo, 657 const struct timespec *, uts, size_t, sigsetsize) 658 #endif 659 safe_syscall4(int, accept4, int, fd, struct sockaddr *, addr, socklen_t *, len, 660 int, flags) 661 #if defined(TARGET_NR_nanosleep) 662 safe_syscall2(int, nanosleep, const struct timespec *, req, 663 struct timespec *, rem) 664 #endif 665 #if defined(TARGET_NR_clock_nanosleep) || \ 666 defined(TARGET_NR_clock_nanosleep_time64) 667 safe_syscall4(int, clock_nanosleep, const clockid_t, clock, int, flags, 668 const struct timespec *, req, struct timespec *, rem) 669 #endif 670 #ifdef __NR_ipc 671 #ifdef __s390x__ 672 safe_syscall5(int, ipc, int, call, long, first, long, second, long, third, 673 void *, ptr) 674 #else 675 safe_syscall6(int, ipc, int, call, long, first, long, second, long, third, 676 void *, ptr, long, fifth) 677 #endif 678 #endif 679 #ifdef __NR_msgsnd 680 safe_syscall4(int, msgsnd, int, msgid, const void *, msgp, size_t, sz, 681 int, flags) 682 #endif 683 #ifdef __NR_msgrcv 684 safe_syscall5(int, msgrcv, int, msgid, void *, msgp, size_t, sz, 685 long, msgtype, int, flags) 686 #endif 687 #ifdef __NR_semtimedop 688 safe_syscall4(int, semtimedop, int, semid, struct sembuf *, tsops, 689 unsigned, nsops, const struct timespec *, timeout) 690 #endif 691 #if defined(TARGET_NR_mq_timedsend) || \ 692 defined(TARGET_NR_mq_timedsend_time64) 693 safe_syscall5(int, mq_timedsend, int, mqdes, const char *, msg_ptr, 694 size_t, len, unsigned, prio, const struct timespec *, timeout) 695 #endif 696 #if defined(TARGET_NR_mq_timedreceive) || \ 697 defined(TARGET_NR_mq_timedreceive_time64) 698 safe_syscall5(int, mq_timedreceive, int, mqdes, char *, msg_ptr, 699 size_t, len, unsigned *, prio, const struct timespec *, timeout) 700 #endif 701 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range) 702 safe_syscall6(ssize_t, copy_file_range, int, infd, loff_t *, pinoff, 703 int, outfd, loff_t *, poutoff, size_t, length, 704 unsigned int, flags) 705 #endif 706 707 /* We do ioctl like this rather than via safe_syscall3 to preserve the 708 * "third argument might be integer or pointer or not present" behaviour of 709 * the libc function. 710 */ 711 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__) 712 /* Similarly for fcntl. Note that callers must always: 713 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK 714 * use the flock64 struct rather than unsuffixed flock 715 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts. 716 */ 717 #ifdef __NR_fcntl64 718 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__) 719 #else 720 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__) 721 #endif 722 723 static inline int host_to_target_sock_type(int host_type) 724 { 725 int target_type; 726 727 switch (host_type & 0xf /* SOCK_TYPE_MASK */) { 728 case SOCK_DGRAM: 729 target_type = TARGET_SOCK_DGRAM; 730 break; 731 case SOCK_STREAM: 732 target_type = TARGET_SOCK_STREAM; 733 break; 734 default: 735 target_type = host_type & 0xf /* SOCK_TYPE_MASK */; 736 break; 737 } 738 739 #if defined(SOCK_CLOEXEC) 740 if (host_type & SOCK_CLOEXEC) { 741 target_type |= TARGET_SOCK_CLOEXEC; 742 } 743 #endif 744 745 #if defined(SOCK_NONBLOCK) 746 if (host_type & SOCK_NONBLOCK) { 747 target_type |= TARGET_SOCK_NONBLOCK; 748 } 749 #endif 750 751 return target_type; 752 } 753 754 static abi_ulong target_brk; 755 static abi_ulong target_original_brk; 756 static abi_ulong brk_page; 757 758 void target_set_brk(abi_ulong new_brk) 759 { 760 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk); 761 brk_page = HOST_PAGE_ALIGN(target_brk); 762 } 763 764 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0) 765 #define DEBUGF_BRK(message, args...) 766 767 /* do_brk() must return target values and target errnos. */ 768 abi_long do_brk(abi_ulong new_brk) 769 { 770 abi_long mapped_addr; 771 abi_ulong new_alloc_size; 772 773 /* brk pointers are always untagged */ 774 775 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk); 776 777 if (!new_brk) { 778 DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk); 779 return target_brk; 780 } 781 if (new_brk < target_original_brk) { 782 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n", 783 target_brk); 784 return target_brk; 785 } 786 787 /* If the new brk is less than the highest page reserved to the 788 * target heap allocation, set it and we're almost done... */ 789 if (new_brk <= brk_page) { 790 /* Heap contents are initialized to zero, as for anonymous 791 * mapped pages. */ 792 if (new_brk > target_brk) { 793 memset(g2h_untagged(target_brk), 0, new_brk - target_brk); 794 } 795 target_brk = new_brk; 796 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk); 797 return target_brk; 798 } 799 800 /* We need to allocate more memory after the brk... Note that 801 * we don't use MAP_FIXED because that will map over the top of 802 * any existing mapping (like the one with the host libc or qemu 803 * itself); instead we treat "mapped but at wrong address" as 804 * a failure and unmap again. 805 */ 806 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page); 807 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size, 808 PROT_READ|PROT_WRITE, 809 MAP_ANON|MAP_PRIVATE, 0, 0)); 810 811 if (mapped_addr == brk_page) { 812 /* Heap contents are initialized to zero, as for anonymous 813 * mapped pages. Technically the new pages are already 814 * initialized to zero since they *are* anonymous mapped 815 * pages, however we have to take care with the contents that 816 * come from the remaining part of the previous page: it may 817 * contains garbage data due to a previous heap usage (grown 818 * then shrunken). */ 819 memset(g2h_untagged(target_brk), 0, brk_page - target_brk); 820 821 target_brk = new_brk; 822 brk_page = HOST_PAGE_ALIGN(target_brk); 823 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n", 824 target_brk); 825 return target_brk; 826 } else if (mapped_addr != -1) { 827 /* Mapped but at wrong address, meaning there wasn't actually 828 * enough space for this brk. 829 */ 830 target_munmap(mapped_addr, new_alloc_size); 831 mapped_addr = -1; 832 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk); 833 } 834 else { 835 DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk); 836 } 837 838 #if defined(TARGET_ALPHA) 839 /* We (partially) emulate OSF/1 on Alpha, which requires we 840 return a proper errno, not an unchanged brk value. */ 841 return -TARGET_ENOMEM; 842 #endif 843 /* For everything else, return the previous break. */ 844 return target_brk; 845 } 846 847 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \ 848 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64) 849 static inline abi_long copy_from_user_fdset(fd_set *fds, 850 abi_ulong target_fds_addr, 851 int n) 852 { 853 int i, nw, j, k; 854 abi_ulong b, *target_fds; 855 856 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS); 857 if (!(target_fds = lock_user(VERIFY_READ, 858 target_fds_addr, 859 sizeof(abi_ulong) * nw, 860 1))) 861 return -TARGET_EFAULT; 862 863 FD_ZERO(fds); 864 k = 0; 865 for (i = 0; i < nw; i++) { 866 /* grab the abi_ulong */ 867 __get_user(b, &target_fds[i]); 868 for (j = 0; j < TARGET_ABI_BITS; j++) { 869 /* check the bit inside the abi_ulong */ 870 if ((b >> j) & 1) 871 FD_SET(k, fds); 872 k++; 873 } 874 } 875 876 unlock_user(target_fds, target_fds_addr, 0); 877 878 return 0; 879 } 880 881 static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr, 882 abi_ulong target_fds_addr, 883 int n) 884 { 885 if (target_fds_addr) { 886 if (copy_from_user_fdset(fds, target_fds_addr, n)) 887 return -TARGET_EFAULT; 888 *fds_ptr = fds; 889 } else { 890 *fds_ptr = NULL; 891 } 892 return 0; 893 } 894 895 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr, 896 const fd_set *fds, 897 int n) 898 { 899 int i, nw, j, k; 900 abi_long v; 901 abi_ulong *target_fds; 902 903 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS); 904 if (!(target_fds = lock_user(VERIFY_WRITE, 905 target_fds_addr, 906 sizeof(abi_ulong) * nw, 907 0))) 908 return -TARGET_EFAULT; 909 910 k = 0; 911 for (i = 0; i < nw; i++) { 912 v = 0; 913 for (j = 0; j < TARGET_ABI_BITS; j++) { 914 v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j); 915 k++; 916 } 917 __put_user(v, &target_fds[i]); 918 } 919 920 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw); 921 922 return 0; 923 } 924 #endif 925 926 #if defined(__alpha__) 927 #define HOST_HZ 1024 928 #else 929 #define HOST_HZ 100 930 #endif 931 932 static inline abi_long host_to_target_clock_t(long ticks) 933 { 934 #if HOST_HZ == TARGET_HZ 935 return ticks; 936 #else 937 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ; 938 #endif 939 } 940 941 static inline abi_long host_to_target_rusage(abi_ulong target_addr, 942 const struct rusage *rusage) 943 { 944 struct target_rusage *target_rusage; 945 946 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0)) 947 return -TARGET_EFAULT; 948 target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec); 949 target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec); 950 target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec); 951 target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec); 952 target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss); 953 target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss); 954 target_rusage->ru_idrss = tswapal(rusage->ru_idrss); 955 target_rusage->ru_isrss = tswapal(rusage->ru_isrss); 956 target_rusage->ru_minflt = tswapal(rusage->ru_minflt); 957 target_rusage->ru_majflt = tswapal(rusage->ru_majflt); 958 target_rusage->ru_nswap = tswapal(rusage->ru_nswap); 959 target_rusage->ru_inblock = tswapal(rusage->ru_inblock); 960 target_rusage->ru_oublock = tswapal(rusage->ru_oublock); 961 target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd); 962 target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv); 963 target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals); 964 target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw); 965 target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw); 966 unlock_user_struct(target_rusage, target_addr, 1); 967 968 return 0; 969 } 970 971 #ifdef TARGET_NR_setrlimit 972 static inline rlim_t target_to_host_rlim(abi_ulong target_rlim) 973 { 974 abi_ulong target_rlim_swap; 975 rlim_t result; 976 977 target_rlim_swap = tswapal(target_rlim); 978 if (target_rlim_swap == TARGET_RLIM_INFINITY) 979 return RLIM_INFINITY; 980 981 result = target_rlim_swap; 982 if (target_rlim_swap != (rlim_t)result) 983 return RLIM_INFINITY; 984 985 return result; 986 } 987 #endif 988 989 #if defined(TARGET_NR_getrlimit) || defined(TARGET_NR_ugetrlimit) 990 static inline abi_ulong host_to_target_rlim(rlim_t rlim) 991 { 992 abi_ulong target_rlim_swap; 993 abi_ulong result; 994 995 if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim) 996 target_rlim_swap = TARGET_RLIM_INFINITY; 997 else 998 target_rlim_swap = rlim; 999 result = tswapal(target_rlim_swap); 1000 1001 return result; 1002 } 1003 #endif 1004 1005 static inline int target_to_host_resource(int code) 1006 { 1007 switch (code) { 1008 case TARGET_RLIMIT_AS: 1009 return RLIMIT_AS; 1010 case TARGET_RLIMIT_CORE: 1011 return RLIMIT_CORE; 1012 case TARGET_RLIMIT_CPU: 1013 return RLIMIT_CPU; 1014 case TARGET_RLIMIT_DATA: 1015 return RLIMIT_DATA; 1016 case TARGET_RLIMIT_FSIZE: 1017 return RLIMIT_FSIZE; 1018 case TARGET_RLIMIT_LOCKS: 1019 return RLIMIT_LOCKS; 1020 case TARGET_RLIMIT_MEMLOCK: 1021 return RLIMIT_MEMLOCK; 1022 case TARGET_RLIMIT_MSGQUEUE: 1023 return RLIMIT_MSGQUEUE; 1024 case TARGET_RLIMIT_NICE: 1025 return RLIMIT_NICE; 1026 case TARGET_RLIMIT_NOFILE: 1027 return RLIMIT_NOFILE; 1028 case TARGET_RLIMIT_NPROC: 1029 return RLIMIT_NPROC; 1030 case TARGET_RLIMIT_RSS: 1031 return RLIMIT_RSS; 1032 case TARGET_RLIMIT_RTPRIO: 1033 return RLIMIT_RTPRIO; 1034 case TARGET_RLIMIT_SIGPENDING: 1035 return RLIMIT_SIGPENDING; 1036 case TARGET_RLIMIT_STACK: 1037 return RLIMIT_STACK; 1038 default: 1039 return code; 1040 } 1041 } 1042 1043 static inline abi_long copy_from_user_timeval(struct timeval *tv, 1044 abi_ulong target_tv_addr) 1045 { 1046 struct target_timeval *target_tv; 1047 1048 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) { 1049 return -TARGET_EFAULT; 1050 } 1051 1052 __get_user(tv->tv_sec, &target_tv->tv_sec); 1053 __get_user(tv->tv_usec, &target_tv->tv_usec); 1054 1055 unlock_user_struct(target_tv, target_tv_addr, 0); 1056 1057 return 0; 1058 } 1059 1060 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr, 1061 const struct timeval *tv) 1062 { 1063 struct target_timeval *target_tv; 1064 1065 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) { 1066 return -TARGET_EFAULT; 1067 } 1068 1069 __put_user(tv->tv_sec, &target_tv->tv_sec); 1070 __put_user(tv->tv_usec, &target_tv->tv_usec); 1071 1072 unlock_user_struct(target_tv, target_tv_addr, 1); 1073 1074 return 0; 1075 } 1076 1077 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME) 1078 static inline abi_long copy_from_user_timeval64(struct timeval *tv, 1079 abi_ulong target_tv_addr) 1080 { 1081 struct target__kernel_sock_timeval *target_tv; 1082 1083 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) { 1084 return -TARGET_EFAULT; 1085 } 1086 1087 __get_user(tv->tv_sec, &target_tv->tv_sec); 1088 __get_user(tv->tv_usec, &target_tv->tv_usec); 1089 1090 unlock_user_struct(target_tv, target_tv_addr, 0); 1091 1092 return 0; 1093 } 1094 #endif 1095 1096 static inline abi_long copy_to_user_timeval64(abi_ulong target_tv_addr, 1097 const struct timeval *tv) 1098 { 1099 struct target__kernel_sock_timeval *target_tv; 1100 1101 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) { 1102 return -TARGET_EFAULT; 1103 } 1104 1105 __put_user(tv->tv_sec, &target_tv->tv_sec); 1106 __put_user(tv->tv_usec, &target_tv->tv_usec); 1107 1108 unlock_user_struct(target_tv, target_tv_addr, 1); 1109 1110 return 0; 1111 } 1112 1113 #if defined(TARGET_NR_futex) || \ 1114 defined(TARGET_NR_rt_sigtimedwait) || \ 1115 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6) || \ 1116 defined(TARGET_NR_nanosleep) || defined(TARGET_NR_clock_settime) || \ 1117 defined(TARGET_NR_utimensat) || defined(TARGET_NR_mq_timedsend) || \ 1118 defined(TARGET_NR_mq_timedreceive) || defined(TARGET_NR_ipc) || \ 1119 defined(TARGET_NR_semop) || defined(TARGET_NR_semtimedop) || \ 1120 defined(TARGET_NR_timer_settime) || \ 1121 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)) 1122 static inline abi_long target_to_host_timespec(struct timespec *host_ts, 1123 abi_ulong target_addr) 1124 { 1125 struct target_timespec *target_ts; 1126 1127 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) { 1128 return -TARGET_EFAULT; 1129 } 1130 __get_user(host_ts->tv_sec, &target_ts->tv_sec); 1131 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec); 1132 unlock_user_struct(target_ts, target_addr, 0); 1133 return 0; 1134 } 1135 #endif 1136 1137 #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \ 1138 defined(TARGET_NR_timer_settime64) || \ 1139 defined(TARGET_NR_mq_timedsend_time64) || \ 1140 defined(TARGET_NR_mq_timedreceive_time64) || \ 1141 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)) || \ 1142 defined(TARGET_NR_clock_nanosleep_time64) || \ 1143 defined(TARGET_NR_rt_sigtimedwait_time64) || \ 1144 defined(TARGET_NR_utimensat) || \ 1145 defined(TARGET_NR_utimensat_time64) || \ 1146 defined(TARGET_NR_semtimedop_time64) || \ 1147 defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) 1148 static inline abi_long target_to_host_timespec64(struct timespec *host_ts, 1149 abi_ulong target_addr) 1150 { 1151 struct target__kernel_timespec *target_ts; 1152 1153 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) { 1154 return -TARGET_EFAULT; 1155 } 1156 __get_user(host_ts->tv_sec, &target_ts->tv_sec); 1157 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec); 1158 /* in 32bit mode, this drops the padding */ 1159 host_ts->tv_nsec = (long)(abi_long)host_ts->tv_nsec; 1160 unlock_user_struct(target_ts, target_addr, 0); 1161 return 0; 1162 } 1163 #endif 1164 1165 static inline abi_long host_to_target_timespec(abi_ulong target_addr, 1166 struct timespec *host_ts) 1167 { 1168 struct target_timespec *target_ts; 1169 1170 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) { 1171 return -TARGET_EFAULT; 1172 } 1173 __put_user(host_ts->tv_sec, &target_ts->tv_sec); 1174 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec); 1175 unlock_user_struct(target_ts, target_addr, 1); 1176 return 0; 1177 } 1178 1179 static inline abi_long host_to_target_timespec64(abi_ulong target_addr, 1180 struct timespec *host_ts) 1181 { 1182 struct target__kernel_timespec *target_ts; 1183 1184 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) { 1185 return -TARGET_EFAULT; 1186 } 1187 __put_user(host_ts->tv_sec, &target_ts->tv_sec); 1188 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec); 1189 unlock_user_struct(target_ts, target_addr, 1); 1190 return 0; 1191 } 1192 1193 #if defined(TARGET_NR_gettimeofday) 1194 static inline abi_long copy_to_user_timezone(abi_ulong target_tz_addr, 1195 struct timezone *tz) 1196 { 1197 struct target_timezone *target_tz; 1198 1199 if (!lock_user_struct(VERIFY_WRITE, target_tz, target_tz_addr, 1)) { 1200 return -TARGET_EFAULT; 1201 } 1202 1203 __put_user(tz->tz_minuteswest, &target_tz->tz_minuteswest); 1204 __put_user(tz->tz_dsttime, &target_tz->tz_dsttime); 1205 1206 unlock_user_struct(target_tz, target_tz_addr, 1); 1207 1208 return 0; 1209 } 1210 #endif 1211 1212 #if defined(TARGET_NR_settimeofday) 1213 static inline abi_long copy_from_user_timezone(struct timezone *tz, 1214 abi_ulong target_tz_addr) 1215 { 1216 struct target_timezone *target_tz; 1217 1218 if (!lock_user_struct(VERIFY_READ, target_tz, target_tz_addr, 1)) { 1219 return -TARGET_EFAULT; 1220 } 1221 1222 __get_user(tz->tz_minuteswest, &target_tz->tz_minuteswest); 1223 __get_user(tz->tz_dsttime, &target_tz->tz_dsttime); 1224 1225 unlock_user_struct(target_tz, target_tz_addr, 0); 1226 1227 return 0; 1228 } 1229 #endif 1230 1231 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open) 1232 #include <mqueue.h> 1233 1234 static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr, 1235 abi_ulong target_mq_attr_addr) 1236 { 1237 struct target_mq_attr *target_mq_attr; 1238 1239 if (!lock_user_struct(VERIFY_READ, target_mq_attr, 1240 target_mq_attr_addr, 1)) 1241 return -TARGET_EFAULT; 1242 1243 __get_user(attr->mq_flags, &target_mq_attr->mq_flags); 1244 __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg); 1245 __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize); 1246 __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs); 1247 1248 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0); 1249 1250 return 0; 1251 } 1252 1253 static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr, 1254 const struct mq_attr *attr) 1255 { 1256 struct target_mq_attr *target_mq_attr; 1257 1258 if (!lock_user_struct(VERIFY_WRITE, target_mq_attr, 1259 target_mq_attr_addr, 0)) 1260 return -TARGET_EFAULT; 1261 1262 __put_user(attr->mq_flags, &target_mq_attr->mq_flags); 1263 __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg); 1264 __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize); 1265 __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs); 1266 1267 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1); 1268 1269 return 0; 1270 } 1271 #endif 1272 1273 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) 1274 /* do_select() must return target values and target errnos. */ 1275 static abi_long do_select(int n, 1276 abi_ulong rfd_addr, abi_ulong wfd_addr, 1277 abi_ulong efd_addr, abi_ulong target_tv_addr) 1278 { 1279 fd_set rfds, wfds, efds; 1280 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr; 1281 struct timeval tv; 1282 struct timespec ts, *ts_ptr; 1283 abi_long ret; 1284 1285 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n); 1286 if (ret) { 1287 return ret; 1288 } 1289 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n); 1290 if (ret) { 1291 return ret; 1292 } 1293 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n); 1294 if (ret) { 1295 return ret; 1296 } 1297 1298 if (target_tv_addr) { 1299 if (copy_from_user_timeval(&tv, target_tv_addr)) 1300 return -TARGET_EFAULT; 1301 ts.tv_sec = tv.tv_sec; 1302 ts.tv_nsec = tv.tv_usec * 1000; 1303 ts_ptr = &ts; 1304 } else { 1305 ts_ptr = NULL; 1306 } 1307 1308 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr, 1309 ts_ptr, NULL)); 1310 1311 if (!is_error(ret)) { 1312 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) 1313 return -TARGET_EFAULT; 1314 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) 1315 return -TARGET_EFAULT; 1316 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) 1317 return -TARGET_EFAULT; 1318 1319 if (target_tv_addr) { 1320 tv.tv_sec = ts.tv_sec; 1321 tv.tv_usec = ts.tv_nsec / 1000; 1322 if (copy_to_user_timeval(target_tv_addr, &tv)) { 1323 return -TARGET_EFAULT; 1324 } 1325 } 1326 } 1327 1328 return ret; 1329 } 1330 1331 #if defined(TARGET_WANT_OLD_SYS_SELECT) 1332 static abi_long do_old_select(abi_ulong arg1) 1333 { 1334 struct target_sel_arg_struct *sel; 1335 abi_ulong inp, outp, exp, tvp; 1336 long nsel; 1337 1338 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1)) { 1339 return -TARGET_EFAULT; 1340 } 1341 1342 nsel = tswapal(sel->n); 1343 inp = tswapal(sel->inp); 1344 outp = tswapal(sel->outp); 1345 exp = tswapal(sel->exp); 1346 tvp = tswapal(sel->tvp); 1347 1348 unlock_user_struct(sel, arg1, 0); 1349 1350 return do_select(nsel, inp, outp, exp, tvp); 1351 } 1352 #endif 1353 #endif 1354 1355 #if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64) 1356 static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3, 1357 abi_long arg4, abi_long arg5, abi_long arg6, 1358 bool time64) 1359 { 1360 abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr; 1361 fd_set rfds, wfds, efds; 1362 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr; 1363 struct timespec ts, *ts_ptr; 1364 abi_long ret; 1365 1366 /* 1367 * The 6th arg is actually two args smashed together, 1368 * so we cannot use the C library. 1369 */ 1370 sigset_t set; 1371 struct { 1372 sigset_t *set; 1373 size_t size; 1374 } sig, *sig_ptr; 1375 1376 abi_ulong arg_sigset, arg_sigsize, *arg7; 1377 target_sigset_t *target_sigset; 1378 1379 n = arg1; 1380 rfd_addr = arg2; 1381 wfd_addr = arg3; 1382 efd_addr = arg4; 1383 ts_addr = arg5; 1384 1385 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n); 1386 if (ret) { 1387 return ret; 1388 } 1389 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n); 1390 if (ret) { 1391 return ret; 1392 } 1393 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n); 1394 if (ret) { 1395 return ret; 1396 } 1397 1398 /* 1399 * This takes a timespec, and not a timeval, so we cannot 1400 * use the do_select() helper ... 1401 */ 1402 if (ts_addr) { 1403 if (time64) { 1404 if (target_to_host_timespec64(&ts, ts_addr)) { 1405 return -TARGET_EFAULT; 1406 } 1407 } else { 1408 if (target_to_host_timespec(&ts, ts_addr)) { 1409 return -TARGET_EFAULT; 1410 } 1411 } 1412 ts_ptr = &ts; 1413 } else { 1414 ts_ptr = NULL; 1415 } 1416 1417 /* Extract the two packed args for the sigset */ 1418 if (arg6) { 1419 sig_ptr = &sig; 1420 sig.size = SIGSET_T_SIZE; 1421 1422 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1); 1423 if (!arg7) { 1424 return -TARGET_EFAULT; 1425 } 1426 arg_sigset = tswapal(arg7[0]); 1427 arg_sigsize = tswapal(arg7[1]); 1428 unlock_user(arg7, arg6, 0); 1429 1430 if (arg_sigset) { 1431 sig.set = &set; 1432 if (arg_sigsize != sizeof(*target_sigset)) { 1433 /* Like the kernel, we enforce correct size sigsets */ 1434 return -TARGET_EINVAL; 1435 } 1436 target_sigset = lock_user(VERIFY_READ, arg_sigset, 1437 sizeof(*target_sigset), 1); 1438 if (!target_sigset) { 1439 return -TARGET_EFAULT; 1440 } 1441 target_to_host_sigset(&set, target_sigset); 1442 unlock_user(target_sigset, arg_sigset, 0); 1443 } else { 1444 sig.set = NULL; 1445 } 1446 } else { 1447 sig_ptr = NULL; 1448 } 1449 1450 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr, 1451 ts_ptr, sig_ptr)); 1452 1453 if (!is_error(ret)) { 1454 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) { 1455 return -TARGET_EFAULT; 1456 } 1457 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) { 1458 return -TARGET_EFAULT; 1459 } 1460 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) { 1461 return -TARGET_EFAULT; 1462 } 1463 if (time64) { 1464 if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) { 1465 return -TARGET_EFAULT; 1466 } 1467 } else { 1468 if (ts_addr && host_to_target_timespec(ts_addr, &ts)) { 1469 return -TARGET_EFAULT; 1470 } 1471 } 1472 } 1473 return ret; 1474 } 1475 #endif 1476 1477 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \ 1478 defined(TARGET_NR_ppoll_time64) 1479 static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3, 1480 abi_long arg4, abi_long arg5, bool ppoll, bool time64) 1481 { 1482 struct target_pollfd *target_pfd; 1483 unsigned int nfds = arg2; 1484 struct pollfd *pfd; 1485 unsigned int i; 1486 abi_long ret; 1487 1488 pfd = NULL; 1489 target_pfd = NULL; 1490 if (nfds) { 1491 if (nfds > (INT_MAX / sizeof(struct target_pollfd))) { 1492 return -TARGET_EINVAL; 1493 } 1494 target_pfd = lock_user(VERIFY_WRITE, arg1, 1495 sizeof(struct target_pollfd) * nfds, 1); 1496 if (!target_pfd) { 1497 return -TARGET_EFAULT; 1498 } 1499 1500 pfd = alloca(sizeof(struct pollfd) * nfds); 1501 for (i = 0; i < nfds; i++) { 1502 pfd[i].fd = tswap32(target_pfd[i].fd); 1503 pfd[i].events = tswap16(target_pfd[i].events); 1504 } 1505 } 1506 if (ppoll) { 1507 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts; 1508 target_sigset_t *target_set; 1509 sigset_t _set, *set = &_set; 1510 1511 if (arg3) { 1512 if (time64) { 1513 if (target_to_host_timespec64(timeout_ts, arg3)) { 1514 unlock_user(target_pfd, arg1, 0); 1515 return -TARGET_EFAULT; 1516 } 1517 } else { 1518 if (target_to_host_timespec(timeout_ts, arg3)) { 1519 unlock_user(target_pfd, arg1, 0); 1520 return -TARGET_EFAULT; 1521 } 1522 } 1523 } else { 1524 timeout_ts = NULL; 1525 } 1526 1527 if (arg4) { 1528 if (arg5 != sizeof(target_sigset_t)) { 1529 unlock_user(target_pfd, arg1, 0); 1530 return -TARGET_EINVAL; 1531 } 1532 1533 target_set = lock_user(VERIFY_READ, arg4, 1534 sizeof(target_sigset_t), 1); 1535 if (!target_set) { 1536 unlock_user(target_pfd, arg1, 0); 1537 return -TARGET_EFAULT; 1538 } 1539 target_to_host_sigset(set, target_set); 1540 } else { 1541 set = NULL; 1542 } 1543 1544 ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts, 1545 set, SIGSET_T_SIZE)); 1546 1547 if (!is_error(ret) && arg3) { 1548 if (time64) { 1549 if (host_to_target_timespec64(arg3, timeout_ts)) { 1550 return -TARGET_EFAULT; 1551 } 1552 } else { 1553 if (host_to_target_timespec(arg3, timeout_ts)) { 1554 return -TARGET_EFAULT; 1555 } 1556 } 1557 } 1558 if (arg4) { 1559 unlock_user(target_set, arg4, 0); 1560 } 1561 } else { 1562 struct timespec ts, *pts; 1563 1564 if (arg3 >= 0) { 1565 /* Convert ms to secs, ns */ 1566 ts.tv_sec = arg3 / 1000; 1567 ts.tv_nsec = (arg3 % 1000) * 1000000LL; 1568 pts = &ts; 1569 } else { 1570 /* -ve poll() timeout means "infinite" */ 1571 pts = NULL; 1572 } 1573 ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0)); 1574 } 1575 1576 if (!is_error(ret)) { 1577 for (i = 0; i < nfds; i++) { 1578 target_pfd[i].revents = tswap16(pfd[i].revents); 1579 } 1580 } 1581 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds); 1582 return ret; 1583 } 1584 #endif 1585 1586 static abi_long do_pipe2(int host_pipe[], int flags) 1587 { 1588 #ifdef CONFIG_PIPE2 1589 return pipe2(host_pipe, flags); 1590 #else 1591 return -ENOSYS; 1592 #endif 1593 } 1594 1595 static abi_long do_pipe(void *cpu_env, abi_ulong pipedes, 1596 int flags, int is_pipe2) 1597 { 1598 int host_pipe[2]; 1599 abi_long ret; 1600 ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe); 1601 1602 if (is_error(ret)) 1603 return get_errno(ret); 1604 1605 /* Several targets have special calling conventions for the original 1606 pipe syscall, but didn't replicate this into the pipe2 syscall. */ 1607 if (!is_pipe2) { 1608 #if defined(TARGET_ALPHA) 1609 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1]; 1610 return host_pipe[0]; 1611 #elif defined(TARGET_MIPS) 1612 ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1]; 1613 return host_pipe[0]; 1614 #elif defined(TARGET_SH4) 1615 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1]; 1616 return host_pipe[0]; 1617 #elif defined(TARGET_SPARC) 1618 ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1]; 1619 return host_pipe[0]; 1620 #endif 1621 } 1622 1623 if (put_user_s32(host_pipe[0], pipedes) 1624 || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0]))) 1625 return -TARGET_EFAULT; 1626 return get_errno(ret); 1627 } 1628 1629 static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn, 1630 abi_ulong target_addr, 1631 socklen_t len) 1632 { 1633 struct target_ip_mreqn *target_smreqn; 1634 1635 target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1); 1636 if (!target_smreqn) 1637 return -TARGET_EFAULT; 1638 mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr; 1639 mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr; 1640 if (len == sizeof(struct target_ip_mreqn)) 1641 mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex); 1642 unlock_user(target_smreqn, target_addr, 0); 1643 1644 return 0; 1645 } 1646 1647 static inline abi_long target_to_host_sockaddr(int fd, struct sockaddr *addr, 1648 abi_ulong target_addr, 1649 socklen_t len) 1650 { 1651 const socklen_t unix_maxlen = sizeof (struct sockaddr_un); 1652 sa_family_t sa_family; 1653 struct target_sockaddr *target_saddr; 1654 1655 if (fd_trans_target_to_host_addr(fd)) { 1656 return fd_trans_target_to_host_addr(fd)(addr, target_addr, len); 1657 } 1658 1659 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1); 1660 if (!target_saddr) 1661 return -TARGET_EFAULT; 1662 1663 sa_family = tswap16(target_saddr->sa_family); 1664 1665 /* Oops. The caller might send a incomplete sun_path; sun_path 1666 * must be terminated by \0 (see the manual page), but 1667 * unfortunately it is quite common to specify sockaddr_un 1668 * length as "strlen(x->sun_path)" while it should be 1669 * "strlen(...) + 1". We'll fix that here if needed. 1670 * Linux kernel has a similar feature. 1671 */ 1672 1673 if (sa_family == AF_UNIX) { 1674 if (len < unix_maxlen && len > 0) { 1675 char *cp = (char*)target_saddr; 1676 1677 if ( cp[len-1] && !cp[len] ) 1678 len++; 1679 } 1680 if (len > unix_maxlen) 1681 len = unix_maxlen; 1682 } 1683 1684 memcpy(addr, target_saddr, len); 1685 addr->sa_family = sa_family; 1686 if (sa_family == AF_NETLINK) { 1687 struct sockaddr_nl *nladdr; 1688 1689 nladdr = (struct sockaddr_nl *)addr; 1690 nladdr->nl_pid = tswap32(nladdr->nl_pid); 1691 nladdr->nl_groups = tswap32(nladdr->nl_groups); 1692 } else if (sa_family == AF_PACKET) { 1693 struct target_sockaddr_ll *lladdr; 1694 1695 lladdr = (struct target_sockaddr_ll *)addr; 1696 lladdr->sll_ifindex = tswap32(lladdr->sll_ifindex); 1697 lladdr->sll_hatype = tswap16(lladdr->sll_hatype); 1698 } 1699 unlock_user(target_saddr, target_addr, 0); 1700 1701 return 0; 1702 } 1703 1704 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr, 1705 struct sockaddr *addr, 1706 socklen_t len) 1707 { 1708 struct target_sockaddr *target_saddr; 1709 1710 if (len == 0) { 1711 return 0; 1712 } 1713 assert(addr); 1714 1715 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0); 1716 if (!target_saddr) 1717 return -TARGET_EFAULT; 1718 memcpy(target_saddr, addr, len); 1719 if (len >= offsetof(struct target_sockaddr, sa_family) + 1720 sizeof(target_saddr->sa_family)) { 1721 target_saddr->sa_family = tswap16(addr->sa_family); 1722 } 1723 if (addr->sa_family == AF_NETLINK && 1724 len >= sizeof(struct target_sockaddr_nl)) { 1725 struct target_sockaddr_nl *target_nl = 1726 (struct target_sockaddr_nl *)target_saddr; 1727 target_nl->nl_pid = tswap32(target_nl->nl_pid); 1728 target_nl->nl_groups = tswap32(target_nl->nl_groups); 1729 } else if (addr->sa_family == AF_PACKET) { 1730 struct sockaddr_ll *target_ll = (struct sockaddr_ll *)target_saddr; 1731 target_ll->sll_ifindex = tswap32(target_ll->sll_ifindex); 1732 target_ll->sll_hatype = tswap16(target_ll->sll_hatype); 1733 } else if (addr->sa_family == AF_INET6 && 1734 len >= sizeof(struct target_sockaddr_in6)) { 1735 struct target_sockaddr_in6 *target_in6 = 1736 (struct target_sockaddr_in6 *)target_saddr; 1737 target_in6->sin6_scope_id = tswap16(target_in6->sin6_scope_id); 1738 } 1739 unlock_user(target_saddr, target_addr, len); 1740 1741 return 0; 1742 } 1743 1744 static inline abi_long target_to_host_cmsg(struct msghdr *msgh, 1745 struct target_msghdr *target_msgh) 1746 { 1747 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh); 1748 abi_long msg_controllen; 1749 abi_ulong target_cmsg_addr; 1750 struct target_cmsghdr *target_cmsg, *target_cmsg_start; 1751 socklen_t space = 0; 1752 1753 msg_controllen = tswapal(target_msgh->msg_controllen); 1754 if (msg_controllen < sizeof (struct target_cmsghdr)) 1755 goto the_end; 1756 target_cmsg_addr = tswapal(target_msgh->msg_control); 1757 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1); 1758 target_cmsg_start = target_cmsg; 1759 if (!target_cmsg) 1760 return -TARGET_EFAULT; 1761 1762 while (cmsg && target_cmsg) { 1763 void *data = CMSG_DATA(cmsg); 1764 void *target_data = TARGET_CMSG_DATA(target_cmsg); 1765 1766 int len = tswapal(target_cmsg->cmsg_len) 1767 - sizeof(struct target_cmsghdr); 1768 1769 space += CMSG_SPACE(len); 1770 if (space > msgh->msg_controllen) { 1771 space -= CMSG_SPACE(len); 1772 /* This is a QEMU bug, since we allocated the payload 1773 * area ourselves (unlike overflow in host-to-target 1774 * conversion, which is just the guest giving us a buffer 1775 * that's too small). It can't happen for the payload types 1776 * we currently support; if it becomes an issue in future 1777 * we would need to improve our allocation strategy to 1778 * something more intelligent than "twice the size of the 1779 * target buffer we're reading from". 1780 */ 1781 qemu_log_mask(LOG_UNIMP, 1782 ("Unsupported ancillary data %d/%d: " 1783 "unhandled msg size\n"), 1784 tswap32(target_cmsg->cmsg_level), 1785 tswap32(target_cmsg->cmsg_type)); 1786 break; 1787 } 1788 1789 if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) { 1790 cmsg->cmsg_level = SOL_SOCKET; 1791 } else { 1792 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level); 1793 } 1794 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type); 1795 cmsg->cmsg_len = CMSG_LEN(len); 1796 1797 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) { 1798 int *fd = (int *)data; 1799 int *target_fd = (int *)target_data; 1800 int i, numfds = len / sizeof(int); 1801 1802 for (i = 0; i < numfds; i++) { 1803 __get_user(fd[i], target_fd + i); 1804 } 1805 } else if (cmsg->cmsg_level == SOL_SOCKET 1806 && cmsg->cmsg_type == SCM_CREDENTIALS) { 1807 struct ucred *cred = (struct ucred *)data; 1808 struct target_ucred *target_cred = 1809 (struct target_ucred *)target_data; 1810 1811 __get_user(cred->pid, &target_cred->pid); 1812 __get_user(cred->uid, &target_cred->uid); 1813 __get_user(cred->gid, &target_cred->gid); 1814 } else { 1815 qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n", 1816 cmsg->cmsg_level, cmsg->cmsg_type); 1817 memcpy(data, target_data, len); 1818 } 1819 1820 cmsg = CMSG_NXTHDR(msgh, cmsg); 1821 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg, 1822 target_cmsg_start); 1823 } 1824 unlock_user(target_cmsg, target_cmsg_addr, 0); 1825 the_end: 1826 msgh->msg_controllen = space; 1827 return 0; 1828 } 1829 1830 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh, 1831 struct msghdr *msgh) 1832 { 1833 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh); 1834 abi_long msg_controllen; 1835 abi_ulong target_cmsg_addr; 1836 struct target_cmsghdr *target_cmsg, *target_cmsg_start; 1837 socklen_t space = 0; 1838 1839 msg_controllen = tswapal(target_msgh->msg_controllen); 1840 if (msg_controllen < sizeof (struct target_cmsghdr)) 1841 goto the_end; 1842 target_cmsg_addr = tswapal(target_msgh->msg_control); 1843 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0); 1844 target_cmsg_start = target_cmsg; 1845 if (!target_cmsg) 1846 return -TARGET_EFAULT; 1847 1848 while (cmsg && target_cmsg) { 1849 void *data = CMSG_DATA(cmsg); 1850 void *target_data = TARGET_CMSG_DATA(target_cmsg); 1851 1852 int len = cmsg->cmsg_len - sizeof(struct cmsghdr); 1853 int tgt_len, tgt_space; 1854 1855 /* We never copy a half-header but may copy half-data; 1856 * this is Linux's behaviour in put_cmsg(). Note that 1857 * truncation here is a guest problem (which we report 1858 * to the guest via the CTRUNC bit), unlike truncation 1859 * in target_to_host_cmsg, which is a QEMU bug. 1860 */ 1861 if (msg_controllen < sizeof(struct target_cmsghdr)) { 1862 target_msgh->msg_flags |= tswap32(MSG_CTRUNC); 1863 break; 1864 } 1865 1866 if (cmsg->cmsg_level == SOL_SOCKET) { 1867 target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET); 1868 } else { 1869 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level); 1870 } 1871 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type); 1872 1873 /* Payload types which need a different size of payload on 1874 * the target must adjust tgt_len here. 1875 */ 1876 tgt_len = len; 1877 switch (cmsg->cmsg_level) { 1878 case SOL_SOCKET: 1879 switch (cmsg->cmsg_type) { 1880 case SO_TIMESTAMP: 1881 tgt_len = sizeof(struct target_timeval); 1882 break; 1883 default: 1884 break; 1885 } 1886 break; 1887 default: 1888 break; 1889 } 1890 1891 if (msg_controllen < TARGET_CMSG_LEN(tgt_len)) { 1892 target_msgh->msg_flags |= tswap32(MSG_CTRUNC); 1893 tgt_len = msg_controllen - sizeof(struct target_cmsghdr); 1894 } 1895 1896 /* We must now copy-and-convert len bytes of payload 1897 * into tgt_len bytes of destination space. Bear in mind 1898 * that in both source and destination we may be dealing 1899 * with a truncated value! 1900 */ 1901 switch (cmsg->cmsg_level) { 1902 case SOL_SOCKET: 1903 switch (cmsg->cmsg_type) { 1904 case SCM_RIGHTS: 1905 { 1906 int *fd = (int *)data; 1907 int *target_fd = (int *)target_data; 1908 int i, numfds = tgt_len / sizeof(int); 1909 1910 for (i = 0; i < numfds; i++) { 1911 __put_user(fd[i], target_fd + i); 1912 } 1913 break; 1914 } 1915 case SO_TIMESTAMP: 1916 { 1917 struct timeval *tv = (struct timeval *)data; 1918 struct target_timeval *target_tv = 1919 (struct target_timeval *)target_data; 1920 1921 if (len != sizeof(struct timeval) || 1922 tgt_len != sizeof(struct target_timeval)) { 1923 goto unimplemented; 1924 } 1925 1926 /* copy struct timeval to target */ 1927 __put_user(tv->tv_sec, &target_tv->tv_sec); 1928 __put_user(tv->tv_usec, &target_tv->tv_usec); 1929 break; 1930 } 1931 case SCM_CREDENTIALS: 1932 { 1933 struct ucred *cred = (struct ucred *)data; 1934 struct target_ucred *target_cred = 1935 (struct target_ucred *)target_data; 1936 1937 __put_user(cred->pid, &target_cred->pid); 1938 __put_user(cred->uid, &target_cred->uid); 1939 __put_user(cred->gid, &target_cred->gid); 1940 break; 1941 } 1942 default: 1943 goto unimplemented; 1944 } 1945 break; 1946 1947 case SOL_IP: 1948 switch (cmsg->cmsg_type) { 1949 case IP_TTL: 1950 { 1951 uint32_t *v = (uint32_t *)data; 1952 uint32_t *t_int = (uint32_t *)target_data; 1953 1954 if (len != sizeof(uint32_t) || 1955 tgt_len != sizeof(uint32_t)) { 1956 goto unimplemented; 1957 } 1958 __put_user(*v, t_int); 1959 break; 1960 } 1961 case IP_RECVERR: 1962 { 1963 struct errhdr_t { 1964 struct sock_extended_err ee; 1965 struct sockaddr_in offender; 1966 }; 1967 struct errhdr_t *errh = (struct errhdr_t *)data; 1968 struct errhdr_t *target_errh = 1969 (struct errhdr_t *)target_data; 1970 1971 if (len != sizeof(struct errhdr_t) || 1972 tgt_len != sizeof(struct errhdr_t)) { 1973 goto unimplemented; 1974 } 1975 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno); 1976 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin); 1977 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type); 1978 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code); 1979 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad); 1980 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info); 1981 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data); 1982 host_to_target_sockaddr((unsigned long) &target_errh->offender, 1983 (void *) &errh->offender, sizeof(errh->offender)); 1984 break; 1985 } 1986 default: 1987 goto unimplemented; 1988 } 1989 break; 1990 1991 case SOL_IPV6: 1992 switch (cmsg->cmsg_type) { 1993 case IPV6_HOPLIMIT: 1994 { 1995 uint32_t *v = (uint32_t *)data; 1996 uint32_t *t_int = (uint32_t *)target_data; 1997 1998 if (len != sizeof(uint32_t) || 1999 tgt_len != sizeof(uint32_t)) { 2000 goto unimplemented; 2001 } 2002 __put_user(*v, t_int); 2003 break; 2004 } 2005 case IPV6_RECVERR: 2006 { 2007 struct errhdr6_t { 2008 struct sock_extended_err ee; 2009 struct sockaddr_in6 offender; 2010 }; 2011 struct errhdr6_t *errh = (struct errhdr6_t *)data; 2012 struct errhdr6_t *target_errh = 2013 (struct errhdr6_t *)target_data; 2014 2015 if (len != sizeof(struct errhdr6_t) || 2016 tgt_len != sizeof(struct errhdr6_t)) { 2017 goto unimplemented; 2018 } 2019 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno); 2020 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin); 2021 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type); 2022 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code); 2023 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad); 2024 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info); 2025 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data); 2026 host_to_target_sockaddr((unsigned long) &target_errh->offender, 2027 (void *) &errh->offender, sizeof(errh->offender)); 2028 break; 2029 } 2030 default: 2031 goto unimplemented; 2032 } 2033 break; 2034 2035 default: 2036 unimplemented: 2037 qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n", 2038 cmsg->cmsg_level, cmsg->cmsg_type); 2039 memcpy(target_data, data, MIN(len, tgt_len)); 2040 if (tgt_len > len) { 2041 memset(target_data + len, 0, tgt_len - len); 2042 } 2043 } 2044 2045 target_cmsg->cmsg_len = tswapal(TARGET_CMSG_LEN(tgt_len)); 2046 tgt_space = TARGET_CMSG_SPACE(tgt_len); 2047 if (msg_controllen < tgt_space) { 2048 tgt_space = msg_controllen; 2049 } 2050 msg_controllen -= tgt_space; 2051 space += tgt_space; 2052 cmsg = CMSG_NXTHDR(msgh, cmsg); 2053 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg, 2054 target_cmsg_start); 2055 } 2056 unlock_user(target_cmsg, target_cmsg_addr, space); 2057 the_end: 2058 target_msgh->msg_controllen = tswapal(space); 2059 return 0; 2060 } 2061 2062 /* do_setsockopt() Must return target values and target errnos. */ 2063 static abi_long do_setsockopt(int sockfd, int level, int optname, 2064 abi_ulong optval_addr, socklen_t optlen) 2065 { 2066 abi_long ret; 2067 int val; 2068 struct ip_mreqn *ip_mreq; 2069 struct ip_mreq_source *ip_mreq_source; 2070 2071 switch(level) { 2072 case SOL_TCP: 2073 case SOL_UDP: 2074 /* TCP and UDP options all take an 'int' value. */ 2075 if (optlen < sizeof(uint32_t)) 2076 return -TARGET_EINVAL; 2077 2078 if (get_user_u32(val, optval_addr)) 2079 return -TARGET_EFAULT; 2080 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val))); 2081 break; 2082 case SOL_IP: 2083 switch(optname) { 2084 case IP_TOS: 2085 case IP_TTL: 2086 case IP_HDRINCL: 2087 case IP_ROUTER_ALERT: 2088 case IP_RECVOPTS: 2089 case IP_RETOPTS: 2090 case IP_PKTINFO: 2091 case IP_MTU_DISCOVER: 2092 case IP_RECVERR: 2093 case IP_RECVTTL: 2094 case IP_RECVTOS: 2095 #ifdef IP_FREEBIND 2096 case IP_FREEBIND: 2097 #endif 2098 case IP_MULTICAST_TTL: 2099 case IP_MULTICAST_LOOP: 2100 val = 0; 2101 if (optlen >= sizeof(uint32_t)) { 2102 if (get_user_u32(val, optval_addr)) 2103 return -TARGET_EFAULT; 2104 } else if (optlen >= 1) { 2105 if (get_user_u8(val, optval_addr)) 2106 return -TARGET_EFAULT; 2107 } 2108 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val))); 2109 break; 2110 case IP_ADD_MEMBERSHIP: 2111 case IP_DROP_MEMBERSHIP: 2112 if (optlen < sizeof (struct target_ip_mreq) || 2113 optlen > sizeof (struct target_ip_mreqn)) 2114 return -TARGET_EINVAL; 2115 2116 ip_mreq = (struct ip_mreqn *) alloca(optlen); 2117 target_to_host_ip_mreq(ip_mreq, optval_addr, optlen); 2118 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen)); 2119 break; 2120 2121 case IP_BLOCK_SOURCE: 2122 case IP_UNBLOCK_SOURCE: 2123 case IP_ADD_SOURCE_MEMBERSHIP: 2124 case IP_DROP_SOURCE_MEMBERSHIP: 2125 if (optlen != sizeof (struct target_ip_mreq_source)) 2126 return -TARGET_EINVAL; 2127 2128 ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1); 2129 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen)); 2130 unlock_user (ip_mreq_source, optval_addr, 0); 2131 break; 2132 2133 default: 2134 goto unimplemented; 2135 } 2136 break; 2137 case SOL_IPV6: 2138 switch (optname) { 2139 case IPV6_MTU_DISCOVER: 2140 case IPV6_MTU: 2141 case IPV6_V6ONLY: 2142 case IPV6_RECVPKTINFO: 2143 case IPV6_UNICAST_HOPS: 2144 case IPV6_MULTICAST_HOPS: 2145 case IPV6_MULTICAST_LOOP: 2146 case IPV6_RECVERR: 2147 case IPV6_RECVHOPLIMIT: 2148 case IPV6_2292HOPLIMIT: 2149 case IPV6_CHECKSUM: 2150 case IPV6_ADDRFORM: 2151 case IPV6_2292PKTINFO: 2152 case IPV6_RECVTCLASS: 2153 case IPV6_RECVRTHDR: 2154 case IPV6_2292RTHDR: 2155 case IPV6_RECVHOPOPTS: 2156 case IPV6_2292HOPOPTS: 2157 case IPV6_RECVDSTOPTS: 2158 case IPV6_2292DSTOPTS: 2159 case IPV6_TCLASS: 2160 case IPV6_ADDR_PREFERENCES: 2161 #ifdef IPV6_RECVPATHMTU 2162 case IPV6_RECVPATHMTU: 2163 #endif 2164 #ifdef IPV6_TRANSPARENT 2165 case IPV6_TRANSPARENT: 2166 #endif 2167 #ifdef IPV6_FREEBIND 2168 case IPV6_FREEBIND: 2169 #endif 2170 #ifdef IPV6_RECVORIGDSTADDR 2171 case IPV6_RECVORIGDSTADDR: 2172 #endif 2173 val = 0; 2174 if (optlen < sizeof(uint32_t)) { 2175 return -TARGET_EINVAL; 2176 } 2177 if (get_user_u32(val, optval_addr)) { 2178 return -TARGET_EFAULT; 2179 } 2180 ret = get_errno(setsockopt(sockfd, level, optname, 2181 &val, sizeof(val))); 2182 break; 2183 case IPV6_PKTINFO: 2184 { 2185 struct in6_pktinfo pki; 2186 2187 if (optlen < sizeof(pki)) { 2188 return -TARGET_EINVAL; 2189 } 2190 2191 if (copy_from_user(&pki, optval_addr, sizeof(pki))) { 2192 return -TARGET_EFAULT; 2193 } 2194 2195 pki.ipi6_ifindex = tswap32(pki.ipi6_ifindex); 2196 2197 ret = get_errno(setsockopt(sockfd, level, optname, 2198 &pki, sizeof(pki))); 2199 break; 2200 } 2201 case IPV6_ADD_MEMBERSHIP: 2202 case IPV6_DROP_MEMBERSHIP: 2203 { 2204 struct ipv6_mreq ipv6mreq; 2205 2206 if (optlen < sizeof(ipv6mreq)) { 2207 return -TARGET_EINVAL; 2208 } 2209 2210 if (copy_from_user(&ipv6mreq, optval_addr, sizeof(ipv6mreq))) { 2211 return -TARGET_EFAULT; 2212 } 2213 2214 ipv6mreq.ipv6mr_interface = tswap32(ipv6mreq.ipv6mr_interface); 2215 2216 ret = get_errno(setsockopt(sockfd, level, optname, 2217 &ipv6mreq, sizeof(ipv6mreq))); 2218 break; 2219 } 2220 default: 2221 goto unimplemented; 2222 } 2223 break; 2224 case SOL_ICMPV6: 2225 switch (optname) { 2226 case ICMPV6_FILTER: 2227 { 2228 struct icmp6_filter icmp6f; 2229 2230 if (optlen > sizeof(icmp6f)) { 2231 optlen = sizeof(icmp6f); 2232 } 2233 2234 if (copy_from_user(&icmp6f, optval_addr, optlen)) { 2235 return -TARGET_EFAULT; 2236 } 2237 2238 for (val = 0; val < 8; val++) { 2239 icmp6f.data[val] = tswap32(icmp6f.data[val]); 2240 } 2241 2242 ret = get_errno(setsockopt(sockfd, level, optname, 2243 &icmp6f, optlen)); 2244 break; 2245 } 2246 default: 2247 goto unimplemented; 2248 } 2249 break; 2250 case SOL_RAW: 2251 switch (optname) { 2252 case ICMP_FILTER: 2253 case IPV6_CHECKSUM: 2254 /* those take an u32 value */ 2255 if (optlen < sizeof(uint32_t)) { 2256 return -TARGET_EINVAL; 2257 } 2258 2259 if (get_user_u32(val, optval_addr)) { 2260 return -TARGET_EFAULT; 2261 } 2262 ret = get_errno(setsockopt(sockfd, level, optname, 2263 &val, sizeof(val))); 2264 break; 2265 2266 default: 2267 goto unimplemented; 2268 } 2269 break; 2270 #if defined(SOL_ALG) && defined(ALG_SET_KEY) && defined(ALG_SET_AEAD_AUTHSIZE) 2271 case SOL_ALG: 2272 switch (optname) { 2273 case ALG_SET_KEY: 2274 { 2275 char *alg_key = g_malloc(optlen); 2276 2277 if (!alg_key) { 2278 return -TARGET_ENOMEM; 2279 } 2280 if (copy_from_user(alg_key, optval_addr, optlen)) { 2281 g_free(alg_key); 2282 return -TARGET_EFAULT; 2283 } 2284 ret = get_errno(setsockopt(sockfd, level, optname, 2285 alg_key, optlen)); 2286 g_free(alg_key); 2287 break; 2288 } 2289 case ALG_SET_AEAD_AUTHSIZE: 2290 { 2291 ret = get_errno(setsockopt(sockfd, level, optname, 2292 NULL, optlen)); 2293 break; 2294 } 2295 default: 2296 goto unimplemented; 2297 } 2298 break; 2299 #endif 2300 case TARGET_SOL_SOCKET: 2301 switch (optname) { 2302 case TARGET_SO_RCVTIMEO: 2303 { 2304 struct timeval tv; 2305 2306 optname = SO_RCVTIMEO; 2307 2308 set_timeout: 2309 if (optlen != sizeof(struct target_timeval)) { 2310 return -TARGET_EINVAL; 2311 } 2312 2313 if (copy_from_user_timeval(&tv, optval_addr)) { 2314 return -TARGET_EFAULT; 2315 } 2316 2317 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, 2318 &tv, sizeof(tv))); 2319 return ret; 2320 } 2321 case TARGET_SO_SNDTIMEO: 2322 optname = SO_SNDTIMEO; 2323 goto set_timeout; 2324 case TARGET_SO_ATTACH_FILTER: 2325 { 2326 struct target_sock_fprog *tfprog; 2327 struct target_sock_filter *tfilter; 2328 struct sock_fprog fprog; 2329 struct sock_filter *filter; 2330 int i; 2331 2332 if (optlen != sizeof(*tfprog)) { 2333 return -TARGET_EINVAL; 2334 } 2335 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) { 2336 return -TARGET_EFAULT; 2337 } 2338 if (!lock_user_struct(VERIFY_READ, tfilter, 2339 tswapal(tfprog->filter), 0)) { 2340 unlock_user_struct(tfprog, optval_addr, 1); 2341 return -TARGET_EFAULT; 2342 } 2343 2344 fprog.len = tswap16(tfprog->len); 2345 filter = g_try_new(struct sock_filter, fprog.len); 2346 if (filter == NULL) { 2347 unlock_user_struct(tfilter, tfprog->filter, 1); 2348 unlock_user_struct(tfprog, optval_addr, 1); 2349 return -TARGET_ENOMEM; 2350 } 2351 for (i = 0; i < fprog.len; i++) { 2352 filter[i].code = tswap16(tfilter[i].code); 2353 filter[i].jt = tfilter[i].jt; 2354 filter[i].jf = tfilter[i].jf; 2355 filter[i].k = tswap32(tfilter[i].k); 2356 } 2357 fprog.filter = filter; 2358 2359 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, 2360 SO_ATTACH_FILTER, &fprog, sizeof(fprog))); 2361 g_free(filter); 2362 2363 unlock_user_struct(tfilter, tfprog->filter, 1); 2364 unlock_user_struct(tfprog, optval_addr, 1); 2365 return ret; 2366 } 2367 case TARGET_SO_BINDTODEVICE: 2368 { 2369 char *dev_ifname, *addr_ifname; 2370 2371 if (optlen > IFNAMSIZ - 1) { 2372 optlen = IFNAMSIZ - 1; 2373 } 2374 dev_ifname = lock_user(VERIFY_READ, optval_addr, optlen, 1); 2375 if (!dev_ifname) { 2376 return -TARGET_EFAULT; 2377 } 2378 optname = SO_BINDTODEVICE; 2379 addr_ifname = alloca(IFNAMSIZ); 2380 memcpy(addr_ifname, dev_ifname, optlen); 2381 addr_ifname[optlen] = 0; 2382 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, 2383 addr_ifname, optlen)); 2384 unlock_user (dev_ifname, optval_addr, 0); 2385 return ret; 2386 } 2387 case TARGET_SO_LINGER: 2388 { 2389 struct linger lg; 2390 struct target_linger *tlg; 2391 2392 if (optlen != sizeof(struct target_linger)) { 2393 return -TARGET_EINVAL; 2394 } 2395 if (!lock_user_struct(VERIFY_READ, tlg, optval_addr, 1)) { 2396 return -TARGET_EFAULT; 2397 } 2398 __get_user(lg.l_onoff, &tlg->l_onoff); 2399 __get_user(lg.l_linger, &tlg->l_linger); 2400 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, SO_LINGER, 2401 &lg, sizeof(lg))); 2402 unlock_user_struct(tlg, optval_addr, 0); 2403 return ret; 2404 } 2405 /* Options with 'int' argument. */ 2406 case TARGET_SO_DEBUG: 2407 optname = SO_DEBUG; 2408 break; 2409 case TARGET_SO_REUSEADDR: 2410 optname = SO_REUSEADDR; 2411 break; 2412 #ifdef SO_REUSEPORT 2413 case TARGET_SO_REUSEPORT: 2414 optname = SO_REUSEPORT; 2415 break; 2416 #endif 2417 case TARGET_SO_TYPE: 2418 optname = SO_TYPE; 2419 break; 2420 case TARGET_SO_ERROR: 2421 optname = SO_ERROR; 2422 break; 2423 case TARGET_SO_DONTROUTE: 2424 optname = SO_DONTROUTE; 2425 break; 2426 case TARGET_SO_BROADCAST: 2427 optname = SO_BROADCAST; 2428 break; 2429 case TARGET_SO_SNDBUF: 2430 optname = SO_SNDBUF; 2431 break; 2432 case TARGET_SO_SNDBUFFORCE: 2433 optname = SO_SNDBUFFORCE; 2434 break; 2435 case TARGET_SO_RCVBUF: 2436 optname = SO_RCVBUF; 2437 break; 2438 case TARGET_SO_RCVBUFFORCE: 2439 optname = SO_RCVBUFFORCE; 2440 break; 2441 case TARGET_SO_KEEPALIVE: 2442 optname = SO_KEEPALIVE; 2443 break; 2444 case TARGET_SO_OOBINLINE: 2445 optname = SO_OOBINLINE; 2446 break; 2447 case TARGET_SO_NO_CHECK: 2448 optname = SO_NO_CHECK; 2449 break; 2450 case TARGET_SO_PRIORITY: 2451 optname = SO_PRIORITY; 2452 break; 2453 #ifdef SO_BSDCOMPAT 2454 case TARGET_SO_BSDCOMPAT: 2455 optname = SO_BSDCOMPAT; 2456 break; 2457 #endif 2458 case TARGET_SO_PASSCRED: 2459 optname = SO_PASSCRED; 2460 break; 2461 case TARGET_SO_PASSSEC: 2462 optname = SO_PASSSEC; 2463 break; 2464 case TARGET_SO_TIMESTAMP: 2465 optname = SO_TIMESTAMP; 2466 break; 2467 case TARGET_SO_RCVLOWAT: 2468 optname = SO_RCVLOWAT; 2469 break; 2470 default: 2471 goto unimplemented; 2472 } 2473 if (optlen < sizeof(uint32_t)) 2474 return -TARGET_EINVAL; 2475 2476 if (get_user_u32(val, optval_addr)) 2477 return -TARGET_EFAULT; 2478 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val))); 2479 break; 2480 #ifdef SOL_NETLINK 2481 case SOL_NETLINK: 2482 switch (optname) { 2483 case NETLINK_PKTINFO: 2484 case NETLINK_ADD_MEMBERSHIP: 2485 case NETLINK_DROP_MEMBERSHIP: 2486 case NETLINK_BROADCAST_ERROR: 2487 case NETLINK_NO_ENOBUFS: 2488 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) 2489 case NETLINK_LISTEN_ALL_NSID: 2490 case NETLINK_CAP_ACK: 2491 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */ 2492 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) 2493 case NETLINK_EXT_ACK: 2494 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */ 2495 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0) 2496 case NETLINK_GET_STRICT_CHK: 2497 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */ 2498 break; 2499 default: 2500 goto unimplemented; 2501 } 2502 val = 0; 2503 if (optlen < sizeof(uint32_t)) { 2504 return -TARGET_EINVAL; 2505 } 2506 if (get_user_u32(val, optval_addr)) { 2507 return -TARGET_EFAULT; 2508 } 2509 ret = get_errno(setsockopt(sockfd, SOL_NETLINK, optname, &val, 2510 sizeof(val))); 2511 break; 2512 #endif /* SOL_NETLINK */ 2513 default: 2514 unimplemented: 2515 qemu_log_mask(LOG_UNIMP, "Unsupported setsockopt level=%d optname=%d\n", 2516 level, optname); 2517 ret = -TARGET_ENOPROTOOPT; 2518 } 2519 return ret; 2520 } 2521 2522 /* do_getsockopt() Must return target values and target errnos. */ 2523 static abi_long do_getsockopt(int sockfd, int level, int optname, 2524 abi_ulong optval_addr, abi_ulong optlen) 2525 { 2526 abi_long ret; 2527 int len, val; 2528 socklen_t lv; 2529 2530 switch(level) { 2531 case TARGET_SOL_SOCKET: 2532 level = SOL_SOCKET; 2533 switch (optname) { 2534 /* These don't just return a single integer */ 2535 case TARGET_SO_PEERNAME: 2536 goto unimplemented; 2537 case TARGET_SO_RCVTIMEO: { 2538 struct timeval tv; 2539 socklen_t tvlen; 2540 2541 optname = SO_RCVTIMEO; 2542 2543 get_timeout: 2544 if (get_user_u32(len, optlen)) { 2545 return -TARGET_EFAULT; 2546 } 2547 if (len < 0) { 2548 return -TARGET_EINVAL; 2549 } 2550 2551 tvlen = sizeof(tv); 2552 ret = get_errno(getsockopt(sockfd, level, optname, 2553 &tv, &tvlen)); 2554 if (ret < 0) { 2555 return ret; 2556 } 2557 if (len > sizeof(struct target_timeval)) { 2558 len = sizeof(struct target_timeval); 2559 } 2560 if (copy_to_user_timeval(optval_addr, &tv)) { 2561 return -TARGET_EFAULT; 2562 } 2563 if (put_user_u32(len, optlen)) { 2564 return -TARGET_EFAULT; 2565 } 2566 break; 2567 } 2568 case TARGET_SO_SNDTIMEO: 2569 optname = SO_SNDTIMEO; 2570 goto get_timeout; 2571 case TARGET_SO_PEERCRED: { 2572 struct ucred cr; 2573 socklen_t crlen; 2574 struct target_ucred *tcr; 2575 2576 if (get_user_u32(len, optlen)) { 2577 return -TARGET_EFAULT; 2578 } 2579 if (len < 0) { 2580 return -TARGET_EINVAL; 2581 } 2582 2583 crlen = sizeof(cr); 2584 ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED, 2585 &cr, &crlen)); 2586 if (ret < 0) { 2587 return ret; 2588 } 2589 if (len > crlen) { 2590 len = crlen; 2591 } 2592 if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) { 2593 return -TARGET_EFAULT; 2594 } 2595 __put_user(cr.pid, &tcr->pid); 2596 __put_user(cr.uid, &tcr->uid); 2597 __put_user(cr.gid, &tcr->gid); 2598 unlock_user_struct(tcr, optval_addr, 1); 2599 if (put_user_u32(len, optlen)) { 2600 return -TARGET_EFAULT; 2601 } 2602 break; 2603 } 2604 case TARGET_SO_PEERSEC: { 2605 char *name; 2606 2607 if (get_user_u32(len, optlen)) { 2608 return -TARGET_EFAULT; 2609 } 2610 if (len < 0) { 2611 return -TARGET_EINVAL; 2612 } 2613 name = lock_user(VERIFY_WRITE, optval_addr, len, 0); 2614 if (!name) { 2615 return -TARGET_EFAULT; 2616 } 2617 lv = len; 2618 ret = get_errno(getsockopt(sockfd, level, SO_PEERSEC, 2619 name, &lv)); 2620 if (put_user_u32(lv, optlen)) { 2621 ret = -TARGET_EFAULT; 2622 } 2623 unlock_user(name, optval_addr, lv); 2624 break; 2625 } 2626 case TARGET_SO_LINGER: 2627 { 2628 struct linger lg; 2629 socklen_t lglen; 2630 struct target_linger *tlg; 2631 2632 if (get_user_u32(len, optlen)) { 2633 return -TARGET_EFAULT; 2634 } 2635 if (len < 0) { 2636 return -TARGET_EINVAL; 2637 } 2638 2639 lglen = sizeof(lg); 2640 ret = get_errno(getsockopt(sockfd, level, SO_LINGER, 2641 &lg, &lglen)); 2642 if (ret < 0) { 2643 return ret; 2644 } 2645 if (len > lglen) { 2646 len = lglen; 2647 } 2648 if (!lock_user_struct(VERIFY_WRITE, tlg, optval_addr, 0)) { 2649 return -TARGET_EFAULT; 2650 } 2651 __put_user(lg.l_onoff, &tlg->l_onoff); 2652 __put_user(lg.l_linger, &tlg->l_linger); 2653 unlock_user_struct(tlg, optval_addr, 1); 2654 if (put_user_u32(len, optlen)) { 2655 return -TARGET_EFAULT; 2656 } 2657 break; 2658 } 2659 /* Options with 'int' argument. */ 2660 case TARGET_SO_DEBUG: 2661 optname = SO_DEBUG; 2662 goto int_case; 2663 case TARGET_SO_REUSEADDR: 2664 optname = SO_REUSEADDR; 2665 goto int_case; 2666 #ifdef SO_REUSEPORT 2667 case TARGET_SO_REUSEPORT: 2668 optname = SO_REUSEPORT; 2669 goto int_case; 2670 #endif 2671 case TARGET_SO_TYPE: 2672 optname = SO_TYPE; 2673 goto int_case; 2674 case TARGET_SO_ERROR: 2675 optname = SO_ERROR; 2676 goto int_case; 2677 case TARGET_SO_DONTROUTE: 2678 optname = SO_DONTROUTE; 2679 goto int_case; 2680 case TARGET_SO_BROADCAST: 2681 optname = SO_BROADCAST; 2682 goto int_case; 2683 case TARGET_SO_SNDBUF: 2684 optname = SO_SNDBUF; 2685 goto int_case; 2686 case TARGET_SO_RCVBUF: 2687 optname = SO_RCVBUF; 2688 goto int_case; 2689 case TARGET_SO_KEEPALIVE: 2690 optname = SO_KEEPALIVE; 2691 goto int_case; 2692 case TARGET_SO_OOBINLINE: 2693 optname = SO_OOBINLINE; 2694 goto int_case; 2695 case TARGET_SO_NO_CHECK: 2696 optname = SO_NO_CHECK; 2697 goto int_case; 2698 case TARGET_SO_PRIORITY: 2699 optname = SO_PRIORITY; 2700 goto int_case; 2701 #ifdef SO_BSDCOMPAT 2702 case TARGET_SO_BSDCOMPAT: 2703 optname = SO_BSDCOMPAT; 2704 goto int_case; 2705 #endif 2706 case TARGET_SO_PASSCRED: 2707 optname = SO_PASSCRED; 2708 goto int_case; 2709 case TARGET_SO_TIMESTAMP: 2710 optname = SO_TIMESTAMP; 2711 goto int_case; 2712 case TARGET_SO_RCVLOWAT: 2713 optname = SO_RCVLOWAT; 2714 goto int_case; 2715 case TARGET_SO_ACCEPTCONN: 2716 optname = SO_ACCEPTCONN; 2717 goto int_case; 2718 case TARGET_SO_PROTOCOL: 2719 optname = SO_PROTOCOL; 2720 goto int_case; 2721 case TARGET_SO_DOMAIN: 2722 optname = SO_DOMAIN; 2723 goto int_case; 2724 default: 2725 goto int_case; 2726 } 2727 break; 2728 case SOL_TCP: 2729 case SOL_UDP: 2730 /* TCP and UDP options all take an 'int' value. */ 2731 int_case: 2732 if (get_user_u32(len, optlen)) 2733 return -TARGET_EFAULT; 2734 if (len < 0) 2735 return -TARGET_EINVAL; 2736 lv = sizeof(lv); 2737 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 2738 if (ret < 0) 2739 return ret; 2740 if (optname == SO_TYPE) { 2741 val = host_to_target_sock_type(val); 2742 } 2743 if (len > lv) 2744 len = lv; 2745 if (len == 4) { 2746 if (put_user_u32(val, optval_addr)) 2747 return -TARGET_EFAULT; 2748 } else { 2749 if (put_user_u8(val, optval_addr)) 2750 return -TARGET_EFAULT; 2751 } 2752 if (put_user_u32(len, optlen)) 2753 return -TARGET_EFAULT; 2754 break; 2755 case SOL_IP: 2756 switch(optname) { 2757 case IP_TOS: 2758 case IP_TTL: 2759 case IP_HDRINCL: 2760 case IP_ROUTER_ALERT: 2761 case IP_RECVOPTS: 2762 case IP_RETOPTS: 2763 case IP_PKTINFO: 2764 case IP_MTU_DISCOVER: 2765 case IP_RECVERR: 2766 case IP_RECVTOS: 2767 #ifdef IP_FREEBIND 2768 case IP_FREEBIND: 2769 #endif 2770 case IP_MULTICAST_TTL: 2771 case IP_MULTICAST_LOOP: 2772 if (get_user_u32(len, optlen)) 2773 return -TARGET_EFAULT; 2774 if (len < 0) 2775 return -TARGET_EINVAL; 2776 lv = sizeof(lv); 2777 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 2778 if (ret < 0) 2779 return ret; 2780 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) { 2781 len = 1; 2782 if (put_user_u32(len, optlen) 2783 || put_user_u8(val, optval_addr)) 2784 return -TARGET_EFAULT; 2785 } else { 2786 if (len > sizeof(int)) 2787 len = sizeof(int); 2788 if (put_user_u32(len, optlen) 2789 || put_user_u32(val, optval_addr)) 2790 return -TARGET_EFAULT; 2791 } 2792 break; 2793 default: 2794 ret = -TARGET_ENOPROTOOPT; 2795 break; 2796 } 2797 break; 2798 case SOL_IPV6: 2799 switch (optname) { 2800 case IPV6_MTU_DISCOVER: 2801 case IPV6_MTU: 2802 case IPV6_V6ONLY: 2803 case IPV6_RECVPKTINFO: 2804 case IPV6_UNICAST_HOPS: 2805 case IPV6_MULTICAST_HOPS: 2806 case IPV6_MULTICAST_LOOP: 2807 case IPV6_RECVERR: 2808 case IPV6_RECVHOPLIMIT: 2809 case IPV6_2292HOPLIMIT: 2810 case IPV6_CHECKSUM: 2811 case IPV6_ADDRFORM: 2812 case IPV6_2292PKTINFO: 2813 case IPV6_RECVTCLASS: 2814 case IPV6_RECVRTHDR: 2815 case IPV6_2292RTHDR: 2816 case IPV6_RECVHOPOPTS: 2817 case IPV6_2292HOPOPTS: 2818 case IPV6_RECVDSTOPTS: 2819 case IPV6_2292DSTOPTS: 2820 case IPV6_TCLASS: 2821 case IPV6_ADDR_PREFERENCES: 2822 #ifdef IPV6_RECVPATHMTU 2823 case IPV6_RECVPATHMTU: 2824 #endif 2825 #ifdef IPV6_TRANSPARENT 2826 case IPV6_TRANSPARENT: 2827 #endif 2828 #ifdef IPV6_FREEBIND 2829 case IPV6_FREEBIND: 2830 #endif 2831 #ifdef IPV6_RECVORIGDSTADDR 2832 case IPV6_RECVORIGDSTADDR: 2833 #endif 2834 if (get_user_u32(len, optlen)) 2835 return -TARGET_EFAULT; 2836 if (len < 0) 2837 return -TARGET_EINVAL; 2838 lv = sizeof(lv); 2839 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 2840 if (ret < 0) 2841 return ret; 2842 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) { 2843 len = 1; 2844 if (put_user_u32(len, optlen) 2845 || put_user_u8(val, optval_addr)) 2846 return -TARGET_EFAULT; 2847 } else { 2848 if (len > sizeof(int)) 2849 len = sizeof(int); 2850 if (put_user_u32(len, optlen) 2851 || put_user_u32(val, optval_addr)) 2852 return -TARGET_EFAULT; 2853 } 2854 break; 2855 default: 2856 ret = -TARGET_ENOPROTOOPT; 2857 break; 2858 } 2859 break; 2860 #ifdef SOL_NETLINK 2861 case SOL_NETLINK: 2862 switch (optname) { 2863 case NETLINK_PKTINFO: 2864 case NETLINK_BROADCAST_ERROR: 2865 case NETLINK_NO_ENOBUFS: 2866 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) 2867 case NETLINK_LISTEN_ALL_NSID: 2868 case NETLINK_CAP_ACK: 2869 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */ 2870 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) 2871 case NETLINK_EXT_ACK: 2872 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */ 2873 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0) 2874 case NETLINK_GET_STRICT_CHK: 2875 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */ 2876 if (get_user_u32(len, optlen)) { 2877 return -TARGET_EFAULT; 2878 } 2879 if (len != sizeof(val)) { 2880 return -TARGET_EINVAL; 2881 } 2882 lv = len; 2883 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 2884 if (ret < 0) { 2885 return ret; 2886 } 2887 if (put_user_u32(lv, optlen) 2888 || put_user_u32(val, optval_addr)) { 2889 return -TARGET_EFAULT; 2890 } 2891 break; 2892 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) 2893 case NETLINK_LIST_MEMBERSHIPS: 2894 { 2895 uint32_t *results; 2896 int i; 2897 if (get_user_u32(len, optlen)) { 2898 return -TARGET_EFAULT; 2899 } 2900 if (len < 0) { 2901 return -TARGET_EINVAL; 2902 } 2903 results = lock_user(VERIFY_WRITE, optval_addr, len, 1); 2904 if (!results && len > 0) { 2905 return -TARGET_EFAULT; 2906 } 2907 lv = len; 2908 ret = get_errno(getsockopt(sockfd, level, optname, results, &lv)); 2909 if (ret < 0) { 2910 unlock_user(results, optval_addr, 0); 2911 return ret; 2912 } 2913 /* swap host endianess to target endianess. */ 2914 for (i = 0; i < (len / sizeof(uint32_t)); i++) { 2915 results[i] = tswap32(results[i]); 2916 } 2917 if (put_user_u32(lv, optlen)) { 2918 return -TARGET_EFAULT; 2919 } 2920 unlock_user(results, optval_addr, 0); 2921 break; 2922 } 2923 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */ 2924 default: 2925 goto unimplemented; 2926 } 2927 break; 2928 #endif /* SOL_NETLINK */ 2929 default: 2930 unimplemented: 2931 qemu_log_mask(LOG_UNIMP, 2932 "getsockopt level=%d optname=%d not yet supported\n", 2933 level, optname); 2934 ret = -TARGET_EOPNOTSUPP; 2935 break; 2936 } 2937 return ret; 2938 } 2939 2940 /* Convert target low/high pair representing file offset into the host 2941 * low/high pair. This function doesn't handle offsets bigger than 64 bits 2942 * as the kernel doesn't handle them either. 2943 */ 2944 static void target_to_host_low_high(abi_ulong tlow, 2945 abi_ulong thigh, 2946 unsigned long *hlow, 2947 unsigned long *hhigh) 2948 { 2949 uint64_t off = tlow | 2950 ((unsigned long long)thigh << TARGET_LONG_BITS / 2) << 2951 TARGET_LONG_BITS / 2; 2952 2953 *hlow = off; 2954 *hhigh = (off >> HOST_LONG_BITS / 2) >> HOST_LONG_BITS / 2; 2955 } 2956 2957 static struct iovec *lock_iovec(int type, abi_ulong target_addr, 2958 abi_ulong count, int copy) 2959 { 2960 struct target_iovec *target_vec; 2961 struct iovec *vec; 2962 abi_ulong total_len, max_len; 2963 int i; 2964 int err = 0; 2965 bool bad_address = false; 2966 2967 if (count == 0) { 2968 errno = 0; 2969 return NULL; 2970 } 2971 if (count > IOV_MAX) { 2972 errno = EINVAL; 2973 return NULL; 2974 } 2975 2976 vec = g_try_new0(struct iovec, count); 2977 if (vec == NULL) { 2978 errno = ENOMEM; 2979 return NULL; 2980 } 2981 2982 target_vec = lock_user(VERIFY_READ, target_addr, 2983 count * sizeof(struct target_iovec), 1); 2984 if (target_vec == NULL) { 2985 err = EFAULT; 2986 goto fail2; 2987 } 2988 2989 /* ??? If host page size > target page size, this will result in a 2990 value larger than what we can actually support. */ 2991 max_len = 0x7fffffff & TARGET_PAGE_MASK; 2992 total_len = 0; 2993 2994 for (i = 0; i < count; i++) { 2995 abi_ulong base = tswapal(target_vec[i].iov_base); 2996 abi_long len = tswapal(target_vec[i].iov_len); 2997 2998 if (len < 0) { 2999 err = EINVAL; 3000 goto fail; 3001 } else if (len == 0) { 3002 /* Zero length pointer is ignored. */ 3003 vec[i].iov_base = 0; 3004 } else { 3005 vec[i].iov_base = lock_user(type, base, len, copy); 3006 /* If the first buffer pointer is bad, this is a fault. But 3007 * subsequent bad buffers will result in a partial write; this 3008 * is realized by filling the vector with null pointers and 3009 * zero lengths. */ 3010 if (!vec[i].iov_base) { 3011 if (i == 0) { 3012 err = EFAULT; 3013 goto fail; 3014 } else { 3015 bad_address = true; 3016 } 3017 } 3018 if (bad_address) { 3019 len = 0; 3020 } 3021 if (len > max_len - total_len) { 3022 len = max_len - total_len; 3023 } 3024 } 3025 vec[i].iov_len = len; 3026 total_len += len; 3027 } 3028 3029 unlock_user(target_vec, target_addr, 0); 3030 return vec; 3031 3032 fail: 3033 while (--i >= 0) { 3034 if (tswapal(target_vec[i].iov_len) > 0) { 3035 unlock_user(vec[i].iov_base, tswapal(target_vec[i].iov_base), 0); 3036 } 3037 } 3038 unlock_user(target_vec, target_addr, 0); 3039 fail2: 3040 g_free(vec); 3041 errno = err; 3042 return NULL; 3043 } 3044 3045 static void unlock_iovec(struct iovec *vec, abi_ulong target_addr, 3046 abi_ulong count, int copy) 3047 { 3048 struct target_iovec *target_vec; 3049 int i; 3050 3051 target_vec = lock_user(VERIFY_READ, target_addr, 3052 count * sizeof(struct target_iovec), 1); 3053 if (target_vec) { 3054 for (i = 0; i < count; i++) { 3055 abi_ulong base = tswapal(target_vec[i].iov_base); 3056 abi_long len = tswapal(target_vec[i].iov_len); 3057 if (len < 0) { 3058 break; 3059 } 3060 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0); 3061 } 3062 unlock_user(target_vec, target_addr, 0); 3063 } 3064 3065 g_free(vec); 3066 } 3067 3068 static inline int target_to_host_sock_type(int *type) 3069 { 3070 int host_type = 0; 3071 int target_type = *type; 3072 3073 switch (target_type & TARGET_SOCK_TYPE_MASK) { 3074 case TARGET_SOCK_DGRAM: 3075 host_type = SOCK_DGRAM; 3076 break; 3077 case TARGET_SOCK_STREAM: 3078 host_type = SOCK_STREAM; 3079 break; 3080 default: 3081 host_type = target_type & TARGET_SOCK_TYPE_MASK; 3082 break; 3083 } 3084 if (target_type & TARGET_SOCK_CLOEXEC) { 3085 #if defined(SOCK_CLOEXEC) 3086 host_type |= SOCK_CLOEXEC; 3087 #else 3088 return -TARGET_EINVAL; 3089 #endif 3090 } 3091 if (target_type & TARGET_SOCK_NONBLOCK) { 3092 #if defined(SOCK_NONBLOCK) 3093 host_type |= SOCK_NONBLOCK; 3094 #elif !defined(O_NONBLOCK) 3095 return -TARGET_EINVAL; 3096 #endif 3097 } 3098 *type = host_type; 3099 return 0; 3100 } 3101 3102 /* Try to emulate socket type flags after socket creation. */ 3103 static int sock_flags_fixup(int fd, int target_type) 3104 { 3105 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK) 3106 if (target_type & TARGET_SOCK_NONBLOCK) { 3107 int flags = fcntl(fd, F_GETFL); 3108 if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) { 3109 close(fd); 3110 return -TARGET_EINVAL; 3111 } 3112 } 3113 #endif 3114 return fd; 3115 } 3116 3117 /* do_socket() Must return target values and target errnos. */ 3118 static abi_long do_socket(int domain, int type, int protocol) 3119 { 3120 int target_type = type; 3121 int ret; 3122 3123 ret = target_to_host_sock_type(&type); 3124 if (ret) { 3125 return ret; 3126 } 3127 3128 if (domain == PF_NETLINK && !( 3129 #ifdef CONFIG_RTNETLINK 3130 protocol == NETLINK_ROUTE || 3131 #endif 3132 protocol == NETLINK_KOBJECT_UEVENT || 3133 protocol == NETLINK_AUDIT)) { 3134 return -TARGET_EPROTONOSUPPORT; 3135 } 3136 3137 if (domain == AF_PACKET || 3138 (domain == AF_INET && type == SOCK_PACKET)) { 3139 protocol = tswap16(protocol); 3140 } 3141 3142 ret = get_errno(socket(domain, type, protocol)); 3143 if (ret >= 0) { 3144 ret = sock_flags_fixup(ret, target_type); 3145 if (type == SOCK_PACKET) { 3146 /* Manage an obsolete case : 3147 * if socket type is SOCK_PACKET, bind by name 3148 */ 3149 fd_trans_register(ret, &target_packet_trans); 3150 } else if (domain == PF_NETLINK) { 3151 switch (protocol) { 3152 #ifdef CONFIG_RTNETLINK 3153 case NETLINK_ROUTE: 3154 fd_trans_register(ret, &target_netlink_route_trans); 3155 break; 3156 #endif 3157 case NETLINK_KOBJECT_UEVENT: 3158 /* nothing to do: messages are strings */ 3159 break; 3160 case NETLINK_AUDIT: 3161 fd_trans_register(ret, &target_netlink_audit_trans); 3162 break; 3163 default: 3164 g_assert_not_reached(); 3165 } 3166 } 3167 } 3168 return ret; 3169 } 3170 3171 /* do_bind() Must return target values and target errnos. */ 3172 static abi_long do_bind(int sockfd, abi_ulong target_addr, 3173 socklen_t addrlen) 3174 { 3175 void *addr; 3176 abi_long ret; 3177 3178 if ((int)addrlen < 0) { 3179 return -TARGET_EINVAL; 3180 } 3181 3182 addr = alloca(addrlen+1); 3183 3184 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen); 3185 if (ret) 3186 return ret; 3187 3188 return get_errno(bind(sockfd, addr, addrlen)); 3189 } 3190 3191 /* do_connect() Must return target values and target errnos. */ 3192 static abi_long do_connect(int sockfd, abi_ulong target_addr, 3193 socklen_t addrlen) 3194 { 3195 void *addr; 3196 abi_long ret; 3197 3198 if ((int)addrlen < 0) { 3199 return -TARGET_EINVAL; 3200 } 3201 3202 addr = alloca(addrlen+1); 3203 3204 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen); 3205 if (ret) 3206 return ret; 3207 3208 return get_errno(safe_connect(sockfd, addr, addrlen)); 3209 } 3210 3211 /* do_sendrecvmsg_locked() Must return target values and target errnos. */ 3212 static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp, 3213 int flags, int send) 3214 { 3215 abi_long ret, len; 3216 struct msghdr msg; 3217 abi_ulong count; 3218 struct iovec *vec; 3219 abi_ulong target_vec; 3220 3221 if (msgp->msg_name) { 3222 msg.msg_namelen = tswap32(msgp->msg_namelen); 3223 msg.msg_name = alloca(msg.msg_namelen+1); 3224 ret = target_to_host_sockaddr(fd, msg.msg_name, 3225 tswapal(msgp->msg_name), 3226 msg.msg_namelen); 3227 if (ret == -TARGET_EFAULT) { 3228 /* For connected sockets msg_name and msg_namelen must 3229 * be ignored, so returning EFAULT immediately is wrong. 3230 * Instead, pass a bad msg_name to the host kernel, and 3231 * let it decide whether to return EFAULT or not. 3232 */ 3233 msg.msg_name = (void *)-1; 3234 } else if (ret) { 3235 goto out2; 3236 } 3237 } else { 3238 msg.msg_name = NULL; 3239 msg.msg_namelen = 0; 3240 } 3241 msg.msg_controllen = 2 * tswapal(msgp->msg_controllen); 3242 msg.msg_control = alloca(msg.msg_controllen); 3243 memset(msg.msg_control, 0, msg.msg_controllen); 3244 3245 msg.msg_flags = tswap32(msgp->msg_flags); 3246 3247 count = tswapal(msgp->msg_iovlen); 3248 target_vec = tswapal(msgp->msg_iov); 3249 3250 if (count > IOV_MAX) { 3251 /* sendrcvmsg returns a different errno for this condition than 3252 * readv/writev, so we must catch it here before lock_iovec() does. 3253 */ 3254 ret = -TARGET_EMSGSIZE; 3255 goto out2; 3256 } 3257 3258 vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE, 3259 target_vec, count, send); 3260 if (vec == NULL) { 3261 ret = -host_to_target_errno(errno); 3262 goto out2; 3263 } 3264 msg.msg_iovlen = count; 3265 msg.msg_iov = vec; 3266 3267 if (send) { 3268 if (fd_trans_target_to_host_data(fd)) { 3269 void *host_msg; 3270 3271 host_msg = g_malloc(msg.msg_iov->iov_len); 3272 memcpy(host_msg, msg.msg_iov->iov_base, msg.msg_iov->iov_len); 3273 ret = fd_trans_target_to_host_data(fd)(host_msg, 3274 msg.msg_iov->iov_len); 3275 if (ret >= 0) { 3276 msg.msg_iov->iov_base = host_msg; 3277 ret = get_errno(safe_sendmsg(fd, &msg, flags)); 3278 } 3279 g_free(host_msg); 3280 } else { 3281 ret = target_to_host_cmsg(&msg, msgp); 3282 if (ret == 0) { 3283 ret = get_errno(safe_sendmsg(fd, &msg, flags)); 3284 } 3285 } 3286 } else { 3287 ret = get_errno(safe_recvmsg(fd, &msg, flags)); 3288 if (!is_error(ret)) { 3289 len = ret; 3290 if (fd_trans_host_to_target_data(fd)) { 3291 ret = fd_trans_host_to_target_data(fd)(msg.msg_iov->iov_base, 3292 MIN(msg.msg_iov->iov_len, len)); 3293 } else { 3294 ret = host_to_target_cmsg(msgp, &msg); 3295 } 3296 if (!is_error(ret)) { 3297 msgp->msg_namelen = tswap32(msg.msg_namelen); 3298 msgp->msg_flags = tswap32(msg.msg_flags); 3299 if (msg.msg_name != NULL && msg.msg_name != (void *)-1) { 3300 ret = host_to_target_sockaddr(tswapal(msgp->msg_name), 3301 msg.msg_name, msg.msg_namelen); 3302 if (ret) { 3303 goto out; 3304 } 3305 } 3306 3307 ret = len; 3308 } 3309 } 3310 } 3311 3312 out: 3313 unlock_iovec(vec, target_vec, count, !send); 3314 out2: 3315 return ret; 3316 } 3317 3318 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg, 3319 int flags, int send) 3320 { 3321 abi_long ret; 3322 struct target_msghdr *msgp; 3323 3324 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE, 3325 msgp, 3326 target_msg, 3327 send ? 1 : 0)) { 3328 return -TARGET_EFAULT; 3329 } 3330 ret = do_sendrecvmsg_locked(fd, msgp, flags, send); 3331 unlock_user_struct(msgp, target_msg, send ? 0 : 1); 3332 return ret; 3333 } 3334 3335 /* We don't rely on the C library to have sendmmsg/recvmmsg support, 3336 * so it might not have this *mmsg-specific flag either. 3337 */ 3338 #ifndef MSG_WAITFORONE 3339 #define MSG_WAITFORONE 0x10000 3340 #endif 3341 3342 static abi_long do_sendrecvmmsg(int fd, abi_ulong target_msgvec, 3343 unsigned int vlen, unsigned int flags, 3344 int send) 3345 { 3346 struct target_mmsghdr *mmsgp; 3347 abi_long ret = 0; 3348 int i; 3349 3350 if (vlen > UIO_MAXIOV) { 3351 vlen = UIO_MAXIOV; 3352 } 3353 3354 mmsgp = lock_user(VERIFY_WRITE, target_msgvec, sizeof(*mmsgp) * vlen, 1); 3355 if (!mmsgp) { 3356 return -TARGET_EFAULT; 3357 } 3358 3359 for (i = 0; i < vlen; i++) { 3360 ret = do_sendrecvmsg_locked(fd, &mmsgp[i].msg_hdr, flags, send); 3361 if (is_error(ret)) { 3362 break; 3363 } 3364 mmsgp[i].msg_len = tswap32(ret); 3365 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */ 3366 if (flags & MSG_WAITFORONE) { 3367 flags |= MSG_DONTWAIT; 3368 } 3369 } 3370 3371 unlock_user(mmsgp, target_msgvec, sizeof(*mmsgp) * i); 3372 3373 /* Return number of datagrams sent if we sent any at all; 3374 * otherwise return the error. 3375 */ 3376 if (i) { 3377 return i; 3378 } 3379 return ret; 3380 } 3381 3382 /* do_accept4() Must return target values and target errnos. */ 3383 static abi_long do_accept4(int fd, abi_ulong target_addr, 3384 abi_ulong target_addrlen_addr, int flags) 3385 { 3386 socklen_t addrlen, ret_addrlen; 3387 void *addr; 3388 abi_long ret; 3389 int host_flags; 3390 3391 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl); 3392 3393 if (target_addr == 0) { 3394 return get_errno(safe_accept4(fd, NULL, NULL, host_flags)); 3395 } 3396 3397 /* linux returns EFAULT if addrlen pointer is invalid */ 3398 if (get_user_u32(addrlen, target_addrlen_addr)) 3399 return -TARGET_EFAULT; 3400 3401 if ((int)addrlen < 0) { 3402 return -TARGET_EINVAL; 3403 } 3404 3405 if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) { 3406 return -TARGET_EFAULT; 3407 } 3408 3409 addr = alloca(addrlen); 3410 3411 ret_addrlen = addrlen; 3412 ret = get_errno(safe_accept4(fd, addr, &ret_addrlen, host_flags)); 3413 if (!is_error(ret)) { 3414 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen)); 3415 if (put_user_u32(ret_addrlen, target_addrlen_addr)) { 3416 ret = -TARGET_EFAULT; 3417 } 3418 } 3419 return ret; 3420 } 3421 3422 /* do_getpeername() Must return target values and target errnos. */ 3423 static abi_long do_getpeername(int fd, abi_ulong target_addr, 3424 abi_ulong target_addrlen_addr) 3425 { 3426 socklen_t addrlen, ret_addrlen; 3427 void *addr; 3428 abi_long ret; 3429 3430 if (get_user_u32(addrlen, target_addrlen_addr)) 3431 return -TARGET_EFAULT; 3432 3433 if ((int)addrlen < 0) { 3434 return -TARGET_EINVAL; 3435 } 3436 3437 if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) { 3438 return -TARGET_EFAULT; 3439 } 3440 3441 addr = alloca(addrlen); 3442 3443 ret_addrlen = addrlen; 3444 ret = get_errno(getpeername(fd, addr, &ret_addrlen)); 3445 if (!is_error(ret)) { 3446 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen)); 3447 if (put_user_u32(ret_addrlen, target_addrlen_addr)) { 3448 ret = -TARGET_EFAULT; 3449 } 3450 } 3451 return ret; 3452 } 3453 3454 /* do_getsockname() Must return target values and target errnos. */ 3455 static abi_long do_getsockname(int fd, abi_ulong target_addr, 3456 abi_ulong target_addrlen_addr) 3457 { 3458 socklen_t addrlen, ret_addrlen; 3459 void *addr; 3460 abi_long ret; 3461 3462 if (get_user_u32(addrlen, target_addrlen_addr)) 3463 return -TARGET_EFAULT; 3464 3465 if ((int)addrlen < 0) { 3466 return -TARGET_EINVAL; 3467 } 3468 3469 if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) { 3470 return -TARGET_EFAULT; 3471 } 3472 3473 addr = alloca(addrlen); 3474 3475 ret_addrlen = addrlen; 3476 ret = get_errno(getsockname(fd, addr, &ret_addrlen)); 3477 if (!is_error(ret)) { 3478 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen)); 3479 if (put_user_u32(ret_addrlen, target_addrlen_addr)) { 3480 ret = -TARGET_EFAULT; 3481 } 3482 } 3483 return ret; 3484 } 3485 3486 /* do_socketpair() Must return target values and target errnos. */ 3487 static abi_long do_socketpair(int domain, int type, int protocol, 3488 abi_ulong target_tab_addr) 3489 { 3490 int tab[2]; 3491 abi_long ret; 3492 3493 target_to_host_sock_type(&type); 3494 3495 ret = get_errno(socketpair(domain, type, protocol, tab)); 3496 if (!is_error(ret)) { 3497 if (put_user_s32(tab[0], target_tab_addr) 3498 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0]))) 3499 ret = -TARGET_EFAULT; 3500 } 3501 return ret; 3502 } 3503 3504 /* do_sendto() Must return target values and target errnos. */ 3505 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags, 3506 abi_ulong target_addr, socklen_t addrlen) 3507 { 3508 void *addr; 3509 void *host_msg; 3510 void *copy_msg = NULL; 3511 abi_long ret; 3512 3513 if ((int)addrlen < 0) { 3514 return -TARGET_EINVAL; 3515 } 3516 3517 host_msg = lock_user(VERIFY_READ, msg, len, 1); 3518 if (!host_msg) 3519 return -TARGET_EFAULT; 3520 if (fd_trans_target_to_host_data(fd)) { 3521 copy_msg = host_msg; 3522 host_msg = g_malloc(len); 3523 memcpy(host_msg, copy_msg, len); 3524 ret = fd_trans_target_to_host_data(fd)(host_msg, len); 3525 if (ret < 0) { 3526 goto fail; 3527 } 3528 } 3529 if (target_addr) { 3530 addr = alloca(addrlen+1); 3531 ret = target_to_host_sockaddr(fd, addr, target_addr, addrlen); 3532 if (ret) { 3533 goto fail; 3534 } 3535 ret = get_errno(safe_sendto(fd, host_msg, len, flags, addr, addrlen)); 3536 } else { 3537 ret = get_errno(safe_sendto(fd, host_msg, len, flags, NULL, 0)); 3538 } 3539 fail: 3540 if (copy_msg) { 3541 g_free(host_msg); 3542 host_msg = copy_msg; 3543 } 3544 unlock_user(host_msg, msg, 0); 3545 return ret; 3546 } 3547 3548 /* do_recvfrom() Must return target values and target errnos. */ 3549 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags, 3550 abi_ulong target_addr, 3551 abi_ulong target_addrlen) 3552 { 3553 socklen_t addrlen, ret_addrlen; 3554 void *addr; 3555 void *host_msg; 3556 abi_long ret; 3557 3558 if (!msg) { 3559 host_msg = NULL; 3560 } else { 3561 host_msg = lock_user(VERIFY_WRITE, msg, len, 0); 3562 if (!host_msg) { 3563 return -TARGET_EFAULT; 3564 } 3565 } 3566 if (target_addr) { 3567 if (get_user_u32(addrlen, target_addrlen)) { 3568 ret = -TARGET_EFAULT; 3569 goto fail; 3570 } 3571 if ((int)addrlen < 0) { 3572 ret = -TARGET_EINVAL; 3573 goto fail; 3574 } 3575 addr = alloca(addrlen); 3576 ret_addrlen = addrlen; 3577 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, 3578 addr, &ret_addrlen)); 3579 } else { 3580 addr = NULL; /* To keep compiler quiet. */ 3581 addrlen = 0; /* To keep compiler quiet. */ 3582 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, NULL, 0)); 3583 } 3584 if (!is_error(ret)) { 3585 if (fd_trans_host_to_target_data(fd)) { 3586 abi_long trans; 3587 trans = fd_trans_host_to_target_data(fd)(host_msg, MIN(ret, len)); 3588 if (is_error(trans)) { 3589 ret = trans; 3590 goto fail; 3591 } 3592 } 3593 if (target_addr) { 3594 host_to_target_sockaddr(target_addr, addr, 3595 MIN(addrlen, ret_addrlen)); 3596 if (put_user_u32(ret_addrlen, target_addrlen)) { 3597 ret = -TARGET_EFAULT; 3598 goto fail; 3599 } 3600 } 3601 unlock_user(host_msg, msg, len); 3602 } else { 3603 fail: 3604 unlock_user(host_msg, msg, 0); 3605 } 3606 return ret; 3607 } 3608 3609 #ifdef TARGET_NR_socketcall 3610 /* do_socketcall() must return target values and target errnos. */ 3611 static abi_long do_socketcall(int num, abi_ulong vptr) 3612 { 3613 static const unsigned nargs[] = { /* number of arguments per operation */ 3614 [TARGET_SYS_SOCKET] = 3, /* domain, type, protocol */ 3615 [TARGET_SYS_BIND] = 3, /* fd, addr, addrlen */ 3616 [TARGET_SYS_CONNECT] = 3, /* fd, addr, addrlen */ 3617 [TARGET_SYS_LISTEN] = 2, /* fd, backlog */ 3618 [TARGET_SYS_ACCEPT] = 3, /* fd, addr, addrlen */ 3619 [TARGET_SYS_GETSOCKNAME] = 3, /* fd, addr, addrlen */ 3620 [TARGET_SYS_GETPEERNAME] = 3, /* fd, addr, addrlen */ 3621 [TARGET_SYS_SOCKETPAIR] = 4, /* domain, type, protocol, tab */ 3622 [TARGET_SYS_SEND] = 4, /* fd, msg, len, flags */ 3623 [TARGET_SYS_RECV] = 4, /* fd, msg, len, flags */ 3624 [TARGET_SYS_SENDTO] = 6, /* fd, msg, len, flags, addr, addrlen */ 3625 [TARGET_SYS_RECVFROM] = 6, /* fd, msg, len, flags, addr, addrlen */ 3626 [TARGET_SYS_SHUTDOWN] = 2, /* fd, how */ 3627 [TARGET_SYS_SETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */ 3628 [TARGET_SYS_GETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */ 3629 [TARGET_SYS_SENDMSG] = 3, /* fd, msg, flags */ 3630 [TARGET_SYS_RECVMSG] = 3, /* fd, msg, flags */ 3631 [TARGET_SYS_ACCEPT4] = 4, /* fd, addr, addrlen, flags */ 3632 [TARGET_SYS_RECVMMSG] = 4, /* fd, msgvec, vlen, flags */ 3633 [TARGET_SYS_SENDMMSG] = 4, /* fd, msgvec, vlen, flags */ 3634 }; 3635 abi_long a[6]; /* max 6 args */ 3636 unsigned i; 3637 3638 /* check the range of the first argument num */ 3639 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */ 3640 if (num < 1 || num > TARGET_SYS_SENDMMSG) { 3641 return -TARGET_EINVAL; 3642 } 3643 /* ensure we have space for args */ 3644 if (nargs[num] > ARRAY_SIZE(a)) { 3645 return -TARGET_EINVAL; 3646 } 3647 /* collect the arguments in a[] according to nargs[] */ 3648 for (i = 0; i < nargs[num]; ++i) { 3649 if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) { 3650 return -TARGET_EFAULT; 3651 } 3652 } 3653 /* now when we have the args, invoke the appropriate underlying function */ 3654 switch (num) { 3655 case TARGET_SYS_SOCKET: /* domain, type, protocol */ 3656 return do_socket(a[0], a[1], a[2]); 3657 case TARGET_SYS_BIND: /* sockfd, addr, addrlen */ 3658 return do_bind(a[0], a[1], a[2]); 3659 case TARGET_SYS_CONNECT: /* sockfd, addr, addrlen */ 3660 return do_connect(a[0], a[1], a[2]); 3661 case TARGET_SYS_LISTEN: /* sockfd, backlog */ 3662 return get_errno(listen(a[0], a[1])); 3663 case TARGET_SYS_ACCEPT: /* sockfd, addr, addrlen */ 3664 return do_accept4(a[0], a[1], a[2], 0); 3665 case TARGET_SYS_GETSOCKNAME: /* sockfd, addr, addrlen */ 3666 return do_getsockname(a[0], a[1], a[2]); 3667 case TARGET_SYS_GETPEERNAME: /* sockfd, addr, addrlen */ 3668 return do_getpeername(a[0], a[1], a[2]); 3669 case TARGET_SYS_SOCKETPAIR: /* domain, type, protocol, tab */ 3670 return do_socketpair(a[0], a[1], a[2], a[3]); 3671 case TARGET_SYS_SEND: /* sockfd, msg, len, flags */ 3672 return do_sendto(a[0], a[1], a[2], a[3], 0, 0); 3673 case TARGET_SYS_RECV: /* sockfd, msg, len, flags */ 3674 return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0); 3675 case TARGET_SYS_SENDTO: /* sockfd, msg, len, flags, addr, addrlen */ 3676 return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]); 3677 case TARGET_SYS_RECVFROM: /* sockfd, msg, len, flags, addr, addrlen */ 3678 return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]); 3679 case TARGET_SYS_SHUTDOWN: /* sockfd, how */ 3680 return get_errno(shutdown(a[0], a[1])); 3681 case TARGET_SYS_SETSOCKOPT: /* sockfd, level, optname, optval, optlen */ 3682 return do_setsockopt(a[0], a[1], a[2], a[3], a[4]); 3683 case TARGET_SYS_GETSOCKOPT: /* sockfd, level, optname, optval, optlen */ 3684 return do_getsockopt(a[0], a[1], a[2], a[3], a[4]); 3685 case TARGET_SYS_SENDMSG: /* sockfd, msg, flags */ 3686 return do_sendrecvmsg(a[0], a[1], a[2], 1); 3687 case TARGET_SYS_RECVMSG: /* sockfd, msg, flags */ 3688 return do_sendrecvmsg(a[0], a[1], a[2], 0); 3689 case TARGET_SYS_ACCEPT4: /* sockfd, addr, addrlen, flags */ 3690 return do_accept4(a[0], a[1], a[2], a[3]); 3691 case TARGET_SYS_RECVMMSG: /* sockfd, msgvec, vlen, flags */ 3692 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0); 3693 case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */ 3694 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1); 3695 default: 3696 qemu_log_mask(LOG_UNIMP, "Unsupported socketcall: %d\n", num); 3697 return -TARGET_EINVAL; 3698 } 3699 } 3700 #endif 3701 3702 #define N_SHM_REGIONS 32 3703 3704 static struct shm_region { 3705 abi_ulong start; 3706 abi_ulong size; 3707 bool in_use; 3708 } shm_regions[N_SHM_REGIONS]; 3709 3710 #ifndef TARGET_SEMID64_DS 3711 /* asm-generic version of this struct */ 3712 struct target_semid64_ds 3713 { 3714 struct target_ipc_perm sem_perm; 3715 abi_ulong sem_otime; 3716 #if TARGET_ABI_BITS == 32 3717 abi_ulong __unused1; 3718 #endif 3719 abi_ulong sem_ctime; 3720 #if TARGET_ABI_BITS == 32 3721 abi_ulong __unused2; 3722 #endif 3723 abi_ulong sem_nsems; 3724 abi_ulong __unused3; 3725 abi_ulong __unused4; 3726 }; 3727 #endif 3728 3729 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip, 3730 abi_ulong target_addr) 3731 { 3732 struct target_ipc_perm *target_ip; 3733 struct target_semid64_ds *target_sd; 3734 3735 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) 3736 return -TARGET_EFAULT; 3737 target_ip = &(target_sd->sem_perm); 3738 host_ip->__key = tswap32(target_ip->__key); 3739 host_ip->uid = tswap32(target_ip->uid); 3740 host_ip->gid = tswap32(target_ip->gid); 3741 host_ip->cuid = tswap32(target_ip->cuid); 3742 host_ip->cgid = tswap32(target_ip->cgid); 3743 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC) 3744 host_ip->mode = tswap32(target_ip->mode); 3745 #else 3746 host_ip->mode = tswap16(target_ip->mode); 3747 #endif 3748 #if defined(TARGET_PPC) 3749 host_ip->__seq = tswap32(target_ip->__seq); 3750 #else 3751 host_ip->__seq = tswap16(target_ip->__seq); 3752 #endif 3753 unlock_user_struct(target_sd, target_addr, 0); 3754 return 0; 3755 } 3756 3757 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr, 3758 struct ipc_perm *host_ip) 3759 { 3760 struct target_ipc_perm *target_ip; 3761 struct target_semid64_ds *target_sd; 3762 3763 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) 3764 return -TARGET_EFAULT; 3765 target_ip = &(target_sd->sem_perm); 3766 target_ip->__key = tswap32(host_ip->__key); 3767 target_ip->uid = tswap32(host_ip->uid); 3768 target_ip->gid = tswap32(host_ip->gid); 3769 target_ip->cuid = tswap32(host_ip->cuid); 3770 target_ip->cgid = tswap32(host_ip->cgid); 3771 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC) 3772 target_ip->mode = tswap32(host_ip->mode); 3773 #else 3774 target_ip->mode = tswap16(host_ip->mode); 3775 #endif 3776 #if defined(TARGET_PPC) 3777 target_ip->__seq = tswap32(host_ip->__seq); 3778 #else 3779 target_ip->__seq = tswap16(host_ip->__seq); 3780 #endif 3781 unlock_user_struct(target_sd, target_addr, 1); 3782 return 0; 3783 } 3784 3785 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd, 3786 abi_ulong target_addr) 3787 { 3788 struct target_semid64_ds *target_sd; 3789 3790 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) 3791 return -TARGET_EFAULT; 3792 if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr)) 3793 return -TARGET_EFAULT; 3794 host_sd->sem_nsems = tswapal(target_sd->sem_nsems); 3795 host_sd->sem_otime = tswapal(target_sd->sem_otime); 3796 host_sd->sem_ctime = tswapal(target_sd->sem_ctime); 3797 unlock_user_struct(target_sd, target_addr, 0); 3798 return 0; 3799 } 3800 3801 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr, 3802 struct semid_ds *host_sd) 3803 { 3804 struct target_semid64_ds *target_sd; 3805 3806 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) 3807 return -TARGET_EFAULT; 3808 if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm))) 3809 return -TARGET_EFAULT; 3810 target_sd->sem_nsems = tswapal(host_sd->sem_nsems); 3811 target_sd->sem_otime = tswapal(host_sd->sem_otime); 3812 target_sd->sem_ctime = tswapal(host_sd->sem_ctime); 3813 unlock_user_struct(target_sd, target_addr, 1); 3814 return 0; 3815 } 3816 3817 struct target_seminfo { 3818 int semmap; 3819 int semmni; 3820 int semmns; 3821 int semmnu; 3822 int semmsl; 3823 int semopm; 3824 int semume; 3825 int semusz; 3826 int semvmx; 3827 int semaem; 3828 }; 3829 3830 static inline abi_long host_to_target_seminfo(abi_ulong target_addr, 3831 struct seminfo *host_seminfo) 3832 { 3833 struct target_seminfo *target_seminfo; 3834 if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0)) 3835 return -TARGET_EFAULT; 3836 __put_user(host_seminfo->semmap, &target_seminfo->semmap); 3837 __put_user(host_seminfo->semmni, &target_seminfo->semmni); 3838 __put_user(host_seminfo->semmns, &target_seminfo->semmns); 3839 __put_user(host_seminfo->semmnu, &target_seminfo->semmnu); 3840 __put_user(host_seminfo->semmsl, &target_seminfo->semmsl); 3841 __put_user(host_seminfo->semopm, &target_seminfo->semopm); 3842 __put_user(host_seminfo->semume, &target_seminfo->semume); 3843 __put_user(host_seminfo->semusz, &target_seminfo->semusz); 3844 __put_user(host_seminfo->semvmx, &target_seminfo->semvmx); 3845 __put_user(host_seminfo->semaem, &target_seminfo->semaem); 3846 unlock_user_struct(target_seminfo, target_addr, 1); 3847 return 0; 3848 } 3849 3850 union semun { 3851 int val; 3852 struct semid_ds *buf; 3853 unsigned short *array; 3854 struct seminfo *__buf; 3855 }; 3856 3857 union target_semun { 3858 int val; 3859 abi_ulong buf; 3860 abi_ulong array; 3861 abi_ulong __buf; 3862 }; 3863 3864 static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array, 3865 abi_ulong target_addr) 3866 { 3867 int nsems; 3868 unsigned short *array; 3869 union semun semun; 3870 struct semid_ds semid_ds; 3871 int i, ret; 3872 3873 semun.buf = &semid_ds; 3874 3875 ret = semctl(semid, 0, IPC_STAT, semun); 3876 if (ret == -1) 3877 return get_errno(ret); 3878 3879 nsems = semid_ds.sem_nsems; 3880 3881 *host_array = g_try_new(unsigned short, nsems); 3882 if (!*host_array) { 3883 return -TARGET_ENOMEM; 3884 } 3885 array = lock_user(VERIFY_READ, target_addr, 3886 nsems*sizeof(unsigned short), 1); 3887 if (!array) { 3888 g_free(*host_array); 3889 return -TARGET_EFAULT; 3890 } 3891 3892 for(i=0; i<nsems; i++) { 3893 __get_user((*host_array)[i], &array[i]); 3894 } 3895 unlock_user(array, target_addr, 0); 3896 3897 return 0; 3898 } 3899 3900 static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr, 3901 unsigned short **host_array) 3902 { 3903 int nsems; 3904 unsigned short *array; 3905 union semun semun; 3906 struct semid_ds semid_ds; 3907 int i, ret; 3908 3909 semun.buf = &semid_ds; 3910 3911 ret = semctl(semid, 0, IPC_STAT, semun); 3912 if (ret == -1) 3913 return get_errno(ret); 3914 3915 nsems = semid_ds.sem_nsems; 3916 3917 array = lock_user(VERIFY_WRITE, target_addr, 3918 nsems*sizeof(unsigned short), 0); 3919 if (!array) 3920 return -TARGET_EFAULT; 3921 3922 for(i=0; i<nsems; i++) { 3923 __put_user((*host_array)[i], &array[i]); 3924 } 3925 g_free(*host_array); 3926 unlock_user(array, target_addr, 1); 3927 3928 return 0; 3929 } 3930 3931 static inline abi_long do_semctl(int semid, int semnum, int cmd, 3932 abi_ulong target_arg) 3933 { 3934 union target_semun target_su = { .buf = target_arg }; 3935 union semun arg; 3936 struct semid_ds dsarg; 3937 unsigned short *array = NULL; 3938 struct seminfo seminfo; 3939 abi_long ret = -TARGET_EINVAL; 3940 abi_long err; 3941 cmd &= 0xff; 3942 3943 switch( cmd ) { 3944 case GETVAL: 3945 case SETVAL: 3946 /* In 64 bit cross-endian situations, we will erroneously pick up 3947 * the wrong half of the union for the "val" element. To rectify 3948 * this, the entire 8-byte structure is byteswapped, followed by 3949 * a swap of the 4 byte val field. In other cases, the data is 3950 * already in proper host byte order. */ 3951 if (sizeof(target_su.val) != (sizeof(target_su.buf))) { 3952 target_su.buf = tswapal(target_su.buf); 3953 arg.val = tswap32(target_su.val); 3954 } else { 3955 arg.val = target_su.val; 3956 } 3957 ret = get_errno(semctl(semid, semnum, cmd, arg)); 3958 break; 3959 case GETALL: 3960 case SETALL: 3961 err = target_to_host_semarray(semid, &array, target_su.array); 3962 if (err) 3963 return err; 3964 arg.array = array; 3965 ret = get_errno(semctl(semid, semnum, cmd, arg)); 3966 err = host_to_target_semarray(semid, target_su.array, &array); 3967 if (err) 3968 return err; 3969 break; 3970 case IPC_STAT: 3971 case IPC_SET: 3972 case SEM_STAT: 3973 err = target_to_host_semid_ds(&dsarg, target_su.buf); 3974 if (err) 3975 return err; 3976 arg.buf = &dsarg; 3977 ret = get_errno(semctl(semid, semnum, cmd, arg)); 3978 err = host_to_target_semid_ds(target_su.buf, &dsarg); 3979 if (err) 3980 return err; 3981 break; 3982 case IPC_INFO: 3983 case SEM_INFO: 3984 arg.__buf = &seminfo; 3985 ret = get_errno(semctl(semid, semnum, cmd, arg)); 3986 err = host_to_target_seminfo(target_su.__buf, &seminfo); 3987 if (err) 3988 return err; 3989 break; 3990 case IPC_RMID: 3991 case GETPID: 3992 case GETNCNT: 3993 case GETZCNT: 3994 ret = get_errno(semctl(semid, semnum, cmd, NULL)); 3995 break; 3996 } 3997 3998 return ret; 3999 } 4000 4001 struct target_sembuf { 4002 unsigned short sem_num; 4003 short sem_op; 4004 short sem_flg; 4005 }; 4006 4007 static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf, 4008 abi_ulong target_addr, 4009 unsigned nsops) 4010 { 4011 struct target_sembuf *target_sembuf; 4012 int i; 4013 4014 target_sembuf = lock_user(VERIFY_READ, target_addr, 4015 nsops*sizeof(struct target_sembuf), 1); 4016 if (!target_sembuf) 4017 return -TARGET_EFAULT; 4018 4019 for(i=0; i<nsops; i++) { 4020 __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num); 4021 __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op); 4022 __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg); 4023 } 4024 4025 unlock_user(target_sembuf, target_addr, 0); 4026 4027 return 0; 4028 } 4029 4030 #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \ 4031 defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64) 4032 4033 /* 4034 * This macro is required to handle the s390 variants, which passes the 4035 * arguments in a different order than default. 4036 */ 4037 #ifdef __s390x__ 4038 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \ 4039 (__nsops), (__timeout), (__sops) 4040 #else 4041 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \ 4042 (__nsops), 0, (__sops), (__timeout) 4043 #endif 4044 4045 static inline abi_long do_semtimedop(int semid, 4046 abi_long ptr, 4047 unsigned nsops, 4048 abi_long timeout, bool time64) 4049 { 4050 struct sembuf *sops; 4051 struct timespec ts, *pts = NULL; 4052 abi_long ret; 4053 4054 if (timeout) { 4055 pts = &ts; 4056 if (time64) { 4057 if (target_to_host_timespec64(pts, timeout)) { 4058 return -TARGET_EFAULT; 4059 } 4060 } else { 4061 if (target_to_host_timespec(pts, timeout)) { 4062 return -TARGET_EFAULT; 4063 } 4064 } 4065 } 4066 4067 if (nsops > TARGET_SEMOPM) { 4068 return -TARGET_E2BIG; 4069 } 4070 4071 sops = g_new(struct sembuf, nsops); 4072 4073 if (target_to_host_sembuf(sops, ptr, nsops)) { 4074 g_free(sops); 4075 return -TARGET_EFAULT; 4076 } 4077 4078 ret = -TARGET_ENOSYS; 4079 #ifdef __NR_semtimedop 4080 ret = get_errno(safe_semtimedop(semid, sops, nsops, pts)); 4081 #endif 4082 #ifdef __NR_ipc 4083 if (ret == -TARGET_ENOSYS) { 4084 ret = get_errno(safe_ipc(IPCOP_semtimedop, semid, 4085 SEMTIMEDOP_IPC_ARGS(nsops, sops, (long)pts))); 4086 } 4087 #endif 4088 g_free(sops); 4089 return ret; 4090 } 4091 #endif 4092 4093 struct target_msqid_ds 4094 { 4095 struct target_ipc_perm msg_perm; 4096 abi_ulong msg_stime; 4097 #if TARGET_ABI_BITS == 32 4098 abi_ulong __unused1; 4099 #endif 4100 abi_ulong msg_rtime; 4101 #if TARGET_ABI_BITS == 32 4102 abi_ulong __unused2; 4103 #endif 4104 abi_ulong msg_ctime; 4105 #if TARGET_ABI_BITS == 32 4106 abi_ulong __unused3; 4107 #endif 4108 abi_ulong __msg_cbytes; 4109 abi_ulong msg_qnum; 4110 abi_ulong msg_qbytes; 4111 abi_ulong msg_lspid; 4112 abi_ulong msg_lrpid; 4113 abi_ulong __unused4; 4114 abi_ulong __unused5; 4115 }; 4116 4117 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md, 4118 abi_ulong target_addr) 4119 { 4120 struct target_msqid_ds *target_md; 4121 4122 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1)) 4123 return -TARGET_EFAULT; 4124 if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr)) 4125 return -TARGET_EFAULT; 4126 host_md->msg_stime = tswapal(target_md->msg_stime); 4127 host_md->msg_rtime = tswapal(target_md->msg_rtime); 4128 host_md->msg_ctime = tswapal(target_md->msg_ctime); 4129 host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes); 4130 host_md->msg_qnum = tswapal(target_md->msg_qnum); 4131 host_md->msg_qbytes = tswapal(target_md->msg_qbytes); 4132 host_md->msg_lspid = tswapal(target_md->msg_lspid); 4133 host_md->msg_lrpid = tswapal(target_md->msg_lrpid); 4134 unlock_user_struct(target_md, target_addr, 0); 4135 return 0; 4136 } 4137 4138 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr, 4139 struct msqid_ds *host_md) 4140 { 4141 struct target_msqid_ds *target_md; 4142 4143 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0)) 4144 return -TARGET_EFAULT; 4145 if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm))) 4146 return -TARGET_EFAULT; 4147 target_md->msg_stime = tswapal(host_md->msg_stime); 4148 target_md->msg_rtime = tswapal(host_md->msg_rtime); 4149 target_md->msg_ctime = tswapal(host_md->msg_ctime); 4150 target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes); 4151 target_md->msg_qnum = tswapal(host_md->msg_qnum); 4152 target_md->msg_qbytes = tswapal(host_md->msg_qbytes); 4153 target_md->msg_lspid = tswapal(host_md->msg_lspid); 4154 target_md->msg_lrpid = tswapal(host_md->msg_lrpid); 4155 unlock_user_struct(target_md, target_addr, 1); 4156 return 0; 4157 } 4158 4159 struct target_msginfo { 4160 int msgpool; 4161 int msgmap; 4162 int msgmax; 4163 int msgmnb; 4164 int msgmni; 4165 int msgssz; 4166 int msgtql; 4167 unsigned short int msgseg; 4168 }; 4169 4170 static inline abi_long host_to_target_msginfo(abi_ulong target_addr, 4171 struct msginfo *host_msginfo) 4172 { 4173 struct target_msginfo *target_msginfo; 4174 if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0)) 4175 return -TARGET_EFAULT; 4176 __put_user(host_msginfo->msgpool, &target_msginfo->msgpool); 4177 __put_user(host_msginfo->msgmap, &target_msginfo->msgmap); 4178 __put_user(host_msginfo->msgmax, &target_msginfo->msgmax); 4179 __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb); 4180 __put_user(host_msginfo->msgmni, &target_msginfo->msgmni); 4181 __put_user(host_msginfo->msgssz, &target_msginfo->msgssz); 4182 __put_user(host_msginfo->msgtql, &target_msginfo->msgtql); 4183 __put_user(host_msginfo->msgseg, &target_msginfo->msgseg); 4184 unlock_user_struct(target_msginfo, target_addr, 1); 4185 return 0; 4186 } 4187 4188 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr) 4189 { 4190 struct msqid_ds dsarg; 4191 struct msginfo msginfo; 4192 abi_long ret = -TARGET_EINVAL; 4193 4194 cmd &= 0xff; 4195 4196 switch (cmd) { 4197 case IPC_STAT: 4198 case IPC_SET: 4199 case MSG_STAT: 4200 if (target_to_host_msqid_ds(&dsarg,ptr)) 4201 return -TARGET_EFAULT; 4202 ret = get_errno(msgctl(msgid, cmd, &dsarg)); 4203 if (host_to_target_msqid_ds(ptr,&dsarg)) 4204 return -TARGET_EFAULT; 4205 break; 4206 case IPC_RMID: 4207 ret = get_errno(msgctl(msgid, cmd, NULL)); 4208 break; 4209 case IPC_INFO: 4210 case MSG_INFO: 4211 ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo)); 4212 if (host_to_target_msginfo(ptr, &msginfo)) 4213 return -TARGET_EFAULT; 4214 break; 4215 } 4216 4217 return ret; 4218 } 4219 4220 struct target_msgbuf { 4221 abi_long mtype; 4222 char mtext[1]; 4223 }; 4224 4225 static inline abi_long do_msgsnd(int msqid, abi_long msgp, 4226 ssize_t msgsz, int msgflg) 4227 { 4228 struct target_msgbuf *target_mb; 4229 struct msgbuf *host_mb; 4230 abi_long ret = 0; 4231 4232 if (msgsz < 0) { 4233 return -TARGET_EINVAL; 4234 } 4235 4236 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0)) 4237 return -TARGET_EFAULT; 4238 host_mb = g_try_malloc(msgsz + sizeof(long)); 4239 if (!host_mb) { 4240 unlock_user_struct(target_mb, msgp, 0); 4241 return -TARGET_ENOMEM; 4242 } 4243 host_mb->mtype = (abi_long) tswapal(target_mb->mtype); 4244 memcpy(host_mb->mtext, target_mb->mtext, msgsz); 4245 ret = -TARGET_ENOSYS; 4246 #ifdef __NR_msgsnd 4247 ret = get_errno(safe_msgsnd(msqid, host_mb, msgsz, msgflg)); 4248 #endif 4249 #ifdef __NR_ipc 4250 if (ret == -TARGET_ENOSYS) { 4251 #ifdef __s390x__ 4252 ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg, 4253 host_mb)); 4254 #else 4255 ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg, 4256 host_mb, 0)); 4257 #endif 4258 } 4259 #endif 4260 g_free(host_mb); 4261 unlock_user_struct(target_mb, msgp, 0); 4262 4263 return ret; 4264 } 4265 4266 #ifdef __NR_ipc 4267 #if defined(__sparc__) 4268 /* SPARC for msgrcv it does not use the kludge on final 2 arguments. */ 4269 #define MSGRCV_ARGS(__msgp, __msgtyp) __msgp, __msgtyp 4270 #elif defined(__s390x__) 4271 /* The s390 sys_ipc variant has only five parameters. */ 4272 #define MSGRCV_ARGS(__msgp, __msgtyp) \ 4273 ((long int[]){(long int)__msgp, __msgtyp}) 4274 #else 4275 #define MSGRCV_ARGS(__msgp, __msgtyp) \ 4276 ((long int[]){(long int)__msgp, __msgtyp}), 0 4277 #endif 4278 #endif 4279 4280 static inline abi_long do_msgrcv(int msqid, abi_long msgp, 4281 ssize_t msgsz, abi_long msgtyp, 4282 int msgflg) 4283 { 4284 struct target_msgbuf *target_mb; 4285 char *target_mtext; 4286 struct msgbuf *host_mb; 4287 abi_long ret = 0; 4288 4289 if (msgsz < 0) { 4290 return -TARGET_EINVAL; 4291 } 4292 4293 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0)) 4294 return -TARGET_EFAULT; 4295 4296 host_mb = g_try_malloc(msgsz + sizeof(long)); 4297 if (!host_mb) { 4298 ret = -TARGET_ENOMEM; 4299 goto end; 4300 } 4301 ret = -TARGET_ENOSYS; 4302 #ifdef __NR_msgrcv 4303 ret = get_errno(safe_msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg)); 4304 #endif 4305 #ifdef __NR_ipc 4306 if (ret == -TARGET_ENOSYS) { 4307 ret = get_errno(safe_ipc(IPCOP_CALL(1, IPCOP_msgrcv), msqid, msgsz, 4308 msgflg, MSGRCV_ARGS(host_mb, msgtyp))); 4309 } 4310 #endif 4311 4312 if (ret > 0) { 4313 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong); 4314 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0); 4315 if (!target_mtext) { 4316 ret = -TARGET_EFAULT; 4317 goto end; 4318 } 4319 memcpy(target_mb->mtext, host_mb->mtext, ret); 4320 unlock_user(target_mtext, target_mtext_addr, ret); 4321 } 4322 4323 target_mb->mtype = tswapal(host_mb->mtype); 4324 4325 end: 4326 if (target_mb) 4327 unlock_user_struct(target_mb, msgp, 1); 4328 g_free(host_mb); 4329 return ret; 4330 } 4331 4332 static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd, 4333 abi_ulong target_addr) 4334 { 4335 struct target_shmid_ds *target_sd; 4336 4337 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) 4338 return -TARGET_EFAULT; 4339 if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr)) 4340 return -TARGET_EFAULT; 4341 __get_user(host_sd->shm_segsz, &target_sd->shm_segsz); 4342 __get_user(host_sd->shm_atime, &target_sd->shm_atime); 4343 __get_user(host_sd->shm_dtime, &target_sd->shm_dtime); 4344 __get_user(host_sd->shm_ctime, &target_sd->shm_ctime); 4345 __get_user(host_sd->shm_cpid, &target_sd->shm_cpid); 4346 __get_user(host_sd->shm_lpid, &target_sd->shm_lpid); 4347 __get_user(host_sd->shm_nattch, &target_sd->shm_nattch); 4348 unlock_user_struct(target_sd, target_addr, 0); 4349 return 0; 4350 } 4351 4352 static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr, 4353 struct shmid_ds *host_sd) 4354 { 4355 struct target_shmid_ds *target_sd; 4356 4357 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) 4358 return -TARGET_EFAULT; 4359 if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm))) 4360 return -TARGET_EFAULT; 4361 __put_user(host_sd->shm_segsz, &target_sd->shm_segsz); 4362 __put_user(host_sd->shm_atime, &target_sd->shm_atime); 4363 __put_user(host_sd->shm_dtime, &target_sd->shm_dtime); 4364 __put_user(host_sd->shm_ctime, &target_sd->shm_ctime); 4365 __put_user(host_sd->shm_cpid, &target_sd->shm_cpid); 4366 __put_user(host_sd->shm_lpid, &target_sd->shm_lpid); 4367 __put_user(host_sd->shm_nattch, &target_sd->shm_nattch); 4368 unlock_user_struct(target_sd, target_addr, 1); 4369 return 0; 4370 } 4371 4372 struct target_shminfo { 4373 abi_ulong shmmax; 4374 abi_ulong shmmin; 4375 abi_ulong shmmni; 4376 abi_ulong shmseg; 4377 abi_ulong shmall; 4378 }; 4379 4380 static inline abi_long host_to_target_shminfo(abi_ulong target_addr, 4381 struct shminfo *host_shminfo) 4382 { 4383 struct target_shminfo *target_shminfo; 4384 if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0)) 4385 return -TARGET_EFAULT; 4386 __put_user(host_shminfo->shmmax, &target_shminfo->shmmax); 4387 __put_user(host_shminfo->shmmin, &target_shminfo->shmmin); 4388 __put_user(host_shminfo->shmmni, &target_shminfo->shmmni); 4389 __put_user(host_shminfo->shmseg, &target_shminfo->shmseg); 4390 __put_user(host_shminfo->shmall, &target_shminfo->shmall); 4391 unlock_user_struct(target_shminfo, target_addr, 1); 4392 return 0; 4393 } 4394 4395 struct target_shm_info { 4396 int used_ids; 4397 abi_ulong shm_tot; 4398 abi_ulong shm_rss; 4399 abi_ulong shm_swp; 4400 abi_ulong swap_attempts; 4401 abi_ulong swap_successes; 4402 }; 4403 4404 static inline abi_long host_to_target_shm_info(abi_ulong target_addr, 4405 struct shm_info *host_shm_info) 4406 { 4407 struct target_shm_info *target_shm_info; 4408 if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0)) 4409 return -TARGET_EFAULT; 4410 __put_user(host_shm_info->used_ids, &target_shm_info->used_ids); 4411 __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot); 4412 __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss); 4413 __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp); 4414 __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts); 4415 __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes); 4416 unlock_user_struct(target_shm_info, target_addr, 1); 4417 return 0; 4418 } 4419 4420 static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf) 4421 { 4422 struct shmid_ds dsarg; 4423 struct shminfo shminfo; 4424 struct shm_info shm_info; 4425 abi_long ret = -TARGET_EINVAL; 4426 4427 cmd &= 0xff; 4428 4429 switch(cmd) { 4430 case IPC_STAT: 4431 case IPC_SET: 4432 case SHM_STAT: 4433 if (target_to_host_shmid_ds(&dsarg, buf)) 4434 return -TARGET_EFAULT; 4435 ret = get_errno(shmctl(shmid, cmd, &dsarg)); 4436 if (host_to_target_shmid_ds(buf, &dsarg)) 4437 return -TARGET_EFAULT; 4438 break; 4439 case IPC_INFO: 4440 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo)); 4441 if (host_to_target_shminfo(buf, &shminfo)) 4442 return -TARGET_EFAULT; 4443 break; 4444 case SHM_INFO: 4445 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info)); 4446 if (host_to_target_shm_info(buf, &shm_info)) 4447 return -TARGET_EFAULT; 4448 break; 4449 case IPC_RMID: 4450 case SHM_LOCK: 4451 case SHM_UNLOCK: 4452 ret = get_errno(shmctl(shmid, cmd, NULL)); 4453 break; 4454 } 4455 4456 return ret; 4457 } 4458 4459 #ifndef TARGET_FORCE_SHMLBA 4460 /* For most architectures, SHMLBA is the same as the page size; 4461 * some architectures have larger values, in which case they should 4462 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function. 4463 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA 4464 * and defining its own value for SHMLBA. 4465 * 4466 * The kernel also permits SHMLBA to be set by the architecture to a 4467 * value larger than the page size without setting __ARCH_FORCE_SHMLBA; 4468 * this means that addresses are rounded to the large size if 4469 * SHM_RND is set but addresses not aligned to that size are not rejected 4470 * as long as they are at least page-aligned. Since the only architecture 4471 * which uses this is ia64 this code doesn't provide for that oddity. 4472 */ 4473 static inline abi_ulong target_shmlba(CPUArchState *cpu_env) 4474 { 4475 return TARGET_PAGE_SIZE; 4476 } 4477 #endif 4478 4479 static inline abi_ulong do_shmat(CPUArchState *cpu_env, 4480 int shmid, abi_ulong shmaddr, int shmflg) 4481 { 4482 CPUState *cpu = env_cpu(cpu_env); 4483 abi_long raddr; 4484 void *host_raddr; 4485 struct shmid_ds shm_info; 4486 int i,ret; 4487 abi_ulong shmlba; 4488 4489 /* shmat pointers are always untagged */ 4490 4491 /* find out the length of the shared memory segment */ 4492 ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info)); 4493 if (is_error(ret)) { 4494 /* can't get length, bail out */ 4495 return ret; 4496 } 4497 4498 shmlba = target_shmlba(cpu_env); 4499 4500 if (shmaddr & (shmlba - 1)) { 4501 if (shmflg & SHM_RND) { 4502 shmaddr &= ~(shmlba - 1); 4503 } else { 4504 return -TARGET_EINVAL; 4505 } 4506 } 4507 if (!guest_range_valid_untagged(shmaddr, shm_info.shm_segsz)) { 4508 return -TARGET_EINVAL; 4509 } 4510 4511 mmap_lock(); 4512 4513 /* 4514 * We're mapping shared memory, so ensure we generate code for parallel 4515 * execution and flush old translations. This will work up to the level 4516 * supported by the host -- anything that requires EXCP_ATOMIC will not 4517 * be atomic with respect to an external process. 4518 */ 4519 if (!(cpu->tcg_cflags & CF_PARALLEL)) { 4520 cpu->tcg_cflags |= CF_PARALLEL; 4521 tb_flush(cpu); 4522 } 4523 4524 if (shmaddr) 4525 host_raddr = shmat(shmid, (void *)g2h_untagged(shmaddr), shmflg); 4526 else { 4527 abi_ulong mmap_start; 4528 4529 /* In order to use the host shmat, we need to honor host SHMLBA. */ 4530 mmap_start = mmap_find_vma(0, shm_info.shm_segsz, MAX(SHMLBA, shmlba)); 4531 4532 if (mmap_start == -1) { 4533 errno = ENOMEM; 4534 host_raddr = (void *)-1; 4535 } else 4536 host_raddr = shmat(shmid, g2h_untagged(mmap_start), 4537 shmflg | SHM_REMAP); 4538 } 4539 4540 if (host_raddr == (void *)-1) { 4541 mmap_unlock(); 4542 return get_errno((long)host_raddr); 4543 } 4544 raddr=h2g((unsigned long)host_raddr); 4545 4546 page_set_flags(raddr, raddr + shm_info.shm_segsz, 4547 PAGE_VALID | PAGE_RESET | PAGE_READ | 4548 (shmflg & SHM_RDONLY ? 0 : PAGE_WRITE)); 4549 4550 for (i = 0; i < N_SHM_REGIONS; i++) { 4551 if (!shm_regions[i].in_use) { 4552 shm_regions[i].in_use = true; 4553 shm_regions[i].start = raddr; 4554 shm_regions[i].size = shm_info.shm_segsz; 4555 break; 4556 } 4557 } 4558 4559 mmap_unlock(); 4560 return raddr; 4561 4562 } 4563 4564 static inline abi_long do_shmdt(abi_ulong shmaddr) 4565 { 4566 int i; 4567 abi_long rv; 4568 4569 /* shmdt pointers are always untagged */ 4570 4571 mmap_lock(); 4572 4573 for (i = 0; i < N_SHM_REGIONS; ++i) { 4574 if (shm_regions[i].in_use && shm_regions[i].start == shmaddr) { 4575 shm_regions[i].in_use = false; 4576 page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0); 4577 break; 4578 } 4579 } 4580 rv = get_errno(shmdt(g2h_untagged(shmaddr))); 4581 4582 mmap_unlock(); 4583 4584 return rv; 4585 } 4586 4587 #ifdef TARGET_NR_ipc 4588 /* ??? This only works with linear mappings. */ 4589 /* do_ipc() must return target values and target errnos. */ 4590 static abi_long do_ipc(CPUArchState *cpu_env, 4591 unsigned int call, abi_long first, 4592 abi_long second, abi_long third, 4593 abi_long ptr, abi_long fifth) 4594 { 4595 int version; 4596 abi_long ret = 0; 4597 4598 version = call >> 16; 4599 call &= 0xffff; 4600 4601 switch (call) { 4602 case IPCOP_semop: 4603 ret = do_semtimedop(first, ptr, second, 0, false); 4604 break; 4605 case IPCOP_semtimedop: 4606 /* 4607 * The s390 sys_ipc variant has only five parameters instead of six 4608 * (as for default variant) and the only difference is the handling of 4609 * SEMTIMEDOP where on s390 the third parameter is used as a pointer 4610 * to a struct timespec where the generic variant uses fifth parameter. 4611 */ 4612 #if defined(TARGET_S390X) 4613 ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64); 4614 #else 4615 ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64); 4616 #endif 4617 break; 4618 4619 case IPCOP_semget: 4620 ret = get_errno(semget(first, second, third)); 4621 break; 4622 4623 case IPCOP_semctl: { 4624 /* The semun argument to semctl is passed by value, so dereference the 4625 * ptr argument. */ 4626 abi_ulong atptr; 4627 get_user_ual(atptr, ptr); 4628 ret = do_semctl(first, second, third, atptr); 4629 break; 4630 } 4631 4632 case IPCOP_msgget: 4633 ret = get_errno(msgget(first, second)); 4634 break; 4635 4636 case IPCOP_msgsnd: 4637 ret = do_msgsnd(first, ptr, second, third); 4638 break; 4639 4640 case IPCOP_msgctl: 4641 ret = do_msgctl(first, second, ptr); 4642 break; 4643 4644 case IPCOP_msgrcv: 4645 switch (version) { 4646 case 0: 4647 { 4648 struct target_ipc_kludge { 4649 abi_long msgp; 4650 abi_long msgtyp; 4651 } *tmp; 4652 4653 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) { 4654 ret = -TARGET_EFAULT; 4655 break; 4656 } 4657 4658 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third); 4659 4660 unlock_user_struct(tmp, ptr, 0); 4661 break; 4662 } 4663 default: 4664 ret = do_msgrcv(first, ptr, second, fifth, third); 4665 } 4666 break; 4667 4668 case IPCOP_shmat: 4669 switch (version) { 4670 default: 4671 { 4672 abi_ulong raddr; 4673 raddr = do_shmat(cpu_env, first, ptr, second); 4674 if (is_error(raddr)) 4675 return get_errno(raddr); 4676 if (put_user_ual(raddr, third)) 4677 return -TARGET_EFAULT; 4678 break; 4679 } 4680 case 1: 4681 ret = -TARGET_EINVAL; 4682 break; 4683 } 4684 break; 4685 case IPCOP_shmdt: 4686 ret = do_shmdt(ptr); 4687 break; 4688 4689 case IPCOP_shmget: 4690 /* IPC_* flag values are the same on all linux platforms */ 4691 ret = get_errno(shmget(first, second, third)); 4692 break; 4693 4694 /* IPC_* and SHM_* command values are the same on all linux platforms */ 4695 case IPCOP_shmctl: 4696 ret = do_shmctl(first, second, ptr); 4697 break; 4698 default: 4699 qemu_log_mask(LOG_UNIMP, "Unsupported ipc call: %d (version %d)\n", 4700 call, version); 4701 ret = -TARGET_ENOSYS; 4702 break; 4703 } 4704 return ret; 4705 } 4706 #endif 4707 4708 /* kernel structure types definitions */ 4709 4710 #define STRUCT(name, ...) STRUCT_ ## name, 4711 #define STRUCT_SPECIAL(name) STRUCT_ ## name, 4712 enum { 4713 #include "syscall_types.h" 4714 STRUCT_MAX 4715 }; 4716 #undef STRUCT 4717 #undef STRUCT_SPECIAL 4718 4719 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL }; 4720 #define STRUCT_SPECIAL(name) 4721 #include "syscall_types.h" 4722 #undef STRUCT 4723 #undef STRUCT_SPECIAL 4724 4725 #define MAX_STRUCT_SIZE 4096 4726 4727 #ifdef CONFIG_FIEMAP 4728 /* So fiemap access checks don't overflow on 32 bit systems. 4729 * This is very slightly smaller than the limit imposed by 4730 * the underlying kernel. 4731 */ 4732 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \ 4733 / sizeof(struct fiemap_extent)) 4734 4735 static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp, 4736 int fd, int cmd, abi_long arg) 4737 { 4738 /* The parameter for this ioctl is a struct fiemap followed 4739 * by an array of struct fiemap_extent whose size is set 4740 * in fiemap->fm_extent_count. The array is filled in by the 4741 * ioctl. 4742 */ 4743 int target_size_in, target_size_out; 4744 struct fiemap *fm; 4745 const argtype *arg_type = ie->arg_type; 4746 const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) }; 4747 void *argptr, *p; 4748 abi_long ret; 4749 int i, extent_size = thunk_type_size(extent_arg_type, 0); 4750 uint32_t outbufsz; 4751 int free_fm = 0; 4752 4753 assert(arg_type[0] == TYPE_PTR); 4754 assert(ie->access == IOC_RW); 4755 arg_type++; 4756 target_size_in = thunk_type_size(arg_type, 0); 4757 argptr = lock_user(VERIFY_READ, arg, target_size_in, 1); 4758 if (!argptr) { 4759 return -TARGET_EFAULT; 4760 } 4761 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 4762 unlock_user(argptr, arg, 0); 4763 fm = (struct fiemap *)buf_temp; 4764 if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) { 4765 return -TARGET_EINVAL; 4766 } 4767 4768 outbufsz = sizeof (*fm) + 4769 (sizeof(struct fiemap_extent) * fm->fm_extent_count); 4770 4771 if (outbufsz > MAX_STRUCT_SIZE) { 4772 /* We can't fit all the extents into the fixed size buffer. 4773 * Allocate one that is large enough and use it instead. 4774 */ 4775 fm = g_try_malloc(outbufsz); 4776 if (!fm) { 4777 return -TARGET_ENOMEM; 4778 } 4779 memcpy(fm, buf_temp, sizeof(struct fiemap)); 4780 free_fm = 1; 4781 } 4782 ret = get_errno(safe_ioctl(fd, ie->host_cmd, fm)); 4783 if (!is_error(ret)) { 4784 target_size_out = target_size_in; 4785 /* An extent_count of 0 means we were only counting the extents 4786 * so there are no structs to copy 4787 */ 4788 if (fm->fm_extent_count != 0) { 4789 target_size_out += fm->fm_mapped_extents * extent_size; 4790 } 4791 argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0); 4792 if (!argptr) { 4793 ret = -TARGET_EFAULT; 4794 } else { 4795 /* Convert the struct fiemap */ 4796 thunk_convert(argptr, fm, arg_type, THUNK_TARGET); 4797 if (fm->fm_extent_count != 0) { 4798 p = argptr + target_size_in; 4799 /* ...and then all the struct fiemap_extents */ 4800 for (i = 0; i < fm->fm_mapped_extents; i++) { 4801 thunk_convert(p, &fm->fm_extents[i], extent_arg_type, 4802 THUNK_TARGET); 4803 p += extent_size; 4804 } 4805 } 4806 unlock_user(argptr, arg, target_size_out); 4807 } 4808 } 4809 if (free_fm) { 4810 g_free(fm); 4811 } 4812 return ret; 4813 } 4814 #endif 4815 4816 static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp, 4817 int fd, int cmd, abi_long arg) 4818 { 4819 const argtype *arg_type = ie->arg_type; 4820 int target_size; 4821 void *argptr; 4822 int ret; 4823 struct ifconf *host_ifconf; 4824 uint32_t outbufsz; 4825 const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) }; 4826 const argtype ifreq_max_type[] = { MK_STRUCT(STRUCT_ifmap_ifreq) }; 4827 int target_ifreq_size; 4828 int nb_ifreq; 4829 int free_buf = 0; 4830 int i; 4831 int target_ifc_len; 4832 abi_long target_ifc_buf; 4833 int host_ifc_len; 4834 char *host_ifc_buf; 4835 4836 assert(arg_type[0] == TYPE_PTR); 4837 assert(ie->access == IOC_RW); 4838 4839 arg_type++; 4840 target_size = thunk_type_size(arg_type, 0); 4841 4842 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 4843 if (!argptr) 4844 return -TARGET_EFAULT; 4845 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 4846 unlock_user(argptr, arg, 0); 4847 4848 host_ifconf = (struct ifconf *)(unsigned long)buf_temp; 4849 target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf; 4850 target_ifreq_size = thunk_type_size(ifreq_max_type, 0); 4851 4852 if (target_ifc_buf != 0) { 4853 target_ifc_len = host_ifconf->ifc_len; 4854 nb_ifreq = target_ifc_len / target_ifreq_size; 4855 host_ifc_len = nb_ifreq * sizeof(struct ifreq); 4856 4857 outbufsz = sizeof(*host_ifconf) + host_ifc_len; 4858 if (outbufsz > MAX_STRUCT_SIZE) { 4859 /* 4860 * We can't fit all the extents into the fixed size buffer. 4861 * Allocate one that is large enough and use it instead. 4862 */ 4863 host_ifconf = malloc(outbufsz); 4864 if (!host_ifconf) { 4865 return -TARGET_ENOMEM; 4866 } 4867 memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf)); 4868 free_buf = 1; 4869 } 4870 host_ifc_buf = (char *)host_ifconf + sizeof(*host_ifconf); 4871 4872 host_ifconf->ifc_len = host_ifc_len; 4873 } else { 4874 host_ifc_buf = NULL; 4875 } 4876 host_ifconf->ifc_buf = host_ifc_buf; 4877 4878 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_ifconf)); 4879 if (!is_error(ret)) { 4880 /* convert host ifc_len to target ifc_len */ 4881 4882 nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq); 4883 target_ifc_len = nb_ifreq * target_ifreq_size; 4884 host_ifconf->ifc_len = target_ifc_len; 4885 4886 /* restore target ifc_buf */ 4887 4888 host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf; 4889 4890 /* copy struct ifconf to target user */ 4891 4892 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 4893 if (!argptr) 4894 return -TARGET_EFAULT; 4895 thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET); 4896 unlock_user(argptr, arg, target_size); 4897 4898 if (target_ifc_buf != 0) { 4899 /* copy ifreq[] to target user */ 4900 argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0); 4901 for (i = 0; i < nb_ifreq ; i++) { 4902 thunk_convert(argptr + i * target_ifreq_size, 4903 host_ifc_buf + i * sizeof(struct ifreq), 4904 ifreq_arg_type, THUNK_TARGET); 4905 } 4906 unlock_user(argptr, target_ifc_buf, target_ifc_len); 4907 } 4908 } 4909 4910 if (free_buf) { 4911 free(host_ifconf); 4912 } 4913 4914 return ret; 4915 } 4916 4917 #if defined(CONFIG_USBFS) 4918 #if HOST_LONG_BITS > 64 4919 #error USBDEVFS thunks do not support >64 bit hosts yet. 4920 #endif 4921 struct live_urb { 4922 uint64_t target_urb_adr; 4923 uint64_t target_buf_adr; 4924 char *target_buf_ptr; 4925 struct usbdevfs_urb host_urb; 4926 }; 4927 4928 static GHashTable *usbdevfs_urb_hashtable(void) 4929 { 4930 static GHashTable *urb_hashtable; 4931 4932 if (!urb_hashtable) { 4933 urb_hashtable = g_hash_table_new(g_int64_hash, g_int64_equal); 4934 } 4935 return urb_hashtable; 4936 } 4937 4938 static void urb_hashtable_insert(struct live_urb *urb) 4939 { 4940 GHashTable *urb_hashtable = usbdevfs_urb_hashtable(); 4941 g_hash_table_insert(urb_hashtable, urb, urb); 4942 } 4943 4944 static struct live_urb *urb_hashtable_lookup(uint64_t target_urb_adr) 4945 { 4946 GHashTable *urb_hashtable = usbdevfs_urb_hashtable(); 4947 return g_hash_table_lookup(urb_hashtable, &target_urb_adr); 4948 } 4949 4950 static void urb_hashtable_remove(struct live_urb *urb) 4951 { 4952 GHashTable *urb_hashtable = usbdevfs_urb_hashtable(); 4953 g_hash_table_remove(urb_hashtable, urb); 4954 } 4955 4956 static abi_long 4957 do_ioctl_usbdevfs_reapurb(const IOCTLEntry *ie, uint8_t *buf_temp, 4958 int fd, int cmd, abi_long arg) 4959 { 4960 const argtype usbfsurb_arg_type[] = { MK_STRUCT(STRUCT_usbdevfs_urb) }; 4961 const argtype ptrvoid_arg_type[] = { TYPE_PTRVOID, 0, 0 }; 4962 struct live_urb *lurb; 4963 void *argptr; 4964 uint64_t hurb; 4965 int target_size; 4966 uintptr_t target_urb_adr; 4967 abi_long ret; 4968 4969 target_size = thunk_type_size(usbfsurb_arg_type, THUNK_TARGET); 4970 4971 memset(buf_temp, 0, sizeof(uint64_t)); 4972 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 4973 if (is_error(ret)) { 4974 return ret; 4975 } 4976 4977 memcpy(&hurb, buf_temp, sizeof(uint64_t)); 4978 lurb = (void *)((uintptr_t)hurb - offsetof(struct live_urb, host_urb)); 4979 if (!lurb->target_urb_adr) { 4980 return -TARGET_EFAULT; 4981 } 4982 urb_hashtable_remove(lurb); 4983 unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr, 4984 lurb->host_urb.buffer_length); 4985 lurb->target_buf_ptr = NULL; 4986 4987 /* restore the guest buffer pointer */ 4988 lurb->host_urb.buffer = (void *)(uintptr_t)lurb->target_buf_adr; 4989 4990 /* update the guest urb struct */ 4991 argptr = lock_user(VERIFY_WRITE, lurb->target_urb_adr, target_size, 0); 4992 if (!argptr) { 4993 g_free(lurb); 4994 return -TARGET_EFAULT; 4995 } 4996 thunk_convert(argptr, &lurb->host_urb, usbfsurb_arg_type, THUNK_TARGET); 4997 unlock_user(argptr, lurb->target_urb_adr, target_size); 4998 4999 target_size = thunk_type_size(ptrvoid_arg_type, THUNK_TARGET); 5000 /* write back the urb handle */ 5001 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 5002 if (!argptr) { 5003 g_free(lurb); 5004 return -TARGET_EFAULT; 5005 } 5006 5007 /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */ 5008 target_urb_adr = lurb->target_urb_adr; 5009 thunk_convert(argptr, &target_urb_adr, ptrvoid_arg_type, THUNK_TARGET); 5010 unlock_user(argptr, arg, target_size); 5011 5012 g_free(lurb); 5013 return ret; 5014 } 5015 5016 static abi_long 5017 do_ioctl_usbdevfs_discardurb(const IOCTLEntry *ie, 5018 uint8_t *buf_temp __attribute__((unused)), 5019 int fd, int cmd, abi_long arg) 5020 { 5021 struct live_urb *lurb; 5022 5023 /* map target address back to host URB with metadata. */ 5024 lurb = urb_hashtable_lookup(arg); 5025 if (!lurb) { 5026 return -TARGET_EFAULT; 5027 } 5028 return get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb)); 5029 } 5030 5031 static abi_long 5032 do_ioctl_usbdevfs_submiturb(const IOCTLEntry *ie, uint8_t *buf_temp, 5033 int fd, int cmd, abi_long arg) 5034 { 5035 const argtype *arg_type = ie->arg_type; 5036 int target_size; 5037 abi_long ret; 5038 void *argptr; 5039 int rw_dir; 5040 struct live_urb *lurb; 5041 5042 /* 5043 * each submitted URB needs to map to a unique ID for the 5044 * kernel, and that unique ID needs to be a pointer to 5045 * host memory. hence, we need to malloc for each URB. 5046 * isochronous transfers have a variable length struct. 5047 */ 5048 arg_type++; 5049 target_size = thunk_type_size(arg_type, THUNK_TARGET); 5050 5051 /* construct host copy of urb and metadata */ 5052 lurb = g_try_malloc0(sizeof(struct live_urb)); 5053 if (!lurb) { 5054 return -TARGET_ENOMEM; 5055 } 5056 5057 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5058 if (!argptr) { 5059 g_free(lurb); 5060 return -TARGET_EFAULT; 5061 } 5062 thunk_convert(&lurb->host_urb, argptr, arg_type, THUNK_HOST); 5063 unlock_user(argptr, arg, 0); 5064 5065 lurb->target_urb_adr = arg; 5066 lurb->target_buf_adr = (uintptr_t)lurb->host_urb.buffer; 5067 5068 /* buffer space used depends on endpoint type so lock the entire buffer */ 5069 /* control type urbs should check the buffer contents for true direction */ 5070 rw_dir = lurb->host_urb.endpoint & USB_DIR_IN ? VERIFY_WRITE : VERIFY_READ; 5071 lurb->target_buf_ptr = lock_user(rw_dir, lurb->target_buf_adr, 5072 lurb->host_urb.buffer_length, 1); 5073 if (lurb->target_buf_ptr == NULL) { 5074 g_free(lurb); 5075 return -TARGET_EFAULT; 5076 } 5077 5078 /* update buffer pointer in host copy */ 5079 lurb->host_urb.buffer = lurb->target_buf_ptr; 5080 5081 ret = get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb)); 5082 if (is_error(ret)) { 5083 unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr, 0); 5084 g_free(lurb); 5085 } else { 5086 urb_hashtable_insert(lurb); 5087 } 5088 5089 return ret; 5090 } 5091 #endif /* CONFIG_USBFS */ 5092 5093 static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd, 5094 int cmd, abi_long arg) 5095 { 5096 void *argptr; 5097 struct dm_ioctl *host_dm; 5098 abi_long guest_data; 5099 uint32_t guest_data_size; 5100 int target_size; 5101 const argtype *arg_type = ie->arg_type; 5102 abi_long ret; 5103 void *big_buf = NULL; 5104 char *host_data; 5105 5106 arg_type++; 5107 target_size = thunk_type_size(arg_type, 0); 5108 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5109 if (!argptr) { 5110 ret = -TARGET_EFAULT; 5111 goto out; 5112 } 5113 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 5114 unlock_user(argptr, arg, 0); 5115 5116 /* buf_temp is too small, so fetch things into a bigger buffer */ 5117 big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2); 5118 memcpy(big_buf, buf_temp, target_size); 5119 buf_temp = big_buf; 5120 host_dm = big_buf; 5121 5122 guest_data = arg + host_dm->data_start; 5123 if ((guest_data - arg) < 0) { 5124 ret = -TARGET_EINVAL; 5125 goto out; 5126 } 5127 guest_data_size = host_dm->data_size - host_dm->data_start; 5128 host_data = (char*)host_dm + host_dm->data_start; 5129 5130 argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1); 5131 if (!argptr) { 5132 ret = -TARGET_EFAULT; 5133 goto out; 5134 } 5135 5136 switch (ie->host_cmd) { 5137 case DM_REMOVE_ALL: 5138 case DM_LIST_DEVICES: 5139 case DM_DEV_CREATE: 5140 case DM_DEV_REMOVE: 5141 case DM_DEV_SUSPEND: 5142 case DM_DEV_STATUS: 5143 case DM_DEV_WAIT: 5144 case DM_TABLE_STATUS: 5145 case DM_TABLE_CLEAR: 5146 case DM_TABLE_DEPS: 5147 case DM_LIST_VERSIONS: 5148 /* no input data */ 5149 break; 5150 case DM_DEV_RENAME: 5151 case DM_DEV_SET_GEOMETRY: 5152 /* data contains only strings */ 5153 memcpy(host_data, argptr, guest_data_size); 5154 break; 5155 case DM_TARGET_MSG: 5156 memcpy(host_data, argptr, guest_data_size); 5157 *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr); 5158 break; 5159 case DM_TABLE_LOAD: 5160 { 5161 void *gspec = argptr; 5162 void *cur_data = host_data; 5163 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) }; 5164 int spec_size = thunk_type_size(arg_type, 0); 5165 int i; 5166 5167 for (i = 0; i < host_dm->target_count; i++) { 5168 struct dm_target_spec *spec = cur_data; 5169 uint32_t next; 5170 int slen; 5171 5172 thunk_convert(spec, gspec, arg_type, THUNK_HOST); 5173 slen = strlen((char*)gspec + spec_size) + 1; 5174 next = spec->next; 5175 spec->next = sizeof(*spec) + slen; 5176 strcpy((char*)&spec[1], gspec + spec_size); 5177 gspec += next; 5178 cur_data += spec->next; 5179 } 5180 break; 5181 } 5182 default: 5183 ret = -TARGET_EINVAL; 5184 unlock_user(argptr, guest_data, 0); 5185 goto out; 5186 } 5187 unlock_user(argptr, guest_data, 0); 5188 5189 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 5190 if (!is_error(ret)) { 5191 guest_data = arg + host_dm->data_start; 5192 guest_data_size = host_dm->data_size - host_dm->data_start; 5193 argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0); 5194 switch (ie->host_cmd) { 5195 case DM_REMOVE_ALL: 5196 case DM_DEV_CREATE: 5197 case DM_DEV_REMOVE: 5198 case DM_DEV_RENAME: 5199 case DM_DEV_SUSPEND: 5200 case DM_DEV_STATUS: 5201 case DM_TABLE_LOAD: 5202 case DM_TABLE_CLEAR: 5203 case DM_TARGET_MSG: 5204 case DM_DEV_SET_GEOMETRY: 5205 /* no return data */ 5206 break; 5207 case DM_LIST_DEVICES: 5208 { 5209 struct dm_name_list *nl = (void*)host_dm + host_dm->data_start; 5210 uint32_t remaining_data = guest_data_size; 5211 void *cur_data = argptr; 5212 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) }; 5213 int nl_size = 12; /* can't use thunk_size due to alignment */ 5214 5215 while (1) { 5216 uint32_t next = nl->next; 5217 if (next) { 5218 nl->next = nl_size + (strlen(nl->name) + 1); 5219 } 5220 if (remaining_data < nl->next) { 5221 host_dm->flags |= DM_BUFFER_FULL_FLAG; 5222 break; 5223 } 5224 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET); 5225 strcpy(cur_data + nl_size, nl->name); 5226 cur_data += nl->next; 5227 remaining_data -= nl->next; 5228 if (!next) { 5229 break; 5230 } 5231 nl = (void*)nl + next; 5232 } 5233 break; 5234 } 5235 case DM_DEV_WAIT: 5236 case DM_TABLE_STATUS: 5237 { 5238 struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start; 5239 void *cur_data = argptr; 5240 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) }; 5241 int spec_size = thunk_type_size(arg_type, 0); 5242 int i; 5243 5244 for (i = 0; i < host_dm->target_count; i++) { 5245 uint32_t next = spec->next; 5246 int slen = strlen((char*)&spec[1]) + 1; 5247 spec->next = (cur_data - argptr) + spec_size + slen; 5248 if (guest_data_size < spec->next) { 5249 host_dm->flags |= DM_BUFFER_FULL_FLAG; 5250 break; 5251 } 5252 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET); 5253 strcpy(cur_data + spec_size, (char*)&spec[1]); 5254 cur_data = argptr + spec->next; 5255 spec = (void*)host_dm + host_dm->data_start + next; 5256 } 5257 break; 5258 } 5259 case DM_TABLE_DEPS: 5260 { 5261 void *hdata = (void*)host_dm + host_dm->data_start; 5262 int count = *(uint32_t*)hdata; 5263 uint64_t *hdev = hdata + 8; 5264 uint64_t *gdev = argptr + 8; 5265 int i; 5266 5267 *(uint32_t*)argptr = tswap32(count); 5268 for (i = 0; i < count; i++) { 5269 *gdev = tswap64(*hdev); 5270 gdev++; 5271 hdev++; 5272 } 5273 break; 5274 } 5275 case DM_LIST_VERSIONS: 5276 { 5277 struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start; 5278 uint32_t remaining_data = guest_data_size; 5279 void *cur_data = argptr; 5280 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) }; 5281 int vers_size = thunk_type_size(arg_type, 0); 5282 5283 while (1) { 5284 uint32_t next = vers->next; 5285 if (next) { 5286 vers->next = vers_size + (strlen(vers->name) + 1); 5287 } 5288 if (remaining_data < vers->next) { 5289 host_dm->flags |= DM_BUFFER_FULL_FLAG; 5290 break; 5291 } 5292 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET); 5293 strcpy(cur_data + vers_size, vers->name); 5294 cur_data += vers->next; 5295 remaining_data -= vers->next; 5296 if (!next) { 5297 break; 5298 } 5299 vers = (void*)vers + next; 5300 } 5301 break; 5302 } 5303 default: 5304 unlock_user(argptr, guest_data, 0); 5305 ret = -TARGET_EINVAL; 5306 goto out; 5307 } 5308 unlock_user(argptr, guest_data, guest_data_size); 5309 5310 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 5311 if (!argptr) { 5312 ret = -TARGET_EFAULT; 5313 goto out; 5314 } 5315 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET); 5316 unlock_user(argptr, arg, target_size); 5317 } 5318 out: 5319 g_free(big_buf); 5320 return ret; 5321 } 5322 5323 static abi_long do_ioctl_blkpg(const IOCTLEntry *ie, uint8_t *buf_temp, int fd, 5324 int cmd, abi_long arg) 5325 { 5326 void *argptr; 5327 int target_size; 5328 const argtype *arg_type = ie->arg_type; 5329 const argtype part_arg_type[] = { MK_STRUCT(STRUCT_blkpg_partition) }; 5330 abi_long ret; 5331 5332 struct blkpg_ioctl_arg *host_blkpg = (void*)buf_temp; 5333 struct blkpg_partition host_part; 5334 5335 /* Read and convert blkpg */ 5336 arg_type++; 5337 target_size = thunk_type_size(arg_type, 0); 5338 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5339 if (!argptr) { 5340 ret = -TARGET_EFAULT; 5341 goto out; 5342 } 5343 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 5344 unlock_user(argptr, arg, 0); 5345 5346 switch (host_blkpg->op) { 5347 case BLKPG_ADD_PARTITION: 5348 case BLKPG_DEL_PARTITION: 5349 /* payload is struct blkpg_partition */ 5350 break; 5351 default: 5352 /* Unknown opcode */ 5353 ret = -TARGET_EINVAL; 5354 goto out; 5355 } 5356 5357 /* Read and convert blkpg->data */ 5358 arg = (abi_long)(uintptr_t)host_blkpg->data; 5359 target_size = thunk_type_size(part_arg_type, 0); 5360 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5361 if (!argptr) { 5362 ret = -TARGET_EFAULT; 5363 goto out; 5364 } 5365 thunk_convert(&host_part, argptr, part_arg_type, THUNK_HOST); 5366 unlock_user(argptr, arg, 0); 5367 5368 /* Swizzle the data pointer to our local copy and call! */ 5369 host_blkpg->data = &host_part; 5370 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_blkpg)); 5371 5372 out: 5373 return ret; 5374 } 5375 5376 static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp, 5377 int fd, int cmd, abi_long arg) 5378 { 5379 const argtype *arg_type = ie->arg_type; 5380 const StructEntry *se; 5381 const argtype *field_types; 5382 const int *dst_offsets, *src_offsets; 5383 int target_size; 5384 void *argptr; 5385 abi_ulong *target_rt_dev_ptr = NULL; 5386 unsigned long *host_rt_dev_ptr = NULL; 5387 abi_long ret; 5388 int i; 5389 5390 assert(ie->access == IOC_W); 5391 assert(*arg_type == TYPE_PTR); 5392 arg_type++; 5393 assert(*arg_type == TYPE_STRUCT); 5394 target_size = thunk_type_size(arg_type, 0); 5395 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5396 if (!argptr) { 5397 return -TARGET_EFAULT; 5398 } 5399 arg_type++; 5400 assert(*arg_type == (int)STRUCT_rtentry); 5401 se = struct_entries + *arg_type++; 5402 assert(se->convert[0] == NULL); 5403 /* convert struct here to be able to catch rt_dev string */ 5404 field_types = se->field_types; 5405 dst_offsets = se->field_offsets[THUNK_HOST]; 5406 src_offsets = se->field_offsets[THUNK_TARGET]; 5407 for (i = 0; i < se->nb_fields; i++) { 5408 if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) { 5409 assert(*field_types == TYPE_PTRVOID); 5410 target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]); 5411 host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]); 5412 if (*target_rt_dev_ptr != 0) { 5413 *host_rt_dev_ptr = (unsigned long)lock_user_string( 5414 tswapal(*target_rt_dev_ptr)); 5415 if (!*host_rt_dev_ptr) { 5416 unlock_user(argptr, arg, 0); 5417 return -TARGET_EFAULT; 5418 } 5419 } else { 5420 *host_rt_dev_ptr = 0; 5421 } 5422 field_types++; 5423 continue; 5424 } 5425 field_types = thunk_convert(buf_temp + dst_offsets[i], 5426 argptr + src_offsets[i], 5427 field_types, THUNK_HOST); 5428 } 5429 unlock_user(argptr, arg, 0); 5430 5431 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 5432 5433 assert(host_rt_dev_ptr != NULL); 5434 assert(target_rt_dev_ptr != NULL); 5435 if (*host_rt_dev_ptr != 0) { 5436 unlock_user((void *)*host_rt_dev_ptr, 5437 *target_rt_dev_ptr, 0); 5438 } 5439 return ret; 5440 } 5441 5442 static abi_long do_ioctl_kdsigaccept(const IOCTLEntry *ie, uint8_t *buf_temp, 5443 int fd, int cmd, abi_long arg) 5444 { 5445 int sig = target_to_host_signal(arg); 5446 return get_errno(safe_ioctl(fd, ie->host_cmd, sig)); 5447 } 5448 5449 static abi_long do_ioctl_SIOCGSTAMP(const IOCTLEntry *ie, uint8_t *buf_temp, 5450 int fd, int cmd, abi_long arg) 5451 { 5452 struct timeval tv; 5453 abi_long ret; 5454 5455 ret = get_errno(safe_ioctl(fd, SIOCGSTAMP, &tv)); 5456 if (is_error(ret)) { 5457 return ret; 5458 } 5459 5460 if (cmd == (int)TARGET_SIOCGSTAMP_OLD) { 5461 if (copy_to_user_timeval(arg, &tv)) { 5462 return -TARGET_EFAULT; 5463 } 5464 } else { 5465 if (copy_to_user_timeval64(arg, &tv)) { 5466 return -TARGET_EFAULT; 5467 } 5468 } 5469 5470 return ret; 5471 } 5472 5473 static abi_long do_ioctl_SIOCGSTAMPNS(const IOCTLEntry *ie, uint8_t *buf_temp, 5474 int fd, int cmd, abi_long arg) 5475 { 5476 struct timespec ts; 5477 abi_long ret; 5478 5479 ret = get_errno(safe_ioctl(fd, SIOCGSTAMPNS, &ts)); 5480 if (is_error(ret)) { 5481 return ret; 5482 } 5483 5484 if (cmd == (int)TARGET_SIOCGSTAMPNS_OLD) { 5485 if (host_to_target_timespec(arg, &ts)) { 5486 return -TARGET_EFAULT; 5487 } 5488 } else{ 5489 if (host_to_target_timespec64(arg, &ts)) { 5490 return -TARGET_EFAULT; 5491 } 5492 } 5493 5494 return ret; 5495 } 5496 5497 #ifdef TIOCGPTPEER 5498 static abi_long do_ioctl_tiocgptpeer(const IOCTLEntry *ie, uint8_t *buf_temp, 5499 int fd, int cmd, abi_long arg) 5500 { 5501 int flags = target_to_host_bitmask(arg, fcntl_flags_tbl); 5502 return get_errno(safe_ioctl(fd, ie->host_cmd, flags)); 5503 } 5504 #endif 5505 5506 #ifdef HAVE_DRM_H 5507 5508 static void unlock_drm_version(struct drm_version *host_ver, 5509 struct target_drm_version *target_ver, 5510 bool copy) 5511 { 5512 unlock_user(host_ver->name, target_ver->name, 5513 copy ? host_ver->name_len : 0); 5514 unlock_user(host_ver->date, target_ver->date, 5515 copy ? host_ver->date_len : 0); 5516 unlock_user(host_ver->desc, target_ver->desc, 5517 copy ? host_ver->desc_len : 0); 5518 } 5519 5520 static inline abi_long target_to_host_drmversion(struct drm_version *host_ver, 5521 struct target_drm_version *target_ver) 5522 { 5523 memset(host_ver, 0, sizeof(*host_ver)); 5524 5525 __get_user(host_ver->name_len, &target_ver->name_len); 5526 if (host_ver->name_len) { 5527 host_ver->name = lock_user(VERIFY_WRITE, target_ver->name, 5528 target_ver->name_len, 0); 5529 if (!host_ver->name) { 5530 return -EFAULT; 5531 } 5532 } 5533 5534 __get_user(host_ver->date_len, &target_ver->date_len); 5535 if (host_ver->date_len) { 5536 host_ver->date = lock_user(VERIFY_WRITE, target_ver->date, 5537 target_ver->date_len, 0); 5538 if (!host_ver->date) { 5539 goto err; 5540 } 5541 } 5542 5543 __get_user(host_ver->desc_len, &target_ver->desc_len); 5544 if (host_ver->desc_len) { 5545 host_ver->desc = lock_user(VERIFY_WRITE, target_ver->desc, 5546 target_ver->desc_len, 0); 5547 if (!host_ver->desc) { 5548 goto err; 5549 } 5550 } 5551 5552 return 0; 5553 err: 5554 unlock_drm_version(host_ver, target_ver, false); 5555 return -EFAULT; 5556 } 5557 5558 static inline void host_to_target_drmversion( 5559 struct target_drm_version *target_ver, 5560 struct drm_version *host_ver) 5561 { 5562 __put_user(host_ver->version_major, &target_ver->version_major); 5563 __put_user(host_ver->version_minor, &target_ver->version_minor); 5564 __put_user(host_ver->version_patchlevel, &target_ver->version_patchlevel); 5565 __put_user(host_ver->name_len, &target_ver->name_len); 5566 __put_user(host_ver->date_len, &target_ver->date_len); 5567 __put_user(host_ver->desc_len, &target_ver->desc_len); 5568 unlock_drm_version(host_ver, target_ver, true); 5569 } 5570 5571 static abi_long do_ioctl_drm(const IOCTLEntry *ie, uint8_t *buf_temp, 5572 int fd, int cmd, abi_long arg) 5573 { 5574 struct drm_version *ver; 5575 struct target_drm_version *target_ver; 5576 abi_long ret; 5577 5578 switch (ie->host_cmd) { 5579 case DRM_IOCTL_VERSION: 5580 if (!lock_user_struct(VERIFY_WRITE, target_ver, arg, 0)) { 5581 return -TARGET_EFAULT; 5582 } 5583 ver = (struct drm_version *)buf_temp; 5584 ret = target_to_host_drmversion(ver, target_ver); 5585 if (!is_error(ret)) { 5586 ret = get_errno(safe_ioctl(fd, ie->host_cmd, ver)); 5587 if (is_error(ret)) { 5588 unlock_drm_version(ver, target_ver, false); 5589 } else { 5590 host_to_target_drmversion(target_ver, ver); 5591 } 5592 } 5593 unlock_user_struct(target_ver, arg, 0); 5594 return ret; 5595 } 5596 return -TARGET_ENOSYS; 5597 } 5598 5599 static abi_long do_ioctl_drm_i915_getparam(const IOCTLEntry *ie, 5600 struct drm_i915_getparam *gparam, 5601 int fd, abi_long arg) 5602 { 5603 abi_long ret; 5604 int value; 5605 struct target_drm_i915_getparam *target_gparam; 5606 5607 if (!lock_user_struct(VERIFY_READ, target_gparam, arg, 0)) { 5608 return -TARGET_EFAULT; 5609 } 5610 5611 __get_user(gparam->param, &target_gparam->param); 5612 gparam->value = &value; 5613 ret = get_errno(safe_ioctl(fd, ie->host_cmd, gparam)); 5614 put_user_s32(value, target_gparam->value); 5615 5616 unlock_user_struct(target_gparam, arg, 0); 5617 return ret; 5618 } 5619 5620 static abi_long do_ioctl_drm_i915(const IOCTLEntry *ie, uint8_t *buf_temp, 5621 int fd, int cmd, abi_long arg) 5622 { 5623 switch (ie->host_cmd) { 5624 case DRM_IOCTL_I915_GETPARAM: 5625 return do_ioctl_drm_i915_getparam(ie, 5626 (struct drm_i915_getparam *)buf_temp, 5627 fd, arg); 5628 default: 5629 return -TARGET_ENOSYS; 5630 } 5631 } 5632 5633 #endif 5634 5635 static abi_long do_ioctl_TUNSETTXFILTER(const IOCTLEntry *ie, uint8_t *buf_temp, 5636 int fd, int cmd, abi_long arg) 5637 { 5638 struct tun_filter *filter = (struct tun_filter *)buf_temp; 5639 struct tun_filter *target_filter; 5640 char *target_addr; 5641 5642 assert(ie->access == IOC_W); 5643 5644 target_filter = lock_user(VERIFY_READ, arg, sizeof(*target_filter), 1); 5645 if (!target_filter) { 5646 return -TARGET_EFAULT; 5647 } 5648 filter->flags = tswap16(target_filter->flags); 5649 filter->count = tswap16(target_filter->count); 5650 unlock_user(target_filter, arg, 0); 5651 5652 if (filter->count) { 5653 if (offsetof(struct tun_filter, addr) + filter->count * ETH_ALEN > 5654 MAX_STRUCT_SIZE) { 5655 return -TARGET_EFAULT; 5656 } 5657 5658 target_addr = lock_user(VERIFY_READ, 5659 arg + offsetof(struct tun_filter, addr), 5660 filter->count * ETH_ALEN, 1); 5661 if (!target_addr) { 5662 return -TARGET_EFAULT; 5663 } 5664 memcpy(filter->addr, target_addr, filter->count * ETH_ALEN); 5665 unlock_user(target_addr, arg + offsetof(struct tun_filter, addr), 0); 5666 } 5667 5668 return get_errno(safe_ioctl(fd, ie->host_cmd, filter)); 5669 } 5670 5671 IOCTLEntry ioctl_entries[] = { 5672 #define IOCTL(cmd, access, ...) \ 5673 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } }, 5674 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \ 5675 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } }, 5676 #define IOCTL_IGNORE(cmd) \ 5677 { TARGET_ ## cmd, 0, #cmd }, 5678 #include "ioctls.h" 5679 { 0, 0, }, 5680 }; 5681 5682 /* ??? Implement proper locking for ioctls. */ 5683 /* do_ioctl() Must return target values and target errnos. */ 5684 static abi_long do_ioctl(int fd, int cmd, abi_long arg) 5685 { 5686 const IOCTLEntry *ie; 5687 const argtype *arg_type; 5688 abi_long ret; 5689 uint8_t buf_temp[MAX_STRUCT_SIZE]; 5690 int target_size; 5691 void *argptr; 5692 5693 ie = ioctl_entries; 5694 for(;;) { 5695 if (ie->target_cmd == 0) { 5696 qemu_log_mask( 5697 LOG_UNIMP, "Unsupported ioctl: cmd=0x%04lx\n", (long)cmd); 5698 return -TARGET_ENOSYS; 5699 } 5700 if (ie->target_cmd == cmd) 5701 break; 5702 ie++; 5703 } 5704 arg_type = ie->arg_type; 5705 if (ie->do_ioctl) { 5706 return ie->do_ioctl(ie, buf_temp, fd, cmd, arg); 5707 } else if (!ie->host_cmd) { 5708 /* Some architectures define BSD ioctls in their headers 5709 that are not implemented in Linux. */ 5710 return -TARGET_ENOSYS; 5711 } 5712 5713 switch(arg_type[0]) { 5714 case TYPE_NULL: 5715 /* no argument */ 5716 ret = get_errno(safe_ioctl(fd, ie->host_cmd)); 5717 break; 5718 case TYPE_PTRVOID: 5719 case TYPE_INT: 5720 case TYPE_LONG: 5721 case TYPE_ULONG: 5722 ret = get_errno(safe_ioctl(fd, ie->host_cmd, arg)); 5723 break; 5724 case TYPE_PTR: 5725 arg_type++; 5726 target_size = thunk_type_size(arg_type, 0); 5727 switch(ie->access) { 5728 case IOC_R: 5729 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 5730 if (!is_error(ret)) { 5731 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 5732 if (!argptr) 5733 return -TARGET_EFAULT; 5734 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET); 5735 unlock_user(argptr, arg, target_size); 5736 } 5737 break; 5738 case IOC_W: 5739 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5740 if (!argptr) 5741 return -TARGET_EFAULT; 5742 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 5743 unlock_user(argptr, arg, 0); 5744 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 5745 break; 5746 default: 5747 case IOC_RW: 5748 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 5749 if (!argptr) 5750 return -TARGET_EFAULT; 5751 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 5752 unlock_user(argptr, arg, 0); 5753 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp)); 5754 if (!is_error(ret)) { 5755 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 5756 if (!argptr) 5757 return -TARGET_EFAULT; 5758 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET); 5759 unlock_user(argptr, arg, target_size); 5760 } 5761 break; 5762 } 5763 break; 5764 default: 5765 qemu_log_mask(LOG_UNIMP, 5766 "Unsupported ioctl type: cmd=0x%04lx type=%d\n", 5767 (long)cmd, arg_type[0]); 5768 ret = -TARGET_ENOSYS; 5769 break; 5770 } 5771 return ret; 5772 } 5773 5774 static const bitmask_transtbl iflag_tbl[] = { 5775 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK }, 5776 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT }, 5777 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR }, 5778 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK }, 5779 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK }, 5780 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP }, 5781 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR }, 5782 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR }, 5783 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL }, 5784 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC }, 5785 { TARGET_IXON, TARGET_IXON, IXON, IXON }, 5786 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY }, 5787 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF }, 5788 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL }, 5789 { TARGET_IUTF8, TARGET_IUTF8, IUTF8, IUTF8}, 5790 { 0, 0, 0, 0 } 5791 }; 5792 5793 static const bitmask_transtbl oflag_tbl[] = { 5794 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST }, 5795 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC }, 5796 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR }, 5797 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL }, 5798 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR }, 5799 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET }, 5800 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL }, 5801 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL }, 5802 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 }, 5803 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 }, 5804 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 }, 5805 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 }, 5806 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 }, 5807 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 }, 5808 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 }, 5809 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 }, 5810 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 }, 5811 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 }, 5812 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 }, 5813 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 }, 5814 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 }, 5815 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 }, 5816 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 }, 5817 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 }, 5818 { 0, 0, 0, 0 } 5819 }; 5820 5821 static const bitmask_transtbl cflag_tbl[] = { 5822 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 }, 5823 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 }, 5824 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 }, 5825 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 }, 5826 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 }, 5827 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 }, 5828 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 }, 5829 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 }, 5830 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 }, 5831 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 }, 5832 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 }, 5833 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 }, 5834 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 }, 5835 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 }, 5836 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 }, 5837 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 }, 5838 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 }, 5839 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 }, 5840 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 }, 5841 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 }, 5842 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 }, 5843 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 }, 5844 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 }, 5845 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 }, 5846 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB }, 5847 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD }, 5848 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB }, 5849 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD }, 5850 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL }, 5851 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL }, 5852 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS }, 5853 { 0, 0, 0, 0 } 5854 }; 5855 5856 static const bitmask_transtbl lflag_tbl[] = { 5857 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG }, 5858 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON }, 5859 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE }, 5860 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO }, 5861 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE }, 5862 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK }, 5863 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL }, 5864 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH }, 5865 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP }, 5866 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL }, 5867 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT }, 5868 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE }, 5869 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO }, 5870 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN }, 5871 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN }, 5872 { TARGET_EXTPROC, TARGET_EXTPROC, EXTPROC, EXTPROC}, 5873 { 0, 0, 0, 0 } 5874 }; 5875 5876 static void target_to_host_termios (void *dst, const void *src) 5877 { 5878 struct host_termios *host = dst; 5879 const struct target_termios *target = src; 5880 5881 host->c_iflag = 5882 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl); 5883 host->c_oflag = 5884 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl); 5885 host->c_cflag = 5886 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl); 5887 host->c_lflag = 5888 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl); 5889 host->c_line = target->c_line; 5890 5891 memset(host->c_cc, 0, sizeof(host->c_cc)); 5892 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR]; 5893 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT]; 5894 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE]; 5895 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL]; 5896 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF]; 5897 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME]; 5898 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN]; 5899 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC]; 5900 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART]; 5901 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP]; 5902 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP]; 5903 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL]; 5904 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT]; 5905 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD]; 5906 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE]; 5907 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT]; 5908 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2]; 5909 } 5910 5911 static void host_to_target_termios (void *dst, const void *src) 5912 { 5913 struct target_termios *target = dst; 5914 const struct host_termios *host = src; 5915 5916 target->c_iflag = 5917 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl)); 5918 target->c_oflag = 5919 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl)); 5920 target->c_cflag = 5921 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl)); 5922 target->c_lflag = 5923 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl)); 5924 target->c_line = host->c_line; 5925 5926 memset(target->c_cc, 0, sizeof(target->c_cc)); 5927 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR]; 5928 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT]; 5929 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE]; 5930 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL]; 5931 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF]; 5932 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME]; 5933 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN]; 5934 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC]; 5935 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART]; 5936 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP]; 5937 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP]; 5938 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL]; 5939 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT]; 5940 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD]; 5941 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE]; 5942 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT]; 5943 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2]; 5944 } 5945 5946 static const StructEntry struct_termios_def = { 5947 .convert = { host_to_target_termios, target_to_host_termios }, 5948 .size = { sizeof(struct target_termios), sizeof(struct host_termios) }, 5949 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) }, 5950 .print = print_termios, 5951 }; 5952 5953 static const bitmask_transtbl mmap_flags_tbl[] = { 5954 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED }, 5955 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE }, 5956 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED }, 5957 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, 5958 MAP_ANONYMOUS, MAP_ANONYMOUS }, 5959 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, 5960 MAP_GROWSDOWN, MAP_GROWSDOWN }, 5961 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, 5962 MAP_DENYWRITE, MAP_DENYWRITE }, 5963 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, 5964 MAP_EXECUTABLE, MAP_EXECUTABLE }, 5965 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED }, 5966 { TARGET_MAP_NORESERVE, TARGET_MAP_NORESERVE, 5967 MAP_NORESERVE, MAP_NORESERVE }, 5968 { TARGET_MAP_HUGETLB, TARGET_MAP_HUGETLB, MAP_HUGETLB, MAP_HUGETLB }, 5969 /* MAP_STACK had been ignored by the kernel for quite some time. 5970 Recognize it for the target insofar as we do not want to pass 5971 it through to the host. */ 5972 { TARGET_MAP_STACK, TARGET_MAP_STACK, 0, 0 }, 5973 { 0, 0, 0, 0 } 5974 }; 5975 5976 /* 5977 * NOTE: TARGET_ABI32 is defined for TARGET_I386 (but not for TARGET_X86_64) 5978 * TARGET_I386 is defined if TARGET_X86_64 is defined 5979 */ 5980 #if defined(TARGET_I386) 5981 5982 /* NOTE: there is really one LDT for all the threads */ 5983 static uint8_t *ldt_table; 5984 5985 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount) 5986 { 5987 int size; 5988 void *p; 5989 5990 if (!ldt_table) 5991 return 0; 5992 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE; 5993 if (size > bytecount) 5994 size = bytecount; 5995 p = lock_user(VERIFY_WRITE, ptr, size, 0); 5996 if (!p) 5997 return -TARGET_EFAULT; 5998 /* ??? Should this by byteswapped? */ 5999 memcpy(p, ldt_table, size); 6000 unlock_user(p, ptr, size); 6001 return size; 6002 } 6003 6004 /* XXX: add locking support */ 6005 static abi_long write_ldt(CPUX86State *env, 6006 abi_ulong ptr, unsigned long bytecount, int oldmode) 6007 { 6008 struct target_modify_ldt_ldt_s ldt_info; 6009 struct target_modify_ldt_ldt_s *target_ldt_info; 6010 int seg_32bit, contents, read_exec_only, limit_in_pages; 6011 int seg_not_present, useable, lm; 6012 uint32_t *lp, entry_1, entry_2; 6013 6014 if (bytecount != sizeof(ldt_info)) 6015 return -TARGET_EINVAL; 6016 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1)) 6017 return -TARGET_EFAULT; 6018 ldt_info.entry_number = tswap32(target_ldt_info->entry_number); 6019 ldt_info.base_addr = tswapal(target_ldt_info->base_addr); 6020 ldt_info.limit = tswap32(target_ldt_info->limit); 6021 ldt_info.flags = tswap32(target_ldt_info->flags); 6022 unlock_user_struct(target_ldt_info, ptr, 0); 6023 6024 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES) 6025 return -TARGET_EINVAL; 6026 seg_32bit = ldt_info.flags & 1; 6027 contents = (ldt_info.flags >> 1) & 3; 6028 read_exec_only = (ldt_info.flags >> 3) & 1; 6029 limit_in_pages = (ldt_info.flags >> 4) & 1; 6030 seg_not_present = (ldt_info.flags >> 5) & 1; 6031 useable = (ldt_info.flags >> 6) & 1; 6032 #ifdef TARGET_ABI32 6033 lm = 0; 6034 #else 6035 lm = (ldt_info.flags >> 7) & 1; 6036 #endif 6037 if (contents == 3) { 6038 if (oldmode) 6039 return -TARGET_EINVAL; 6040 if (seg_not_present == 0) 6041 return -TARGET_EINVAL; 6042 } 6043 /* allocate the LDT */ 6044 if (!ldt_table) { 6045 env->ldt.base = target_mmap(0, 6046 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE, 6047 PROT_READ|PROT_WRITE, 6048 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); 6049 if (env->ldt.base == -1) 6050 return -TARGET_ENOMEM; 6051 memset(g2h_untagged(env->ldt.base), 0, 6052 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); 6053 env->ldt.limit = 0xffff; 6054 ldt_table = g2h_untagged(env->ldt.base); 6055 } 6056 6057 /* NOTE: same code as Linux kernel */ 6058 /* Allow LDTs to be cleared by the user. */ 6059 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) { 6060 if (oldmode || 6061 (contents == 0 && 6062 read_exec_only == 1 && 6063 seg_32bit == 0 && 6064 limit_in_pages == 0 && 6065 seg_not_present == 1 && 6066 useable == 0 )) { 6067 entry_1 = 0; 6068 entry_2 = 0; 6069 goto install; 6070 } 6071 } 6072 6073 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) | 6074 (ldt_info.limit & 0x0ffff); 6075 entry_2 = (ldt_info.base_addr & 0xff000000) | 6076 ((ldt_info.base_addr & 0x00ff0000) >> 16) | 6077 (ldt_info.limit & 0xf0000) | 6078 ((read_exec_only ^ 1) << 9) | 6079 (contents << 10) | 6080 ((seg_not_present ^ 1) << 15) | 6081 (seg_32bit << 22) | 6082 (limit_in_pages << 23) | 6083 (lm << 21) | 6084 0x7000; 6085 if (!oldmode) 6086 entry_2 |= (useable << 20); 6087 6088 /* Install the new entry ... */ 6089 install: 6090 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3)); 6091 lp[0] = tswap32(entry_1); 6092 lp[1] = tswap32(entry_2); 6093 return 0; 6094 } 6095 6096 /* specific and weird i386 syscalls */ 6097 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr, 6098 unsigned long bytecount) 6099 { 6100 abi_long ret; 6101 6102 switch (func) { 6103 case 0: 6104 ret = read_ldt(ptr, bytecount); 6105 break; 6106 case 1: 6107 ret = write_ldt(env, ptr, bytecount, 1); 6108 break; 6109 case 0x11: 6110 ret = write_ldt(env, ptr, bytecount, 0); 6111 break; 6112 default: 6113 ret = -TARGET_ENOSYS; 6114 break; 6115 } 6116 return ret; 6117 } 6118 6119 #if defined(TARGET_ABI32) 6120 abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr) 6121 { 6122 uint64_t *gdt_table = g2h_untagged(env->gdt.base); 6123 struct target_modify_ldt_ldt_s ldt_info; 6124 struct target_modify_ldt_ldt_s *target_ldt_info; 6125 int seg_32bit, contents, read_exec_only, limit_in_pages; 6126 int seg_not_present, useable, lm; 6127 uint32_t *lp, entry_1, entry_2; 6128 int i; 6129 6130 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1); 6131 if (!target_ldt_info) 6132 return -TARGET_EFAULT; 6133 ldt_info.entry_number = tswap32(target_ldt_info->entry_number); 6134 ldt_info.base_addr = tswapal(target_ldt_info->base_addr); 6135 ldt_info.limit = tswap32(target_ldt_info->limit); 6136 ldt_info.flags = tswap32(target_ldt_info->flags); 6137 if (ldt_info.entry_number == -1) { 6138 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) { 6139 if (gdt_table[i] == 0) { 6140 ldt_info.entry_number = i; 6141 target_ldt_info->entry_number = tswap32(i); 6142 break; 6143 } 6144 } 6145 } 6146 unlock_user_struct(target_ldt_info, ptr, 1); 6147 6148 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN || 6149 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX) 6150 return -TARGET_EINVAL; 6151 seg_32bit = ldt_info.flags & 1; 6152 contents = (ldt_info.flags >> 1) & 3; 6153 read_exec_only = (ldt_info.flags >> 3) & 1; 6154 limit_in_pages = (ldt_info.flags >> 4) & 1; 6155 seg_not_present = (ldt_info.flags >> 5) & 1; 6156 useable = (ldt_info.flags >> 6) & 1; 6157 #ifdef TARGET_ABI32 6158 lm = 0; 6159 #else 6160 lm = (ldt_info.flags >> 7) & 1; 6161 #endif 6162 6163 if (contents == 3) { 6164 if (seg_not_present == 0) 6165 return -TARGET_EINVAL; 6166 } 6167 6168 /* NOTE: same code as Linux kernel */ 6169 /* Allow LDTs to be cleared by the user. */ 6170 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) { 6171 if ((contents == 0 && 6172 read_exec_only == 1 && 6173 seg_32bit == 0 && 6174 limit_in_pages == 0 && 6175 seg_not_present == 1 && 6176 useable == 0 )) { 6177 entry_1 = 0; 6178 entry_2 = 0; 6179 goto install; 6180 } 6181 } 6182 6183 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) | 6184 (ldt_info.limit & 0x0ffff); 6185 entry_2 = (ldt_info.base_addr & 0xff000000) | 6186 ((ldt_info.base_addr & 0x00ff0000) >> 16) | 6187 (ldt_info.limit & 0xf0000) | 6188 ((read_exec_only ^ 1) << 9) | 6189 (contents << 10) | 6190 ((seg_not_present ^ 1) << 15) | 6191 (seg_32bit << 22) | 6192 (limit_in_pages << 23) | 6193 (useable << 20) | 6194 (lm << 21) | 6195 0x7000; 6196 6197 /* Install the new entry ... */ 6198 install: 6199 lp = (uint32_t *)(gdt_table + ldt_info.entry_number); 6200 lp[0] = tswap32(entry_1); 6201 lp[1] = tswap32(entry_2); 6202 return 0; 6203 } 6204 6205 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr) 6206 { 6207 struct target_modify_ldt_ldt_s *target_ldt_info; 6208 uint64_t *gdt_table = g2h_untagged(env->gdt.base); 6209 uint32_t base_addr, limit, flags; 6210 int seg_32bit, contents, read_exec_only, limit_in_pages, idx; 6211 int seg_not_present, useable, lm; 6212 uint32_t *lp, entry_1, entry_2; 6213 6214 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1); 6215 if (!target_ldt_info) 6216 return -TARGET_EFAULT; 6217 idx = tswap32(target_ldt_info->entry_number); 6218 if (idx < TARGET_GDT_ENTRY_TLS_MIN || 6219 idx > TARGET_GDT_ENTRY_TLS_MAX) { 6220 unlock_user_struct(target_ldt_info, ptr, 1); 6221 return -TARGET_EINVAL; 6222 } 6223 lp = (uint32_t *)(gdt_table + idx); 6224 entry_1 = tswap32(lp[0]); 6225 entry_2 = tswap32(lp[1]); 6226 6227 read_exec_only = ((entry_2 >> 9) & 1) ^ 1; 6228 contents = (entry_2 >> 10) & 3; 6229 seg_not_present = ((entry_2 >> 15) & 1) ^ 1; 6230 seg_32bit = (entry_2 >> 22) & 1; 6231 limit_in_pages = (entry_2 >> 23) & 1; 6232 useable = (entry_2 >> 20) & 1; 6233 #ifdef TARGET_ABI32 6234 lm = 0; 6235 #else 6236 lm = (entry_2 >> 21) & 1; 6237 #endif 6238 flags = (seg_32bit << 0) | (contents << 1) | 6239 (read_exec_only << 3) | (limit_in_pages << 4) | 6240 (seg_not_present << 5) | (useable << 6) | (lm << 7); 6241 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000); 6242 base_addr = (entry_1 >> 16) | 6243 (entry_2 & 0xff000000) | 6244 ((entry_2 & 0xff) << 16); 6245 target_ldt_info->base_addr = tswapal(base_addr); 6246 target_ldt_info->limit = tswap32(limit); 6247 target_ldt_info->flags = tswap32(flags); 6248 unlock_user_struct(target_ldt_info, ptr, 1); 6249 return 0; 6250 } 6251 6252 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr) 6253 { 6254 return -TARGET_ENOSYS; 6255 } 6256 #else 6257 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr) 6258 { 6259 abi_long ret = 0; 6260 abi_ulong val; 6261 int idx; 6262 6263 switch(code) { 6264 case TARGET_ARCH_SET_GS: 6265 case TARGET_ARCH_SET_FS: 6266 if (code == TARGET_ARCH_SET_GS) 6267 idx = R_GS; 6268 else 6269 idx = R_FS; 6270 cpu_x86_load_seg(env, idx, 0); 6271 env->segs[idx].base = addr; 6272 break; 6273 case TARGET_ARCH_GET_GS: 6274 case TARGET_ARCH_GET_FS: 6275 if (code == TARGET_ARCH_GET_GS) 6276 idx = R_GS; 6277 else 6278 idx = R_FS; 6279 val = env->segs[idx].base; 6280 if (put_user(val, addr, abi_ulong)) 6281 ret = -TARGET_EFAULT; 6282 break; 6283 default: 6284 ret = -TARGET_EINVAL; 6285 break; 6286 } 6287 return ret; 6288 } 6289 #endif /* defined(TARGET_ABI32 */ 6290 6291 #endif /* defined(TARGET_I386) */ 6292 6293 #define NEW_STACK_SIZE 0x40000 6294 6295 6296 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER; 6297 typedef struct { 6298 CPUArchState *env; 6299 pthread_mutex_t mutex; 6300 pthread_cond_t cond; 6301 pthread_t thread; 6302 uint32_t tid; 6303 abi_ulong child_tidptr; 6304 abi_ulong parent_tidptr; 6305 sigset_t sigmask; 6306 } new_thread_info; 6307 6308 static void *clone_func(void *arg) 6309 { 6310 new_thread_info *info = arg; 6311 CPUArchState *env; 6312 CPUState *cpu; 6313 TaskState *ts; 6314 6315 rcu_register_thread(); 6316 tcg_register_thread(); 6317 env = info->env; 6318 cpu = env_cpu(env); 6319 thread_cpu = cpu; 6320 ts = (TaskState *)cpu->opaque; 6321 info->tid = sys_gettid(); 6322 task_settid(ts); 6323 if (info->child_tidptr) 6324 put_user_u32(info->tid, info->child_tidptr); 6325 if (info->parent_tidptr) 6326 put_user_u32(info->tid, info->parent_tidptr); 6327 qemu_guest_random_seed_thread_part2(cpu->random_seed); 6328 /* Enable signals. */ 6329 sigprocmask(SIG_SETMASK, &info->sigmask, NULL); 6330 /* Signal to the parent that we're ready. */ 6331 pthread_mutex_lock(&info->mutex); 6332 pthread_cond_broadcast(&info->cond); 6333 pthread_mutex_unlock(&info->mutex); 6334 /* Wait until the parent has finished initializing the tls state. */ 6335 pthread_mutex_lock(&clone_lock); 6336 pthread_mutex_unlock(&clone_lock); 6337 cpu_loop(env); 6338 /* never exits */ 6339 return NULL; 6340 } 6341 6342 /* do_fork() Must return host values and target errnos (unlike most 6343 do_*() functions). */ 6344 static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp, 6345 abi_ulong parent_tidptr, target_ulong newtls, 6346 abi_ulong child_tidptr) 6347 { 6348 CPUState *cpu = env_cpu(env); 6349 int ret; 6350 TaskState *ts; 6351 CPUState *new_cpu; 6352 CPUArchState *new_env; 6353 sigset_t sigmask; 6354 6355 flags &= ~CLONE_IGNORED_FLAGS; 6356 6357 /* Emulate vfork() with fork() */ 6358 if (flags & CLONE_VFORK) 6359 flags &= ~(CLONE_VFORK | CLONE_VM); 6360 6361 if (flags & CLONE_VM) { 6362 TaskState *parent_ts = (TaskState *)cpu->opaque; 6363 new_thread_info info; 6364 pthread_attr_t attr; 6365 6366 if (((flags & CLONE_THREAD_FLAGS) != CLONE_THREAD_FLAGS) || 6367 (flags & CLONE_INVALID_THREAD_FLAGS)) { 6368 return -TARGET_EINVAL; 6369 } 6370 6371 ts = g_new0(TaskState, 1); 6372 init_task_state(ts); 6373 6374 /* Grab a mutex so that thread setup appears atomic. */ 6375 pthread_mutex_lock(&clone_lock); 6376 6377 /* 6378 * If this is our first additional thread, we need to ensure we 6379 * generate code for parallel execution and flush old translations. 6380 * Do this now so that the copy gets CF_PARALLEL too. 6381 */ 6382 if (!(cpu->tcg_cflags & CF_PARALLEL)) { 6383 cpu->tcg_cflags |= CF_PARALLEL; 6384 tb_flush(cpu); 6385 } 6386 6387 /* we create a new CPU instance. */ 6388 new_env = cpu_copy(env); 6389 /* Init regs that differ from the parent. */ 6390 cpu_clone_regs_child(new_env, newsp, flags); 6391 cpu_clone_regs_parent(env, flags); 6392 new_cpu = env_cpu(new_env); 6393 new_cpu->opaque = ts; 6394 ts->bprm = parent_ts->bprm; 6395 ts->info = parent_ts->info; 6396 ts->signal_mask = parent_ts->signal_mask; 6397 6398 if (flags & CLONE_CHILD_CLEARTID) { 6399 ts->child_tidptr = child_tidptr; 6400 } 6401 6402 if (flags & CLONE_SETTLS) { 6403 cpu_set_tls (new_env, newtls); 6404 } 6405 6406 memset(&info, 0, sizeof(info)); 6407 pthread_mutex_init(&info.mutex, NULL); 6408 pthread_mutex_lock(&info.mutex); 6409 pthread_cond_init(&info.cond, NULL); 6410 info.env = new_env; 6411 if (flags & CLONE_CHILD_SETTID) { 6412 info.child_tidptr = child_tidptr; 6413 } 6414 if (flags & CLONE_PARENT_SETTID) { 6415 info.parent_tidptr = parent_tidptr; 6416 } 6417 6418 ret = pthread_attr_init(&attr); 6419 ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE); 6420 ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 6421 /* It is not safe to deliver signals until the child has finished 6422 initializing, so temporarily block all signals. */ 6423 sigfillset(&sigmask); 6424 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask); 6425 cpu->random_seed = qemu_guest_random_seed_thread_part1(); 6426 6427 ret = pthread_create(&info.thread, &attr, clone_func, &info); 6428 /* TODO: Free new CPU state if thread creation failed. */ 6429 6430 sigprocmask(SIG_SETMASK, &info.sigmask, NULL); 6431 pthread_attr_destroy(&attr); 6432 if (ret == 0) { 6433 /* Wait for the child to initialize. */ 6434 pthread_cond_wait(&info.cond, &info.mutex); 6435 ret = info.tid; 6436 } else { 6437 ret = -1; 6438 } 6439 pthread_mutex_unlock(&info.mutex); 6440 pthread_cond_destroy(&info.cond); 6441 pthread_mutex_destroy(&info.mutex); 6442 pthread_mutex_unlock(&clone_lock); 6443 } else { 6444 /* if no CLONE_VM, we consider it is a fork */ 6445 if (flags & CLONE_INVALID_FORK_FLAGS) { 6446 return -TARGET_EINVAL; 6447 } 6448 6449 /* We can't support custom termination signals */ 6450 if ((flags & CSIGNAL) != TARGET_SIGCHLD) { 6451 return -TARGET_EINVAL; 6452 } 6453 6454 if (block_signals()) { 6455 return -TARGET_ERESTARTSYS; 6456 } 6457 6458 fork_start(); 6459 ret = fork(); 6460 if (ret == 0) { 6461 /* Child Process. */ 6462 cpu_clone_regs_child(env, newsp, flags); 6463 fork_end(1); 6464 /* There is a race condition here. The parent process could 6465 theoretically read the TID in the child process before the child 6466 tid is set. This would require using either ptrace 6467 (not implemented) or having *_tidptr to point at a shared memory 6468 mapping. We can't repeat the spinlock hack used above because 6469 the child process gets its own copy of the lock. */ 6470 if (flags & CLONE_CHILD_SETTID) 6471 put_user_u32(sys_gettid(), child_tidptr); 6472 if (flags & CLONE_PARENT_SETTID) 6473 put_user_u32(sys_gettid(), parent_tidptr); 6474 ts = (TaskState *)cpu->opaque; 6475 if (flags & CLONE_SETTLS) 6476 cpu_set_tls (env, newtls); 6477 if (flags & CLONE_CHILD_CLEARTID) 6478 ts->child_tidptr = child_tidptr; 6479 } else { 6480 cpu_clone_regs_parent(env, flags); 6481 fork_end(0); 6482 } 6483 } 6484 return ret; 6485 } 6486 6487 /* warning : doesn't handle linux specific flags... */ 6488 static int target_to_host_fcntl_cmd(int cmd) 6489 { 6490 int ret; 6491 6492 switch(cmd) { 6493 case TARGET_F_DUPFD: 6494 case TARGET_F_GETFD: 6495 case TARGET_F_SETFD: 6496 case TARGET_F_GETFL: 6497 case TARGET_F_SETFL: 6498 case TARGET_F_OFD_GETLK: 6499 case TARGET_F_OFD_SETLK: 6500 case TARGET_F_OFD_SETLKW: 6501 ret = cmd; 6502 break; 6503 case TARGET_F_GETLK: 6504 ret = F_GETLK64; 6505 break; 6506 case TARGET_F_SETLK: 6507 ret = F_SETLK64; 6508 break; 6509 case TARGET_F_SETLKW: 6510 ret = F_SETLKW64; 6511 break; 6512 case TARGET_F_GETOWN: 6513 ret = F_GETOWN; 6514 break; 6515 case TARGET_F_SETOWN: 6516 ret = F_SETOWN; 6517 break; 6518 case TARGET_F_GETSIG: 6519 ret = F_GETSIG; 6520 break; 6521 case TARGET_F_SETSIG: 6522 ret = F_SETSIG; 6523 break; 6524 #if TARGET_ABI_BITS == 32 6525 case TARGET_F_GETLK64: 6526 ret = F_GETLK64; 6527 break; 6528 case TARGET_F_SETLK64: 6529 ret = F_SETLK64; 6530 break; 6531 case TARGET_F_SETLKW64: 6532 ret = F_SETLKW64; 6533 break; 6534 #endif 6535 case TARGET_F_SETLEASE: 6536 ret = F_SETLEASE; 6537 break; 6538 case TARGET_F_GETLEASE: 6539 ret = F_GETLEASE; 6540 break; 6541 #ifdef F_DUPFD_CLOEXEC 6542 case TARGET_F_DUPFD_CLOEXEC: 6543 ret = F_DUPFD_CLOEXEC; 6544 break; 6545 #endif 6546 case TARGET_F_NOTIFY: 6547 ret = F_NOTIFY; 6548 break; 6549 #ifdef F_GETOWN_EX 6550 case TARGET_F_GETOWN_EX: 6551 ret = F_GETOWN_EX; 6552 break; 6553 #endif 6554 #ifdef F_SETOWN_EX 6555 case TARGET_F_SETOWN_EX: 6556 ret = F_SETOWN_EX; 6557 break; 6558 #endif 6559 #ifdef F_SETPIPE_SZ 6560 case TARGET_F_SETPIPE_SZ: 6561 ret = F_SETPIPE_SZ; 6562 break; 6563 case TARGET_F_GETPIPE_SZ: 6564 ret = F_GETPIPE_SZ; 6565 break; 6566 #endif 6567 #ifdef F_ADD_SEALS 6568 case TARGET_F_ADD_SEALS: 6569 ret = F_ADD_SEALS; 6570 break; 6571 case TARGET_F_GET_SEALS: 6572 ret = F_GET_SEALS; 6573 break; 6574 #endif 6575 default: 6576 ret = -TARGET_EINVAL; 6577 break; 6578 } 6579 6580 #if defined(__powerpc64__) 6581 /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and 6582 * is not supported by kernel. The glibc fcntl call actually adjusts 6583 * them to 5, 6 and 7 before making the syscall(). Since we make the 6584 * syscall directly, adjust to what is supported by the kernel. 6585 */ 6586 if (ret >= F_GETLK64 && ret <= F_SETLKW64) { 6587 ret -= F_GETLK64 - 5; 6588 } 6589 #endif 6590 6591 return ret; 6592 } 6593 6594 #define FLOCK_TRANSTBL \ 6595 switch (type) { \ 6596 TRANSTBL_CONVERT(F_RDLCK); \ 6597 TRANSTBL_CONVERT(F_WRLCK); \ 6598 TRANSTBL_CONVERT(F_UNLCK); \ 6599 } 6600 6601 static int target_to_host_flock(int type) 6602 { 6603 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a 6604 FLOCK_TRANSTBL 6605 #undef TRANSTBL_CONVERT 6606 return -TARGET_EINVAL; 6607 } 6608 6609 static int host_to_target_flock(int type) 6610 { 6611 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a 6612 FLOCK_TRANSTBL 6613 #undef TRANSTBL_CONVERT 6614 /* if we don't know how to convert the value coming 6615 * from the host we copy to the target field as-is 6616 */ 6617 return type; 6618 } 6619 6620 static inline abi_long copy_from_user_flock(struct flock64 *fl, 6621 abi_ulong target_flock_addr) 6622 { 6623 struct target_flock *target_fl; 6624 int l_type; 6625 6626 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) { 6627 return -TARGET_EFAULT; 6628 } 6629 6630 __get_user(l_type, &target_fl->l_type); 6631 l_type = target_to_host_flock(l_type); 6632 if (l_type < 0) { 6633 return l_type; 6634 } 6635 fl->l_type = l_type; 6636 __get_user(fl->l_whence, &target_fl->l_whence); 6637 __get_user(fl->l_start, &target_fl->l_start); 6638 __get_user(fl->l_len, &target_fl->l_len); 6639 __get_user(fl->l_pid, &target_fl->l_pid); 6640 unlock_user_struct(target_fl, target_flock_addr, 0); 6641 return 0; 6642 } 6643 6644 static inline abi_long copy_to_user_flock(abi_ulong target_flock_addr, 6645 const struct flock64 *fl) 6646 { 6647 struct target_flock *target_fl; 6648 short l_type; 6649 6650 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) { 6651 return -TARGET_EFAULT; 6652 } 6653 6654 l_type = host_to_target_flock(fl->l_type); 6655 __put_user(l_type, &target_fl->l_type); 6656 __put_user(fl->l_whence, &target_fl->l_whence); 6657 __put_user(fl->l_start, &target_fl->l_start); 6658 __put_user(fl->l_len, &target_fl->l_len); 6659 __put_user(fl->l_pid, &target_fl->l_pid); 6660 unlock_user_struct(target_fl, target_flock_addr, 1); 6661 return 0; 6662 } 6663 6664 typedef abi_long from_flock64_fn(struct flock64 *fl, abi_ulong target_addr); 6665 typedef abi_long to_flock64_fn(abi_ulong target_addr, const struct flock64 *fl); 6666 6667 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32 6668 static inline abi_long copy_from_user_oabi_flock64(struct flock64 *fl, 6669 abi_ulong target_flock_addr) 6670 { 6671 struct target_oabi_flock64 *target_fl; 6672 int l_type; 6673 6674 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) { 6675 return -TARGET_EFAULT; 6676 } 6677 6678 __get_user(l_type, &target_fl->l_type); 6679 l_type = target_to_host_flock(l_type); 6680 if (l_type < 0) { 6681 return l_type; 6682 } 6683 fl->l_type = l_type; 6684 __get_user(fl->l_whence, &target_fl->l_whence); 6685 __get_user(fl->l_start, &target_fl->l_start); 6686 __get_user(fl->l_len, &target_fl->l_len); 6687 __get_user(fl->l_pid, &target_fl->l_pid); 6688 unlock_user_struct(target_fl, target_flock_addr, 0); 6689 return 0; 6690 } 6691 6692 static inline abi_long copy_to_user_oabi_flock64(abi_ulong target_flock_addr, 6693 const struct flock64 *fl) 6694 { 6695 struct target_oabi_flock64 *target_fl; 6696 short l_type; 6697 6698 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) { 6699 return -TARGET_EFAULT; 6700 } 6701 6702 l_type = host_to_target_flock(fl->l_type); 6703 __put_user(l_type, &target_fl->l_type); 6704 __put_user(fl->l_whence, &target_fl->l_whence); 6705 __put_user(fl->l_start, &target_fl->l_start); 6706 __put_user(fl->l_len, &target_fl->l_len); 6707 __put_user(fl->l_pid, &target_fl->l_pid); 6708 unlock_user_struct(target_fl, target_flock_addr, 1); 6709 return 0; 6710 } 6711 #endif 6712 6713 static inline abi_long copy_from_user_flock64(struct flock64 *fl, 6714 abi_ulong target_flock_addr) 6715 { 6716 struct target_flock64 *target_fl; 6717 int l_type; 6718 6719 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) { 6720 return -TARGET_EFAULT; 6721 } 6722 6723 __get_user(l_type, &target_fl->l_type); 6724 l_type = target_to_host_flock(l_type); 6725 if (l_type < 0) { 6726 return l_type; 6727 } 6728 fl->l_type = l_type; 6729 __get_user(fl->l_whence, &target_fl->l_whence); 6730 __get_user(fl->l_start, &target_fl->l_start); 6731 __get_user(fl->l_len, &target_fl->l_len); 6732 __get_user(fl->l_pid, &target_fl->l_pid); 6733 unlock_user_struct(target_fl, target_flock_addr, 0); 6734 return 0; 6735 } 6736 6737 static inline abi_long copy_to_user_flock64(abi_ulong target_flock_addr, 6738 const struct flock64 *fl) 6739 { 6740 struct target_flock64 *target_fl; 6741 short l_type; 6742 6743 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) { 6744 return -TARGET_EFAULT; 6745 } 6746 6747 l_type = host_to_target_flock(fl->l_type); 6748 __put_user(l_type, &target_fl->l_type); 6749 __put_user(fl->l_whence, &target_fl->l_whence); 6750 __put_user(fl->l_start, &target_fl->l_start); 6751 __put_user(fl->l_len, &target_fl->l_len); 6752 __put_user(fl->l_pid, &target_fl->l_pid); 6753 unlock_user_struct(target_fl, target_flock_addr, 1); 6754 return 0; 6755 } 6756 6757 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg) 6758 { 6759 struct flock64 fl64; 6760 #ifdef F_GETOWN_EX 6761 struct f_owner_ex fox; 6762 struct target_f_owner_ex *target_fox; 6763 #endif 6764 abi_long ret; 6765 int host_cmd = target_to_host_fcntl_cmd(cmd); 6766 6767 if (host_cmd == -TARGET_EINVAL) 6768 return host_cmd; 6769 6770 switch(cmd) { 6771 case TARGET_F_GETLK: 6772 ret = copy_from_user_flock(&fl64, arg); 6773 if (ret) { 6774 return ret; 6775 } 6776 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64)); 6777 if (ret == 0) { 6778 ret = copy_to_user_flock(arg, &fl64); 6779 } 6780 break; 6781 6782 case TARGET_F_SETLK: 6783 case TARGET_F_SETLKW: 6784 ret = copy_from_user_flock(&fl64, arg); 6785 if (ret) { 6786 return ret; 6787 } 6788 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64)); 6789 break; 6790 6791 case TARGET_F_GETLK64: 6792 case TARGET_F_OFD_GETLK: 6793 ret = copy_from_user_flock64(&fl64, arg); 6794 if (ret) { 6795 return ret; 6796 } 6797 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64)); 6798 if (ret == 0) { 6799 ret = copy_to_user_flock64(arg, &fl64); 6800 } 6801 break; 6802 case TARGET_F_SETLK64: 6803 case TARGET_F_SETLKW64: 6804 case TARGET_F_OFD_SETLK: 6805 case TARGET_F_OFD_SETLKW: 6806 ret = copy_from_user_flock64(&fl64, arg); 6807 if (ret) { 6808 return ret; 6809 } 6810 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64)); 6811 break; 6812 6813 case TARGET_F_GETFL: 6814 ret = get_errno(safe_fcntl(fd, host_cmd, arg)); 6815 if (ret >= 0) { 6816 ret = host_to_target_bitmask(ret, fcntl_flags_tbl); 6817 } 6818 break; 6819 6820 case TARGET_F_SETFL: 6821 ret = get_errno(safe_fcntl(fd, host_cmd, 6822 target_to_host_bitmask(arg, 6823 fcntl_flags_tbl))); 6824 break; 6825 6826 #ifdef F_GETOWN_EX 6827 case TARGET_F_GETOWN_EX: 6828 ret = get_errno(safe_fcntl(fd, host_cmd, &fox)); 6829 if (ret >= 0) { 6830 if (!lock_user_struct(VERIFY_WRITE, target_fox, arg, 0)) 6831 return -TARGET_EFAULT; 6832 target_fox->type = tswap32(fox.type); 6833 target_fox->pid = tswap32(fox.pid); 6834 unlock_user_struct(target_fox, arg, 1); 6835 } 6836 break; 6837 #endif 6838 6839 #ifdef F_SETOWN_EX 6840 case TARGET_F_SETOWN_EX: 6841 if (!lock_user_struct(VERIFY_READ, target_fox, arg, 1)) 6842 return -TARGET_EFAULT; 6843 fox.type = tswap32(target_fox->type); 6844 fox.pid = tswap32(target_fox->pid); 6845 unlock_user_struct(target_fox, arg, 0); 6846 ret = get_errno(safe_fcntl(fd, host_cmd, &fox)); 6847 break; 6848 #endif 6849 6850 case TARGET_F_SETSIG: 6851 ret = get_errno(safe_fcntl(fd, host_cmd, target_to_host_signal(arg))); 6852 break; 6853 6854 case TARGET_F_GETSIG: 6855 ret = host_to_target_signal(get_errno(safe_fcntl(fd, host_cmd, arg))); 6856 break; 6857 6858 case TARGET_F_SETOWN: 6859 case TARGET_F_GETOWN: 6860 case TARGET_F_SETLEASE: 6861 case TARGET_F_GETLEASE: 6862 case TARGET_F_SETPIPE_SZ: 6863 case TARGET_F_GETPIPE_SZ: 6864 case TARGET_F_ADD_SEALS: 6865 case TARGET_F_GET_SEALS: 6866 ret = get_errno(safe_fcntl(fd, host_cmd, arg)); 6867 break; 6868 6869 default: 6870 ret = get_errno(safe_fcntl(fd, cmd, arg)); 6871 break; 6872 } 6873 return ret; 6874 } 6875 6876 #ifdef USE_UID16 6877 6878 static inline int high2lowuid(int uid) 6879 { 6880 if (uid > 65535) 6881 return 65534; 6882 else 6883 return uid; 6884 } 6885 6886 static inline int high2lowgid(int gid) 6887 { 6888 if (gid > 65535) 6889 return 65534; 6890 else 6891 return gid; 6892 } 6893 6894 static inline int low2highuid(int uid) 6895 { 6896 if ((int16_t)uid == -1) 6897 return -1; 6898 else 6899 return uid; 6900 } 6901 6902 static inline int low2highgid(int gid) 6903 { 6904 if ((int16_t)gid == -1) 6905 return -1; 6906 else 6907 return gid; 6908 } 6909 static inline int tswapid(int id) 6910 { 6911 return tswap16(id); 6912 } 6913 6914 #define put_user_id(x, gaddr) put_user_u16(x, gaddr) 6915 6916 #else /* !USE_UID16 */ 6917 static inline int high2lowuid(int uid) 6918 { 6919 return uid; 6920 } 6921 static inline int high2lowgid(int gid) 6922 { 6923 return gid; 6924 } 6925 static inline int low2highuid(int uid) 6926 { 6927 return uid; 6928 } 6929 static inline int low2highgid(int gid) 6930 { 6931 return gid; 6932 } 6933 static inline int tswapid(int id) 6934 { 6935 return tswap32(id); 6936 } 6937 6938 #define put_user_id(x, gaddr) put_user_u32(x, gaddr) 6939 6940 #endif /* USE_UID16 */ 6941 6942 /* We must do direct syscalls for setting UID/GID, because we want to 6943 * implement the Linux system call semantics of "change only for this thread", 6944 * not the libc/POSIX semantics of "change for all threads in process". 6945 * (See http://ewontfix.com/17/ for more details.) 6946 * We use the 32-bit version of the syscalls if present; if it is not 6947 * then either the host architecture supports 32-bit UIDs natively with 6948 * the standard syscall, or the 16-bit UID is the best we can do. 6949 */ 6950 #ifdef __NR_setuid32 6951 #define __NR_sys_setuid __NR_setuid32 6952 #else 6953 #define __NR_sys_setuid __NR_setuid 6954 #endif 6955 #ifdef __NR_setgid32 6956 #define __NR_sys_setgid __NR_setgid32 6957 #else 6958 #define __NR_sys_setgid __NR_setgid 6959 #endif 6960 #ifdef __NR_setresuid32 6961 #define __NR_sys_setresuid __NR_setresuid32 6962 #else 6963 #define __NR_sys_setresuid __NR_setresuid 6964 #endif 6965 #ifdef __NR_setresgid32 6966 #define __NR_sys_setresgid __NR_setresgid32 6967 #else 6968 #define __NR_sys_setresgid __NR_setresgid 6969 #endif 6970 6971 _syscall1(int, sys_setuid, uid_t, uid) 6972 _syscall1(int, sys_setgid, gid_t, gid) 6973 _syscall3(int, sys_setresuid, uid_t, ruid, uid_t, euid, uid_t, suid) 6974 _syscall3(int, sys_setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid) 6975 6976 void syscall_init(void) 6977 { 6978 IOCTLEntry *ie; 6979 const argtype *arg_type; 6980 int size; 6981 6982 thunk_init(STRUCT_MAX); 6983 6984 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def); 6985 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def); 6986 #include "syscall_types.h" 6987 #undef STRUCT 6988 #undef STRUCT_SPECIAL 6989 6990 /* we patch the ioctl size if necessary. We rely on the fact that 6991 no ioctl has all the bits at '1' in the size field */ 6992 ie = ioctl_entries; 6993 while (ie->target_cmd != 0) { 6994 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) == 6995 TARGET_IOC_SIZEMASK) { 6996 arg_type = ie->arg_type; 6997 if (arg_type[0] != TYPE_PTR) { 6998 fprintf(stderr, "cannot patch size for ioctl 0x%x\n", 6999 ie->target_cmd); 7000 exit(1); 7001 } 7002 arg_type++; 7003 size = thunk_type_size(arg_type, 0); 7004 ie->target_cmd = (ie->target_cmd & 7005 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) | 7006 (size << TARGET_IOC_SIZESHIFT); 7007 } 7008 7009 /* automatic consistency check if same arch */ 7010 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \ 7011 (defined(__x86_64__) && defined(TARGET_X86_64)) 7012 if (unlikely(ie->target_cmd != ie->host_cmd)) { 7013 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n", 7014 ie->name, ie->target_cmd, ie->host_cmd); 7015 } 7016 #endif 7017 ie++; 7018 } 7019 } 7020 7021 #ifdef TARGET_NR_truncate64 7022 static inline abi_long target_truncate64(void *cpu_env, const char *arg1, 7023 abi_long arg2, 7024 abi_long arg3, 7025 abi_long arg4) 7026 { 7027 if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) { 7028 arg2 = arg3; 7029 arg3 = arg4; 7030 } 7031 return get_errno(truncate64(arg1, target_offset64(arg2, arg3))); 7032 } 7033 #endif 7034 7035 #ifdef TARGET_NR_ftruncate64 7036 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1, 7037 abi_long arg2, 7038 abi_long arg3, 7039 abi_long arg4) 7040 { 7041 if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) { 7042 arg2 = arg3; 7043 arg3 = arg4; 7044 } 7045 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3))); 7046 } 7047 #endif 7048 7049 #if defined(TARGET_NR_timer_settime) || \ 7050 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)) 7051 static inline abi_long target_to_host_itimerspec(struct itimerspec *host_its, 7052 abi_ulong target_addr) 7053 { 7054 if (target_to_host_timespec(&host_its->it_interval, target_addr + 7055 offsetof(struct target_itimerspec, 7056 it_interval)) || 7057 target_to_host_timespec(&host_its->it_value, target_addr + 7058 offsetof(struct target_itimerspec, 7059 it_value))) { 7060 return -TARGET_EFAULT; 7061 } 7062 7063 return 0; 7064 } 7065 #endif 7066 7067 #if defined(TARGET_NR_timer_settime64) || \ 7068 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)) 7069 static inline abi_long target_to_host_itimerspec64(struct itimerspec *host_its, 7070 abi_ulong target_addr) 7071 { 7072 if (target_to_host_timespec64(&host_its->it_interval, target_addr + 7073 offsetof(struct target__kernel_itimerspec, 7074 it_interval)) || 7075 target_to_host_timespec64(&host_its->it_value, target_addr + 7076 offsetof(struct target__kernel_itimerspec, 7077 it_value))) { 7078 return -TARGET_EFAULT; 7079 } 7080 7081 return 0; 7082 } 7083 #endif 7084 7085 #if ((defined(TARGET_NR_timerfd_gettime) || \ 7086 defined(TARGET_NR_timerfd_settime)) && defined(CONFIG_TIMERFD)) || \ 7087 defined(TARGET_NR_timer_gettime) || defined(TARGET_NR_timer_settime) 7088 static inline abi_long host_to_target_itimerspec(abi_ulong target_addr, 7089 struct itimerspec *host_its) 7090 { 7091 if (host_to_target_timespec(target_addr + offsetof(struct target_itimerspec, 7092 it_interval), 7093 &host_its->it_interval) || 7094 host_to_target_timespec(target_addr + offsetof(struct target_itimerspec, 7095 it_value), 7096 &host_its->it_value)) { 7097 return -TARGET_EFAULT; 7098 } 7099 return 0; 7100 } 7101 #endif 7102 7103 #if ((defined(TARGET_NR_timerfd_gettime64) || \ 7104 defined(TARGET_NR_timerfd_settime64)) && defined(CONFIG_TIMERFD)) || \ 7105 defined(TARGET_NR_timer_gettime64) || defined(TARGET_NR_timer_settime64) 7106 static inline abi_long host_to_target_itimerspec64(abi_ulong target_addr, 7107 struct itimerspec *host_its) 7108 { 7109 if (host_to_target_timespec64(target_addr + 7110 offsetof(struct target__kernel_itimerspec, 7111 it_interval), 7112 &host_its->it_interval) || 7113 host_to_target_timespec64(target_addr + 7114 offsetof(struct target__kernel_itimerspec, 7115 it_value), 7116 &host_its->it_value)) { 7117 return -TARGET_EFAULT; 7118 } 7119 return 0; 7120 } 7121 #endif 7122 7123 #if defined(TARGET_NR_adjtimex) || \ 7124 (defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)) 7125 static inline abi_long target_to_host_timex(struct timex *host_tx, 7126 abi_long target_addr) 7127 { 7128 struct target_timex *target_tx; 7129 7130 if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) { 7131 return -TARGET_EFAULT; 7132 } 7133 7134 __get_user(host_tx->modes, &target_tx->modes); 7135 __get_user(host_tx->offset, &target_tx->offset); 7136 __get_user(host_tx->freq, &target_tx->freq); 7137 __get_user(host_tx->maxerror, &target_tx->maxerror); 7138 __get_user(host_tx->esterror, &target_tx->esterror); 7139 __get_user(host_tx->status, &target_tx->status); 7140 __get_user(host_tx->constant, &target_tx->constant); 7141 __get_user(host_tx->precision, &target_tx->precision); 7142 __get_user(host_tx->tolerance, &target_tx->tolerance); 7143 __get_user(host_tx->time.tv_sec, &target_tx->time.tv_sec); 7144 __get_user(host_tx->time.tv_usec, &target_tx->time.tv_usec); 7145 __get_user(host_tx->tick, &target_tx->tick); 7146 __get_user(host_tx->ppsfreq, &target_tx->ppsfreq); 7147 __get_user(host_tx->jitter, &target_tx->jitter); 7148 __get_user(host_tx->shift, &target_tx->shift); 7149 __get_user(host_tx->stabil, &target_tx->stabil); 7150 __get_user(host_tx->jitcnt, &target_tx->jitcnt); 7151 __get_user(host_tx->calcnt, &target_tx->calcnt); 7152 __get_user(host_tx->errcnt, &target_tx->errcnt); 7153 __get_user(host_tx->stbcnt, &target_tx->stbcnt); 7154 __get_user(host_tx->tai, &target_tx->tai); 7155 7156 unlock_user_struct(target_tx, target_addr, 0); 7157 return 0; 7158 } 7159 7160 static inline abi_long host_to_target_timex(abi_long target_addr, 7161 struct timex *host_tx) 7162 { 7163 struct target_timex *target_tx; 7164 7165 if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) { 7166 return -TARGET_EFAULT; 7167 } 7168 7169 __put_user(host_tx->modes, &target_tx->modes); 7170 __put_user(host_tx->offset, &target_tx->offset); 7171 __put_user(host_tx->freq, &target_tx->freq); 7172 __put_user(host_tx->maxerror, &target_tx->maxerror); 7173 __put_user(host_tx->esterror, &target_tx->esterror); 7174 __put_user(host_tx->status, &target_tx->status); 7175 __put_user(host_tx->constant, &target_tx->constant); 7176 __put_user(host_tx->precision, &target_tx->precision); 7177 __put_user(host_tx->tolerance, &target_tx->tolerance); 7178 __put_user(host_tx->time.tv_sec, &target_tx->time.tv_sec); 7179 __put_user(host_tx->time.tv_usec, &target_tx->time.tv_usec); 7180 __put_user(host_tx->tick, &target_tx->tick); 7181 __put_user(host_tx->ppsfreq, &target_tx->ppsfreq); 7182 __put_user(host_tx->jitter, &target_tx->jitter); 7183 __put_user(host_tx->shift, &target_tx->shift); 7184 __put_user(host_tx->stabil, &target_tx->stabil); 7185 __put_user(host_tx->jitcnt, &target_tx->jitcnt); 7186 __put_user(host_tx->calcnt, &target_tx->calcnt); 7187 __put_user(host_tx->errcnt, &target_tx->errcnt); 7188 __put_user(host_tx->stbcnt, &target_tx->stbcnt); 7189 __put_user(host_tx->tai, &target_tx->tai); 7190 7191 unlock_user_struct(target_tx, target_addr, 1); 7192 return 0; 7193 } 7194 #endif 7195 7196 7197 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME) 7198 static inline abi_long target_to_host_timex64(struct timex *host_tx, 7199 abi_long target_addr) 7200 { 7201 struct target__kernel_timex *target_tx; 7202 7203 if (copy_from_user_timeval64(&host_tx->time, target_addr + 7204 offsetof(struct target__kernel_timex, 7205 time))) { 7206 return -TARGET_EFAULT; 7207 } 7208 7209 if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) { 7210 return -TARGET_EFAULT; 7211 } 7212 7213 __get_user(host_tx->modes, &target_tx->modes); 7214 __get_user(host_tx->offset, &target_tx->offset); 7215 __get_user(host_tx->freq, &target_tx->freq); 7216 __get_user(host_tx->maxerror, &target_tx->maxerror); 7217 __get_user(host_tx->esterror, &target_tx->esterror); 7218 __get_user(host_tx->status, &target_tx->status); 7219 __get_user(host_tx->constant, &target_tx->constant); 7220 __get_user(host_tx->precision, &target_tx->precision); 7221 __get_user(host_tx->tolerance, &target_tx->tolerance); 7222 __get_user(host_tx->tick, &target_tx->tick); 7223 __get_user(host_tx->ppsfreq, &target_tx->ppsfreq); 7224 __get_user(host_tx->jitter, &target_tx->jitter); 7225 __get_user(host_tx->shift, &target_tx->shift); 7226 __get_user(host_tx->stabil, &target_tx->stabil); 7227 __get_user(host_tx->jitcnt, &target_tx->jitcnt); 7228 __get_user(host_tx->calcnt, &target_tx->calcnt); 7229 __get_user(host_tx->errcnt, &target_tx->errcnt); 7230 __get_user(host_tx->stbcnt, &target_tx->stbcnt); 7231 __get_user(host_tx->tai, &target_tx->tai); 7232 7233 unlock_user_struct(target_tx, target_addr, 0); 7234 return 0; 7235 } 7236 7237 static inline abi_long host_to_target_timex64(abi_long target_addr, 7238 struct timex *host_tx) 7239 { 7240 struct target__kernel_timex *target_tx; 7241 7242 if (copy_to_user_timeval64(target_addr + 7243 offsetof(struct target__kernel_timex, time), 7244 &host_tx->time)) { 7245 return -TARGET_EFAULT; 7246 } 7247 7248 if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) { 7249 return -TARGET_EFAULT; 7250 } 7251 7252 __put_user(host_tx->modes, &target_tx->modes); 7253 __put_user(host_tx->offset, &target_tx->offset); 7254 __put_user(host_tx->freq, &target_tx->freq); 7255 __put_user(host_tx->maxerror, &target_tx->maxerror); 7256 __put_user(host_tx->esterror, &target_tx->esterror); 7257 __put_user(host_tx->status, &target_tx->status); 7258 __put_user(host_tx->constant, &target_tx->constant); 7259 __put_user(host_tx->precision, &target_tx->precision); 7260 __put_user(host_tx->tolerance, &target_tx->tolerance); 7261 __put_user(host_tx->tick, &target_tx->tick); 7262 __put_user(host_tx->ppsfreq, &target_tx->ppsfreq); 7263 __put_user(host_tx->jitter, &target_tx->jitter); 7264 __put_user(host_tx->shift, &target_tx->shift); 7265 __put_user(host_tx->stabil, &target_tx->stabil); 7266 __put_user(host_tx->jitcnt, &target_tx->jitcnt); 7267 __put_user(host_tx->calcnt, &target_tx->calcnt); 7268 __put_user(host_tx->errcnt, &target_tx->errcnt); 7269 __put_user(host_tx->stbcnt, &target_tx->stbcnt); 7270 __put_user(host_tx->tai, &target_tx->tai); 7271 7272 unlock_user_struct(target_tx, target_addr, 1); 7273 return 0; 7274 } 7275 #endif 7276 7277 #ifndef HAVE_SIGEV_NOTIFY_THREAD_ID 7278 #define sigev_notify_thread_id _sigev_un._tid 7279 #endif 7280 7281 static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp, 7282 abi_ulong target_addr) 7283 { 7284 struct target_sigevent *target_sevp; 7285 7286 if (!lock_user_struct(VERIFY_READ, target_sevp, target_addr, 1)) { 7287 return -TARGET_EFAULT; 7288 } 7289 7290 /* This union is awkward on 64 bit systems because it has a 32 bit 7291 * integer and a pointer in it; we follow the conversion approach 7292 * used for handling sigval types in signal.c so the guest should get 7293 * the correct value back even if we did a 64 bit byteswap and it's 7294 * using the 32 bit integer. 7295 */ 7296 host_sevp->sigev_value.sival_ptr = 7297 (void *)(uintptr_t)tswapal(target_sevp->sigev_value.sival_ptr); 7298 host_sevp->sigev_signo = 7299 target_to_host_signal(tswap32(target_sevp->sigev_signo)); 7300 host_sevp->sigev_notify = tswap32(target_sevp->sigev_notify); 7301 host_sevp->sigev_notify_thread_id = tswap32(target_sevp->_sigev_un._tid); 7302 7303 unlock_user_struct(target_sevp, target_addr, 1); 7304 return 0; 7305 } 7306 7307 #if defined(TARGET_NR_mlockall) 7308 static inline int target_to_host_mlockall_arg(int arg) 7309 { 7310 int result = 0; 7311 7312 if (arg & TARGET_MCL_CURRENT) { 7313 result |= MCL_CURRENT; 7314 } 7315 if (arg & TARGET_MCL_FUTURE) { 7316 result |= MCL_FUTURE; 7317 } 7318 #ifdef MCL_ONFAULT 7319 if (arg & TARGET_MCL_ONFAULT) { 7320 result |= MCL_ONFAULT; 7321 } 7322 #endif 7323 7324 return result; 7325 } 7326 #endif 7327 7328 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) || \ 7329 defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) || \ 7330 defined(TARGET_NR_newfstatat)) 7331 static inline abi_long host_to_target_stat64(void *cpu_env, 7332 abi_ulong target_addr, 7333 struct stat *host_st) 7334 { 7335 #if defined(TARGET_ARM) && defined(TARGET_ABI32) 7336 if (((CPUARMState *)cpu_env)->eabi) { 7337 struct target_eabi_stat64 *target_st; 7338 7339 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0)) 7340 return -TARGET_EFAULT; 7341 memset(target_st, 0, sizeof(struct target_eabi_stat64)); 7342 __put_user(host_st->st_dev, &target_st->st_dev); 7343 __put_user(host_st->st_ino, &target_st->st_ino); 7344 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO 7345 __put_user(host_st->st_ino, &target_st->__st_ino); 7346 #endif 7347 __put_user(host_st->st_mode, &target_st->st_mode); 7348 __put_user(host_st->st_nlink, &target_st->st_nlink); 7349 __put_user(host_st->st_uid, &target_st->st_uid); 7350 __put_user(host_st->st_gid, &target_st->st_gid); 7351 __put_user(host_st->st_rdev, &target_st->st_rdev); 7352 __put_user(host_st->st_size, &target_st->st_size); 7353 __put_user(host_st->st_blksize, &target_st->st_blksize); 7354 __put_user(host_st->st_blocks, &target_st->st_blocks); 7355 __put_user(host_st->st_atime, &target_st->target_st_atime); 7356 __put_user(host_st->st_mtime, &target_st->target_st_mtime); 7357 __put_user(host_st->st_ctime, &target_st->target_st_ctime); 7358 #ifdef HAVE_STRUCT_STAT_ST_ATIM 7359 __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec); 7360 __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec); 7361 __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec); 7362 #endif 7363 unlock_user_struct(target_st, target_addr, 1); 7364 } else 7365 #endif 7366 { 7367 #if defined(TARGET_HAS_STRUCT_STAT64) 7368 struct target_stat64 *target_st; 7369 #else 7370 struct target_stat *target_st; 7371 #endif 7372 7373 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0)) 7374 return -TARGET_EFAULT; 7375 memset(target_st, 0, sizeof(*target_st)); 7376 __put_user(host_st->st_dev, &target_st->st_dev); 7377 __put_user(host_st->st_ino, &target_st->st_ino); 7378 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO 7379 __put_user(host_st->st_ino, &target_st->__st_ino); 7380 #endif 7381 __put_user(host_st->st_mode, &target_st->st_mode); 7382 __put_user(host_st->st_nlink, &target_st->st_nlink); 7383 __put_user(host_st->st_uid, &target_st->st_uid); 7384 __put_user(host_st->st_gid, &target_st->st_gid); 7385 __put_user(host_st->st_rdev, &target_st->st_rdev); 7386 /* XXX: better use of kernel struct */ 7387 __put_user(host_st->st_size, &target_st->st_size); 7388 __put_user(host_st->st_blksize, &target_st->st_blksize); 7389 __put_user(host_st->st_blocks, &target_st->st_blocks); 7390 __put_user(host_st->st_atime, &target_st->target_st_atime); 7391 __put_user(host_st->st_mtime, &target_st->target_st_mtime); 7392 __put_user(host_st->st_ctime, &target_st->target_st_ctime); 7393 #ifdef HAVE_STRUCT_STAT_ST_ATIM 7394 __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec); 7395 __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec); 7396 __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec); 7397 #endif 7398 unlock_user_struct(target_st, target_addr, 1); 7399 } 7400 7401 return 0; 7402 } 7403 #endif 7404 7405 #if defined(TARGET_NR_statx) && defined(__NR_statx) 7406 static inline abi_long host_to_target_statx(struct target_statx *host_stx, 7407 abi_ulong target_addr) 7408 { 7409 struct target_statx *target_stx; 7410 7411 if (!lock_user_struct(VERIFY_WRITE, target_stx, target_addr, 0)) { 7412 return -TARGET_EFAULT; 7413 } 7414 memset(target_stx, 0, sizeof(*target_stx)); 7415 7416 __put_user(host_stx->stx_mask, &target_stx->stx_mask); 7417 __put_user(host_stx->stx_blksize, &target_stx->stx_blksize); 7418 __put_user(host_stx->stx_attributes, &target_stx->stx_attributes); 7419 __put_user(host_stx->stx_nlink, &target_stx->stx_nlink); 7420 __put_user(host_stx->stx_uid, &target_stx->stx_uid); 7421 __put_user(host_stx->stx_gid, &target_stx->stx_gid); 7422 __put_user(host_stx->stx_mode, &target_stx->stx_mode); 7423 __put_user(host_stx->stx_ino, &target_stx->stx_ino); 7424 __put_user(host_stx->stx_size, &target_stx->stx_size); 7425 __put_user(host_stx->stx_blocks, &target_stx->stx_blocks); 7426 __put_user(host_stx->stx_attributes_mask, &target_stx->stx_attributes_mask); 7427 __put_user(host_stx->stx_atime.tv_sec, &target_stx->stx_atime.tv_sec); 7428 __put_user(host_stx->stx_atime.tv_nsec, &target_stx->stx_atime.tv_nsec); 7429 __put_user(host_stx->stx_btime.tv_sec, &target_stx->stx_btime.tv_sec); 7430 __put_user(host_stx->stx_btime.tv_nsec, &target_stx->stx_btime.tv_nsec); 7431 __put_user(host_stx->stx_ctime.tv_sec, &target_stx->stx_ctime.tv_sec); 7432 __put_user(host_stx->stx_ctime.tv_nsec, &target_stx->stx_ctime.tv_nsec); 7433 __put_user(host_stx->stx_mtime.tv_sec, &target_stx->stx_mtime.tv_sec); 7434 __put_user(host_stx->stx_mtime.tv_nsec, &target_stx->stx_mtime.tv_nsec); 7435 __put_user(host_stx->stx_rdev_major, &target_stx->stx_rdev_major); 7436 __put_user(host_stx->stx_rdev_minor, &target_stx->stx_rdev_minor); 7437 __put_user(host_stx->stx_dev_major, &target_stx->stx_dev_major); 7438 __put_user(host_stx->stx_dev_minor, &target_stx->stx_dev_minor); 7439 7440 unlock_user_struct(target_stx, target_addr, 1); 7441 7442 return 0; 7443 } 7444 #endif 7445 7446 static int do_sys_futex(int *uaddr, int op, int val, 7447 const struct timespec *timeout, int *uaddr2, 7448 int val3) 7449 { 7450 #if HOST_LONG_BITS == 64 7451 #if defined(__NR_futex) 7452 /* always a 64-bit time_t, it doesn't define _time64 version */ 7453 return sys_futex(uaddr, op, val, timeout, uaddr2, val3); 7454 7455 #endif 7456 #else /* HOST_LONG_BITS == 64 */ 7457 #if defined(__NR_futex_time64) 7458 if (sizeof(timeout->tv_sec) == 8) { 7459 /* _time64 function on 32bit arch */ 7460 return sys_futex_time64(uaddr, op, val, timeout, uaddr2, val3); 7461 } 7462 #endif 7463 #if defined(__NR_futex) 7464 /* old function on 32bit arch */ 7465 return sys_futex(uaddr, op, val, timeout, uaddr2, val3); 7466 #endif 7467 #endif /* HOST_LONG_BITS == 64 */ 7468 g_assert_not_reached(); 7469 } 7470 7471 static int do_safe_futex(int *uaddr, int op, int val, 7472 const struct timespec *timeout, int *uaddr2, 7473 int val3) 7474 { 7475 #if HOST_LONG_BITS == 64 7476 #if defined(__NR_futex) 7477 /* always a 64-bit time_t, it doesn't define _time64 version */ 7478 return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3)); 7479 #endif 7480 #else /* HOST_LONG_BITS == 64 */ 7481 #if defined(__NR_futex_time64) 7482 if (sizeof(timeout->tv_sec) == 8) { 7483 /* _time64 function on 32bit arch */ 7484 return get_errno(safe_futex_time64(uaddr, op, val, timeout, uaddr2, 7485 val3)); 7486 } 7487 #endif 7488 #if defined(__NR_futex) 7489 /* old function on 32bit arch */ 7490 return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3)); 7491 #endif 7492 #endif /* HOST_LONG_BITS == 64 */ 7493 return -TARGET_ENOSYS; 7494 } 7495 7496 /* ??? Using host futex calls even when target atomic operations 7497 are not really atomic probably breaks things. However implementing 7498 futexes locally would make futexes shared between multiple processes 7499 tricky. However they're probably useless because guest atomic 7500 operations won't work either. */ 7501 #if defined(TARGET_NR_futex) 7502 static int do_futex(CPUState *cpu, target_ulong uaddr, int op, int val, 7503 target_ulong timeout, target_ulong uaddr2, int val3) 7504 { 7505 struct timespec ts, *pts; 7506 int base_op; 7507 7508 /* ??? We assume FUTEX_* constants are the same on both host 7509 and target. */ 7510 #ifdef FUTEX_CMD_MASK 7511 base_op = op & FUTEX_CMD_MASK; 7512 #else 7513 base_op = op; 7514 #endif 7515 switch (base_op) { 7516 case FUTEX_WAIT: 7517 case FUTEX_WAIT_BITSET: 7518 if (timeout) { 7519 pts = &ts; 7520 target_to_host_timespec(pts, timeout); 7521 } else { 7522 pts = NULL; 7523 } 7524 return do_safe_futex(g2h(cpu, uaddr), 7525 op, tswap32(val), pts, NULL, val3); 7526 case FUTEX_WAKE: 7527 return do_safe_futex(g2h(cpu, uaddr), 7528 op, val, NULL, NULL, 0); 7529 case FUTEX_FD: 7530 return do_safe_futex(g2h(cpu, uaddr), 7531 op, val, NULL, NULL, 0); 7532 case FUTEX_REQUEUE: 7533 case FUTEX_CMP_REQUEUE: 7534 case FUTEX_WAKE_OP: 7535 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the 7536 TIMEOUT parameter is interpreted as a uint32_t by the kernel. 7537 But the prototype takes a `struct timespec *'; insert casts 7538 to satisfy the compiler. We do not need to tswap TIMEOUT 7539 since it's not compared to guest memory. */ 7540 pts = (struct timespec *)(uintptr_t) timeout; 7541 return do_safe_futex(g2h(cpu, uaddr), op, val, pts, g2h(cpu, uaddr2), 7542 (base_op == FUTEX_CMP_REQUEUE 7543 ? tswap32(val3) : val3)); 7544 default: 7545 return -TARGET_ENOSYS; 7546 } 7547 } 7548 #endif 7549 7550 #if defined(TARGET_NR_futex_time64) 7551 static int do_futex_time64(CPUState *cpu, target_ulong uaddr, int op, 7552 int val, target_ulong timeout, 7553 target_ulong uaddr2, int val3) 7554 { 7555 struct timespec ts, *pts; 7556 int base_op; 7557 7558 /* ??? We assume FUTEX_* constants are the same on both host 7559 and target. */ 7560 #ifdef FUTEX_CMD_MASK 7561 base_op = op & FUTEX_CMD_MASK; 7562 #else 7563 base_op = op; 7564 #endif 7565 switch (base_op) { 7566 case FUTEX_WAIT: 7567 case FUTEX_WAIT_BITSET: 7568 if (timeout) { 7569 pts = &ts; 7570 if (target_to_host_timespec64(pts, timeout)) { 7571 return -TARGET_EFAULT; 7572 } 7573 } else { 7574 pts = NULL; 7575 } 7576 return do_safe_futex(g2h(cpu, uaddr), op, 7577 tswap32(val), pts, NULL, val3); 7578 case FUTEX_WAKE: 7579 return do_safe_futex(g2h(cpu, uaddr), op, val, NULL, NULL, 0); 7580 case FUTEX_FD: 7581 return do_safe_futex(g2h(cpu, uaddr), op, val, NULL, NULL, 0); 7582 case FUTEX_REQUEUE: 7583 case FUTEX_CMP_REQUEUE: 7584 case FUTEX_WAKE_OP: 7585 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the 7586 TIMEOUT parameter is interpreted as a uint32_t by the kernel. 7587 But the prototype takes a `struct timespec *'; insert casts 7588 to satisfy the compiler. We do not need to tswap TIMEOUT 7589 since it's not compared to guest memory. */ 7590 pts = (struct timespec *)(uintptr_t) timeout; 7591 return do_safe_futex(g2h(cpu, uaddr), op, val, pts, g2h(cpu, uaddr2), 7592 (base_op == FUTEX_CMP_REQUEUE 7593 ? tswap32(val3) : val3)); 7594 default: 7595 return -TARGET_ENOSYS; 7596 } 7597 } 7598 #endif 7599 7600 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE) 7601 static abi_long do_name_to_handle_at(abi_long dirfd, abi_long pathname, 7602 abi_long handle, abi_long mount_id, 7603 abi_long flags) 7604 { 7605 struct file_handle *target_fh; 7606 struct file_handle *fh; 7607 int mid = 0; 7608 abi_long ret; 7609 char *name; 7610 unsigned int size, total_size; 7611 7612 if (get_user_s32(size, handle)) { 7613 return -TARGET_EFAULT; 7614 } 7615 7616 name = lock_user_string(pathname); 7617 if (!name) { 7618 return -TARGET_EFAULT; 7619 } 7620 7621 total_size = sizeof(struct file_handle) + size; 7622 target_fh = lock_user(VERIFY_WRITE, handle, total_size, 0); 7623 if (!target_fh) { 7624 unlock_user(name, pathname, 0); 7625 return -TARGET_EFAULT; 7626 } 7627 7628 fh = g_malloc0(total_size); 7629 fh->handle_bytes = size; 7630 7631 ret = get_errno(name_to_handle_at(dirfd, path(name), fh, &mid, flags)); 7632 unlock_user(name, pathname, 0); 7633 7634 /* man name_to_handle_at(2): 7635 * Other than the use of the handle_bytes field, the caller should treat 7636 * the file_handle structure as an opaque data type 7637 */ 7638 7639 memcpy(target_fh, fh, total_size); 7640 target_fh->handle_bytes = tswap32(fh->handle_bytes); 7641 target_fh->handle_type = tswap32(fh->handle_type); 7642 g_free(fh); 7643 unlock_user(target_fh, handle, total_size); 7644 7645 if (put_user_s32(mid, mount_id)) { 7646 return -TARGET_EFAULT; 7647 } 7648 7649 return ret; 7650 7651 } 7652 #endif 7653 7654 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE) 7655 static abi_long do_open_by_handle_at(abi_long mount_fd, abi_long handle, 7656 abi_long flags) 7657 { 7658 struct file_handle *target_fh; 7659 struct file_handle *fh; 7660 unsigned int size, total_size; 7661 abi_long ret; 7662 7663 if (get_user_s32(size, handle)) { 7664 return -TARGET_EFAULT; 7665 } 7666 7667 total_size = sizeof(struct file_handle) + size; 7668 target_fh = lock_user(VERIFY_READ, handle, total_size, 1); 7669 if (!target_fh) { 7670 return -TARGET_EFAULT; 7671 } 7672 7673 fh = g_memdup(target_fh, total_size); 7674 fh->handle_bytes = size; 7675 fh->handle_type = tswap32(target_fh->handle_type); 7676 7677 ret = get_errno(open_by_handle_at(mount_fd, fh, 7678 target_to_host_bitmask(flags, fcntl_flags_tbl))); 7679 7680 g_free(fh); 7681 7682 unlock_user(target_fh, handle, total_size); 7683 7684 return ret; 7685 } 7686 #endif 7687 7688 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4) 7689 7690 static abi_long do_signalfd4(int fd, abi_long mask, int flags) 7691 { 7692 int host_flags; 7693 target_sigset_t *target_mask; 7694 sigset_t host_mask; 7695 abi_long ret; 7696 7697 if (flags & ~(TARGET_O_NONBLOCK_MASK | TARGET_O_CLOEXEC)) { 7698 return -TARGET_EINVAL; 7699 } 7700 if (!lock_user_struct(VERIFY_READ, target_mask, mask, 1)) { 7701 return -TARGET_EFAULT; 7702 } 7703 7704 target_to_host_sigset(&host_mask, target_mask); 7705 7706 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl); 7707 7708 ret = get_errno(signalfd(fd, &host_mask, host_flags)); 7709 if (ret >= 0) { 7710 fd_trans_register(ret, &target_signalfd_trans); 7711 } 7712 7713 unlock_user_struct(target_mask, mask, 0); 7714 7715 return ret; 7716 } 7717 #endif 7718 7719 /* Map host to target signal numbers for the wait family of syscalls. 7720 Assume all other status bits are the same. */ 7721 int host_to_target_waitstatus(int status) 7722 { 7723 if (WIFSIGNALED(status)) { 7724 return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f); 7725 } 7726 if (WIFSTOPPED(status)) { 7727 return (host_to_target_signal(WSTOPSIG(status)) << 8) 7728 | (status & 0xff); 7729 } 7730 return status; 7731 } 7732 7733 static int open_self_cmdline(void *cpu_env, int fd) 7734 { 7735 CPUState *cpu = env_cpu((CPUArchState *)cpu_env); 7736 struct linux_binprm *bprm = ((TaskState *)cpu->opaque)->bprm; 7737 int i; 7738 7739 for (i = 0; i < bprm->argc; i++) { 7740 size_t len = strlen(bprm->argv[i]) + 1; 7741 7742 if (write(fd, bprm->argv[i], len) != len) { 7743 return -1; 7744 } 7745 } 7746 7747 return 0; 7748 } 7749 7750 static int open_self_maps(void *cpu_env, int fd) 7751 { 7752 CPUState *cpu = env_cpu((CPUArchState *)cpu_env); 7753 TaskState *ts = cpu->opaque; 7754 GSList *map_info = read_self_maps(); 7755 GSList *s; 7756 int count; 7757 7758 for (s = map_info; s; s = g_slist_next(s)) { 7759 MapInfo *e = (MapInfo *) s->data; 7760 7761 if (h2g_valid(e->start)) { 7762 unsigned long min = e->start; 7763 unsigned long max = e->end; 7764 int flags = page_get_flags(h2g(min)); 7765 const char *path; 7766 7767 max = h2g_valid(max - 1) ? 7768 max : (uintptr_t) g2h_untagged(GUEST_ADDR_MAX) + 1; 7769 7770 if (page_check_range(h2g(min), max - min, flags) == -1) { 7771 continue; 7772 } 7773 7774 if (h2g(min) == ts->info->stack_limit) { 7775 path = "[stack]"; 7776 } else { 7777 path = e->path; 7778 } 7779 7780 count = dprintf(fd, TARGET_ABI_FMT_ptr "-" TARGET_ABI_FMT_ptr 7781 " %c%c%c%c %08" PRIx64 " %s %"PRId64, 7782 h2g(min), h2g(max - 1) + 1, 7783 (flags & PAGE_READ) ? 'r' : '-', 7784 (flags & PAGE_WRITE_ORG) ? 'w' : '-', 7785 (flags & PAGE_EXEC) ? 'x' : '-', 7786 e->is_priv ? 'p' : '-', 7787 (uint64_t) e->offset, e->dev, e->inode); 7788 if (path) { 7789 dprintf(fd, "%*s%s\n", 73 - count, "", path); 7790 } else { 7791 dprintf(fd, "\n"); 7792 } 7793 } 7794 } 7795 7796 free_self_maps(map_info); 7797 7798 #ifdef TARGET_VSYSCALL_PAGE 7799 /* 7800 * We only support execution from the vsyscall page. 7801 * This is as if CONFIG_LEGACY_VSYSCALL_XONLY=y from v5.3. 7802 */ 7803 count = dprintf(fd, TARGET_FMT_lx "-" TARGET_FMT_lx 7804 " --xp 00000000 00:00 0", 7805 TARGET_VSYSCALL_PAGE, TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE); 7806 dprintf(fd, "%*s%s\n", 73 - count, "", "[vsyscall]"); 7807 #endif 7808 7809 return 0; 7810 } 7811 7812 static int open_self_stat(void *cpu_env, int fd) 7813 { 7814 CPUState *cpu = env_cpu((CPUArchState *)cpu_env); 7815 TaskState *ts = cpu->opaque; 7816 g_autoptr(GString) buf = g_string_new(NULL); 7817 int i; 7818 7819 for (i = 0; i < 44; i++) { 7820 if (i == 0) { 7821 /* pid */ 7822 g_string_printf(buf, FMT_pid " ", getpid()); 7823 } else if (i == 1) { 7824 /* app name */ 7825 gchar *bin = g_strrstr(ts->bprm->argv[0], "/"); 7826 bin = bin ? bin + 1 : ts->bprm->argv[0]; 7827 g_string_printf(buf, "(%.15s) ", bin); 7828 } else if (i == 3) { 7829 /* ppid */ 7830 g_string_printf(buf, FMT_pid " ", getppid()); 7831 } else if (i == 27) { 7832 /* stack bottom */ 7833 g_string_printf(buf, TARGET_ABI_FMT_ld " ", ts->info->start_stack); 7834 } else { 7835 /* for the rest, there is MasterCard */ 7836 g_string_printf(buf, "0%c", i == 43 ? '\n' : ' '); 7837 } 7838 7839 if (write(fd, buf->str, buf->len) != buf->len) { 7840 return -1; 7841 } 7842 } 7843 7844 return 0; 7845 } 7846 7847 static int open_self_auxv(void *cpu_env, int fd) 7848 { 7849 CPUState *cpu = env_cpu((CPUArchState *)cpu_env); 7850 TaskState *ts = cpu->opaque; 7851 abi_ulong auxv = ts->info->saved_auxv; 7852 abi_ulong len = ts->info->auxv_len; 7853 char *ptr; 7854 7855 /* 7856 * Auxiliary vector is stored in target process stack. 7857 * read in whole auxv vector and copy it to file 7858 */ 7859 ptr = lock_user(VERIFY_READ, auxv, len, 0); 7860 if (ptr != NULL) { 7861 while (len > 0) { 7862 ssize_t r; 7863 r = write(fd, ptr, len); 7864 if (r <= 0) { 7865 break; 7866 } 7867 len -= r; 7868 ptr += r; 7869 } 7870 lseek(fd, 0, SEEK_SET); 7871 unlock_user(ptr, auxv, len); 7872 } 7873 7874 return 0; 7875 } 7876 7877 static int is_proc_myself(const char *filename, const char *entry) 7878 { 7879 if (!strncmp(filename, "/proc/", strlen("/proc/"))) { 7880 filename += strlen("/proc/"); 7881 if (!strncmp(filename, "self/", strlen("self/"))) { 7882 filename += strlen("self/"); 7883 } else if (*filename >= '1' && *filename <= '9') { 7884 char myself[80]; 7885 snprintf(myself, sizeof(myself), "%d/", getpid()); 7886 if (!strncmp(filename, myself, strlen(myself))) { 7887 filename += strlen(myself); 7888 } else { 7889 return 0; 7890 } 7891 } else { 7892 return 0; 7893 } 7894 if (!strcmp(filename, entry)) { 7895 return 1; 7896 } 7897 } 7898 return 0; 7899 } 7900 7901 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) || \ 7902 defined(TARGET_SPARC) || defined(TARGET_M68K) || defined(TARGET_HPPA) 7903 static int is_proc(const char *filename, const char *entry) 7904 { 7905 return strcmp(filename, entry) == 0; 7906 } 7907 #endif 7908 7909 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) 7910 static int open_net_route(void *cpu_env, int fd) 7911 { 7912 FILE *fp; 7913 char *line = NULL; 7914 size_t len = 0; 7915 ssize_t read; 7916 7917 fp = fopen("/proc/net/route", "r"); 7918 if (fp == NULL) { 7919 return -1; 7920 } 7921 7922 /* read header */ 7923 7924 read = getline(&line, &len, fp); 7925 dprintf(fd, "%s", line); 7926 7927 /* read routes */ 7928 7929 while ((read = getline(&line, &len, fp)) != -1) { 7930 char iface[16]; 7931 uint32_t dest, gw, mask; 7932 unsigned int flags, refcnt, use, metric, mtu, window, irtt; 7933 int fields; 7934 7935 fields = sscanf(line, 7936 "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n", 7937 iface, &dest, &gw, &flags, &refcnt, &use, &metric, 7938 &mask, &mtu, &window, &irtt); 7939 if (fields != 11) { 7940 continue; 7941 } 7942 dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n", 7943 iface, tswap32(dest), tswap32(gw), flags, refcnt, use, 7944 metric, tswap32(mask), mtu, window, irtt); 7945 } 7946 7947 free(line); 7948 fclose(fp); 7949 7950 return 0; 7951 } 7952 #endif 7953 7954 #if defined(TARGET_SPARC) 7955 static int open_cpuinfo(void *cpu_env, int fd) 7956 { 7957 dprintf(fd, "type\t\t: sun4u\n"); 7958 return 0; 7959 } 7960 #endif 7961 7962 #if defined(TARGET_HPPA) 7963 static int open_cpuinfo(void *cpu_env, int fd) 7964 { 7965 dprintf(fd, "cpu family\t: PA-RISC 1.1e\n"); 7966 dprintf(fd, "cpu\t\t: PA7300LC (PCX-L2)\n"); 7967 dprintf(fd, "capabilities\t: os32\n"); 7968 dprintf(fd, "model\t\t: 9000/778/B160L\n"); 7969 dprintf(fd, "model name\t: Merlin L2 160 QEMU (9000/778/B160L)\n"); 7970 return 0; 7971 } 7972 #endif 7973 7974 #if defined(TARGET_M68K) 7975 static int open_hardware(void *cpu_env, int fd) 7976 { 7977 dprintf(fd, "Model:\t\tqemu-m68k\n"); 7978 return 0; 7979 } 7980 #endif 7981 7982 static int do_openat(void *cpu_env, int dirfd, const char *pathname, int flags, mode_t mode) 7983 { 7984 struct fake_open { 7985 const char *filename; 7986 int (*fill)(void *cpu_env, int fd); 7987 int (*cmp)(const char *s1, const char *s2); 7988 }; 7989 const struct fake_open *fake_open; 7990 static const struct fake_open fakes[] = { 7991 { "maps", open_self_maps, is_proc_myself }, 7992 { "stat", open_self_stat, is_proc_myself }, 7993 { "auxv", open_self_auxv, is_proc_myself }, 7994 { "cmdline", open_self_cmdline, is_proc_myself }, 7995 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) 7996 { "/proc/net/route", open_net_route, is_proc }, 7997 #endif 7998 #if defined(TARGET_SPARC) || defined(TARGET_HPPA) 7999 { "/proc/cpuinfo", open_cpuinfo, is_proc }, 8000 #endif 8001 #if defined(TARGET_M68K) 8002 { "/proc/hardware", open_hardware, is_proc }, 8003 #endif 8004 { NULL, NULL, NULL } 8005 }; 8006 8007 if (is_proc_myself(pathname, "exe")) { 8008 int execfd = qemu_getauxval(AT_EXECFD); 8009 return execfd ? execfd : safe_openat(dirfd, exec_path, flags, mode); 8010 } 8011 8012 for (fake_open = fakes; fake_open->filename; fake_open++) { 8013 if (fake_open->cmp(pathname, fake_open->filename)) { 8014 break; 8015 } 8016 } 8017 8018 if (fake_open->filename) { 8019 const char *tmpdir; 8020 char filename[PATH_MAX]; 8021 int fd, r; 8022 8023 /* create temporary file to map stat to */ 8024 tmpdir = getenv("TMPDIR"); 8025 if (!tmpdir) 8026 tmpdir = "/tmp"; 8027 snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir); 8028 fd = mkstemp(filename); 8029 if (fd < 0) { 8030 return fd; 8031 } 8032 unlink(filename); 8033 8034 if ((r = fake_open->fill(cpu_env, fd))) { 8035 int e = errno; 8036 close(fd); 8037 errno = e; 8038 return r; 8039 } 8040 lseek(fd, 0, SEEK_SET); 8041 8042 return fd; 8043 } 8044 8045 return safe_openat(dirfd, path(pathname), flags, mode); 8046 } 8047 8048 #define TIMER_MAGIC 0x0caf0000 8049 #define TIMER_MAGIC_MASK 0xffff0000 8050 8051 /* Convert QEMU provided timer ID back to internal 16bit index format */ 8052 static target_timer_t get_timer_id(abi_long arg) 8053 { 8054 target_timer_t timerid = arg; 8055 8056 if ((timerid & TIMER_MAGIC_MASK) != TIMER_MAGIC) { 8057 return -TARGET_EINVAL; 8058 } 8059 8060 timerid &= 0xffff; 8061 8062 if (timerid >= ARRAY_SIZE(g_posix_timers)) { 8063 return -TARGET_EINVAL; 8064 } 8065 8066 return timerid; 8067 } 8068 8069 static int target_to_host_cpu_mask(unsigned long *host_mask, 8070 size_t host_size, 8071 abi_ulong target_addr, 8072 size_t target_size) 8073 { 8074 unsigned target_bits = sizeof(abi_ulong) * 8; 8075 unsigned host_bits = sizeof(*host_mask) * 8; 8076 abi_ulong *target_mask; 8077 unsigned i, j; 8078 8079 assert(host_size >= target_size); 8080 8081 target_mask = lock_user(VERIFY_READ, target_addr, target_size, 1); 8082 if (!target_mask) { 8083 return -TARGET_EFAULT; 8084 } 8085 memset(host_mask, 0, host_size); 8086 8087 for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) { 8088 unsigned bit = i * target_bits; 8089 abi_ulong val; 8090 8091 __get_user(val, &target_mask[i]); 8092 for (j = 0; j < target_bits; j++, bit++) { 8093 if (val & (1UL << j)) { 8094 host_mask[bit / host_bits] |= 1UL << (bit % host_bits); 8095 } 8096 } 8097 } 8098 8099 unlock_user(target_mask, target_addr, 0); 8100 return 0; 8101 } 8102 8103 static int host_to_target_cpu_mask(const unsigned long *host_mask, 8104 size_t host_size, 8105 abi_ulong target_addr, 8106 size_t target_size) 8107 { 8108 unsigned target_bits = sizeof(abi_ulong) * 8; 8109 unsigned host_bits = sizeof(*host_mask) * 8; 8110 abi_ulong *target_mask; 8111 unsigned i, j; 8112 8113 assert(host_size >= target_size); 8114 8115 target_mask = lock_user(VERIFY_WRITE, target_addr, target_size, 0); 8116 if (!target_mask) { 8117 return -TARGET_EFAULT; 8118 } 8119 8120 for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) { 8121 unsigned bit = i * target_bits; 8122 abi_ulong val = 0; 8123 8124 for (j = 0; j < target_bits; j++, bit++) { 8125 if (host_mask[bit / host_bits] & (1UL << (bit % host_bits))) { 8126 val |= 1UL << j; 8127 } 8128 } 8129 __put_user(val, &target_mask[i]); 8130 } 8131 8132 unlock_user(target_mask, target_addr, target_size); 8133 return 0; 8134 } 8135 8136 #if defined(TARGET_NR_pivot_root) && defined(__NR_pivot_root) 8137 _syscall2(int, pivot_root, const char *, new_root, const char *, put_old) 8138 #endif 8139 8140 /* This is an internal helper for do_syscall so that it is easier 8141 * to have a single return point, so that actions, such as logging 8142 * of syscall results, can be performed. 8143 * All errnos that do_syscall() returns must be -TARGET_<errcode>. 8144 */ 8145 static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, 8146 abi_long arg2, abi_long arg3, abi_long arg4, 8147 abi_long arg5, abi_long arg6, abi_long arg7, 8148 abi_long arg8) 8149 { 8150 CPUState *cpu = env_cpu(cpu_env); 8151 abi_long ret; 8152 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \ 8153 || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \ 8154 || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) \ 8155 || defined(TARGET_NR_statx) 8156 struct stat st; 8157 #endif 8158 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \ 8159 || defined(TARGET_NR_fstatfs) 8160 struct statfs stfs; 8161 #endif 8162 void *p; 8163 8164 switch(num) { 8165 case TARGET_NR_exit: 8166 /* In old applications this may be used to implement _exit(2). 8167 However in threaded applications it is used for thread termination, 8168 and _exit_group is used for application termination. 8169 Do thread termination if we have more then one thread. */ 8170 8171 if (block_signals()) { 8172 return -TARGET_ERESTARTSYS; 8173 } 8174 8175 pthread_mutex_lock(&clone_lock); 8176 8177 if (CPU_NEXT(first_cpu)) { 8178 TaskState *ts = cpu->opaque; 8179 8180 object_property_set_bool(OBJECT(cpu), "realized", false, NULL); 8181 object_unref(OBJECT(cpu)); 8182 /* 8183 * At this point the CPU should be unrealized and removed 8184 * from cpu lists. We can clean-up the rest of the thread 8185 * data without the lock held. 8186 */ 8187 8188 pthread_mutex_unlock(&clone_lock); 8189 8190 if (ts->child_tidptr) { 8191 put_user_u32(0, ts->child_tidptr); 8192 do_sys_futex(g2h(cpu, ts->child_tidptr), 8193 FUTEX_WAKE, INT_MAX, NULL, NULL, 0); 8194 } 8195 thread_cpu = NULL; 8196 g_free(ts); 8197 rcu_unregister_thread(); 8198 pthread_exit(NULL); 8199 } 8200 8201 pthread_mutex_unlock(&clone_lock); 8202 preexit_cleanup(cpu_env, arg1); 8203 _exit(arg1); 8204 return 0; /* avoid warning */ 8205 case TARGET_NR_read: 8206 if (arg2 == 0 && arg3 == 0) { 8207 return get_errno(safe_read(arg1, 0, 0)); 8208 } else { 8209 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0))) 8210 return -TARGET_EFAULT; 8211 ret = get_errno(safe_read(arg1, p, arg3)); 8212 if (ret >= 0 && 8213 fd_trans_host_to_target_data(arg1)) { 8214 ret = fd_trans_host_to_target_data(arg1)(p, ret); 8215 } 8216 unlock_user(p, arg2, ret); 8217 } 8218 return ret; 8219 case TARGET_NR_write: 8220 if (arg2 == 0 && arg3 == 0) { 8221 return get_errno(safe_write(arg1, 0, 0)); 8222 } 8223 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1))) 8224 return -TARGET_EFAULT; 8225 if (fd_trans_target_to_host_data(arg1)) { 8226 void *copy = g_malloc(arg3); 8227 memcpy(copy, p, arg3); 8228 ret = fd_trans_target_to_host_data(arg1)(copy, arg3); 8229 if (ret >= 0) { 8230 ret = get_errno(safe_write(arg1, copy, ret)); 8231 } 8232 g_free(copy); 8233 } else { 8234 ret = get_errno(safe_write(arg1, p, arg3)); 8235 } 8236 unlock_user(p, arg2, 0); 8237 return ret; 8238 8239 #ifdef TARGET_NR_open 8240 case TARGET_NR_open: 8241 if (!(p = lock_user_string(arg1))) 8242 return -TARGET_EFAULT; 8243 ret = get_errno(do_openat(cpu_env, AT_FDCWD, p, 8244 target_to_host_bitmask(arg2, fcntl_flags_tbl), 8245 arg3)); 8246 fd_trans_unregister(ret); 8247 unlock_user(p, arg1, 0); 8248 return ret; 8249 #endif 8250 case TARGET_NR_openat: 8251 if (!(p = lock_user_string(arg2))) 8252 return -TARGET_EFAULT; 8253 ret = get_errno(do_openat(cpu_env, arg1, p, 8254 target_to_host_bitmask(arg3, fcntl_flags_tbl), 8255 arg4)); 8256 fd_trans_unregister(ret); 8257 unlock_user(p, arg2, 0); 8258 return ret; 8259 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE) 8260 case TARGET_NR_name_to_handle_at: 8261 ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5); 8262 return ret; 8263 #endif 8264 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE) 8265 case TARGET_NR_open_by_handle_at: 8266 ret = do_open_by_handle_at(arg1, arg2, arg3); 8267 fd_trans_unregister(ret); 8268 return ret; 8269 #endif 8270 case TARGET_NR_close: 8271 fd_trans_unregister(arg1); 8272 return get_errno(close(arg1)); 8273 8274 case TARGET_NR_brk: 8275 return do_brk(arg1); 8276 #ifdef TARGET_NR_fork 8277 case TARGET_NR_fork: 8278 return get_errno(do_fork(cpu_env, TARGET_SIGCHLD, 0, 0, 0, 0)); 8279 #endif 8280 #ifdef TARGET_NR_waitpid 8281 case TARGET_NR_waitpid: 8282 { 8283 int status; 8284 ret = get_errno(safe_wait4(arg1, &status, arg3, 0)); 8285 if (!is_error(ret) && arg2 && ret 8286 && put_user_s32(host_to_target_waitstatus(status), arg2)) 8287 return -TARGET_EFAULT; 8288 } 8289 return ret; 8290 #endif 8291 #ifdef TARGET_NR_waitid 8292 case TARGET_NR_waitid: 8293 { 8294 siginfo_t info; 8295 info.si_pid = 0; 8296 ret = get_errno(safe_waitid(arg1, arg2, &info, arg4, NULL)); 8297 if (!is_error(ret) && arg3 && info.si_pid != 0) { 8298 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0))) 8299 return -TARGET_EFAULT; 8300 host_to_target_siginfo(p, &info); 8301 unlock_user(p, arg3, sizeof(target_siginfo_t)); 8302 } 8303 } 8304 return ret; 8305 #endif 8306 #ifdef TARGET_NR_creat /* not on alpha */ 8307 case TARGET_NR_creat: 8308 if (!(p = lock_user_string(arg1))) 8309 return -TARGET_EFAULT; 8310 ret = get_errno(creat(p, arg2)); 8311 fd_trans_unregister(ret); 8312 unlock_user(p, arg1, 0); 8313 return ret; 8314 #endif 8315 #ifdef TARGET_NR_link 8316 case TARGET_NR_link: 8317 { 8318 void * p2; 8319 p = lock_user_string(arg1); 8320 p2 = lock_user_string(arg2); 8321 if (!p || !p2) 8322 ret = -TARGET_EFAULT; 8323 else 8324 ret = get_errno(link(p, p2)); 8325 unlock_user(p2, arg2, 0); 8326 unlock_user(p, arg1, 0); 8327 } 8328 return ret; 8329 #endif 8330 #if defined(TARGET_NR_linkat) 8331 case TARGET_NR_linkat: 8332 { 8333 void * p2 = NULL; 8334 if (!arg2 || !arg4) 8335 return -TARGET_EFAULT; 8336 p = lock_user_string(arg2); 8337 p2 = lock_user_string(arg4); 8338 if (!p || !p2) 8339 ret = -TARGET_EFAULT; 8340 else 8341 ret = get_errno(linkat(arg1, p, arg3, p2, arg5)); 8342 unlock_user(p, arg2, 0); 8343 unlock_user(p2, arg4, 0); 8344 } 8345 return ret; 8346 #endif 8347 #ifdef TARGET_NR_unlink 8348 case TARGET_NR_unlink: 8349 if (!(p = lock_user_string(arg1))) 8350 return -TARGET_EFAULT; 8351 ret = get_errno(unlink(p)); 8352 unlock_user(p, arg1, 0); 8353 return ret; 8354 #endif 8355 #if defined(TARGET_NR_unlinkat) 8356 case TARGET_NR_unlinkat: 8357 if (!(p = lock_user_string(arg2))) 8358 return -TARGET_EFAULT; 8359 ret = get_errno(unlinkat(arg1, p, arg3)); 8360 unlock_user(p, arg2, 0); 8361 return ret; 8362 #endif 8363 case TARGET_NR_execve: 8364 { 8365 char **argp, **envp; 8366 int argc, envc; 8367 abi_ulong gp; 8368 abi_ulong guest_argp; 8369 abi_ulong guest_envp; 8370 abi_ulong addr; 8371 char **q; 8372 8373 argc = 0; 8374 guest_argp = arg2; 8375 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) { 8376 if (get_user_ual(addr, gp)) 8377 return -TARGET_EFAULT; 8378 if (!addr) 8379 break; 8380 argc++; 8381 } 8382 envc = 0; 8383 guest_envp = arg3; 8384 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) { 8385 if (get_user_ual(addr, gp)) 8386 return -TARGET_EFAULT; 8387 if (!addr) 8388 break; 8389 envc++; 8390 } 8391 8392 argp = g_new0(char *, argc + 1); 8393 envp = g_new0(char *, envc + 1); 8394 8395 for (gp = guest_argp, q = argp; gp; 8396 gp += sizeof(abi_ulong), q++) { 8397 if (get_user_ual(addr, gp)) 8398 goto execve_efault; 8399 if (!addr) 8400 break; 8401 if (!(*q = lock_user_string(addr))) 8402 goto execve_efault; 8403 } 8404 *q = NULL; 8405 8406 for (gp = guest_envp, q = envp; gp; 8407 gp += sizeof(abi_ulong), q++) { 8408 if (get_user_ual(addr, gp)) 8409 goto execve_efault; 8410 if (!addr) 8411 break; 8412 if (!(*q = lock_user_string(addr))) 8413 goto execve_efault; 8414 } 8415 *q = NULL; 8416 8417 if (!(p = lock_user_string(arg1))) 8418 goto execve_efault; 8419 /* Although execve() is not an interruptible syscall it is 8420 * a special case where we must use the safe_syscall wrapper: 8421 * if we allow a signal to happen before we make the host 8422 * syscall then we will 'lose' it, because at the point of 8423 * execve the process leaves QEMU's control. So we use the 8424 * safe syscall wrapper to ensure that we either take the 8425 * signal as a guest signal, or else it does not happen 8426 * before the execve completes and makes it the other 8427 * program's problem. 8428 */ 8429 ret = get_errno(safe_execve(p, argp, envp)); 8430 unlock_user(p, arg1, 0); 8431 8432 goto execve_end; 8433 8434 execve_efault: 8435 ret = -TARGET_EFAULT; 8436 8437 execve_end: 8438 for (gp = guest_argp, q = argp; *q; 8439 gp += sizeof(abi_ulong), q++) { 8440 if (get_user_ual(addr, gp) 8441 || !addr) 8442 break; 8443 unlock_user(*q, addr, 0); 8444 } 8445 for (gp = guest_envp, q = envp; *q; 8446 gp += sizeof(abi_ulong), q++) { 8447 if (get_user_ual(addr, gp) 8448 || !addr) 8449 break; 8450 unlock_user(*q, addr, 0); 8451 } 8452 8453 g_free(argp); 8454 g_free(envp); 8455 } 8456 return ret; 8457 case TARGET_NR_chdir: 8458 if (!(p = lock_user_string(arg1))) 8459 return -TARGET_EFAULT; 8460 ret = get_errno(chdir(p)); 8461 unlock_user(p, arg1, 0); 8462 return ret; 8463 #ifdef TARGET_NR_time 8464 case TARGET_NR_time: 8465 { 8466 time_t host_time; 8467 ret = get_errno(time(&host_time)); 8468 if (!is_error(ret) 8469 && arg1 8470 && put_user_sal(host_time, arg1)) 8471 return -TARGET_EFAULT; 8472 } 8473 return ret; 8474 #endif 8475 #ifdef TARGET_NR_mknod 8476 case TARGET_NR_mknod: 8477 if (!(p = lock_user_string(arg1))) 8478 return -TARGET_EFAULT; 8479 ret = get_errno(mknod(p, arg2, arg3)); 8480 unlock_user(p, arg1, 0); 8481 return ret; 8482 #endif 8483 #if defined(TARGET_NR_mknodat) 8484 case TARGET_NR_mknodat: 8485 if (!(p = lock_user_string(arg2))) 8486 return -TARGET_EFAULT; 8487 ret = get_errno(mknodat(arg1, p, arg3, arg4)); 8488 unlock_user(p, arg2, 0); 8489 return ret; 8490 #endif 8491 #ifdef TARGET_NR_chmod 8492 case TARGET_NR_chmod: 8493 if (!(p = lock_user_string(arg1))) 8494 return -TARGET_EFAULT; 8495 ret = get_errno(chmod(p, arg2)); 8496 unlock_user(p, arg1, 0); 8497 return ret; 8498 #endif 8499 #ifdef TARGET_NR_lseek 8500 case TARGET_NR_lseek: 8501 return get_errno(lseek(arg1, arg2, arg3)); 8502 #endif 8503 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA) 8504 /* Alpha specific */ 8505 case TARGET_NR_getxpid: 8506 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid(); 8507 return get_errno(getpid()); 8508 #endif 8509 #ifdef TARGET_NR_getpid 8510 case TARGET_NR_getpid: 8511 return get_errno(getpid()); 8512 #endif 8513 case TARGET_NR_mount: 8514 { 8515 /* need to look at the data field */ 8516 void *p2, *p3; 8517 8518 if (arg1) { 8519 p = lock_user_string(arg1); 8520 if (!p) { 8521 return -TARGET_EFAULT; 8522 } 8523 } else { 8524 p = NULL; 8525 } 8526 8527 p2 = lock_user_string(arg2); 8528 if (!p2) { 8529 if (arg1) { 8530 unlock_user(p, arg1, 0); 8531 } 8532 return -TARGET_EFAULT; 8533 } 8534 8535 if (arg3) { 8536 p3 = lock_user_string(arg3); 8537 if (!p3) { 8538 if (arg1) { 8539 unlock_user(p, arg1, 0); 8540 } 8541 unlock_user(p2, arg2, 0); 8542 return -TARGET_EFAULT; 8543 } 8544 } else { 8545 p3 = NULL; 8546 } 8547 8548 /* FIXME - arg5 should be locked, but it isn't clear how to 8549 * do that since it's not guaranteed to be a NULL-terminated 8550 * string. 8551 */ 8552 if (!arg5) { 8553 ret = mount(p, p2, p3, (unsigned long)arg4, NULL); 8554 } else { 8555 ret = mount(p, p2, p3, (unsigned long)arg4, g2h(cpu, arg5)); 8556 } 8557 ret = get_errno(ret); 8558 8559 if (arg1) { 8560 unlock_user(p, arg1, 0); 8561 } 8562 unlock_user(p2, arg2, 0); 8563 if (arg3) { 8564 unlock_user(p3, arg3, 0); 8565 } 8566 } 8567 return ret; 8568 #if defined(TARGET_NR_umount) || defined(TARGET_NR_oldumount) 8569 #if defined(TARGET_NR_umount) 8570 case TARGET_NR_umount: 8571 #endif 8572 #if defined(TARGET_NR_oldumount) 8573 case TARGET_NR_oldumount: 8574 #endif 8575 if (!(p = lock_user_string(arg1))) 8576 return -TARGET_EFAULT; 8577 ret = get_errno(umount(p)); 8578 unlock_user(p, arg1, 0); 8579 return ret; 8580 #endif 8581 #ifdef TARGET_NR_stime /* not on alpha */ 8582 case TARGET_NR_stime: 8583 { 8584 struct timespec ts; 8585 ts.tv_nsec = 0; 8586 if (get_user_sal(ts.tv_sec, arg1)) { 8587 return -TARGET_EFAULT; 8588 } 8589 return get_errno(clock_settime(CLOCK_REALTIME, &ts)); 8590 } 8591 #endif 8592 #ifdef TARGET_NR_alarm /* not on alpha */ 8593 case TARGET_NR_alarm: 8594 return alarm(arg1); 8595 #endif 8596 #ifdef TARGET_NR_pause /* not on alpha */ 8597 case TARGET_NR_pause: 8598 if (!block_signals()) { 8599 sigsuspend(&((TaskState *)cpu->opaque)->signal_mask); 8600 } 8601 return -TARGET_EINTR; 8602 #endif 8603 #ifdef TARGET_NR_utime 8604 case TARGET_NR_utime: 8605 { 8606 struct utimbuf tbuf, *host_tbuf; 8607 struct target_utimbuf *target_tbuf; 8608 if (arg2) { 8609 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1)) 8610 return -TARGET_EFAULT; 8611 tbuf.actime = tswapal(target_tbuf->actime); 8612 tbuf.modtime = tswapal(target_tbuf->modtime); 8613 unlock_user_struct(target_tbuf, arg2, 0); 8614 host_tbuf = &tbuf; 8615 } else { 8616 host_tbuf = NULL; 8617 } 8618 if (!(p = lock_user_string(arg1))) 8619 return -TARGET_EFAULT; 8620 ret = get_errno(utime(p, host_tbuf)); 8621 unlock_user(p, arg1, 0); 8622 } 8623 return ret; 8624 #endif 8625 #ifdef TARGET_NR_utimes 8626 case TARGET_NR_utimes: 8627 { 8628 struct timeval *tvp, tv[2]; 8629 if (arg2) { 8630 if (copy_from_user_timeval(&tv[0], arg2) 8631 || copy_from_user_timeval(&tv[1], 8632 arg2 + sizeof(struct target_timeval))) 8633 return -TARGET_EFAULT; 8634 tvp = tv; 8635 } else { 8636 tvp = NULL; 8637 } 8638 if (!(p = lock_user_string(arg1))) 8639 return -TARGET_EFAULT; 8640 ret = get_errno(utimes(p, tvp)); 8641 unlock_user(p, arg1, 0); 8642 } 8643 return ret; 8644 #endif 8645 #if defined(TARGET_NR_futimesat) 8646 case TARGET_NR_futimesat: 8647 { 8648 struct timeval *tvp, tv[2]; 8649 if (arg3) { 8650 if (copy_from_user_timeval(&tv[0], arg3) 8651 || copy_from_user_timeval(&tv[1], 8652 arg3 + sizeof(struct target_timeval))) 8653 return -TARGET_EFAULT; 8654 tvp = tv; 8655 } else { 8656 tvp = NULL; 8657 } 8658 if (!(p = lock_user_string(arg2))) { 8659 return -TARGET_EFAULT; 8660 } 8661 ret = get_errno(futimesat(arg1, path(p), tvp)); 8662 unlock_user(p, arg2, 0); 8663 } 8664 return ret; 8665 #endif 8666 #ifdef TARGET_NR_access 8667 case TARGET_NR_access: 8668 if (!(p = lock_user_string(arg1))) { 8669 return -TARGET_EFAULT; 8670 } 8671 ret = get_errno(access(path(p), arg2)); 8672 unlock_user(p, arg1, 0); 8673 return ret; 8674 #endif 8675 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat) 8676 case TARGET_NR_faccessat: 8677 if (!(p = lock_user_string(arg2))) { 8678 return -TARGET_EFAULT; 8679 } 8680 ret = get_errno(faccessat(arg1, p, arg3, 0)); 8681 unlock_user(p, arg2, 0); 8682 return ret; 8683 #endif 8684 #ifdef TARGET_NR_nice /* not on alpha */ 8685 case TARGET_NR_nice: 8686 return get_errno(nice(arg1)); 8687 #endif 8688 case TARGET_NR_sync: 8689 sync(); 8690 return 0; 8691 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS) 8692 case TARGET_NR_syncfs: 8693 return get_errno(syncfs(arg1)); 8694 #endif 8695 case TARGET_NR_kill: 8696 return get_errno(safe_kill(arg1, target_to_host_signal(arg2))); 8697 #ifdef TARGET_NR_rename 8698 case TARGET_NR_rename: 8699 { 8700 void *p2; 8701 p = lock_user_string(arg1); 8702 p2 = lock_user_string(arg2); 8703 if (!p || !p2) 8704 ret = -TARGET_EFAULT; 8705 else 8706 ret = get_errno(rename(p, p2)); 8707 unlock_user(p2, arg2, 0); 8708 unlock_user(p, arg1, 0); 8709 } 8710 return ret; 8711 #endif 8712 #if defined(TARGET_NR_renameat) 8713 case TARGET_NR_renameat: 8714 { 8715 void *p2; 8716 p = lock_user_string(arg2); 8717 p2 = lock_user_string(arg4); 8718 if (!p || !p2) 8719 ret = -TARGET_EFAULT; 8720 else 8721 ret = get_errno(renameat(arg1, p, arg3, p2)); 8722 unlock_user(p2, arg4, 0); 8723 unlock_user(p, arg2, 0); 8724 } 8725 return ret; 8726 #endif 8727 #if defined(TARGET_NR_renameat2) 8728 case TARGET_NR_renameat2: 8729 { 8730 void *p2; 8731 p = lock_user_string(arg2); 8732 p2 = lock_user_string(arg4); 8733 if (!p || !p2) { 8734 ret = -TARGET_EFAULT; 8735 } else { 8736 ret = get_errno(sys_renameat2(arg1, p, arg3, p2, arg5)); 8737 } 8738 unlock_user(p2, arg4, 0); 8739 unlock_user(p, arg2, 0); 8740 } 8741 return ret; 8742 #endif 8743 #ifdef TARGET_NR_mkdir 8744 case TARGET_NR_mkdir: 8745 if (!(p = lock_user_string(arg1))) 8746 return -TARGET_EFAULT; 8747 ret = get_errno(mkdir(p, arg2)); 8748 unlock_user(p, arg1, 0); 8749 return ret; 8750 #endif 8751 #if defined(TARGET_NR_mkdirat) 8752 case TARGET_NR_mkdirat: 8753 if (!(p = lock_user_string(arg2))) 8754 return -TARGET_EFAULT; 8755 ret = get_errno(mkdirat(arg1, p, arg3)); 8756 unlock_user(p, arg2, 0); 8757 return ret; 8758 #endif 8759 #ifdef TARGET_NR_rmdir 8760 case TARGET_NR_rmdir: 8761 if (!(p = lock_user_string(arg1))) 8762 return -TARGET_EFAULT; 8763 ret = get_errno(rmdir(p)); 8764 unlock_user(p, arg1, 0); 8765 return ret; 8766 #endif 8767 case TARGET_NR_dup: 8768 ret = get_errno(dup(arg1)); 8769 if (ret >= 0) { 8770 fd_trans_dup(arg1, ret); 8771 } 8772 return ret; 8773 #ifdef TARGET_NR_pipe 8774 case TARGET_NR_pipe: 8775 return do_pipe(cpu_env, arg1, 0, 0); 8776 #endif 8777 #ifdef TARGET_NR_pipe2 8778 case TARGET_NR_pipe2: 8779 return do_pipe(cpu_env, arg1, 8780 target_to_host_bitmask(arg2, fcntl_flags_tbl), 1); 8781 #endif 8782 case TARGET_NR_times: 8783 { 8784 struct target_tms *tmsp; 8785 struct tms tms; 8786 ret = get_errno(times(&tms)); 8787 if (arg1) { 8788 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0); 8789 if (!tmsp) 8790 return -TARGET_EFAULT; 8791 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime)); 8792 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime)); 8793 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime)); 8794 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime)); 8795 } 8796 if (!is_error(ret)) 8797 ret = host_to_target_clock_t(ret); 8798 } 8799 return ret; 8800 case TARGET_NR_acct: 8801 if (arg1 == 0) { 8802 ret = get_errno(acct(NULL)); 8803 } else { 8804 if (!(p = lock_user_string(arg1))) { 8805 return -TARGET_EFAULT; 8806 } 8807 ret = get_errno(acct(path(p))); 8808 unlock_user(p, arg1, 0); 8809 } 8810 return ret; 8811 #ifdef TARGET_NR_umount2 8812 case TARGET_NR_umount2: 8813 if (!(p = lock_user_string(arg1))) 8814 return -TARGET_EFAULT; 8815 ret = get_errno(umount2(p, arg2)); 8816 unlock_user(p, arg1, 0); 8817 return ret; 8818 #endif 8819 case TARGET_NR_ioctl: 8820 return do_ioctl(arg1, arg2, arg3); 8821 #ifdef TARGET_NR_fcntl 8822 case TARGET_NR_fcntl: 8823 return do_fcntl(arg1, arg2, arg3); 8824 #endif 8825 case TARGET_NR_setpgid: 8826 return get_errno(setpgid(arg1, arg2)); 8827 case TARGET_NR_umask: 8828 return get_errno(umask(arg1)); 8829 case TARGET_NR_chroot: 8830 if (!(p = lock_user_string(arg1))) 8831 return -TARGET_EFAULT; 8832 ret = get_errno(chroot(p)); 8833 unlock_user(p, arg1, 0); 8834 return ret; 8835 #ifdef TARGET_NR_dup2 8836 case TARGET_NR_dup2: 8837 ret = get_errno(dup2(arg1, arg2)); 8838 if (ret >= 0) { 8839 fd_trans_dup(arg1, arg2); 8840 } 8841 return ret; 8842 #endif 8843 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3) 8844 case TARGET_NR_dup3: 8845 { 8846 int host_flags; 8847 8848 if ((arg3 & ~TARGET_O_CLOEXEC) != 0) { 8849 return -EINVAL; 8850 } 8851 host_flags = target_to_host_bitmask(arg3, fcntl_flags_tbl); 8852 ret = get_errno(dup3(arg1, arg2, host_flags)); 8853 if (ret >= 0) { 8854 fd_trans_dup(arg1, arg2); 8855 } 8856 return ret; 8857 } 8858 #endif 8859 #ifdef TARGET_NR_getppid /* not on alpha */ 8860 case TARGET_NR_getppid: 8861 return get_errno(getppid()); 8862 #endif 8863 #ifdef TARGET_NR_getpgrp 8864 case TARGET_NR_getpgrp: 8865 return get_errno(getpgrp()); 8866 #endif 8867 case TARGET_NR_setsid: 8868 return get_errno(setsid()); 8869 #ifdef TARGET_NR_sigaction 8870 case TARGET_NR_sigaction: 8871 { 8872 #if defined(TARGET_MIPS) 8873 struct target_sigaction act, oact, *pact, *old_act; 8874 8875 if (arg2) { 8876 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1)) 8877 return -TARGET_EFAULT; 8878 act._sa_handler = old_act->_sa_handler; 8879 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]); 8880 act.sa_flags = old_act->sa_flags; 8881 unlock_user_struct(old_act, arg2, 0); 8882 pact = &act; 8883 } else { 8884 pact = NULL; 8885 } 8886 8887 ret = get_errno(do_sigaction(arg1, pact, &oact, 0)); 8888 8889 if (!is_error(ret) && arg3) { 8890 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0)) 8891 return -TARGET_EFAULT; 8892 old_act->_sa_handler = oact._sa_handler; 8893 old_act->sa_flags = oact.sa_flags; 8894 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0]; 8895 old_act->sa_mask.sig[1] = 0; 8896 old_act->sa_mask.sig[2] = 0; 8897 old_act->sa_mask.sig[3] = 0; 8898 unlock_user_struct(old_act, arg3, 1); 8899 } 8900 #else 8901 struct target_old_sigaction *old_act; 8902 struct target_sigaction act, oact, *pact; 8903 if (arg2) { 8904 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1)) 8905 return -TARGET_EFAULT; 8906 act._sa_handler = old_act->_sa_handler; 8907 target_siginitset(&act.sa_mask, old_act->sa_mask); 8908 act.sa_flags = old_act->sa_flags; 8909 #ifdef TARGET_ARCH_HAS_SA_RESTORER 8910 act.sa_restorer = old_act->sa_restorer; 8911 #endif 8912 unlock_user_struct(old_act, arg2, 0); 8913 pact = &act; 8914 } else { 8915 pact = NULL; 8916 } 8917 ret = get_errno(do_sigaction(arg1, pact, &oact, 0)); 8918 if (!is_error(ret) && arg3) { 8919 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0)) 8920 return -TARGET_EFAULT; 8921 old_act->_sa_handler = oact._sa_handler; 8922 old_act->sa_mask = oact.sa_mask.sig[0]; 8923 old_act->sa_flags = oact.sa_flags; 8924 #ifdef TARGET_ARCH_HAS_SA_RESTORER 8925 old_act->sa_restorer = oact.sa_restorer; 8926 #endif 8927 unlock_user_struct(old_act, arg3, 1); 8928 } 8929 #endif 8930 } 8931 return ret; 8932 #endif 8933 case TARGET_NR_rt_sigaction: 8934 { 8935 /* 8936 * For Alpha and SPARC this is a 5 argument syscall, with 8937 * a 'restorer' parameter which must be copied into the 8938 * sa_restorer field of the sigaction struct. 8939 * For Alpha that 'restorer' is arg5; for SPARC it is arg4, 8940 * and arg5 is the sigsetsize. 8941 */ 8942 #if defined(TARGET_ALPHA) 8943 target_ulong sigsetsize = arg4; 8944 target_ulong restorer = arg5; 8945 #elif defined(TARGET_SPARC) 8946 target_ulong restorer = arg4; 8947 target_ulong sigsetsize = arg5; 8948 #else 8949 target_ulong sigsetsize = arg4; 8950 target_ulong restorer = 0; 8951 #endif 8952 struct target_sigaction *act = NULL; 8953 struct target_sigaction *oact = NULL; 8954 8955 if (sigsetsize != sizeof(target_sigset_t)) { 8956 return -TARGET_EINVAL; 8957 } 8958 if (arg2 && !lock_user_struct(VERIFY_READ, act, arg2, 1)) { 8959 return -TARGET_EFAULT; 8960 } 8961 if (arg3 && !lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) { 8962 ret = -TARGET_EFAULT; 8963 } else { 8964 ret = get_errno(do_sigaction(arg1, act, oact, restorer)); 8965 if (oact) { 8966 unlock_user_struct(oact, arg3, 1); 8967 } 8968 } 8969 if (act) { 8970 unlock_user_struct(act, arg2, 0); 8971 } 8972 } 8973 return ret; 8974 #ifdef TARGET_NR_sgetmask /* not on alpha */ 8975 case TARGET_NR_sgetmask: 8976 { 8977 sigset_t cur_set; 8978 abi_ulong target_set; 8979 ret = do_sigprocmask(0, NULL, &cur_set); 8980 if (!ret) { 8981 host_to_target_old_sigset(&target_set, &cur_set); 8982 ret = target_set; 8983 } 8984 } 8985 return ret; 8986 #endif 8987 #ifdef TARGET_NR_ssetmask /* not on alpha */ 8988 case TARGET_NR_ssetmask: 8989 { 8990 sigset_t set, oset; 8991 abi_ulong target_set = arg1; 8992 target_to_host_old_sigset(&set, &target_set); 8993 ret = do_sigprocmask(SIG_SETMASK, &set, &oset); 8994 if (!ret) { 8995 host_to_target_old_sigset(&target_set, &oset); 8996 ret = target_set; 8997 } 8998 } 8999 return ret; 9000 #endif 9001 #ifdef TARGET_NR_sigprocmask 9002 case TARGET_NR_sigprocmask: 9003 { 9004 #if defined(TARGET_ALPHA) 9005 sigset_t set, oldset; 9006 abi_ulong mask; 9007 int how; 9008 9009 switch (arg1) { 9010 case TARGET_SIG_BLOCK: 9011 how = SIG_BLOCK; 9012 break; 9013 case TARGET_SIG_UNBLOCK: 9014 how = SIG_UNBLOCK; 9015 break; 9016 case TARGET_SIG_SETMASK: 9017 how = SIG_SETMASK; 9018 break; 9019 default: 9020 return -TARGET_EINVAL; 9021 } 9022 mask = arg2; 9023 target_to_host_old_sigset(&set, &mask); 9024 9025 ret = do_sigprocmask(how, &set, &oldset); 9026 if (!is_error(ret)) { 9027 host_to_target_old_sigset(&mask, &oldset); 9028 ret = mask; 9029 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */ 9030 } 9031 #else 9032 sigset_t set, oldset, *set_ptr; 9033 int how; 9034 9035 if (arg2) { 9036 switch (arg1) { 9037 case TARGET_SIG_BLOCK: 9038 how = SIG_BLOCK; 9039 break; 9040 case TARGET_SIG_UNBLOCK: 9041 how = SIG_UNBLOCK; 9042 break; 9043 case TARGET_SIG_SETMASK: 9044 how = SIG_SETMASK; 9045 break; 9046 default: 9047 return -TARGET_EINVAL; 9048 } 9049 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1))) 9050 return -TARGET_EFAULT; 9051 target_to_host_old_sigset(&set, p); 9052 unlock_user(p, arg2, 0); 9053 set_ptr = &set; 9054 } else { 9055 how = 0; 9056 set_ptr = NULL; 9057 } 9058 ret = do_sigprocmask(how, set_ptr, &oldset); 9059 if (!is_error(ret) && arg3) { 9060 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 9061 return -TARGET_EFAULT; 9062 host_to_target_old_sigset(p, &oldset); 9063 unlock_user(p, arg3, sizeof(target_sigset_t)); 9064 } 9065 #endif 9066 } 9067 return ret; 9068 #endif 9069 case TARGET_NR_rt_sigprocmask: 9070 { 9071 int how = arg1; 9072 sigset_t set, oldset, *set_ptr; 9073 9074 if (arg4 != sizeof(target_sigset_t)) { 9075 return -TARGET_EINVAL; 9076 } 9077 9078 if (arg2) { 9079 switch(how) { 9080 case TARGET_SIG_BLOCK: 9081 how = SIG_BLOCK; 9082 break; 9083 case TARGET_SIG_UNBLOCK: 9084 how = SIG_UNBLOCK; 9085 break; 9086 case TARGET_SIG_SETMASK: 9087 how = SIG_SETMASK; 9088 break; 9089 default: 9090 return -TARGET_EINVAL; 9091 } 9092 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1))) 9093 return -TARGET_EFAULT; 9094 target_to_host_sigset(&set, p); 9095 unlock_user(p, arg2, 0); 9096 set_ptr = &set; 9097 } else { 9098 how = 0; 9099 set_ptr = NULL; 9100 } 9101 ret = do_sigprocmask(how, set_ptr, &oldset); 9102 if (!is_error(ret) && arg3) { 9103 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 9104 return -TARGET_EFAULT; 9105 host_to_target_sigset(p, &oldset); 9106 unlock_user(p, arg3, sizeof(target_sigset_t)); 9107 } 9108 } 9109 return ret; 9110 #ifdef TARGET_NR_sigpending 9111 case TARGET_NR_sigpending: 9112 { 9113 sigset_t set; 9114 ret = get_errno(sigpending(&set)); 9115 if (!is_error(ret)) { 9116 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 9117 return -TARGET_EFAULT; 9118 host_to_target_old_sigset(p, &set); 9119 unlock_user(p, arg1, sizeof(target_sigset_t)); 9120 } 9121 } 9122 return ret; 9123 #endif 9124 case TARGET_NR_rt_sigpending: 9125 { 9126 sigset_t set; 9127 9128 /* Yes, this check is >, not != like most. We follow the kernel's 9129 * logic and it does it like this because it implements 9130 * NR_sigpending through the same code path, and in that case 9131 * the old_sigset_t is smaller in size. 9132 */ 9133 if (arg2 > sizeof(target_sigset_t)) { 9134 return -TARGET_EINVAL; 9135 } 9136 9137 ret = get_errno(sigpending(&set)); 9138 if (!is_error(ret)) { 9139 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 9140 return -TARGET_EFAULT; 9141 host_to_target_sigset(p, &set); 9142 unlock_user(p, arg1, sizeof(target_sigset_t)); 9143 } 9144 } 9145 return ret; 9146 #ifdef TARGET_NR_sigsuspend 9147 case TARGET_NR_sigsuspend: 9148 { 9149 TaskState *ts = cpu->opaque; 9150 #if defined(TARGET_ALPHA) 9151 abi_ulong mask = arg1; 9152 target_to_host_old_sigset(&ts->sigsuspend_mask, &mask); 9153 #else 9154 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9155 return -TARGET_EFAULT; 9156 target_to_host_old_sigset(&ts->sigsuspend_mask, p); 9157 unlock_user(p, arg1, 0); 9158 #endif 9159 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask, 9160 SIGSET_T_SIZE)); 9161 if (ret != -TARGET_ERESTARTSYS) { 9162 ts->in_sigsuspend = 1; 9163 } 9164 } 9165 return ret; 9166 #endif 9167 case TARGET_NR_rt_sigsuspend: 9168 { 9169 TaskState *ts = cpu->opaque; 9170 9171 if (arg2 != sizeof(target_sigset_t)) { 9172 return -TARGET_EINVAL; 9173 } 9174 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9175 return -TARGET_EFAULT; 9176 target_to_host_sigset(&ts->sigsuspend_mask, p); 9177 unlock_user(p, arg1, 0); 9178 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask, 9179 SIGSET_T_SIZE)); 9180 if (ret != -TARGET_ERESTARTSYS) { 9181 ts->in_sigsuspend = 1; 9182 } 9183 } 9184 return ret; 9185 #ifdef TARGET_NR_rt_sigtimedwait 9186 case TARGET_NR_rt_sigtimedwait: 9187 { 9188 sigset_t set; 9189 struct timespec uts, *puts; 9190 siginfo_t uinfo; 9191 9192 if (arg4 != sizeof(target_sigset_t)) { 9193 return -TARGET_EINVAL; 9194 } 9195 9196 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9197 return -TARGET_EFAULT; 9198 target_to_host_sigset(&set, p); 9199 unlock_user(p, arg1, 0); 9200 if (arg3) { 9201 puts = &uts; 9202 if (target_to_host_timespec(puts, arg3)) { 9203 return -TARGET_EFAULT; 9204 } 9205 } else { 9206 puts = NULL; 9207 } 9208 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts, 9209 SIGSET_T_SIZE)); 9210 if (!is_error(ret)) { 9211 if (arg2) { 9212 p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 9213 0); 9214 if (!p) { 9215 return -TARGET_EFAULT; 9216 } 9217 host_to_target_siginfo(p, &uinfo); 9218 unlock_user(p, arg2, sizeof(target_siginfo_t)); 9219 } 9220 ret = host_to_target_signal(ret); 9221 } 9222 } 9223 return ret; 9224 #endif 9225 #ifdef TARGET_NR_rt_sigtimedwait_time64 9226 case TARGET_NR_rt_sigtimedwait_time64: 9227 { 9228 sigset_t set; 9229 struct timespec uts, *puts; 9230 siginfo_t uinfo; 9231 9232 if (arg4 != sizeof(target_sigset_t)) { 9233 return -TARGET_EINVAL; 9234 } 9235 9236 p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1); 9237 if (!p) { 9238 return -TARGET_EFAULT; 9239 } 9240 target_to_host_sigset(&set, p); 9241 unlock_user(p, arg1, 0); 9242 if (arg3) { 9243 puts = &uts; 9244 if (target_to_host_timespec64(puts, arg3)) { 9245 return -TARGET_EFAULT; 9246 } 9247 } else { 9248 puts = NULL; 9249 } 9250 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts, 9251 SIGSET_T_SIZE)); 9252 if (!is_error(ret)) { 9253 if (arg2) { 9254 p = lock_user(VERIFY_WRITE, arg2, 9255 sizeof(target_siginfo_t), 0); 9256 if (!p) { 9257 return -TARGET_EFAULT; 9258 } 9259 host_to_target_siginfo(p, &uinfo); 9260 unlock_user(p, arg2, sizeof(target_siginfo_t)); 9261 } 9262 ret = host_to_target_signal(ret); 9263 } 9264 } 9265 return ret; 9266 #endif 9267 case TARGET_NR_rt_sigqueueinfo: 9268 { 9269 siginfo_t uinfo; 9270 9271 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1); 9272 if (!p) { 9273 return -TARGET_EFAULT; 9274 } 9275 target_to_host_siginfo(&uinfo, p); 9276 unlock_user(p, arg3, 0); 9277 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo)); 9278 } 9279 return ret; 9280 case TARGET_NR_rt_tgsigqueueinfo: 9281 { 9282 siginfo_t uinfo; 9283 9284 p = lock_user(VERIFY_READ, arg4, sizeof(target_siginfo_t), 1); 9285 if (!p) { 9286 return -TARGET_EFAULT; 9287 } 9288 target_to_host_siginfo(&uinfo, p); 9289 unlock_user(p, arg4, 0); 9290 ret = get_errno(sys_rt_tgsigqueueinfo(arg1, arg2, arg3, &uinfo)); 9291 } 9292 return ret; 9293 #ifdef TARGET_NR_sigreturn 9294 case TARGET_NR_sigreturn: 9295 if (block_signals()) { 9296 return -TARGET_ERESTARTSYS; 9297 } 9298 return do_sigreturn(cpu_env); 9299 #endif 9300 case TARGET_NR_rt_sigreturn: 9301 if (block_signals()) { 9302 return -TARGET_ERESTARTSYS; 9303 } 9304 return do_rt_sigreturn(cpu_env); 9305 case TARGET_NR_sethostname: 9306 if (!(p = lock_user_string(arg1))) 9307 return -TARGET_EFAULT; 9308 ret = get_errno(sethostname(p, arg2)); 9309 unlock_user(p, arg1, 0); 9310 return ret; 9311 #ifdef TARGET_NR_setrlimit 9312 case TARGET_NR_setrlimit: 9313 { 9314 int resource = target_to_host_resource(arg1); 9315 struct target_rlimit *target_rlim; 9316 struct rlimit rlim; 9317 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) 9318 return -TARGET_EFAULT; 9319 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur); 9320 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max); 9321 unlock_user_struct(target_rlim, arg2, 0); 9322 /* 9323 * If we just passed through resource limit settings for memory then 9324 * they would also apply to QEMU's own allocations, and QEMU will 9325 * crash or hang or die if its allocations fail. Ideally we would 9326 * track the guest allocations in QEMU and apply the limits ourselves. 9327 * For now, just tell the guest the call succeeded but don't actually 9328 * limit anything. 9329 */ 9330 if (resource != RLIMIT_AS && 9331 resource != RLIMIT_DATA && 9332 resource != RLIMIT_STACK) { 9333 return get_errno(setrlimit(resource, &rlim)); 9334 } else { 9335 return 0; 9336 } 9337 } 9338 #endif 9339 #ifdef TARGET_NR_getrlimit 9340 case TARGET_NR_getrlimit: 9341 { 9342 int resource = target_to_host_resource(arg1); 9343 struct target_rlimit *target_rlim; 9344 struct rlimit rlim; 9345 9346 ret = get_errno(getrlimit(resource, &rlim)); 9347 if (!is_error(ret)) { 9348 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 9349 return -TARGET_EFAULT; 9350 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur); 9351 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max); 9352 unlock_user_struct(target_rlim, arg2, 1); 9353 } 9354 } 9355 return ret; 9356 #endif 9357 case TARGET_NR_getrusage: 9358 { 9359 struct rusage rusage; 9360 ret = get_errno(getrusage(arg1, &rusage)); 9361 if (!is_error(ret)) { 9362 ret = host_to_target_rusage(arg2, &rusage); 9363 } 9364 } 9365 return ret; 9366 #if defined(TARGET_NR_gettimeofday) 9367 case TARGET_NR_gettimeofday: 9368 { 9369 struct timeval tv; 9370 struct timezone tz; 9371 9372 ret = get_errno(gettimeofday(&tv, &tz)); 9373 if (!is_error(ret)) { 9374 if (arg1 && copy_to_user_timeval(arg1, &tv)) { 9375 return -TARGET_EFAULT; 9376 } 9377 if (arg2 && copy_to_user_timezone(arg2, &tz)) { 9378 return -TARGET_EFAULT; 9379 } 9380 } 9381 } 9382 return ret; 9383 #endif 9384 #if defined(TARGET_NR_settimeofday) 9385 case TARGET_NR_settimeofday: 9386 { 9387 struct timeval tv, *ptv = NULL; 9388 struct timezone tz, *ptz = NULL; 9389 9390 if (arg1) { 9391 if (copy_from_user_timeval(&tv, arg1)) { 9392 return -TARGET_EFAULT; 9393 } 9394 ptv = &tv; 9395 } 9396 9397 if (arg2) { 9398 if (copy_from_user_timezone(&tz, arg2)) { 9399 return -TARGET_EFAULT; 9400 } 9401 ptz = &tz; 9402 } 9403 9404 return get_errno(settimeofday(ptv, ptz)); 9405 } 9406 #endif 9407 #if defined(TARGET_NR_select) 9408 case TARGET_NR_select: 9409 #if defined(TARGET_WANT_NI_OLD_SELECT) 9410 /* some architectures used to have old_select here 9411 * but now ENOSYS it. 9412 */ 9413 ret = -TARGET_ENOSYS; 9414 #elif defined(TARGET_WANT_OLD_SYS_SELECT) 9415 ret = do_old_select(arg1); 9416 #else 9417 ret = do_select(arg1, arg2, arg3, arg4, arg5); 9418 #endif 9419 return ret; 9420 #endif 9421 #ifdef TARGET_NR_pselect6 9422 case TARGET_NR_pselect6: 9423 return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false); 9424 #endif 9425 #ifdef TARGET_NR_pselect6_time64 9426 case TARGET_NR_pselect6_time64: 9427 return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true); 9428 #endif 9429 #ifdef TARGET_NR_symlink 9430 case TARGET_NR_symlink: 9431 { 9432 void *p2; 9433 p = lock_user_string(arg1); 9434 p2 = lock_user_string(arg2); 9435 if (!p || !p2) 9436 ret = -TARGET_EFAULT; 9437 else 9438 ret = get_errno(symlink(p, p2)); 9439 unlock_user(p2, arg2, 0); 9440 unlock_user(p, arg1, 0); 9441 } 9442 return ret; 9443 #endif 9444 #if defined(TARGET_NR_symlinkat) 9445 case TARGET_NR_symlinkat: 9446 { 9447 void *p2; 9448 p = lock_user_string(arg1); 9449 p2 = lock_user_string(arg3); 9450 if (!p || !p2) 9451 ret = -TARGET_EFAULT; 9452 else 9453 ret = get_errno(symlinkat(p, arg2, p2)); 9454 unlock_user(p2, arg3, 0); 9455 unlock_user(p, arg1, 0); 9456 } 9457 return ret; 9458 #endif 9459 #ifdef TARGET_NR_readlink 9460 case TARGET_NR_readlink: 9461 { 9462 void *p2; 9463 p = lock_user_string(arg1); 9464 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0); 9465 if (!p || !p2) { 9466 ret = -TARGET_EFAULT; 9467 } else if (!arg3) { 9468 /* Short circuit this for the magic exe check. */ 9469 ret = -TARGET_EINVAL; 9470 } else if (is_proc_myself((const char *)p, "exe")) { 9471 char real[PATH_MAX], *temp; 9472 temp = realpath(exec_path, real); 9473 /* Return value is # of bytes that we wrote to the buffer. */ 9474 if (temp == NULL) { 9475 ret = get_errno(-1); 9476 } else { 9477 /* Don't worry about sign mismatch as earlier mapping 9478 * logic would have thrown a bad address error. */ 9479 ret = MIN(strlen(real), arg3); 9480 /* We cannot NUL terminate the string. */ 9481 memcpy(p2, real, ret); 9482 } 9483 } else { 9484 ret = get_errno(readlink(path(p), p2, arg3)); 9485 } 9486 unlock_user(p2, arg2, ret); 9487 unlock_user(p, arg1, 0); 9488 } 9489 return ret; 9490 #endif 9491 #if defined(TARGET_NR_readlinkat) 9492 case TARGET_NR_readlinkat: 9493 { 9494 void *p2; 9495 p = lock_user_string(arg2); 9496 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0); 9497 if (!p || !p2) { 9498 ret = -TARGET_EFAULT; 9499 } else if (is_proc_myself((const char *)p, "exe")) { 9500 char real[PATH_MAX], *temp; 9501 temp = realpath(exec_path, real); 9502 ret = temp == NULL ? get_errno(-1) : strlen(real) ; 9503 snprintf((char *)p2, arg4, "%s", real); 9504 } else { 9505 ret = get_errno(readlinkat(arg1, path(p), p2, arg4)); 9506 } 9507 unlock_user(p2, arg3, ret); 9508 unlock_user(p, arg2, 0); 9509 } 9510 return ret; 9511 #endif 9512 #ifdef TARGET_NR_swapon 9513 case TARGET_NR_swapon: 9514 if (!(p = lock_user_string(arg1))) 9515 return -TARGET_EFAULT; 9516 ret = get_errno(swapon(p, arg2)); 9517 unlock_user(p, arg1, 0); 9518 return ret; 9519 #endif 9520 case TARGET_NR_reboot: 9521 if (arg3 == LINUX_REBOOT_CMD_RESTART2) { 9522 /* arg4 must be ignored in all other cases */ 9523 p = lock_user_string(arg4); 9524 if (!p) { 9525 return -TARGET_EFAULT; 9526 } 9527 ret = get_errno(reboot(arg1, arg2, arg3, p)); 9528 unlock_user(p, arg4, 0); 9529 } else { 9530 ret = get_errno(reboot(arg1, arg2, arg3, NULL)); 9531 } 9532 return ret; 9533 #ifdef TARGET_NR_mmap 9534 case TARGET_NR_mmap: 9535 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \ 9536 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \ 9537 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \ 9538 || defined(TARGET_S390X) 9539 { 9540 abi_ulong *v; 9541 abi_ulong v1, v2, v3, v4, v5, v6; 9542 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1))) 9543 return -TARGET_EFAULT; 9544 v1 = tswapal(v[0]); 9545 v2 = tswapal(v[1]); 9546 v3 = tswapal(v[2]); 9547 v4 = tswapal(v[3]); 9548 v5 = tswapal(v[4]); 9549 v6 = tswapal(v[5]); 9550 unlock_user(v, arg1, 0); 9551 ret = get_errno(target_mmap(v1, v2, v3, 9552 target_to_host_bitmask(v4, mmap_flags_tbl), 9553 v5, v6)); 9554 } 9555 #else 9556 /* mmap pointers are always untagged */ 9557 ret = get_errno(target_mmap(arg1, arg2, arg3, 9558 target_to_host_bitmask(arg4, mmap_flags_tbl), 9559 arg5, 9560 arg6)); 9561 #endif 9562 return ret; 9563 #endif 9564 #ifdef TARGET_NR_mmap2 9565 case TARGET_NR_mmap2: 9566 #ifndef MMAP_SHIFT 9567 #define MMAP_SHIFT 12 9568 #endif 9569 ret = target_mmap(arg1, arg2, arg3, 9570 target_to_host_bitmask(arg4, mmap_flags_tbl), 9571 arg5, arg6 << MMAP_SHIFT); 9572 return get_errno(ret); 9573 #endif 9574 case TARGET_NR_munmap: 9575 arg1 = cpu_untagged_addr(cpu, arg1); 9576 return get_errno(target_munmap(arg1, arg2)); 9577 case TARGET_NR_mprotect: 9578 arg1 = cpu_untagged_addr(cpu, arg1); 9579 { 9580 TaskState *ts = cpu->opaque; 9581 /* Special hack to detect libc making the stack executable. */ 9582 if ((arg3 & PROT_GROWSDOWN) 9583 && arg1 >= ts->info->stack_limit 9584 && arg1 <= ts->info->start_stack) { 9585 arg3 &= ~PROT_GROWSDOWN; 9586 arg2 = arg2 + arg1 - ts->info->stack_limit; 9587 arg1 = ts->info->stack_limit; 9588 } 9589 } 9590 return get_errno(target_mprotect(arg1, arg2, arg3)); 9591 #ifdef TARGET_NR_mremap 9592 case TARGET_NR_mremap: 9593 arg1 = cpu_untagged_addr(cpu, arg1); 9594 /* mremap new_addr (arg5) is always untagged */ 9595 return get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5)); 9596 #endif 9597 /* ??? msync/mlock/munlock are broken for softmmu. */ 9598 #ifdef TARGET_NR_msync 9599 case TARGET_NR_msync: 9600 return get_errno(msync(g2h(cpu, arg1), arg2, arg3)); 9601 #endif 9602 #ifdef TARGET_NR_mlock 9603 case TARGET_NR_mlock: 9604 return get_errno(mlock(g2h(cpu, arg1), arg2)); 9605 #endif 9606 #ifdef TARGET_NR_munlock 9607 case TARGET_NR_munlock: 9608 return get_errno(munlock(g2h(cpu, arg1), arg2)); 9609 #endif 9610 #ifdef TARGET_NR_mlockall 9611 case TARGET_NR_mlockall: 9612 return get_errno(mlockall(target_to_host_mlockall_arg(arg1))); 9613 #endif 9614 #ifdef TARGET_NR_munlockall 9615 case TARGET_NR_munlockall: 9616 return get_errno(munlockall()); 9617 #endif 9618 #ifdef TARGET_NR_truncate 9619 case TARGET_NR_truncate: 9620 if (!(p = lock_user_string(arg1))) 9621 return -TARGET_EFAULT; 9622 ret = get_errno(truncate(p, arg2)); 9623 unlock_user(p, arg1, 0); 9624 return ret; 9625 #endif 9626 #ifdef TARGET_NR_ftruncate 9627 case TARGET_NR_ftruncate: 9628 return get_errno(ftruncate(arg1, arg2)); 9629 #endif 9630 case TARGET_NR_fchmod: 9631 return get_errno(fchmod(arg1, arg2)); 9632 #if defined(TARGET_NR_fchmodat) 9633 case TARGET_NR_fchmodat: 9634 if (!(p = lock_user_string(arg2))) 9635 return -TARGET_EFAULT; 9636 ret = get_errno(fchmodat(arg1, p, arg3, 0)); 9637 unlock_user(p, arg2, 0); 9638 return ret; 9639 #endif 9640 case TARGET_NR_getpriority: 9641 /* Note that negative values are valid for getpriority, so we must 9642 differentiate based on errno settings. */ 9643 errno = 0; 9644 ret = getpriority(arg1, arg2); 9645 if (ret == -1 && errno != 0) { 9646 return -host_to_target_errno(errno); 9647 } 9648 #ifdef TARGET_ALPHA 9649 /* Return value is the unbiased priority. Signal no error. */ 9650 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; 9651 #else 9652 /* Return value is a biased priority to avoid negative numbers. */ 9653 ret = 20 - ret; 9654 #endif 9655 return ret; 9656 case TARGET_NR_setpriority: 9657 return get_errno(setpriority(arg1, arg2, arg3)); 9658 #ifdef TARGET_NR_statfs 9659 case TARGET_NR_statfs: 9660 if (!(p = lock_user_string(arg1))) { 9661 return -TARGET_EFAULT; 9662 } 9663 ret = get_errno(statfs(path(p), &stfs)); 9664 unlock_user(p, arg1, 0); 9665 convert_statfs: 9666 if (!is_error(ret)) { 9667 struct target_statfs *target_stfs; 9668 9669 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0)) 9670 return -TARGET_EFAULT; 9671 __put_user(stfs.f_type, &target_stfs->f_type); 9672 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 9673 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 9674 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 9675 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 9676 __put_user(stfs.f_files, &target_stfs->f_files); 9677 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 9678 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 9679 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 9680 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 9681 __put_user(stfs.f_frsize, &target_stfs->f_frsize); 9682 #ifdef _STATFS_F_FLAGS 9683 __put_user(stfs.f_flags, &target_stfs->f_flags); 9684 #else 9685 __put_user(0, &target_stfs->f_flags); 9686 #endif 9687 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare)); 9688 unlock_user_struct(target_stfs, arg2, 1); 9689 } 9690 return ret; 9691 #endif 9692 #ifdef TARGET_NR_fstatfs 9693 case TARGET_NR_fstatfs: 9694 ret = get_errno(fstatfs(arg1, &stfs)); 9695 goto convert_statfs; 9696 #endif 9697 #ifdef TARGET_NR_statfs64 9698 case TARGET_NR_statfs64: 9699 if (!(p = lock_user_string(arg1))) { 9700 return -TARGET_EFAULT; 9701 } 9702 ret = get_errno(statfs(path(p), &stfs)); 9703 unlock_user(p, arg1, 0); 9704 convert_statfs64: 9705 if (!is_error(ret)) { 9706 struct target_statfs64 *target_stfs; 9707 9708 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0)) 9709 return -TARGET_EFAULT; 9710 __put_user(stfs.f_type, &target_stfs->f_type); 9711 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 9712 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 9713 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 9714 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 9715 __put_user(stfs.f_files, &target_stfs->f_files); 9716 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 9717 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 9718 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 9719 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 9720 __put_user(stfs.f_frsize, &target_stfs->f_frsize); 9721 #ifdef _STATFS_F_FLAGS 9722 __put_user(stfs.f_flags, &target_stfs->f_flags); 9723 #else 9724 __put_user(0, &target_stfs->f_flags); 9725 #endif 9726 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare)); 9727 unlock_user_struct(target_stfs, arg3, 1); 9728 } 9729 return ret; 9730 case TARGET_NR_fstatfs64: 9731 ret = get_errno(fstatfs(arg1, &stfs)); 9732 goto convert_statfs64; 9733 #endif 9734 #ifdef TARGET_NR_socketcall 9735 case TARGET_NR_socketcall: 9736 return do_socketcall(arg1, arg2); 9737 #endif 9738 #ifdef TARGET_NR_accept 9739 case TARGET_NR_accept: 9740 return do_accept4(arg1, arg2, arg3, 0); 9741 #endif 9742 #ifdef TARGET_NR_accept4 9743 case TARGET_NR_accept4: 9744 return do_accept4(arg1, arg2, arg3, arg4); 9745 #endif 9746 #ifdef TARGET_NR_bind 9747 case TARGET_NR_bind: 9748 return do_bind(arg1, arg2, arg3); 9749 #endif 9750 #ifdef TARGET_NR_connect 9751 case TARGET_NR_connect: 9752 return do_connect(arg1, arg2, arg3); 9753 #endif 9754 #ifdef TARGET_NR_getpeername 9755 case TARGET_NR_getpeername: 9756 return do_getpeername(arg1, arg2, arg3); 9757 #endif 9758 #ifdef TARGET_NR_getsockname 9759 case TARGET_NR_getsockname: 9760 return do_getsockname(arg1, arg2, arg3); 9761 #endif 9762 #ifdef TARGET_NR_getsockopt 9763 case TARGET_NR_getsockopt: 9764 return do_getsockopt(arg1, arg2, arg3, arg4, arg5); 9765 #endif 9766 #ifdef TARGET_NR_listen 9767 case TARGET_NR_listen: 9768 return get_errno(listen(arg1, arg2)); 9769 #endif 9770 #ifdef TARGET_NR_recv 9771 case TARGET_NR_recv: 9772 return do_recvfrom(arg1, arg2, arg3, arg4, 0, 0); 9773 #endif 9774 #ifdef TARGET_NR_recvfrom 9775 case TARGET_NR_recvfrom: 9776 return do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); 9777 #endif 9778 #ifdef TARGET_NR_recvmsg 9779 case TARGET_NR_recvmsg: 9780 return do_sendrecvmsg(arg1, arg2, arg3, 0); 9781 #endif 9782 #ifdef TARGET_NR_send 9783 case TARGET_NR_send: 9784 return do_sendto(arg1, arg2, arg3, arg4, 0, 0); 9785 #endif 9786 #ifdef TARGET_NR_sendmsg 9787 case TARGET_NR_sendmsg: 9788 return do_sendrecvmsg(arg1, arg2, arg3, 1); 9789 #endif 9790 #ifdef TARGET_NR_sendmmsg 9791 case TARGET_NR_sendmmsg: 9792 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1); 9793 #endif 9794 #ifdef TARGET_NR_recvmmsg 9795 case TARGET_NR_recvmmsg: 9796 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0); 9797 #endif 9798 #ifdef TARGET_NR_sendto 9799 case TARGET_NR_sendto: 9800 return do_sendto(arg1, arg2, arg3, arg4, arg5, arg6); 9801 #endif 9802 #ifdef TARGET_NR_shutdown 9803 case TARGET_NR_shutdown: 9804 return get_errno(shutdown(arg1, arg2)); 9805 #endif 9806 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom) 9807 case TARGET_NR_getrandom: 9808 p = lock_user(VERIFY_WRITE, arg1, arg2, 0); 9809 if (!p) { 9810 return -TARGET_EFAULT; 9811 } 9812 ret = get_errno(getrandom(p, arg2, arg3)); 9813 unlock_user(p, arg1, ret); 9814 return ret; 9815 #endif 9816 #ifdef TARGET_NR_socket 9817 case TARGET_NR_socket: 9818 return do_socket(arg1, arg2, arg3); 9819 #endif 9820 #ifdef TARGET_NR_socketpair 9821 case TARGET_NR_socketpair: 9822 return do_socketpair(arg1, arg2, arg3, arg4); 9823 #endif 9824 #ifdef TARGET_NR_setsockopt 9825 case TARGET_NR_setsockopt: 9826 return do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5); 9827 #endif 9828 #if defined(TARGET_NR_syslog) 9829 case TARGET_NR_syslog: 9830 { 9831 int len = arg2; 9832 9833 switch (arg1) { 9834 case TARGET_SYSLOG_ACTION_CLOSE: /* Close log */ 9835 case TARGET_SYSLOG_ACTION_OPEN: /* Open log */ 9836 case TARGET_SYSLOG_ACTION_CLEAR: /* Clear ring buffer */ 9837 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging */ 9838 case TARGET_SYSLOG_ACTION_CONSOLE_ON: /* Enable logging */ 9839 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */ 9840 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: /* Number of chars */ 9841 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: /* Size of the buffer */ 9842 return get_errno(sys_syslog((int)arg1, NULL, (int)arg3)); 9843 case TARGET_SYSLOG_ACTION_READ: /* Read from log */ 9844 case TARGET_SYSLOG_ACTION_READ_CLEAR: /* Read/clear msgs */ 9845 case TARGET_SYSLOG_ACTION_READ_ALL: /* Read last messages */ 9846 { 9847 if (len < 0) { 9848 return -TARGET_EINVAL; 9849 } 9850 if (len == 0) { 9851 return 0; 9852 } 9853 p = lock_user(VERIFY_WRITE, arg2, arg3, 0); 9854 if (!p) { 9855 return -TARGET_EFAULT; 9856 } 9857 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3)); 9858 unlock_user(p, arg2, arg3); 9859 } 9860 return ret; 9861 default: 9862 return -TARGET_EINVAL; 9863 } 9864 } 9865 break; 9866 #endif 9867 case TARGET_NR_setitimer: 9868 { 9869 struct itimerval value, ovalue, *pvalue; 9870 9871 if (arg2) { 9872 pvalue = &value; 9873 if (copy_from_user_timeval(&pvalue->it_interval, arg2) 9874 || copy_from_user_timeval(&pvalue->it_value, 9875 arg2 + sizeof(struct target_timeval))) 9876 return -TARGET_EFAULT; 9877 } else { 9878 pvalue = NULL; 9879 } 9880 ret = get_errno(setitimer(arg1, pvalue, &ovalue)); 9881 if (!is_error(ret) && arg3) { 9882 if (copy_to_user_timeval(arg3, 9883 &ovalue.it_interval) 9884 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval), 9885 &ovalue.it_value)) 9886 return -TARGET_EFAULT; 9887 } 9888 } 9889 return ret; 9890 case TARGET_NR_getitimer: 9891 { 9892 struct itimerval value; 9893 9894 ret = get_errno(getitimer(arg1, &value)); 9895 if (!is_error(ret) && arg2) { 9896 if (copy_to_user_timeval(arg2, 9897 &value.it_interval) 9898 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval), 9899 &value.it_value)) 9900 return -TARGET_EFAULT; 9901 } 9902 } 9903 return ret; 9904 #ifdef TARGET_NR_stat 9905 case TARGET_NR_stat: 9906 if (!(p = lock_user_string(arg1))) { 9907 return -TARGET_EFAULT; 9908 } 9909 ret = get_errno(stat(path(p), &st)); 9910 unlock_user(p, arg1, 0); 9911 goto do_stat; 9912 #endif 9913 #ifdef TARGET_NR_lstat 9914 case TARGET_NR_lstat: 9915 if (!(p = lock_user_string(arg1))) { 9916 return -TARGET_EFAULT; 9917 } 9918 ret = get_errno(lstat(path(p), &st)); 9919 unlock_user(p, arg1, 0); 9920 goto do_stat; 9921 #endif 9922 #ifdef TARGET_NR_fstat 9923 case TARGET_NR_fstat: 9924 { 9925 ret = get_errno(fstat(arg1, &st)); 9926 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat) 9927 do_stat: 9928 #endif 9929 if (!is_error(ret)) { 9930 struct target_stat *target_st; 9931 9932 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0)) 9933 return -TARGET_EFAULT; 9934 memset(target_st, 0, sizeof(*target_st)); 9935 __put_user(st.st_dev, &target_st->st_dev); 9936 __put_user(st.st_ino, &target_st->st_ino); 9937 __put_user(st.st_mode, &target_st->st_mode); 9938 __put_user(st.st_uid, &target_st->st_uid); 9939 __put_user(st.st_gid, &target_st->st_gid); 9940 __put_user(st.st_nlink, &target_st->st_nlink); 9941 __put_user(st.st_rdev, &target_st->st_rdev); 9942 __put_user(st.st_size, &target_st->st_size); 9943 __put_user(st.st_blksize, &target_st->st_blksize); 9944 __put_user(st.st_blocks, &target_st->st_blocks); 9945 __put_user(st.st_atime, &target_st->target_st_atime); 9946 __put_user(st.st_mtime, &target_st->target_st_mtime); 9947 __put_user(st.st_ctime, &target_st->target_st_ctime); 9948 #if defined(HAVE_STRUCT_STAT_ST_ATIM) && defined(TARGET_STAT_HAVE_NSEC) 9949 __put_user(st.st_atim.tv_nsec, 9950 &target_st->target_st_atime_nsec); 9951 __put_user(st.st_mtim.tv_nsec, 9952 &target_st->target_st_mtime_nsec); 9953 __put_user(st.st_ctim.tv_nsec, 9954 &target_st->target_st_ctime_nsec); 9955 #endif 9956 unlock_user_struct(target_st, arg2, 1); 9957 } 9958 } 9959 return ret; 9960 #endif 9961 case TARGET_NR_vhangup: 9962 return get_errno(vhangup()); 9963 #ifdef TARGET_NR_syscall 9964 case TARGET_NR_syscall: 9965 return do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5, 9966 arg6, arg7, arg8, 0); 9967 #endif 9968 #if defined(TARGET_NR_wait4) 9969 case TARGET_NR_wait4: 9970 { 9971 int status; 9972 abi_long status_ptr = arg2; 9973 struct rusage rusage, *rusage_ptr; 9974 abi_ulong target_rusage = arg4; 9975 abi_long rusage_err; 9976 if (target_rusage) 9977 rusage_ptr = &rusage; 9978 else 9979 rusage_ptr = NULL; 9980 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr)); 9981 if (!is_error(ret)) { 9982 if (status_ptr && ret) { 9983 status = host_to_target_waitstatus(status); 9984 if (put_user_s32(status, status_ptr)) 9985 return -TARGET_EFAULT; 9986 } 9987 if (target_rusage) { 9988 rusage_err = host_to_target_rusage(target_rusage, &rusage); 9989 if (rusage_err) { 9990 ret = rusage_err; 9991 } 9992 } 9993 } 9994 } 9995 return ret; 9996 #endif 9997 #ifdef TARGET_NR_swapoff 9998 case TARGET_NR_swapoff: 9999 if (!(p = lock_user_string(arg1))) 10000 return -TARGET_EFAULT; 10001 ret = get_errno(swapoff(p)); 10002 unlock_user(p, arg1, 0); 10003 return ret; 10004 #endif 10005 case TARGET_NR_sysinfo: 10006 { 10007 struct target_sysinfo *target_value; 10008 struct sysinfo value; 10009 ret = get_errno(sysinfo(&value)); 10010 if (!is_error(ret) && arg1) 10011 { 10012 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0)) 10013 return -TARGET_EFAULT; 10014 __put_user(value.uptime, &target_value->uptime); 10015 __put_user(value.loads[0], &target_value->loads[0]); 10016 __put_user(value.loads[1], &target_value->loads[1]); 10017 __put_user(value.loads[2], &target_value->loads[2]); 10018 __put_user(value.totalram, &target_value->totalram); 10019 __put_user(value.freeram, &target_value->freeram); 10020 __put_user(value.sharedram, &target_value->sharedram); 10021 __put_user(value.bufferram, &target_value->bufferram); 10022 __put_user(value.totalswap, &target_value->totalswap); 10023 __put_user(value.freeswap, &target_value->freeswap); 10024 __put_user(value.procs, &target_value->procs); 10025 __put_user(value.totalhigh, &target_value->totalhigh); 10026 __put_user(value.freehigh, &target_value->freehigh); 10027 __put_user(value.mem_unit, &target_value->mem_unit); 10028 unlock_user_struct(target_value, arg1, 1); 10029 } 10030 } 10031 return ret; 10032 #ifdef TARGET_NR_ipc 10033 case TARGET_NR_ipc: 10034 return do_ipc(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6); 10035 #endif 10036 #ifdef TARGET_NR_semget 10037 case TARGET_NR_semget: 10038 return get_errno(semget(arg1, arg2, arg3)); 10039 #endif 10040 #ifdef TARGET_NR_semop 10041 case TARGET_NR_semop: 10042 return do_semtimedop(arg1, arg2, arg3, 0, false); 10043 #endif 10044 #ifdef TARGET_NR_semtimedop 10045 case TARGET_NR_semtimedop: 10046 return do_semtimedop(arg1, arg2, arg3, arg4, false); 10047 #endif 10048 #ifdef TARGET_NR_semtimedop_time64 10049 case TARGET_NR_semtimedop_time64: 10050 return do_semtimedop(arg1, arg2, arg3, arg4, true); 10051 #endif 10052 #ifdef TARGET_NR_semctl 10053 case TARGET_NR_semctl: 10054 return do_semctl(arg1, arg2, arg3, arg4); 10055 #endif 10056 #ifdef TARGET_NR_msgctl 10057 case TARGET_NR_msgctl: 10058 return do_msgctl(arg1, arg2, arg3); 10059 #endif 10060 #ifdef TARGET_NR_msgget 10061 case TARGET_NR_msgget: 10062 return get_errno(msgget(arg1, arg2)); 10063 #endif 10064 #ifdef TARGET_NR_msgrcv 10065 case TARGET_NR_msgrcv: 10066 return do_msgrcv(arg1, arg2, arg3, arg4, arg5); 10067 #endif 10068 #ifdef TARGET_NR_msgsnd 10069 case TARGET_NR_msgsnd: 10070 return do_msgsnd(arg1, arg2, arg3, arg4); 10071 #endif 10072 #ifdef TARGET_NR_shmget 10073 case TARGET_NR_shmget: 10074 return get_errno(shmget(arg1, arg2, arg3)); 10075 #endif 10076 #ifdef TARGET_NR_shmctl 10077 case TARGET_NR_shmctl: 10078 return do_shmctl(arg1, arg2, arg3); 10079 #endif 10080 #ifdef TARGET_NR_shmat 10081 case TARGET_NR_shmat: 10082 return do_shmat(cpu_env, arg1, arg2, arg3); 10083 #endif 10084 #ifdef TARGET_NR_shmdt 10085 case TARGET_NR_shmdt: 10086 return do_shmdt(arg1); 10087 #endif 10088 case TARGET_NR_fsync: 10089 return get_errno(fsync(arg1)); 10090 case TARGET_NR_clone: 10091 /* Linux manages to have three different orderings for its 10092 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines 10093 * match the kernel's CONFIG_CLONE_* settings. 10094 * Microblaze is further special in that it uses a sixth 10095 * implicit argument to clone for the TLS pointer. 10096 */ 10097 #if defined(TARGET_MICROBLAZE) 10098 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5)); 10099 #elif defined(TARGET_CLONE_BACKWARDS) 10100 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5)); 10101 #elif defined(TARGET_CLONE_BACKWARDS2) 10102 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4)); 10103 #else 10104 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4)); 10105 #endif 10106 return ret; 10107 #ifdef __NR_exit_group 10108 /* new thread calls */ 10109 case TARGET_NR_exit_group: 10110 preexit_cleanup(cpu_env, arg1); 10111 return get_errno(exit_group(arg1)); 10112 #endif 10113 case TARGET_NR_setdomainname: 10114 if (!(p = lock_user_string(arg1))) 10115 return -TARGET_EFAULT; 10116 ret = get_errno(setdomainname(p, arg2)); 10117 unlock_user(p, arg1, 0); 10118 return ret; 10119 case TARGET_NR_uname: 10120 /* no need to transcode because we use the linux syscall */ 10121 { 10122 struct new_utsname * buf; 10123 10124 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0)) 10125 return -TARGET_EFAULT; 10126 ret = get_errno(sys_uname(buf)); 10127 if (!is_error(ret)) { 10128 /* Overwrite the native machine name with whatever is being 10129 emulated. */ 10130 g_strlcpy(buf->machine, cpu_to_uname_machine(cpu_env), 10131 sizeof(buf->machine)); 10132 /* Allow the user to override the reported release. */ 10133 if (qemu_uname_release && *qemu_uname_release) { 10134 g_strlcpy(buf->release, qemu_uname_release, 10135 sizeof(buf->release)); 10136 } 10137 } 10138 unlock_user_struct(buf, arg1, 1); 10139 } 10140 return ret; 10141 #ifdef TARGET_I386 10142 case TARGET_NR_modify_ldt: 10143 return do_modify_ldt(cpu_env, arg1, arg2, arg3); 10144 #if !defined(TARGET_X86_64) 10145 case TARGET_NR_vm86: 10146 return do_vm86(cpu_env, arg1, arg2); 10147 #endif 10148 #endif 10149 #if defined(TARGET_NR_adjtimex) 10150 case TARGET_NR_adjtimex: 10151 { 10152 struct timex host_buf; 10153 10154 if (target_to_host_timex(&host_buf, arg1) != 0) { 10155 return -TARGET_EFAULT; 10156 } 10157 ret = get_errno(adjtimex(&host_buf)); 10158 if (!is_error(ret)) { 10159 if (host_to_target_timex(arg1, &host_buf) != 0) { 10160 return -TARGET_EFAULT; 10161 } 10162 } 10163 } 10164 return ret; 10165 #endif 10166 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME) 10167 case TARGET_NR_clock_adjtime: 10168 { 10169 struct timex htx, *phtx = &htx; 10170 10171 if (target_to_host_timex(phtx, arg2) != 0) { 10172 return -TARGET_EFAULT; 10173 } 10174 ret = get_errno(clock_adjtime(arg1, phtx)); 10175 if (!is_error(ret) && phtx) { 10176 if (host_to_target_timex(arg2, phtx) != 0) { 10177 return -TARGET_EFAULT; 10178 } 10179 } 10180 } 10181 return ret; 10182 #endif 10183 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME) 10184 case TARGET_NR_clock_adjtime64: 10185 { 10186 struct timex htx; 10187 10188 if (target_to_host_timex64(&htx, arg2) != 0) { 10189 return -TARGET_EFAULT; 10190 } 10191 ret = get_errno(clock_adjtime(arg1, &htx)); 10192 if (!is_error(ret) && host_to_target_timex64(arg2, &htx)) { 10193 return -TARGET_EFAULT; 10194 } 10195 } 10196 return ret; 10197 #endif 10198 case TARGET_NR_getpgid: 10199 return get_errno(getpgid(arg1)); 10200 case TARGET_NR_fchdir: 10201 return get_errno(fchdir(arg1)); 10202 case TARGET_NR_personality: 10203 return get_errno(personality(arg1)); 10204 #ifdef TARGET_NR__llseek /* Not on alpha */ 10205 case TARGET_NR__llseek: 10206 { 10207 int64_t res; 10208 #if !defined(__NR_llseek) 10209 res = lseek(arg1, ((uint64_t)arg2 << 32) | (abi_ulong)arg3, arg5); 10210 if (res == -1) { 10211 ret = get_errno(res); 10212 } else { 10213 ret = 0; 10214 } 10215 #else 10216 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); 10217 #endif 10218 if ((ret == 0) && put_user_s64(res, arg4)) { 10219 return -TARGET_EFAULT; 10220 } 10221 } 10222 return ret; 10223 #endif 10224 #ifdef TARGET_NR_getdents 10225 case TARGET_NR_getdents: 10226 #ifdef EMULATE_GETDENTS_WITH_GETDENTS 10227 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 10228 { 10229 struct target_dirent *target_dirp; 10230 struct linux_dirent *dirp; 10231 abi_long count = arg3; 10232 10233 dirp = g_try_malloc(count); 10234 if (!dirp) { 10235 return -TARGET_ENOMEM; 10236 } 10237 10238 ret = get_errno(sys_getdents(arg1, dirp, count)); 10239 if (!is_error(ret)) { 10240 struct linux_dirent *de; 10241 struct target_dirent *tde; 10242 int len = ret; 10243 int reclen, treclen; 10244 int count1, tnamelen; 10245 10246 count1 = 0; 10247 de = dirp; 10248 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 10249 return -TARGET_EFAULT; 10250 tde = target_dirp; 10251 while (len > 0) { 10252 reclen = de->d_reclen; 10253 tnamelen = reclen - offsetof(struct linux_dirent, d_name); 10254 assert(tnamelen >= 0); 10255 treclen = tnamelen + offsetof(struct target_dirent, d_name); 10256 assert(count1 + treclen <= count); 10257 tde->d_reclen = tswap16(treclen); 10258 tde->d_ino = tswapal(de->d_ino); 10259 tde->d_off = tswapal(de->d_off); 10260 memcpy(tde->d_name, de->d_name, tnamelen); 10261 de = (struct linux_dirent *)((char *)de + reclen); 10262 len -= reclen; 10263 tde = (struct target_dirent *)((char *)tde + treclen); 10264 count1 += treclen; 10265 } 10266 ret = count1; 10267 unlock_user(target_dirp, arg2, ret); 10268 } 10269 g_free(dirp); 10270 } 10271 #else 10272 { 10273 struct linux_dirent *dirp; 10274 abi_long count = arg3; 10275 10276 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 10277 return -TARGET_EFAULT; 10278 ret = get_errno(sys_getdents(arg1, dirp, count)); 10279 if (!is_error(ret)) { 10280 struct linux_dirent *de; 10281 int len = ret; 10282 int reclen; 10283 de = dirp; 10284 while (len > 0) { 10285 reclen = de->d_reclen; 10286 if (reclen > len) 10287 break; 10288 de->d_reclen = tswap16(reclen); 10289 tswapls(&de->d_ino); 10290 tswapls(&de->d_off); 10291 de = (struct linux_dirent *)((char *)de + reclen); 10292 len -= reclen; 10293 } 10294 } 10295 unlock_user(dirp, arg2, ret); 10296 } 10297 #endif 10298 #else 10299 /* Implement getdents in terms of getdents64 */ 10300 { 10301 struct linux_dirent64 *dirp; 10302 abi_long count = arg3; 10303 10304 dirp = lock_user(VERIFY_WRITE, arg2, count, 0); 10305 if (!dirp) { 10306 return -TARGET_EFAULT; 10307 } 10308 ret = get_errno(sys_getdents64(arg1, dirp, count)); 10309 if (!is_error(ret)) { 10310 /* Convert the dirent64 structs to target dirent. We do this 10311 * in-place, since we can guarantee that a target_dirent is no 10312 * larger than a dirent64; however this means we have to be 10313 * careful to read everything before writing in the new format. 10314 */ 10315 struct linux_dirent64 *de; 10316 struct target_dirent *tde; 10317 int len = ret; 10318 int tlen = 0; 10319 10320 de = dirp; 10321 tde = (struct target_dirent *)dirp; 10322 while (len > 0) { 10323 int namelen, treclen; 10324 int reclen = de->d_reclen; 10325 uint64_t ino = de->d_ino; 10326 int64_t off = de->d_off; 10327 uint8_t type = de->d_type; 10328 10329 namelen = strlen(de->d_name); 10330 treclen = offsetof(struct target_dirent, d_name) 10331 + namelen + 2; 10332 treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long)); 10333 10334 memmove(tde->d_name, de->d_name, namelen + 1); 10335 tde->d_ino = tswapal(ino); 10336 tde->d_off = tswapal(off); 10337 tde->d_reclen = tswap16(treclen); 10338 /* The target_dirent type is in what was formerly a padding 10339 * byte at the end of the structure: 10340 */ 10341 *(((char *)tde) + treclen - 1) = type; 10342 10343 de = (struct linux_dirent64 *)((char *)de + reclen); 10344 tde = (struct target_dirent *)((char *)tde + treclen); 10345 len -= reclen; 10346 tlen += treclen; 10347 } 10348 ret = tlen; 10349 } 10350 unlock_user(dirp, arg2, ret); 10351 } 10352 #endif 10353 return ret; 10354 #endif /* TARGET_NR_getdents */ 10355 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) 10356 case TARGET_NR_getdents64: 10357 { 10358 struct linux_dirent64 *dirp; 10359 abi_long count = arg3; 10360 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 10361 return -TARGET_EFAULT; 10362 ret = get_errno(sys_getdents64(arg1, dirp, count)); 10363 if (!is_error(ret)) { 10364 struct linux_dirent64 *de; 10365 int len = ret; 10366 int reclen; 10367 de = dirp; 10368 while (len > 0) { 10369 reclen = de->d_reclen; 10370 if (reclen > len) 10371 break; 10372 de->d_reclen = tswap16(reclen); 10373 tswap64s((uint64_t *)&de->d_ino); 10374 tswap64s((uint64_t *)&de->d_off); 10375 de = (struct linux_dirent64 *)((char *)de + reclen); 10376 len -= reclen; 10377 } 10378 } 10379 unlock_user(dirp, arg2, ret); 10380 } 10381 return ret; 10382 #endif /* TARGET_NR_getdents64 */ 10383 #if defined(TARGET_NR__newselect) 10384 case TARGET_NR__newselect: 10385 return do_select(arg1, arg2, arg3, arg4, arg5); 10386 #endif 10387 #ifdef TARGET_NR_poll 10388 case TARGET_NR_poll: 10389 return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false); 10390 #endif 10391 #ifdef TARGET_NR_ppoll 10392 case TARGET_NR_ppoll: 10393 return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false); 10394 #endif 10395 #ifdef TARGET_NR_ppoll_time64 10396 case TARGET_NR_ppoll_time64: 10397 return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true); 10398 #endif 10399 case TARGET_NR_flock: 10400 /* NOTE: the flock constant seems to be the same for every 10401 Linux platform */ 10402 return get_errno(safe_flock(arg1, arg2)); 10403 case TARGET_NR_readv: 10404 { 10405 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0); 10406 if (vec != NULL) { 10407 ret = get_errno(safe_readv(arg1, vec, arg3)); 10408 unlock_iovec(vec, arg2, arg3, 1); 10409 } else { 10410 ret = -host_to_target_errno(errno); 10411 } 10412 } 10413 return ret; 10414 case TARGET_NR_writev: 10415 { 10416 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 10417 if (vec != NULL) { 10418 ret = get_errno(safe_writev(arg1, vec, arg3)); 10419 unlock_iovec(vec, arg2, arg3, 0); 10420 } else { 10421 ret = -host_to_target_errno(errno); 10422 } 10423 } 10424 return ret; 10425 #if defined(TARGET_NR_preadv) 10426 case TARGET_NR_preadv: 10427 { 10428 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0); 10429 if (vec != NULL) { 10430 unsigned long low, high; 10431 10432 target_to_host_low_high(arg4, arg5, &low, &high); 10433 ret = get_errno(safe_preadv(arg1, vec, arg3, low, high)); 10434 unlock_iovec(vec, arg2, arg3, 1); 10435 } else { 10436 ret = -host_to_target_errno(errno); 10437 } 10438 } 10439 return ret; 10440 #endif 10441 #if defined(TARGET_NR_pwritev) 10442 case TARGET_NR_pwritev: 10443 { 10444 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 10445 if (vec != NULL) { 10446 unsigned long low, high; 10447 10448 target_to_host_low_high(arg4, arg5, &low, &high); 10449 ret = get_errno(safe_pwritev(arg1, vec, arg3, low, high)); 10450 unlock_iovec(vec, arg2, arg3, 0); 10451 } else { 10452 ret = -host_to_target_errno(errno); 10453 } 10454 } 10455 return ret; 10456 #endif 10457 case TARGET_NR_getsid: 10458 return get_errno(getsid(arg1)); 10459 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */ 10460 case TARGET_NR_fdatasync: 10461 return get_errno(fdatasync(arg1)); 10462 #endif 10463 case TARGET_NR_sched_getaffinity: 10464 { 10465 unsigned int mask_size; 10466 unsigned long *mask; 10467 10468 /* 10469 * sched_getaffinity needs multiples of ulong, so need to take 10470 * care of mismatches between target ulong and host ulong sizes. 10471 */ 10472 if (arg2 & (sizeof(abi_ulong) - 1)) { 10473 return -TARGET_EINVAL; 10474 } 10475 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1); 10476 10477 mask = alloca(mask_size); 10478 memset(mask, 0, mask_size); 10479 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask)); 10480 10481 if (!is_error(ret)) { 10482 if (ret > arg2) { 10483 /* More data returned than the caller's buffer will fit. 10484 * This only happens if sizeof(abi_long) < sizeof(long) 10485 * and the caller passed us a buffer holding an odd number 10486 * of abi_longs. If the host kernel is actually using the 10487 * extra 4 bytes then fail EINVAL; otherwise we can just 10488 * ignore them and only copy the interesting part. 10489 */ 10490 int numcpus = sysconf(_SC_NPROCESSORS_CONF); 10491 if (numcpus > arg2 * 8) { 10492 return -TARGET_EINVAL; 10493 } 10494 ret = arg2; 10495 } 10496 10497 if (host_to_target_cpu_mask(mask, mask_size, arg3, ret)) { 10498 return -TARGET_EFAULT; 10499 } 10500 } 10501 } 10502 return ret; 10503 case TARGET_NR_sched_setaffinity: 10504 { 10505 unsigned int mask_size; 10506 unsigned long *mask; 10507 10508 /* 10509 * sched_setaffinity needs multiples of ulong, so need to take 10510 * care of mismatches between target ulong and host ulong sizes. 10511 */ 10512 if (arg2 & (sizeof(abi_ulong) - 1)) { 10513 return -TARGET_EINVAL; 10514 } 10515 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1); 10516 mask = alloca(mask_size); 10517 10518 ret = target_to_host_cpu_mask(mask, mask_size, arg3, arg2); 10519 if (ret) { 10520 return ret; 10521 } 10522 10523 return get_errno(sys_sched_setaffinity(arg1, mask_size, mask)); 10524 } 10525 case TARGET_NR_getcpu: 10526 { 10527 unsigned cpu, node; 10528 ret = get_errno(sys_getcpu(arg1 ? &cpu : NULL, 10529 arg2 ? &node : NULL, 10530 NULL)); 10531 if (is_error(ret)) { 10532 return ret; 10533 } 10534 if (arg1 && put_user_u32(cpu, arg1)) { 10535 return -TARGET_EFAULT; 10536 } 10537 if (arg2 && put_user_u32(node, arg2)) { 10538 return -TARGET_EFAULT; 10539 } 10540 } 10541 return ret; 10542 case TARGET_NR_sched_setparam: 10543 { 10544 struct sched_param *target_schp; 10545 struct sched_param schp; 10546 10547 if (arg2 == 0) { 10548 return -TARGET_EINVAL; 10549 } 10550 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) 10551 return -TARGET_EFAULT; 10552 schp.sched_priority = tswap32(target_schp->sched_priority); 10553 unlock_user_struct(target_schp, arg2, 0); 10554 return get_errno(sched_setparam(arg1, &schp)); 10555 } 10556 case TARGET_NR_sched_getparam: 10557 { 10558 struct sched_param *target_schp; 10559 struct sched_param schp; 10560 10561 if (arg2 == 0) { 10562 return -TARGET_EINVAL; 10563 } 10564 ret = get_errno(sched_getparam(arg1, &schp)); 10565 if (!is_error(ret)) { 10566 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) 10567 return -TARGET_EFAULT; 10568 target_schp->sched_priority = tswap32(schp.sched_priority); 10569 unlock_user_struct(target_schp, arg2, 1); 10570 } 10571 } 10572 return ret; 10573 case TARGET_NR_sched_setscheduler: 10574 { 10575 struct sched_param *target_schp; 10576 struct sched_param schp; 10577 if (arg3 == 0) { 10578 return -TARGET_EINVAL; 10579 } 10580 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) 10581 return -TARGET_EFAULT; 10582 schp.sched_priority = tswap32(target_schp->sched_priority); 10583 unlock_user_struct(target_schp, arg3, 0); 10584 return get_errno(sched_setscheduler(arg1, arg2, &schp)); 10585 } 10586 case TARGET_NR_sched_getscheduler: 10587 return get_errno(sched_getscheduler(arg1)); 10588 case TARGET_NR_sched_yield: 10589 return get_errno(sched_yield()); 10590 case TARGET_NR_sched_get_priority_max: 10591 return get_errno(sched_get_priority_max(arg1)); 10592 case TARGET_NR_sched_get_priority_min: 10593 return get_errno(sched_get_priority_min(arg1)); 10594 #ifdef TARGET_NR_sched_rr_get_interval 10595 case TARGET_NR_sched_rr_get_interval: 10596 { 10597 struct timespec ts; 10598 ret = get_errno(sched_rr_get_interval(arg1, &ts)); 10599 if (!is_error(ret)) { 10600 ret = host_to_target_timespec(arg2, &ts); 10601 } 10602 } 10603 return ret; 10604 #endif 10605 #ifdef TARGET_NR_sched_rr_get_interval_time64 10606 case TARGET_NR_sched_rr_get_interval_time64: 10607 { 10608 struct timespec ts; 10609 ret = get_errno(sched_rr_get_interval(arg1, &ts)); 10610 if (!is_error(ret)) { 10611 ret = host_to_target_timespec64(arg2, &ts); 10612 } 10613 } 10614 return ret; 10615 #endif 10616 #if defined(TARGET_NR_nanosleep) 10617 case TARGET_NR_nanosleep: 10618 { 10619 struct timespec req, rem; 10620 target_to_host_timespec(&req, arg1); 10621 ret = get_errno(safe_nanosleep(&req, &rem)); 10622 if (is_error(ret) && arg2) { 10623 host_to_target_timespec(arg2, &rem); 10624 } 10625 } 10626 return ret; 10627 #endif 10628 case TARGET_NR_prctl: 10629 switch (arg1) { 10630 case PR_GET_PDEATHSIG: 10631 { 10632 int deathsig; 10633 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5)); 10634 if (!is_error(ret) && arg2 10635 && put_user_s32(deathsig, arg2)) { 10636 return -TARGET_EFAULT; 10637 } 10638 return ret; 10639 } 10640 #ifdef PR_GET_NAME 10641 case PR_GET_NAME: 10642 { 10643 void *name = lock_user(VERIFY_WRITE, arg2, 16, 1); 10644 if (!name) { 10645 return -TARGET_EFAULT; 10646 } 10647 ret = get_errno(prctl(arg1, (unsigned long)name, 10648 arg3, arg4, arg5)); 10649 unlock_user(name, arg2, 16); 10650 return ret; 10651 } 10652 case PR_SET_NAME: 10653 { 10654 void *name = lock_user(VERIFY_READ, arg2, 16, 1); 10655 if (!name) { 10656 return -TARGET_EFAULT; 10657 } 10658 ret = get_errno(prctl(arg1, (unsigned long)name, 10659 arg3, arg4, arg5)); 10660 unlock_user(name, arg2, 0); 10661 return ret; 10662 } 10663 #endif 10664 #ifdef TARGET_MIPS 10665 case TARGET_PR_GET_FP_MODE: 10666 { 10667 CPUMIPSState *env = ((CPUMIPSState *)cpu_env); 10668 ret = 0; 10669 if (env->CP0_Status & (1 << CP0St_FR)) { 10670 ret |= TARGET_PR_FP_MODE_FR; 10671 } 10672 if (env->CP0_Config5 & (1 << CP0C5_FRE)) { 10673 ret |= TARGET_PR_FP_MODE_FRE; 10674 } 10675 return ret; 10676 } 10677 case TARGET_PR_SET_FP_MODE: 10678 { 10679 CPUMIPSState *env = ((CPUMIPSState *)cpu_env); 10680 bool old_fr = env->CP0_Status & (1 << CP0St_FR); 10681 bool old_fre = env->CP0_Config5 & (1 << CP0C5_FRE); 10682 bool new_fr = arg2 & TARGET_PR_FP_MODE_FR; 10683 bool new_fre = arg2 & TARGET_PR_FP_MODE_FRE; 10684 10685 const unsigned int known_bits = TARGET_PR_FP_MODE_FR | 10686 TARGET_PR_FP_MODE_FRE; 10687 10688 /* If nothing to change, return right away, successfully. */ 10689 if (old_fr == new_fr && old_fre == new_fre) { 10690 return 0; 10691 } 10692 /* Check the value is valid */ 10693 if (arg2 & ~known_bits) { 10694 return -TARGET_EOPNOTSUPP; 10695 } 10696 /* Setting FRE without FR is not supported. */ 10697 if (new_fre && !new_fr) { 10698 return -TARGET_EOPNOTSUPP; 10699 } 10700 if (new_fr && !(env->active_fpu.fcr0 & (1 << FCR0_F64))) { 10701 /* FR1 is not supported */ 10702 return -TARGET_EOPNOTSUPP; 10703 } 10704 if (!new_fr && (env->active_fpu.fcr0 & (1 << FCR0_F64)) 10705 && !(env->CP0_Status_rw_bitmask & (1 << CP0St_FR))) { 10706 /* cannot set FR=0 */ 10707 return -TARGET_EOPNOTSUPP; 10708 } 10709 if (new_fre && !(env->active_fpu.fcr0 & (1 << FCR0_FREP))) { 10710 /* Cannot set FRE=1 */ 10711 return -TARGET_EOPNOTSUPP; 10712 } 10713 10714 int i; 10715 fpr_t *fpr = env->active_fpu.fpr; 10716 for (i = 0; i < 32 ; i += 2) { 10717 if (!old_fr && new_fr) { 10718 fpr[i].w[!FP_ENDIAN_IDX] = fpr[i + 1].w[FP_ENDIAN_IDX]; 10719 } else if (old_fr && !new_fr) { 10720 fpr[i + 1].w[FP_ENDIAN_IDX] = fpr[i].w[!FP_ENDIAN_IDX]; 10721 } 10722 } 10723 10724 if (new_fr) { 10725 env->CP0_Status |= (1 << CP0St_FR); 10726 env->hflags |= MIPS_HFLAG_F64; 10727 } else { 10728 env->CP0_Status &= ~(1 << CP0St_FR); 10729 env->hflags &= ~MIPS_HFLAG_F64; 10730 } 10731 if (new_fre) { 10732 env->CP0_Config5 |= (1 << CP0C5_FRE); 10733 if (env->active_fpu.fcr0 & (1 << FCR0_FREP)) { 10734 env->hflags |= MIPS_HFLAG_FRE; 10735 } 10736 } else { 10737 env->CP0_Config5 &= ~(1 << CP0C5_FRE); 10738 env->hflags &= ~MIPS_HFLAG_FRE; 10739 } 10740 10741 return 0; 10742 } 10743 #endif /* MIPS */ 10744 #ifdef TARGET_AARCH64 10745 case TARGET_PR_SVE_SET_VL: 10746 /* 10747 * We cannot support either PR_SVE_SET_VL_ONEXEC or 10748 * PR_SVE_VL_INHERIT. Note the kernel definition 10749 * of sve_vl_valid allows for VQ=512, i.e. VL=8192, 10750 * even though the current architectural maximum is VQ=16. 10751 */ 10752 ret = -TARGET_EINVAL; 10753 if (cpu_isar_feature(aa64_sve, env_archcpu(cpu_env)) 10754 && arg2 >= 0 && arg2 <= 512 * 16 && !(arg2 & 15)) { 10755 CPUARMState *env = cpu_env; 10756 ARMCPU *cpu = env_archcpu(env); 10757 uint32_t vq, old_vq; 10758 10759 old_vq = (env->vfp.zcr_el[1] & 0xf) + 1; 10760 vq = MAX(arg2 / 16, 1); 10761 vq = MIN(vq, cpu->sve_max_vq); 10762 10763 if (vq < old_vq) { 10764 aarch64_sve_narrow_vq(env, vq); 10765 } 10766 env->vfp.zcr_el[1] = vq - 1; 10767 arm_rebuild_hflags(env); 10768 ret = vq * 16; 10769 } 10770 return ret; 10771 case TARGET_PR_SVE_GET_VL: 10772 ret = -TARGET_EINVAL; 10773 { 10774 ARMCPU *cpu = env_archcpu(cpu_env); 10775 if (cpu_isar_feature(aa64_sve, cpu)) { 10776 ret = ((cpu->env.vfp.zcr_el[1] & 0xf) + 1) * 16; 10777 } 10778 } 10779 return ret; 10780 case TARGET_PR_PAC_RESET_KEYS: 10781 { 10782 CPUARMState *env = cpu_env; 10783 ARMCPU *cpu = env_archcpu(env); 10784 10785 if (arg3 || arg4 || arg5) { 10786 return -TARGET_EINVAL; 10787 } 10788 if (cpu_isar_feature(aa64_pauth, cpu)) { 10789 int all = (TARGET_PR_PAC_APIAKEY | TARGET_PR_PAC_APIBKEY | 10790 TARGET_PR_PAC_APDAKEY | TARGET_PR_PAC_APDBKEY | 10791 TARGET_PR_PAC_APGAKEY); 10792 int ret = 0; 10793 Error *err = NULL; 10794 10795 if (arg2 == 0) { 10796 arg2 = all; 10797 } else if (arg2 & ~all) { 10798 return -TARGET_EINVAL; 10799 } 10800 if (arg2 & TARGET_PR_PAC_APIAKEY) { 10801 ret |= qemu_guest_getrandom(&env->keys.apia, 10802 sizeof(ARMPACKey), &err); 10803 } 10804 if (arg2 & TARGET_PR_PAC_APIBKEY) { 10805 ret |= qemu_guest_getrandom(&env->keys.apib, 10806 sizeof(ARMPACKey), &err); 10807 } 10808 if (arg2 & TARGET_PR_PAC_APDAKEY) { 10809 ret |= qemu_guest_getrandom(&env->keys.apda, 10810 sizeof(ARMPACKey), &err); 10811 } 10812 if (arg2 & TARGET_PR_PAC_APDBKEY) { 10813 ret |= qemu_guest_getrandom(&env->keys.apdb, 10814 sizeof(ARMPACKey), &err); 10815 } 10816 if (arg2 & TARGET_PR_PAC_APGAKEY) { 10817 ret |= qemu_guest_getrandom(&env->keys.apga, 10818 sizeof(ARMPACKey), &err); 10819 } 10820 if (ret != 0) { 10821 /* 10822 * Some unknown failure in the crypto. The best 10823 * we can do is log it and fail the syscall. 10824 * The real syscall cannot fail this way. 10825 */ 10826 qemu_log_mask(LOG_UNIMP, 10827 "PR_PAC_RESET_KEYS: Crypto failure: %s", 10828 error_get_pretty(err)); 10829 error_free(err); 10830 return -TARGET_EIO; 10831 } 10832 return 0; 10833 } 10834 } 10835 return -TARGET_EINVAL; 10836 case TARGET_PR_SET_TAGGED_ADDR_CTRL: 10837 { 10838 abi_ulong valid_mask = TARGET_PR_TAGGED_ADDR_ENABLE; 10839 CPUARMState *env = cpu_env; 10840 ARMCPU *cpu = env_archcpu(env); 10841 10842 if (cpu_isar_feature(aa64_mte, cpu)) { 10843 valid_mask |= TARGET_PR_MTE_TCF_MASK; 10844 valid_mask |= TARGET_PR_MTE_TAG_MASK; 10845 } 10846 10847 if ((arg2 & ~valid_mask) || arg3 || arg4 || arg5) { 10848 return -TARGET_EINVAL; 10849 } 10850 env->tagged_addr_enable = arg2 & TARGET_PR_TAGGED_ADDR_ENABLE; 10851 10852 if (cpu_isar_feature(aa64_mte, cpu)) { 10853 switch (arg2 & TARGET_PR_MTE_TCF_MASK) { 10854 case TARGET_PR_MTE_TCF_NONE: 10855 case TARGET_PR_MTE_TCF_SYNC: 10856 case TARGET_PR_MTE_TCF_ASYNC: 10857 break; 10858 default: 10859 return -EINVAL; 10860 } 10861 10862 /* 10863 * Write PR_MTE_TCF to SCTLR_EL1[TCF0]. 10864 * Note that the syscall values are consistent with hw. 10865 */ 10866 env->cp15.sctlr_el[1] = 10867 deposit64(env->cp15.sctlr_el[1], 38, 2, 10868 arg2 >> TARGET_PR_MTE_TCF_SHIFT); 10869 10870 /* 10871 * Write PR_MTE_TAG to GCR_EL1[Exclude]. 10872 * Note that the syscall uses an include mask, 10873 * and hardware uses an exclude mask -- invert. 10874 */ 10875 env->cp15.gcr_el1 = 10876 deposit64(env->cp15.gcr_el1, 0, 16, 10877 ~arg2 >> TARGET_PR_MTE_TAG_SHIFT); 10878 arm_rebuild_hflags(env); 10879 } 10880 return 0; 10881 } 10882 case TARGET_PR_GET_TAGGED_ADDR_CTRL: 10883 { 10884 abi_long ret = 0; 10885 CPUARMState *env = cpu_env; 10886 ARMCPU *cpu = env_archcpu(env); 10887 10888 if (arg2 || arg3 || arg4 || arg5) { 10889 return -TARGET_EINVAL; 10890 } 10891 if (env->tagged_addr_enable) { 10892 ret |= TARGET_PR_TAGGED_ADDR_ENABLE; 10893 } 10894 if (cpu_isar_feature(aa64_mte, cpu)) { 10895 /* See above. */ 10896 ret |= (extract64(env->cp15.sctlr_el[1], 38, 2) 10897 << TARGET_PR_MTE_TCF_SHIFT); 10898 ret = deposit64(ret, TARGET_PR_MTE_TAG_SHIFT, 16, 10899 ~env->cp15.gcr_el1); 10900 } 10901 return ret; 10902 } 10903 #endif /* AARCH64 */ 10904 case PR_GET_SECCOMP: 10905 case PR_SET_SECCOMP: 10906 /* Disable seccomp to prevent the target disabling syscalls we 10907 * need. */ 10908 return -TARGET_EINVAL; 10909 default: 10910 /* Most prctl options have no pointer arguments */ 10911 return get_errno(prctl(arg1, arg2, arg3, arg4, arg5)); 10912 } 10913 break; 10914 #ifdef TARGET_NR_arch_prctl 10915 case TARGET_NR_arch_prctl: 10916 return do_arch_prctl(cpu_env, arg1, arg2); 10917 #endif 10918 #ifdef TARGET_NR_pread64 10919 case TARGET_NR_pread64: 10920 if (regpairs_aligned(cpu_env, num)) { 10921 arg4 = arg5; 10922 arg5 = arg6; 10923 } 10924 if (arg2 == 0 && arg3 == 0) { 10925 /* Special-case NULL buffer and zero length, which should succeed */ 10926 p = 0; 10927 } else { 10928 p = lock_user(VERIFY_WRITE, arg2, arg3, 0); 10929 if (!p) { 10930 return -TARGET_EFAULT; 10931 } 10932 } 10933 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5))); 10934 unlock_user(p, arg2, ret); 10935 return ret; 10936 case TARGET_NR_pwrite64: 10937 if (regpairs_aligned(cpu_env, num)) { 10938 arg4 = arg5; 10939 arg5 = arg6; 10940 } 10941 if (arg2 == 0 && arg3 == 0) { 10942 /* Special-case NULL buffer and zero length, which should succeed */ 10943 p = 0; 10944 } else { 10945 p = lock_user(VERIFY_READ, arg2, arg3, 1); 10946 if (!p) { 10947 return -TARGET_EFAULT; 10948 } 10949 } 10950 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5))); 10951 unlock_user(p, arg2, 0); 10952 return ret; 10953 #endif 10954 case TARGET_NR_getcwd: 10955 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0))) 10956 return -TARGET_EFAULT; 10957 ret = get_errno(sys_getcwd1(p, arg2)); 10958 unlock_user(p, arg1, ret); 10959 return ret; 10960 case TARGET_NR_capget: 10961 case TARGET_NR_capset: 10962 { 10963 struct target_user_cap_header *target_header; 10964 struct target_user_cap_data *target_data = NULL; 10965 struct __user_cap_header_struct header; 10966 struct __user_cap_data_struct data[2]; 10967 struct __user_cap_data_struct *dataptr = NULL; 10968 int i, target_datalen; 10969 int data_items = 1; 10970 10971 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) { 10972 return -TARGET_EFAULT; 10973 } 10974 header.version = tswap32(target_header->version); 10975 header.pid = tswap32(target_header->pid); 10976 10977 if (header.version != _LINUX_CAPABILITY_VERSION) { 10978 /* Version 2 and up takes pointer to two user_data structs */ 10979 data_items = 2; 10980 } 10981 10982 target_datalen = sizeof(*target_data) * data_items; 10983 10984 if (arg2) { 10985 if (num == TARGET_NR_capget) { 10986 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0); 10987 } else { 10988 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1); 10989 } 10990 if (!target_data) { 10991 unlock_user_struct(target_header, arg1, 0); 10992 return -TARGET_EFAULT; 10993 } 10994 10995 if (num == TARGET_NR_capset) { 10996 for (i = 0; i < data_items; i++) { 10997 data[i].effective = tswap32(target_data[i].effective); 10998 data[i].permitted = tswap32(target_data[i].permitted); 10999 data[i].inheritable = tswap32(target_data[i].inheritable); 11000 } 11001 } 11002 11003 dataptr = data; 11004 } 11005 11006 if (num == TARGET_NR_capget) { 11007 ret = get_errno(capget(&header, dataptr)); 11008 } else { 11009 ret = get_errno(capset(&header, dataptr)); 11010 } 11011 11012 /* The kernel always updates version for both capget and capset */ 11013 target_header->version = tswap32(header.version); 11014 unlock_user_struct(target_header, arg1, 1); 11015 11016 if (arg2) { 11017 if (num == TARGET_NR_capget) { 11018 for (i = 0; i < data_items; i++) { 11019 target_data[i].effective = tswap32(data[i].effective); 11020 target_data[i].permitted = tswap32(data[i].permitted); 11021 target_data[i].inheritable = tswap32(data[i].inheritable); 11022 } 11023 unlock_user(target_data, arg2, target_datalen); 11024 } else { 11025 unlock_user(target_data, arg2, 0); 11026 } 11027 } 11028 return ret; 11029 } 11030 case TARGET_NR_sigaltstack: 11031 return do_sigaltstack(arg1, arg2, cpu_env); 11032 11033 #ifdef CONFIG_SENDFILE 11034 #ifdef TARGET_NR_sendfile 11035 case TARGET_NR_sendfile: 11036 { 11037 off_t *offp = NULL; 11038 off_t off; 11039 if (arg3) { 11040 ret = get_user_sal(off, arg3); 11041 if (is_error(ret)) { 11042 return ret; 11043 } 11044 offp = &off; 11045 } 11046 ret = get_errno(sendfile(arg1, arg2, offp, arg4)); 11047 if (!is_error(ret) && arg3) { 11048 abi_long ret2 = put_user_sal(off, arg3); 11049 if (is_error(ret2)) { 11050 ret = ret2; 11051 } 11052 } 11053 return ret; 11054 } 11055 #endif 11056 #ifdef TARGET_NR_sendfile64 11057 case TARGET_NR_sendfile64: 11058 { 11059 off_t *offp = NULL; 11060 off_t off; 11061 if (arg3) { 11062 ret = get_user_s64(off, arg3); 11063 if (is_error(ret)) { 11064 return ret; 11065 } 11066 offp = &off; 11067 } 11068 ret = get_errno(sendfile(arg1, arg2, offp, arg4)); 11069 if (!is_error(ret) && arg3) { 11070 abi_long ret2 = put_user_s64(off, arg3); 11071 if (is_error(ret2)) { 11072 ret = ret2; 11073 } 11074 } 11075 return ret; 11076 } 11077 #endif 11078 #endif 11079 #ifdef TARGET_NR_vfork 11080 case TARGET_NR_vfork: 11081 return get_errno(do_fork(cpu_env, 11082 CLONE_VFORK | CLONE_VM | TARGET_SIGCHLD, 11083 0, 0, 0, 0)); 11084 #endif 11085 #ifdef TARGET_NR_ugetrlimit 11086 case TARGET_NR_ugetrlimit: 11087 { 11088 struct rlimit rlim; 11089 int resource = target_to_host_resource(arg1); 11090 ret = get_errno(getrlimit(resource, &rlim)); 11091 if (!is_error(ret)) { 11092 struct target_rlimit *target_rlim; 11093 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 11094 return -TARGET_EFAULT; 11095 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur); 11096 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max); 11097 unlock_user_struct(target_rlim, arg2, 1); 11098 } 11099 return ret; 11100 } 11101 #endif 11102 #ifdef TARGET_NR_truncate64 11103 case TARGET_NR_truncate64: 11104 if (!(p = lock_user_string(arg1))) 11105 return -TARGET_EFAULT; 11106 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4); 11107 unlock_user(p, arg1, 0); 11108 return ret; 11109 #endif 11110 #ifdef TARGET_NR_ftruncate64 11111 case TARGET_NR_ftruncate64: 11112 return target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4); 11113 #endif 11114 #ifdef TARGET_NR_stat64 11115 case TARGET_NR_stat64: 11116 if (!(p = lock_user_string(arg1))) { 11117 return -TARGET_EFAULT; 11118 } 11119 ret = get_errno(stat(path(p), &st)); 11120 unlock_user(p, arg1, 0); 11121 if (!is_error(ret)) 11122 ret = host_to_target_stat64(cpu_env, arg2, &st); 11123 return ret; 11124 #endif 11125 #ifdef TARGET_NR_lstat64 11126 case TARGET_NR_lstat64: 11127 if (!(p = lock_user_string(arg1))) { 11128 return -TARGET_EFAULT; 11129 } 11130 ret = get_errno(lstat(path(p), &st)); 11131 unlock_user(p, arg1, 0); 11132 if (!is_error(ret)) 11133 ret = host_to_target_stat64(cpu_env, arg2, &st); 11134 return ret; 11135 #endif 11136 #ifdef TARGET_NR_fstat64 11137 case TARGET_NR_fstat64: 11138 ret = get_errno(fstat(arg1, &st)); 11139 if (!is_error(ret)) 11140 ret = host_to_target_stat64(cpu_env, arg2, &st); 11141 return ret; 11142 #endif 11143 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) 11144 #ifdef TARGET_NR_fstatat64 11145 case TARGET_NR_fstatat64: 11146 #endif 11147 #ifdef TARGET_NR_newfstatat 11148 case TARGET_NR_newfstatat: 11149 #endif 11150 if (!(p = lock_user_string(arg2))) { 11151 return -TARGET_EFAULT; 11152 } 11153 ret = get_errno(fstatat(arg1, path(p), &st, arg4)); 11154 unlock_user(p, arg2, 0); 11155 if (!is_error(ret)) 11156 ret = host_to_target_stat64(cpu_env, arg3, &st); 11157 return ret; 11158 #endif 11159 #if defined(TARGET_NR_statx) 11160 case TARGET_NR_statx: 11161 { 11162 struct target_statx *target_stx; 11163 int dirfd = arg1; 11164 int flags = arg3; 11165 11166 p = lock_user_string(arg2); 11167 if (p == NULL) { 11168 return -TARGET_EFAULT; 11169 } 11170 #if defined(__NR_statx) 11171 { 11172 /* 11173 * It is assumed that struct statx is architecture independent. 11174 */ 11175 struct target_statx host_stx; 11176 int mask = arg4; 11177 11178 ret = get_errno(sys_statx(dirfd, p, flags, mask, &host_stx)); 11179 if (!is_error(ret)) { 11180 if (host_to_target_statx(&host_stx, arg5) != 0) { 11181 unlock_user(p, arg2, 0); 11182 return -TARGET_EFAULT; 11183 } 11184 } 11185 11186 if (ret != -TARGET_ENOSYS) { 11187 unlock_user(p, arg2, 0); 11188 return ret; 11189 } 11190 } 11191 #endif 11192 ret = get_errno(fstatat(dirfd, path(p), &st, flags)); 11193 unlock_user(p, arg2, 0); 11194 11195 if (!is_error(ret)) { 11196 if (!lock_user_struct(VERIFY_WRITE, target_stx, arg5, 0)) { 11197 return -TARGET_EFAULT; 11198 } 11199 memset(target_stx, 0, sizeof(*target_stx)); 11200 __put_user(major(st.st_dev), &target_stx->stx_dev_major); 11201 __put_user(minor(st.st_dev), &target_stx->stx_dev_minor); 11202 __put_user(st.st_ino, &target_stx->stx_ino); 11203 __put_user(st.st_mode, &target_stx->stx_mode); 11204 __put_user(st.st_uid, &target_stx->stx_uid); 11205 __put_user(st.st_gid, &target_stx->stx_gid); 11206 __put_user(st.st_nlink, &target_stx->stx_nlink); 11207 __put_user(major(st.st_rdev), &target_stx->stx_rdev_major); 11208 __put_user(minor(st.st_rdev), &target_stx->stx_rdev_minor); 11209 __put_user(st.st_size, &target_stx->stx_size); 11210 __put_user(st.st_blksize, &target_stx->stx_blksize); 11211 __put_user(st.st_blocks, &target_stx->stx_blocks); 11212 __put_user(st.st_atime, &target_stx->stx_atime.tv_sec); 11213 __put_user(st.st_mtime, &target_stx->stx_mtime.tv_sec); 11214 __put_user(st.st_ctime, &target_stx->stx_ctime.tv_sec); 11215 unlock_user_struct(target_stx, arg5, 1); 11216 } 11217 } 11218 return ret; 11219 #endif 11220 #ifdef TARGET_NR_lchown 11221 case TARGET_NR_lchown: 11222 if (!(p = lock_user_string(arg1))) 11223 return -TARGET_EFAULT; 11224 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3))); 11225 unlock_user(p, arg1, 0); 11226 return ret; 11227 #endif 11228 #ifdef TARGET_NR_getuid 11229 case TARGET_NR_getuid: 11230 return get_errno(high2lowuid(getuid())); 11231 #endif 11232 #ifdef TARGET_NR_getgid 11233 case TARGET_NR_getgid: 11234 return get_errno(high2lowgid(getgid())); 11235 #endif 11236 #ifdef TARGET_NR_geteuid 11237 case TARGET_NR_geteuid: 11238 return get_errno(high2lowuid(geteuid())); 11239 #endif 11240 #ifdef TARGET_NR_getegid 11241 case TARGET_NR_getegid: 11242 return get_errno(high2lowgid(getegid())); 11243 #endif 11244 case TARGET_NR_setreuid: 11245 return get_errno(setreuid(low2highuid(arg1), low2highuid(arg2))); 11246 case TARGET_NR_setregid: 11247 return get_errno(setregid(low2highgid(arg1), low2highgid(arg2))); 11248 case TARGET_NR_getgroups: 11249 { 11250 int gidsetsize = arg1; 11251 target_id *target_grouplist; 11252 gid_t *grouplist; 11253 int i; 11254 11255 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11256 ret = get_errno(getgroups(gidsetsize, grouplist)); 11257 if (gidsetsize == 0) 11258 return ret; 11259 if (!is_error(ret)) { 11260 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0); 11261 if (!target_grouplist) 11262 return -TARGET_EFAULT; 11263 for(i = 0;i < ret; i++) 11264 target_grouplist[i] = tswapid(high2lowgid(grouplist[i])); 11265 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id)); 11266 } 11267 } 11268 return ret; 11269 case TARGET_NR_setgroups: 11270 { 11271 int gidsetsize = arg1; 11272 target_id *target_grouplist; 11273 gid_t *grouplist = NULL; 11274 int i; 11275 if (gidsetsize) { 11276 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11277 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1); 11278 if (!target_grouplist) { 11279 return -TARGET_EFAULT; 11280 } 11281 for (i = 0; i < gidsetsize; i++) { 11282 grouplist[i] = low2highgid(tswapid(target_grouplist[i])); 11283 } 11284 unlock_user(target_grouplist, arg2, 0); 11285 } 11286 return get_errno(setgroups(gidsetsize, grouplist)); 11287 } 11288 case TARGET_NR_fchown: 11289 return get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3))); 11290 #if defined(TARGET_NR_fchownat) 11291 case TARGET_NR_fchownat: 11292 if (!(p = lock_user_string(arg2))) 11293 return -TARGET_EFAULT; 11294 ret = get_errno(fchownat(arg1, p, low2highuid(arg3), 11295 low2highgid(arg4), arg5)); 11296 unlock_user(p, arg2, 0); 11297 return ret; 11298 #endif 11299 #ifdef TARGET_NR_setresuid 11300 case TARGET_NR_setresuid: 11301 return get_errno(sys_setresuid(low2highuid(arg1), 11302 low2highuid(arg2), 11303 low2highuid(arg3))); 11304 #endif 11305 #ifdef TARGET_NR_getresuid 11306 case TARGET_NR_getresuid: 11307 { 11308 uid_t ruid, euid, suid; 11309 ret = get_errno(getresuid(&ruid, &euid, &suid)); 11310 if (!is_error(ret)) { 11311 if (put_user_id(high2lowuid(ruid), arg1) 11312 || put_user_id(high2lowuid(euid), arg2) 11313 || put_user_id(high2lowuid(suid), arg3)) 11314 return -TARGET_EFAULT; 11315 } 11316 } 11317 return ret; 11318 #endif 11319 #ifdef TARGET_NR_getresgid 11320 case TARGET_NR_setresgid: 11321 return get_errno(sys_setresgid(low2highgid(arg1), 11322 low2highgid(arg2), 11323 low2highgid(arg3))); 11324 #endif 11325 #ifdef TARGET_NR_getresgid 11326 case TARGET_NR_getresgid: 11327 { 11328 gid_t rgid, egid, sgid; 11329 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 11330 if (!is_error(ret)) { 11331 if (put_user_id(high2lowgid(rgid), arg1) 11332 || put_user_id(high2lowgid(egid), arg2) 11333 || put_user_id(high2lowgid(sgid), arg3)) 11334 return -TARGET_EFAULT; 11335 } 11336 } 11337 return ret; 11338 #endif 11339 #ifdef TARGET_NR_chown 11340 case TARGET_NR_chown: 11341 if (!(p = lock_user_string(arg1))) 11342 return -TARGET_EFAULT; 11343 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3))); 11344 unlock_user(p, arg1, 0); 11345 return ret; 11346 #endif 11347 case TARGET_NR_setuid: 11348 return get_errno(sys_setuid(low2highuid(arg1))); 11349 case TARGET_NR_setgid: 11350 return get_errno(sys_setgid(low2highgid(arg1))); 11351 case TARGET_NR_setfsuid: 11352 return get_errno(setfsuid(arg1)); 11353 case TARGET_NR_setfsgid: 11354 return get_errno(setfsgid(arg1)); 11355 11356 #ifdef TARGET_NR_lchown32 11357 case TARGET_NR_lchown32: 11358 if (!(p = lock_user_string(arg1))) 11359 return -TARGET_EFAULT; 11360 ret = get_errno(lchown(p, arg2, arg3)); 11361 unlock_user(p, arg1, 0); 11362 return ret; 11363 #endif 11364 #ifdef TARGET_NR_getuid32 11365 case TARGET_NR_getuid32: 11366 return get_errno(getuid()); 11367 #endif 11368 11369 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA) 11370 /* Alpha specific */ 11371 case TARGET_NR_getxuid: 11372 { 11373 uid_t euid; 11374 euid=geteuid(); 11375 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid; 11376 } 11377 return get_errno(getuid()); 11378 #endif 11379 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA) 11380 /* Alpha specific */ 11381 case TARGET_NR_getxgid: 11382 { 11383 uid_t egid; 11384 egid=getegid(); 11385 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid; 11386 } 11387 return get_errno(getgid()); 11388 #endif 11389 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA) 11390 /* Alpha specific */ 11391 case TARGET_NR_osf_getsysinfo: 11392 ret = -TARGET_EOPNOTSUPP; 11393 switch (arg1) { 11394 case TARGET_GSI_IEEE_FP_CONTROL: 11395 { 11396 uint64_t fpcr = cpu_alpha_load_fpcr(cpu_env); 11397 uint64_t swcr = ((CPUAlphaState *)cpu_env)->swcr; 11398 11399 swcr &= ~SWCR_STATUS_MASK; 11400 swcr |= (fpcr >> 35) & SWCR_STATUS_MASK; 11401 11402 if (put_user_u64 (swcr, arg2)) 11403 return -TARGET_EFAULT; 11404 ret = 0; 11405 } 11406 break; 11407 11408 /* case GSI_IEEE_STATE_AT_SIGNAL: 11409 -- Not implemented in linux kernel. 11410 case GSI_UACPROC: 11411 -- Retrieves current unaligned access state; not much used. 11412 case GSI_PROC_TYPE: 11413 -- Retrieves implver information; surely not used. 11414 case GSI_GET_HWRPB: 11415 -- Grabs a copy of the HWRPB; surely not used. 11416 */ 11417 } 11418 return ret; 11419 #endif 11420 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA) 11421 /* Alpha specific */ 11422 case TARGET_NR_osf_setsysinfo: 11423 ret = -TARGET_EOPNOTSUPP; 11424 switch (arg1) { 11425 case TARGET_SSI_IEEE_FP_CONTROL: 11426 { 11427 uint64_t swcr, fpcr; 11428 11429 if (get_user_u64 (swcr, arg2)) { 11430 return -TARGET_EFAULT; 11431 } 11432 11433 /* 11434 * The kernel calls swcr_update_status to update the 11435 * status bits from the fpcr at every point that it 11436 * could be queried. Therefore, we store the status 11437 * bits only in FPCR. 11438 */ 11439 ((CPUAlphaState *)cpu_env)->swcr 11440 = swcr & (SWCR_TRAP_ENABLE_MASK | SWCR_MAP_MASK); 11441 11442 fpcr = cpu_alpha_load_fpcr(cpu_env); 11443 fpcr &= ((uint64_t)FPCR_DYN_MASK << 32); 11444 fpcr |= alpha_ieee_swcr_to_fpcr(swcr); 11445 cpu_alpha_store_fpcr(cpu_env, fpcr); 11446 ret = 0; 11447 } 11448 break; 11449 11450 case TARGET_SSI_IEEE_RAISE_EXCEPTION: 11451 { 11452 uint64_t exc, fpcr, fex; 11453 11454 if (get_user_u64(exc, arg2)) { 11455 return -TARGET_EFAULT; 11456 } 11457 exc &= SWCR_STATUS_MASK; 11458 fpcr = cpu_alpha_load_fpcr(cpu_env); 11459 11460 /* Old exceptions are not signaled. */ 11461 fex = alpha_ieee_fpcr_to_swcr(fpcr); 11462 fex = exc & ~fex; 11463 fex >>= SWCR_STATUS_TO_EXCSUM_SHIFT; 11464 fex &= ((CPUArchState *)cpu_env)->swcr; 11465 11466 /* Update the hardware fpcr. */ 11467 fpcr |= alpha_ieee_swcr_to_fpcr(exc); 11468 cpu_alpha_store_fpcr(cpu_env, fpcr); 11469 11470 if (fex) { 11471 int si_code = TARGET_FPE_FLTUNK; 11472 target_siginfo_t info; 11473 11474 if (fex & SWCR_TRAP_ENABLE_DNO) { 11475 si_code = TARGET_FPE_FLTUND; 11476 } 11477 if (fex & SWCR_TRAP_ENABLE_INE) { 11478 si_code = TARGET_FPE_FLTRES; 11479 } 11480 if (fex & SWCR_TRAP_ENABLE_UNF) { 11481 si_code = TARGET_FPE_FLTUND; 11482 } 11483 if (fex & SWCR_TRAP_ENABLE_OVF) { 11484 si_code = TARGET_FPE_FLTOVF; 11485 } 11486 if (fex & SWCR_TRAP_ENABLE_DZE) { 11487 si_code = TARGET_FPE_FLTDIV; 11488 } 11489 if (fex & SWCR_TRAP_ENABLE_INV) { 11490 si_code = TARGET_FPE_FLTINV; 11491 } 11492 11493 info.si_signo = SIGFPE; 11494 info.si_errno = 0; 11495 info.si_code = si_code; 11496 info._sifields._sigfault._addr 11497 = ((CPUArchState *)cpu_env)->pc; 11498 queue_signal((CPUArchState *)cpu_env, info.si_signo, 11499 QEMU_SI_FAULT, &info); 11500 } 11501 ret = 0; 11502 } 11503 break; 11504 11505 /* case SSI_NVPAIRS: 11506 -- Used with SSIN_UACPROC to enable unaligned accesses. 11507 case SSI_IEEE_STATE_AT_SIGNAL: 11508 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL: 11509 -- Not implemented in linux kernel 11510 */ 11511 } 11512 return ret; 11513 #endif 11514 #ifdef TARGET_NR_osf_sigprocmask 11515 /* Alpha specific. */ 11516 case TARGET_NR_osf_sigprocmask: 11517 { 11518 abi_ulong mask; 11519 int how; 11520 sigset_t set, oldset; 11521 11522 switch(arg1) { 11523 case TARGET_SIG_BLOCK: 11524 how = SIG_BLOCK; 11525 break; 11526 case TARGET_SIG_UNBLOCK: 11527 how = SIG_UNBLOCK; 11528 break; 11529 case TARGET_SIG_SETMASK: 11530 how = SIG_SETMASK; 11531 break; 11532 default: 11533 return -TARGET_EINVAL; 11534 } 11535 mask = arg2; 11536 target_to_host_old_sigset(&set, &mask); 11537 ret = do_sigprocmask(how, &set, &oldset); 11538 if (!ret) { 11539 host_to_target_old_sigset(&mask, &oldset); 11540 ret = mask; 11541 } 11542 } 11543 return ret; 11544 #endif 11545 11546 #ifdef TARGET_NR_getgid32 11547 case TARGET_NR_getgid32: 11548 return get_errno(getgid()); 11549 #endif 11550 #ifdef TARGET_NR_geteuid32 11551 case TARGET_NR_geteuid32: 11552 return get_errno(geteuid()); 11553 #endif 11554 #ifdef TARGET_NR_getegid32 11555 case TARGET_NR_getegid32: 11556 return get_errno(getegid()); 11557 #endif 11558 #ifdef TARGET_NR_setreuid32 11559 case TARGET_NR_setreuid32: 11560 return get_errno(setreuid(arg1, arg2)); 11561 #endif 11562 #ifdef TARGET_NR_setregid32 11563 case TARGET_NR_setregid32: 11564 return get_errno(setregid(arg1, arg2)); 11565 #endif 11566 #ifdef TARGET_NR_getgroups32 11567 case TARGET_NR_getgroups32: 11568 { 11569 int gidsetsize = arg1; 11570 uint32_t *target_grouplist; 11571 gid_t *grouplist; 11572 int i; 11573 11574 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11575 ret = get_errno(getgroups(gidsetsize, grouplist)); 11576 if (gidsetsize == 0) 11577 return ret; 11578 if (!is_error(ret)) { 11579 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0); 11580 if (!target_grouplist) { 11581 return -TARGET_EFAULT; 11582 } 11583 for(i = 0;i < ret; i++) 11584 target_grouplist[i] = tswap32(grouplist[i]); 11585 unlock_user(target_grouplist, arg2, gidsetsize * 4); 11586 } 11587 } 11588 return ret; 11589 #endif 11590 #ifdef TARGET_NR_setgroups32 11591 case TARGET_NR_setgroups32: 11592 { 11593 int gidsetsize = arg1; 11594 uint32_t *target_grouplist; 11595 gid_t *grouplist; 11596 int i; 11597 11598 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11599 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1); 11600 if (!target_grouplist) { 11601 return -TARGET_EFAULT; 11602 } 11603 for(i = 0;i < gidsetsize; i++) 11604 grouplist[i] = tswap32(target_grouplist[i]); 11605 unlock_user(target_grouplist, arg2, 0); 11606 return get_errno(setgroups(gidsetsize, grouplist)); 11607 } 11608 #endif 11609 #ifdef TARGET_NR_fchown32 11610 case TARGET_NR_fchown32: 11611 return get_errno(fchown(arg1, arg2, arg3)); 11612 #endif 11613 #ifdef TARGET_NR_setresuid32 11614 case TARGET_NR_setresuid32: 11615 return get_errno(sys_setresuid(arg1, arg2, arg3)); 11616 #endif 11617 #ifdef TARGET_NR_getresuid32 11618 case TARGET_NR_getresuid32: 11619 { 11620 uid_t ruid, euid, suid; 11621 ret = get_errno(getresuid(&ruid, &euid, &suid)); 11622 if (!is_error(ret)) { 11623 if (put_user_u32(ruid, arg1) 11624 || put_user_u32(euid, arg2) 11625 || put_user_u32(suid, arg3)) 11626 return -TARGET_EFAULT; 11627 } 11628 } 11629 return ret; 11630 #endif 11631 #ifdef TARGET_NR_setresgid32 11632 case TARGET_NR_setresgid32: 11633 return get_errno(sys_setresgid(arg1, arg2, arg3)); 11634 #endif 11635 #ifdef TARGET_NR_getresgid32 11636 case TARGET_NR_getresgid32: 11637 { 11638 gid_t rgid, egid, sgid; 11639 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 11640 if (!is_error(ret)) { 11641 if (put_user_u32(rgid, arg1) 11642 || put_user_u32(egid, arg2) 11643 || put_user_u32(sgid, arg3)) 11644 return -TARGET_EFAULT; 11645 } 11646 } 11647 return ret; 11648 #endif 11649 #ifdef TARGET_NR_chown32 11650 case TARGET_NR_chown32: 11651 if (!(p = lock_user_string(arg1))) 11652 return -TARGET_EFAULT; 11653 ret = get_errno(chown(p, arg2, arg3)); 11654 unlock_user(p, arg1, 0); 11655 return ret; 11656 #endif 11657 #ifdef TARGET_NR_setuid32 11658 case TARGET_NR_setuid32: 11659 return get_errno(sys_setuid(arg1)); 11660 #endif 11661 #ifdef TARGET_NR_setgid32 11662 case TARGET_NR_setgid32: 11663 return get_errno(sys_setgid(arg1)); 11664 #endif 11665 #ifdef TARGET_NR_setfsuid32 11666 case TARGET_NR_setfsuid32: 11667 return get_errno(setfsuid(arg1)); 11668 #endif 11669 #ifdef TARGET_NR_setfsgid32 11670 case TARGET_NR_setfsgid32: 11671 return get_errno(setfsgid(arg1)); 11672 #endif 11673 #ifdef TARGET_NR_mincore 11674 case TARGET_NR_mincore: 11675 { 11676 void *a = lock_user(VERIFY_READ, arg1, arg2, 0); 11677 if (!a) { 11678 return -TARGET_ENOMEM; 11679 } 11680 p = lock_user_string(arg3); 11681 if (!p) { 11682 ret = -TARGET_EFAULT; 11683 } else { 11684 ret = get_errno(mincore(a, arg2, p)); 11685 unlock_user(p, arg3, ret); 11686 } 11687 unlock_user(a, arg1, 0); 11688 } 11689 return ret; 11690 #endif 11691 #ifdef TARGET_NR_arm_fadvise64_64 11692 case TARGET_NR_arm_fadvise64_64: 11693 /* arm_fadvise64_64 looks like fadvise64_64 but 11694 * with different argument order: fd, advice, offset, len 11695 * rather than the usual fd, offset, len, advice. 11696 * Note that offset and len are both 64-bit so appear as 11697 * pairs of 32-bit registers. 11698 */ 11699 ret = posix_fadvise(arg1, target_offset64(arg3, arg4), 11700 target_offset64(arg5, arg6), arg2); 11701 return -host_to_target_errno(ret); 11702 #endif 11703 11704 #if TARGET_ABI_BITS == 32 11705 11706 #ifdef TARGET_NR_fadvise64_64 11707 case TARGET_NR_fadvise64_64: 11708 #if defined(TARGET_PPC) || defined(TARGET_XTENSA) 11709 /* 6 args: fd, advice, offset (high, low), len (high, low) */ 11710 ret = arg2; 11711 arg2 = arg3; 11712 arg3 = arg4; 11713 arg4 = arg5; 11714 arg5 = arg6; 11715 arg6 = ret; 11716 #else 11717 /* 6 args: fd, offset (high, low), len (high, low), advice */ 11718 if (regpairs_aligned(cpu_env, num)) { 11719 /* offset is in (3,4), len in (5,6) and advice in 7 */ 11720 arg2 = arg3; 11721 arg3 = arg4; 11722 arg4 = arg5; 11723 arg5 = arg6; 11724 arg6 = arg7; 11725 } 11726 #endif 11727 ret = posix_fadvise(arg1, target_offset64(arg2, arg3), 11728 target_offset64(arg4, arg5), arg6); 11729 return -host_to_target_errno(ret); 11730 #endif 11731 11732 #ifdef TARGET_NR_fadvise64 11733 case TARGET_NR_fadvise64: 11734 /* 5 args: fd, offset (high, low), len, advice */ 11735 if (regpairs_aligned(cpu_env, num)) { 11736 /* offset is in (3,4), len in 5 and advice in 6 */ 11737 arg2 = arg3; 11738 arg3 = arg4; 11739 arg4 = arg5; 11740 arg5 = arg6; 11741 } 11742 ret = posix_fadvise(arg1, target_offset64(arg2, arg3), arg4, arg5); 11743 return -host_to_target_errno(ret); 11744 #endif 11745 11746 #else /* not a 32-bit ABI */ 11747 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64) 11748 #ifdef TARGET_NR_fadvise64_64 11749 case TARGET_NR_fadvise64_64: 11750 #endif 11751 #ifdef TARGET_NR_fadvise64 11752 case TARGET_NR_fadvise64: 11753 #endif 11754 #ifdef TARGET_S390X 11755 switch (arg4) { 11756 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */ 11757 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */ 11758 case 6: arg4 = POSIX_FADV_DONTNEED; break; 11759 case 7: arg4 = POSIX_FADV_NOREUSE; break; 11760 default: break; 11761 } 11762 #endif 11763 return -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4)); 11764 #endif 11765 #endif /* end of 64-bit ABI fadvise handling */ 11766 11767 #ifdef TARGET_NR_madvise 11768 case TARGET_NR_madvise: 11769 /* A straight passthrough may not be safe because qemu sometimes 11770 turns private file-backed mappings into anonymous mappings. 11771 This will break MADV_DONTNEED. 11772 This is a hint, so ignoring and returning success is ok. */ 11773 return 0; 11774 #endif 11775 #ifdef TARGET_NR_fcntl64 11776 case TARGET_NR_fcntl64: 11777 { 11778 int cmd; 11779 struct flock64 fl; 11780 from_flock64_fn *copyfrom = copy_from_user_flock64; 11781 to_flock64_fn *copyto = copy_to_user_flock64; 11782 11783 #ifdef TARGET_ARM 11784 if (!((CPUARMState *)cpu_env)->eabi) { 11785 copyfrom = copy_from_user_oabi_flock64; 11786 copyto = copy_to_user_oabi_flock64; 11787 } 11788 #endif 11789 11790 cmd = target_to_host_fcntl_cmd(arg2); 11791 if (cmd == -TARGET_EINVAL) { 11792 return cmd; 11793 } 11794 11795 switch(arg2) { 11796 case TARGET_F_GETLK64: 11797 ret = copyfrom(&fl, arg3); 11798 if (ret) { 11799 break; 11800 } 11801 ret = get_errno(safe_fcntl(arg1, cmd, &fl)); 11802 if (ret == 0) { 11803 ret = copyto(arg3, &fl); 11804 } 11805 break; 11806 11807 case TARGET_F_SETLK64: 11808 case TARGET_F_SETLKW64: 11809 ret = copyfrom(&fl, arg3); 11810 if (ret) { 11811 break; 11812 } 11813 ret = get_errno(safe_fcntl(arg1, cmd, &fl)); 11814 break; 11815 default: 11816 ret = do_fcntl(arg1, arg2, arg3); 11817 break; 11818 } 11819 return ret; 11820 } 11821 #endif 11822 #ifdef TARGET_NR_cacheflush 11823 case TARGET_NR_cacheflush: 11824 /* self-modifying code is handled automatically, so nothing needed */ 11825 return 0; 11826 #endif 11827 #ifdef TARGET_NR_getpagesize 11828 case TARGET_NR_getpagesize: 11829 return TARGET_PAGE_SIZE; 11830 #endif 11831 case TARGET_NR_gettid: 11832 return get_errno(sys_gettid()); 11833 #ifdef TARGET_NR_readahead 11834 case TARGET_NR_readahead: 11835 #if TARGET_ABI_BITS == 32 11836 if (regpairs_aligned(cpu_env, num)) { 11837 arg2 = arg3; 11838 arg3 = arg4; 11839 arg4 = arg5; 11840 } 11841 ret = get_errno(readahead(arg1, target_offset64(arg2, arg3) , arg4)); 11842 #else 11843 ret = get_errno(readahead(arg1, arg2, arg3)); 11844 #endif 11845 return ret; 11846 #endif 11847 #ifdef CONFIG_ATTR 11848 #ifdef TARGET_NR_setxattr 11849 case TARGET_NR_listxattr: 11850 case TARGET_NR_llistxattr: 11851 { 11852 void *p, *b = 0; 11853 if (arg2) { 11854 b = lock_user(VERIFY_WRITE, arg2, arg3, 0); 11855 if (!b) { 11856 return -TARGET_EFAULT; 11857 } 11858 } 11859 p = lock_user_string(arg1); 11860 if (p) { 11861 if (num == TARGET_NR_listxattr) { 11862 ret = get_errno(listxattr(p, b, arg3)); 11863 } else { 11864 ret = get_errno(llistxattr(p, b, arg3)); 11865 } 11866 } else { 11867 ret = -TARGET_EFAULT; 11868 } 11869 unlock_user(p, arg1, 0); 11870 unlock_user(b, arg2, arg3); 11871 return ret; 11872 } 11873 case TARGET_NR_flistxattr: 11874 { 11875 void *b = 0; 11876 if (arg2) { 11877 b = lock_user(VERIFY_WRITE, arg2, arg3, 0); 11878 if (!b) { 11879 return -TARGET_EFAULT; 11880 } 11881 } 11882 ret = get_errno(flistxattr(arg1, b, arg3)); 11883 unlock_user(b, arg2, arg3); 11884 return ret; 11885 } 11886 case TARGET_NR_setxattr: 11887 case TARGET_NR_lsetxattr: 11888 { 11889 void *p, *n, *v = 0; 11890 if (arg3) { 11891 v = lock_user(VERIFY_READ, arg3, arg4, 1); 11892 if (!v) { 11893 return -TARGET_EFAULT; 11894 } 11895 } 11896 p = lock_user_string(arg1); 11897 n = lock_user_string(arg2); 11898 if (p && n) { 11899 if (num == TARGET_NR_setxattr) { 11900 ret = get_errno(setxattr(p, n, v, arg4, arg5)); 11901 } else { 11902 ret = get_errno(lsetxattr(p, n, v, arg4, arg5)); 11903 } 11904 } else { 11905 ret = -TARGET_EFAULT; 11906 } 11907 unlock_user(p, arg1, 0); 11908 unlock_user(n, arg2, 0); 11909 unlock_user(v, arg3, 0); 11910 } 11911 return ret; 11912 case TARGET_NR_fsetxattr: 11913 { 11914 void *n, *v = 0; 11915 if (arg3) { 11916 v = lock_user(VERIFY_READ, arg3, arg4, 1); 11917 if (!v) { 11918 return -TARGET_EFAULT; 11919 } 11920 } 11921 n = lock_user_string(arg2); 11922 if (n) { 11923 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5)); 11924 } else { 11925 ret = -TARGET_EFAULT; 11926 } 11927 unlock_user(n, arg2, 0); 11928 unlock_user(v, arg3, 0); 11929 } 11930 return ret; 11931 case TARGET_NR_getxattr: 11932 case TARGET_NR_lgetxattr: 11933 { 11934 void *p, *n, *v = 0; 11935 if (arg3) { 11936 v = lock_user(VERIFY_WRITE, arg3, arg4, 0); 11937 if (!v) { 11938 return -TARGET_EFAULT; 11939 } 11940 } 11941 p = lock_user_string(arg1); 11942 n = lock_user_string(arg2); 11943 if (p && n) { 11944 if (num == TARGET_NR_getxattr) { 11945 ret = get_errno(getxattr(p, n, v, arg4)); 11946 } else { 11947 ret = get_errno(lgetxattr(p, n, v, arg4)); 11948 } 11949 } else { 11950 ret = -TARGET_EFAULT; 11951 } 11952 unlock_user(p, arg1, 0); 11953 unlock_user(n, arg2, 0); 11954 unlock_user(v, arg3, arg4); 11955 } 11956 return ret; 11957 case TARGET_NR_fgetxattr: 11958 { 11959 void *n, *v = 0; 11960 if (arg3) { 11961 v = lock_user(VERIFY_WRITE, arg3, arg4, 0); 11962 if (!v) { 11963 return -TARGET_EFAULT; 11964 } 11965 } 11966 n = lock_user_string(arg2); 11967 if (n) { 11968 ret = get_errno(fgetxattr(arg1, n, v, arg4)); 11969 } else { 11970 ret = -TARGET_EFAULT; 11971 } 11972 unlock_user(n, arg2, 0); 11973 unlock_user(v, arg3, arg4); 11974 } 11975 return ret; 11976 case TARGET_NR_removexattr: 11977 case TARGET_NR_lremovexattr: 11978 { 11979 void *p, *n; 11980 p = lock_user_string(arg1); 11981 n = lock_user_string(arg2); 11982 if (p && n) { 11983 if (num == TARGET_NR_removexattr) { 11984 ret = get_errno(removexattr(p, n)); 11985 } else { 11986 ret = get_errno(lremovexattr(p, n)); 11987 } 11988 } else { 11989 ret = -TARGET_EFAULT; 11990 } 11991 unlock_user(p, arg1, 0); 11992 unlock_user(n, arg2, 0); 11993 } 11994 return ret; 11995 case TARGET_NR_fremovexattr: 11996 { 11997 void *n; 11998 n = lock_user_string(arg2); 11999 if (n) { 12000 ret = get_errno(fremovexattr(arg1, n)); 12001 } else { 12002 ret = -TARGET_EFAULT; 12003 } 12004 unlock_user(n, arg2, 0); 12005 } 12006 return ret; 12007 #endif 12008 #endif /* CONFIG_ATTR */ 12009 #ifdef TARGET_NR_set_thread_area 12010 case TARGET_NR_set_thread_area: 12011 #if defined(TARGET_MIPS) 12012 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1; 12013 return 0; 12014 #elif defined(TARGET_CRIS) 12015 if (arg1 & 0xff) 12016 ret = -TARGET_EINVAL; 12017 else { 12018 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1; 12019 ret = 0; 12020 } 12021 return ret; 12022 #elif defined(TARGET_I386) && defined(TARGET_ABI32) 12023 return do_set_thread_area(cpu_env, arg1); 12024 #elif defined(TARGET_M68K) 12025 { 12026 TaskState *ts = cpu->opaque; 12027 ts->tp_value = arg1; 12028 return 0; 12029 } 12030 #else 12031 return -TARGET_ENOSYS; 12032 #endif 12033 #endif 12034 #ifdef TARGET_NR_get_thread_area 12035 case TARGET_NR_get_thread_area: 12036 #if defined(TARGET_I386) && defined(TARGET_ABI32) 12037 return do_get_thread_area(cpu_env, arg1); 12038 #elif defined(TARGET_M68K) 12039 { 12040 TaskState *ts = cpu->opaque; 12041 return ts->tp_value; 12042 } 12043 #else 12044 return -TARGET_ENOSYS; 12045 #endif 12046 #endif 12047 #ifdef TARGET_NR_getdomainname 12048 case TARGET_NR_getdomainname: 12049 return -TARGET_ENOSYS; 12050 #endif 12051 12052 #ifdef TARGET_NR_clock_settime 12053 case TARGET_NR_clock_settime: 12054 { 12055 struct timespec ts; 12056 12057 ret = target_to_host_timespec(&ts, arg2); 12058 if (!is_error(ret)) { 12059 ret = get_errno(clock_settime(arg1, &ts)); 12060 } 12061 return ret; 12062 } 12063 #endif 12064 #ifdef TARGET_NR_clock_settime64 12065 case TARGET_NR_clock_settime64: 12066 { 12067 struct timespec ts; 12068 12069 ret = target_to_host_timespec64(&ts, arg2); 12070 if (!is_error(ret)) { 12071 ret = get_errno(clock_settime(arg1, &ts)); 12072 } 12073 return ret; 12074 } 12075 #endif 12076 #ifdef TARGET_NR_clock_gettime 12077 case TARGET_NR_clock_gettime: 12078 { 12079 struct timespec ts; 12080 ret = get_errno(clock_gettime(arg1, &ts)); 12081 if (!is_error(ret)) { 12082 ret = host_to_target_timespec(arg2, &ts); 12083 } 12084 return ret; 12085 } 12086 #endif 12087 #ifdef TARGET_NR_clock_gettime64 12088 case TARGET_NR_clock_gettime64: 12089 { 12090 struct timespec ts; 12091 ret = get_errno(clock_gettime(arg1, &ts)); 12092 if (!is_error(ret)) { 12093 ret = host_to_target_timespec64(arg2, &ts); 12094 } 12095 return ret; 12096 } 12097 #endif 12098 #ifdef TARGET_NR_clock_getres 12099 case TARGET_NR_clock_getres: 12100 { 12101 struct timespec ts; 12102 ret = get_errno(clock_getres(arg1, &ts)); 12103 if (!is_error(ret)) { 12104 host_to_target_timespec(arg2, &ts); 12105 } 12106 return ret; 12107 } 12108 #endif 12109 #ifdef TARGET_NR_clock_getres_time64 12110 case TARGET_NR_clock_getres_time64: 12111 { 12112 struct timespec ts; 12113 ret = get_errno(clock_getres(arg1, &ts)); 12114 if (!is_error(ret)) { 12115 host_to_target_timespec64(arg2, &ts); 12116 } 12117 return ret; 12118 } 12119 #endif 12120 #ifdef TARGET_NR_clock_nanosleep 12121 case TARGET_NR_clock_nanosleep: 12122 { 12123 struct timespec ts; 12124 if (target_to_host_timespec(&ts, arg3)) { 12125 return -TARGET_EFAULT; 12126 } 12127 ret = get_errno(safe_clock_nanosleep(arg1, arg2, 12128 &ts, arg4 ? &ts : NULL)); 12129 /* 12130 * if the call is interrupted by a signal handler, it fails 12131 * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not 12132 * TIMER_ABSTIME, it returns the remaining unslept time in arg4. 12133 */ 12134 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME && 12135 host_to_target_timespec(arg4, &ts)) { 12136 return -TARGET_EFAULT; 12137 } 12138 12139 return ret; 12140 } 12141 #endif 12142 #ifdef TARGET_NR_clock_nanosleep_time64 12143 case TARGET_NR_clock_nanosleep_time64: 12144 { 12145 struct timespec ts; 12146 12147 if (target_to_host_timespec64(&ts, arg3)) { 12148 return -TARGET_EFAULT; 12149 } 12150 12151 ret = get_errno(safe_clock_nanosleep(arg1, arg2, 12152 &ts, arg4 ? &ts : NULL)); 12153 12154 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME && 12155 host_to_target_timespec64(arg4, &ts)) { 12156 return -TARGET_EFAULT; 12157 } 12158 return ret; 12159 } 12160 #endif 12161 12162 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) 12163 case TARGET_NR_set_tid_address: 12164 return get_errno(set_tid_address((int *)g2h(cpu, arg1))); 12165 #endif 12166 12167 case TARGET_NR_tkill: 12168 return get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2))); 12169 12170 case TARGET_NR_tgkill: 12171 return get_errno(safe_tgkill((int)arg1, (int)arg2, 12172 target_to_host_signal(arg3))); 12173 12174 #ifdef TARGET_NR_set_robust_list 12175 case TARGET_NR_set_robust_list: 12176 case TARGET_NR_get_robust_list: 12177 /* The ABI for supporting robust futexes has userspace pass 12178 * the kernel a pointer to a linked list which is updated by 12179 * userspace after the syscall; the list is walked by the kernel 12180 * when the thread exits. Since the linked list in QEMU guest 12181 * memory isn't a valid linked list for the host and we have 12182 * no way to reliably intercept the thread-death event, we can't 12183 * support these. Silently return ENOSYS so that guest userspace 12184 * falls back to a non-robust futex implementation (which should 12185 * be OK except in the corner case of the guest crashing while 12186 * holding a mutex that is shared with another process via 12187 * shared memory). 12188 */ 12189 return -TARGET_ENOSYS; 12190 #endif 12191 12192 #if defined(TARGET_NR_utimensat) 12193 case TARGET_NR_utimensat: 12194 { 12195 struct timespec *tsp, ts[2]; 12196 if (!arg3) { 12197 tsp = NULL; 12198 } else { 12199 if (target_to_host_timespec(ts, arg3)) { 12200 return -TARGET_EFAULT; 12201 } 12202 if (target_to_host_timespec(ts + 1, arg3 + 12203 sizeof(struct target_timespec))) { 12204 return -TARGET_EFAULT; 12205 } 12206 tsp = ts; 12207 } 12208 if (!arg2) 12209 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4)); 12210 else { 12211 if (!(p = lock_user_string(arg2))) { 12212 return -TARGET_EFAULT; 12213 } 12214 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4)); 12215 unlock_user(p, arg2, 0); 12216 } 12217 } 12218 return ret; 12219 #endif 12220 #ifdef TARGET_NR_utimensat_time64 12221 case TARGET_NR_utimensat_time64: 12222 { 12223 struct timespec *tsp, ts[2]; 12224 if (!arg3) { 12225 tsp = NULL; 12226 } else { 12227 if (target_to_host_timespec64(ts, arg3)) { 12228 return -TARGET_EFAULT; 12229 } 12230 if (target_to_host_timespec64(ts + 1, arg3 + 12231 sizeof(struct target__kernel_timespec))) { 12232 return -TARGET_EFAULT; 12233 } 12234 tsp = ts; 12235 } 12236 if (!arg2) 12237 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4)); 12238 else { 12239 p = lock_user_string(arg2); 12240 if (!p) { 12241 return -TARGET_EFAULT; 12242 } 12243 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4)); 12244 unlock_user(p, arg2, 0); 12245 } 12246 } 12247 return ret; 12248 #endif 12249 #ifdef TARGET_NR_futex 12250 case TARGET_NR_futex: 12251 return do_futex(cpu, arg1, arg2, arg3, arg4, arg5, arg6); 12252 #endif 12253 #ifdef TARGET_NR_futex_time64 12254 case TARGET_NR_futex_time64: 12255 return do_futex_time64(cpu, arg1, arg2, arg3, arg4, arg5, arg6); 12256 #endif 12257 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init) 12258 case TARGET_NR_inotify_init: 12259 ret = get_errno(sys_inotify_init()); 12260 if (ret >= 0) { 12261 fd_trans_register(ret, &target_inotify_trans); 12262 } 12263 return ret; 12264 #endif 12265 #ifdef CONFIG_INOTIFY1 12266 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1) 12267 case TARGET_NR_inotify_init1: 12268 ret = get_errno(sys_inotify_init1(target_to_host_bitmask(arg1, 12269 fcntl_flags_tbl))); 12270 if (ret >= 0) { 12271 fd_trans_register(ret, &target_inotify_trans); 12272 } 12273 return ret; 12274 #endif 12275 #endif 12276 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch) 12277 case TARGET_NR_inotify_add_watch: 12278 p = lock_user_string(arg2); 12279 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3)); 12280 unlock_user(p, arg2, 0); 12281 return ret; 12282 #endif 12283 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch) 12284 case TARGET_NR_inotify_rm_watch: 12285 return get_errno(sys_inotify_rm_watch(arg1, arg2)); 12286 #endif 12287 12288 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open) 12289 case TARGET_NR_mq_open: 12290 { 12291 struct mq_attr posix_mq_attr; 12292 struct mq_attr *pposix_mq_attr; 12293 int host_flags; 12294 12295 host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl); 12296 pposix_mq_attr = NULL; 12297 if (arg4) { 12298 if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) { 12299 return -TARGET_EFAULT; 12300 } 12301 pposix_mq_attr = &posix_mq_attr; 12302 } 12303 p = lock_user_string(arg1 - 1); 12304 if (!p) { 12305 return -TARGET_EFAULT; 12306 } 12307 ret = get_errno(mq_open(p, host_flags, arg3, pposix_mq_attr)); 12308 unlock_user (p, arg1, 0); 12309 } 12310 return ret; 12311 12312 case TARGET_NR_mq_unlink: 12313 p = lock_user_string(arg1 - 1); 12314 if (!p) { 12315 return -TARGET_EFAULT; 12316 } 12317 ret = get_errno(mq_unlink(p)); 12318 unlock_user (p, arg1, 0); 12319 return ret; 12320 12321 #ifdef TARGET_NR_mq_timedsend 12322 case TARGET_NR_mq_timedsend: 12323 { 12324 struct timespec ts; 12325 12326 p = lock_user (VERIFY_READ, arg2, arg3, 1); 12327 if (arg5 != 0) { 12328 if (target_to_host_timespec(&ts, arg5)) { 12329 return -TARGET_EFAULT; 12330 } 12331 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts)); 12332 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) { 12333 return -TARGET_EFAULT; 12334 } 12335 } else { 12336 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL)); 12337 } 12338 unlock_user (p, arg2, arg3); 12339 } 12340 return ret; 12341 #endif 12342 #ifdef TARGET_NR_mq_timedsend_time64 12343 case TARGET_NR_mq_timedsend_time64: 12344 { 12345 struct timespec ts; 12346 12347 p = lock_user(VERIFY_READ, arg2, arg3, 1); 12348 if (arg5 != 0) { 12349 if (target_to_host_timespec64(&ts, arg5)) { 12350 return -TARGET_EFAULT; 12351 } 12352 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts)); 12353 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) { 12354 return -TARGET_EFAULT; 12355 } 12356 } else { 12357 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL)); 12358 } 12359 unlock_user(p, arg2, arg3); 12360 } 12361 return ret; 12362 #endif 12363 12364 #ifdef TARGET_NR_mq_timedreceive 12365 case TARGET_NR_mq_timedreceive: 12366 { 12367 struct timespec ts; 12368 unsigned int prio; 12369 12370 p = lock_user (VERIFY_READ, arg2, arg3, 1); 12371 if (arg5 != 0) { 12372 if (target_to_host_timespec(&ts, arg5)) { 12373 return -TARGET_EFAULT; 12374 } 12375 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12376 &prio, &ts)); 12377 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) { 12378 return -TARGET_EFAULT; 12379 } 12380 } else { 12381 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12382 &prio, NULL)); 12383 } 12384 unlock_user (p, arg2, arg3); 12385 if (arg4 != 0) 12386 put_user_u32(prio, arg4); 12387 } 12388 return ret; 12389 #endif 12390 #ifdef TARGET_NR_mq_timedreceive_time64 12391 case TARGET_NR_mq_timedreceive_time64: 12392 { 12393 struct timespec ts; 12394 unsigned int prio; 12395 12396 p = lock_user(VERIFY_READ, arg2, arg3, 1); 12397 if (arg5 != 0) { 12398 if (target_to_host_timespec64(&ts, arg5)) { 12399 return -TARGET_EFAULT; 12400 } 12401 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12402 &prio, &ts)); 12403 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) { 12404 return -TARGET_EFAULT; 12405 } 12406 } else { 12407 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12408 &prio, NULL)); 12409 } 12410 unlock_user(p, arg2, arg3); 12411 if (arg4 != 0) { 12412 put_user_u32(prio, arg4); 12413 } 12414 } 12415 return ret; 12416 #endif 12417 12418 /* Not implemented for now... */ 12419 /* case TARGET_NR_mq_notify: */ 12420 /* break; */ 12421 12422 case TARGET_NR_mq_getsetattr: 12423 { 12424 struct mq_attr posix_mq_attr_in, posix_mq_attr_out; 12425 ret = 0; 12426 if (arg2 != 0) { 12427 copy_from_user_mq_attr(&posix_mq_attr_in, arg2); 12428 ret = get_errno(mq_setattr(arg1, &posix_mq_attr_in, 12429 &posix_mq_attr_out)); 12430 } else if (arg3 != 0) { 12431 ret = get_errno(mq_getattr(arg1, &posix_mq_attr_out)); 12432 } 12433 if (ret == 0 && arg3 != 0) { 12434 copy_to_user_mq_attr(arg3, &posix_mq_attr_out); 12435 } 12436 } 12437 return ret; 12438 #endif 12439 12440 #ifdef CONFIG_SPLICE 12441 #ifdef TARGET_NR_tee 12442 case TARGET_NR_tee: 12443 { 12444 ret = get_errno(tee(arg1,arg2,arg3,arg4)); 12445 } 12446 return ret; 12447 #endif 12448 #ifdef TARGET_NR_splice 12449 case TARGET_NR_splice: 12450 { 12451 loff_t loff_in, loff_out; 12452 loff_t *ploff_in = NULL, *ploff_out = NULL; 12453 if (arg2) { 12454 if (get_user_u64(loff_in, arg2)) { 12455 return -TARGET_EFAULT; 12456 } 12457 ploff_in = &loff_in; 12458 } 12459 if (arg4) { 12460 if (get_user_u64(loff_out, arg4)) { 12461 return -TARGET_EFAULT; 12462 } 12463 ploff_out = &loff_out; 12464 } 12465 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6)); 12466 if (arg2) { 12467 if (put_user_u64(loff_in, arg2)) { 12468 return -TARGET_EFAULT; 12469 } 12470 } 12471 if (arg4) { 12472 if (put_user_u64(loff_out, arg4)) { 12473 return -TARGET_EFAULT; 12474 } 12475 } 12476 } 12477 return ret; 12478 #endif 12479 #ifdef TARGET_NR_vmsplice 12480 case TARGET_NR_vmsplice: 12481 { 12482 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 12483 if (vec != NULL) { 12484 ret = get_errno(vmsplice(arg1, vec, arg3, arg4)); 12485 unlock_iovec(vec, arg2, arg3, 0); 12486 } else { 12487 ret = -host_to_target_errno(errno); 12488 } 12489 } 12490 return ret; 12491 #endif 12492 #endif /* CONFIG_SPLICE */ 12493 #ifdef CONFIG_EVENTFD 12494 #if defined(TARGET_NR_eventfd) 12495 case TARGET_NR_eventfd: 12496 ret = get_errno(eventfd(arg1, 0)); 12497 if (ret >= 0) { 12498 fd_trans_register(ret, &target_eventfd_trans); 12499 } 12500 return ret; 12501 #endif 12502 #if defined(TARGET_NR_eventfd2) 12503 case TARGET_NR_eventfd2: 12504 { 12505 int host_flags = arg2 & (~(TARGET_O_NONBLOCK_MASK | TARGET_O_CLOEXEC)); 12506 if (arg2 & TARGET_O_NONBLOCK) { 12507 host_flags |= O_NONBLOCK; 12508 } 12509 if (arg2 & TARGET_O_CLOEXEC) { 12510 host_flags |= O_CLOEXEC; 12511 } 12512 ret = get_errno(eventfd(arg1, host_flags)); 12513 if (ret >= 0) { 12514 fd_trans_register(ret, &target_eventfd_trans); 12515 } 12516 return ret; 12517 } 12518 #endif 12519 #endif /* CONFIG_EVENTFD */ 12520 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate) 12521 case TARGET_NR_fallocate: 12522 #if TARGET_ABI_BITS == 32 12523 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4), 12524 target_offset64(arg5, arg6))); 12525 #else 12526 ret = get_errno(fallocate(arg1, arg2, arg3, arg4)); 12527 #endif 12528 return ret; 12529 #endif 12530 #if defined(CONFIG_SYNC_FILE_RANGE) 12531 #if defined(TARGET_NR_sync_file_range) 12532 case TARGET_NR_sync_file_range: 12533 #if TARGET_ABI_BITS == 32 12534 #if defined(TARGET_MIPS) 12535 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4), 12536 target_offset64(arg5, arg6), arg7)); 12537 #else 12538 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3), 12539 target_offset64(arg4, arg5), arg6)); 12540 #endif /* !TARGET_MIPS */ 12541 #else 12542 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4)); 12543 #endif 12544 return ret; 12545 #endif 12546 #if defined(TARGET_NR_sync_file_range2) || \ 12547 defined(TARGET_NR_arm_sync_file_range) 12548 #if defined(TARGET_NR_sync_file_range2) 12549 case TARGET_NR_sync_file_range2: 12550 #endif 12551 #if defined(TARGET_NR_arm_sync_file_range) 12552 case TARGET_NR_arm_sync_file_range: 12553 #endif 12554 /* This is like sync_file_range but the arguments are reordered */ 12555 #if TARGET_ABI_BITS == 32 12556 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4), 12557 target_offset64(arg5, arg6), arg2)); 12558 #else 12559 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2)); 12560 #endif 12561 return ret; 12562 #endif 12563 #endif 12564 #if defined(TARGET_NR_signalfd4) 12565 case TARGET_NR_signalfd4: 12566 return do_signalfd4(arg1, arg2, arg4); 12567 #endif 12568 #if defined(TARGET_NR_signalfd) 12569 case TARGET_NR_signalfd: 12570 return do_signalfd4(arg1, arg2, 0); 12571 #endif 12572 #if defined(CONFIG_EPOLL) 12573 #if defined(TARGET_NR_epoll_create) 12574 case TARGET_NR_epoll_create: 12575 return get_errno(epoll_create(arg1)); 12576 #endif 12577 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1) 12578 case TARGET_NR_epoll_create1: 12579 return get_errno(epoll_create1(target_to_host_bitmask(arg1, fcntl_flags_tbl))); 12580 #endif 12581 #if defined(TARGET_NR_epoll_ctl) 12582 case TARGET_NR_epoll_ctl: 12583 { 12584 struct epoll_event ep; 12585 struct epoll_event *epp = 0; 12586 if (arg4) { 12587 if (arg2 != EPOLL_CTL_DEL) { 12588 struct target_epoll_event *target_ep; 12589 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) { 12590 return -TARGET_EFAULT; 12591 } 12592 ep.events = tswap32(target_ep->events); 12593 /* 12594 * The epoll_data_t union is just opaque data to the kernel, 12595 * so we transfer all 64 bits across and need not worry what 12596 * actual data type it is. 12597 */ 12598 ep.data.u64 = tswap64(target_ep->data.u64); 12599 unlock_user_struct(target_ep, arg4, 0); 12600 } 12601 /* 12602 * before kernel 2.6.9, EPOLL_CTL_DEL operation required a 12603 * non-null pointer, even though this argument is ignored. 12604 * 12605 */ 12606 epp = &ep; 12607 } 12608 return get_errno(epoll_ctl(arg1, arg2, arg3, epp)); 12609 } 12610 #endif 12611 12612 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait) 12613 #if defined(TARGET_NR_epoll_wait) 12614 case TARGET_NR_epoll_wait: 12615 #endif 12616 #if defined(TARGET_NR_epoll_pwait) 12617 case TARGET_NR_epoll_pwait: 12618 #endif 12619 { 12620 struct target_epoll_event *target_ep; 12621 struct epoll_event *ep; 12622 int epfd = arg1; 12623 int maxevents = arg3; 12624 int timeout = arg4; 12625 12626 if (maxevents <= 0 || maxevents > TARGET_EP_MAX_EVENTS) { 12627 return -TARGET_EINVAL; 12628 } 12629 12630 target_ep = lock_user(VERIFY_WRITE, arg2, 12631 maxevents * sizeof(struct target_epoll_event), 1); 12632 if (!target_ep) { 12633 return -TARGET_EFAULT; 12634 } 12635 12636 ep = g_try_new(struct epoll_event, maxevents); 12637 if (!ep) { 12638 unlock_user(target_ep, arg2, 0); 12639 return -TARGET_ENOMEM; 12640 } 12641 12642 switch (num) { 12643 #if defined(TARGET_NR_epoll_pwait) 12644 case TARGET_NR_epoll_pwait: 12645 { 12646 target_sigset_t *target_set; 12647 sigset_t _set, *set = &_set; 12648 12649 if (arg5) { 12650 if (arg6 != sizeof(target_sigset_t)) { 12651 ret = -TARGET_EINVAL; 12652 break; 12653 } 12654 12655 target_set = lock_user(VERIFY_READ, arg5, 12656 sizeof(target_sigset_t), 1); 12657 if (!target_set) { 12658 ret = -TARGET_EFAULT; 12659 break; 12660 } 12661 target_to_host_sigset(set, target_set); 12662 unlock_user(target_set, arg5, 0); 12663 } else { 12664 set = NULL; 12665 } 12666 12667 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout, 12668 set, SIGSET_T_SIZE)); 12669 break; 12670 } 12671 #endif 12672 #if defined(TARGET_NR_epoll_wait) 12673 case TARGET_NR_epoll_wait: 12674 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout, 12675 NULL, 0)); 12676 break; 12677 #endif 12678 default: 12679 ret = -TARGET_ENOSYS; 12680 } 12681 if (!is_error(ret)) { 12682 int i; 12683 for (i = 0; i < ret; i++) { 12684 target_ep[i].events = tswap32(ep[i].events); 12685 target_ep[i].data.u64 = tswap64(ep[i].data.u64); 12686 } 12687 unlock_user(target_ep, arg2, 12688 ret * sizeof(struct target_epoll_event)); 12689 } else { 12690 unlock_user(target_ep, arg2, 0); 12691 } 12692 g_free(ep); 12693 return ret; 12694 } 12695 #endif 12696 #endif 12697 #ifdef TARGET_NR_prlimit64 12698 case TARGET_NR_prlimit64: 12699 { 12700 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */ 12701 struct target_rlimit64 *target_rnew, *target_rold; 12702 struct host_rlimit64 rnew, rold, *rnewp = 0; 12703 int resource = target_to_host_resource(arg2); 12704 12705 if (arg3 && (resource != RLIMIT_AS && 12706 resource != RLIMIT_DATA && 12707 resource != RLIMIT_STACK)) { 12708 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) { 12709 return -TARGET_EFAULT; 12710 } 12711 rnew.rlim_cur = tswap64(target_rnew->rlim_cur); 12712 rnew.rlim_max = tswap64(target_rnew->rlim_max); 12713 unlock_user_struct(target_rnew, arg3, 0); 12714 rnewp = &rnew; 12715 } 12716 12717 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0)); 12718 if (!is_error(ret) && arg4) { 12719 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) { 12720 return -TARGET_EFAULT; 12721 } 12722 target_rold->rlim_cur = tswap64(rold.rlim_cur); 12723 target_rold->rlim_max = tswap64(rold.rlim_max); 12724 unlock_user_struct(target_rold, arg4, 1); 12725 } 12726 return ret; 12727 } 12728 #endif 12729 #ifdef TARGET_NR_gethostname 12730 case TARGET_NR_gethostname: 12731 { 12732 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0); 12733 if (name) { 12734 ret = get_errno(gethostname(name, arg2)); 12735 unlock_user(name, arg1, arg2); 12736 } else { 12737 ret = -TARGET_EFAULT; 12738 } 12739 return ret; 12740 } 12741 #endif 12742 #ifdef TARGET_NR_atomic_cmpxchg_32 12743 case TARGET_NR_atomic_cmpxchg_32: 12744 { 12745 /* should use start_exclusive from main.c */ 12746 abi_ulong mem_value; 12747 if (get_user_u32(mem_value, arg6)) { 12748 target_siginfo_t info; 12749 info.si_signo = SIGSEGV; 12750 info.si_errno = 0; 12751 info.si_code = TARGET_SEGV_MAPERR; 12752 info._sifields._sigfault._addr = arg6; 12753 queue_signal((CPUArchState *)cpu_env, info.si_signo, 12754 QEMU_SI_FAULT, &info); 12755 ret = 0xdeadbeef; 12756 12757 } 12758 if (mem_value == arg2) 12759 put_user_u32(arg1, arg6); 12760 return mem_value; 12761 } 12762 #endif 12763 #ifdef TARGET_NR_atomic_barrier 12764 case TARGET_NR_atomic_barrier: 12765 /* Like the kernel implementation and the 12766 qemu arm barrier, no-op this? */ 12767 return 0; 12768 #endif 12769 12770 #ifdef TARGET_NR_timer_create 12771 case TARGET_NR_timer_create: 12772 { 12773 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */ 12774 12775 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL; 12776 12777 int clkid = arg1; 12778 int timer_index = next_free_host_timer(); 12779 12780 if (timer_index < 0) { 12781 ret = -TARGET_EAGAIN; 12782 } else { 12783 timer_t *phtimer = g_posix_timers + timer_index; 12784 12785 if (arg2) { 12786 phost_sevp = &host_sevp; 12787 ret = target_to_host_sigevent(phost_sevp, arg2); 12788 if (ret != 0) { 12789 return ret; 12790 } 12791 } 12792 12793 ret = get_errno(timer_create(clkid, phost_sevp, phtimer)); 12794 if (ret) { 12795 phtimer = NULL; 12796 } else { 12797 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) { 12798 return -TARGET_EFAULT; 12799 } 12800 } 12801 } 12802 return ret; 12803 } 12804 #endif 12805 12806 #ifdef TARGET_NR_timer_settime 12807 case TARGET_NR_timer_settime: 12808 { 12809 /* args: timer_t timerid, int flags, const struct itimerspec *new_value, 12810 * struct itimerspec * old_value */ 12811 target_timer_t timerid = get_timer_id(arg1); 12812 12813 if (timerid < 0) { 12814 ret = timerid; 12815 } else if (arg3 == 0) { 12816 ret = -TARGET_EINVAL; 12817 } else { 12818 timer_t htimer = g_posix_timers[timerid]; 12819 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},}; 12820 12821 if (target_to_host_itimerspec(&hspec_new, arg3)) { 12822 return -TARGET_EFAULT; 12823 } 12824 ret = get_errno( 12825 timer_settime(htimer, arg2, &hspec_new, &hspec_old)); 12826 if (arg4 && host_to_target_itimerspec(arg4, &hspec_old)) { 12827 return -TARGET_EFAULT; 12828 } 12829 } 12830 return ret; 12831 } 12832 #endif 12833 12834 #ifdef TARGET_NR_timer_settime64 12835 case TARGET_NR_timer_settime64: 12836 { 12837 target_timer_t timerid = get_timer_id(arg1); 12838 12839 if (timerid < 0) { 12840 ret = timerid; 12841 } else if (arg3 == 0) { 12842 ret = -TARGET_EINVAL; 12843 } else { 12844 timer_t htimer = g_posix_timers[timerid]; 12845 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},}; 12846 12847 if (target_to_host_itimerspec64(&hspec_new, arg3)) { 12848 return -TARGET_EFAULT; 12849 } 12850 ret = get_errno( 12851 timer_settime(htimer, arg2, &hspec_new, &hspec_old)); 12852 if (arg4 && host_to_target_itimerspec64(arg4, &hspec_old)) { 12853 return -TARGET_EFAULT; 12854 } 12855 } 12856 return ret; 12857 } 12858 #endif 12859 12860 #ifdef TARGET_NR_timer_gettime 12861 case TARGET_NR_timer_gettime: 12862 { 12863 /* args: timer_t timerid, struct itimerspec *curr_value */ 12864 target_timer_t timerid = get_timer_id(arg1); 12865 12866 if (timerid < 0) { 12867 ret = timerid; 12868 } else if (!arg2) { 12869 ret = -TARGET_EFAULT; 12870 } else { 12871 timer_t htimer = g_posix_timers[timerid]; 12872 struct itimerspec hspec; 12873 ret = get_errno(timer_gettime(htimer, &hspec)); 12874 12875 if (host_to_target_itimerspec(arg2, &hspec)) { 12876 ret = -TARGET_EFAULT; 12877 } 12878 } 12879 return ret; 12880 } 12881 #endif 12882 12883 #ifdef TARGET_NR_timer_gettime64 12884 case TARGET_NR_timer_gettime64: 12885 { 12886 /* args: timer_t timerid, struct itimerspec64 *curr_value */ 12887 target_timer_t timerid = get_timer_id(arg1); 12888 12889 if (timerid < 0) { 12890 ret = timerid; 12891 } else if (!arg2) { 12892 ret = -TARGET_EFAULT; 12893 } else { 12894 timer_t htimer = g_posix_timers[timerid]; 12895 struct itimerspec hspec; 12896 ret = get_errno(timer_gettime(htimer, &hspec)); 12897 12898 if (host_to_target_itimerspec64(arg2, &hspec)) { 12899 ret = -TARGET_EFAULT; 12900 } 12901 } 12902 return ret; 12903 } 12904 #endif 12905 12906 #ifdef TARGET_NR_timer_getoverrun 12907 case TARGET_NR_timer_getoverrun: 12908 { 12909 /* args: timer_t timerid */ 12910 target_timer_t timerid = get_timer_id(arg1); 12911 12912 if (timerid < 0) { 12913 ret = timerid; 12914 } else { 12915 timer_t htimer = g_posix_timers[timerid]; 12916 ret = get_errno(timer_getoverrun(htimer)); 12917 } 12918 return ret; 12919 } 12920 #endif 12921 12922 #ifdef TARGET_NR_timer_delete 12923 case TARGET_NR_timer_delete: 12924 { 12925 /* args: timer_t timerid */ 12926 target_timer_t timerid = get_timer_id(arg1); 12927 12928 if (timerid < 0) { 12929 ret = timerid; 12930 } else { 12931 timer_t htimer = g_posix_timers[timerid]; 12932 ret = get_errno(timer_delete(htimer)); 12933 g_posix_timers[timerid] = 0; 12934 } 12935 return ret; 12936 } 12937 #endif 12938 12939 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD) 12940 case TARGET_NR_timerfd_create: 12941 return get_errno(timerfd_create(arg1, 12942 target_to_host_bitmask(arg2, fcntl_flags_tbl))); 12943 #endif 12944 12945 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD) 12946 case TARGET_NR_timerfd_gettime: 12947 { 12948 struct itimerspec its_curr; 12949 12950 ret = get_errno(timerfd_gettime(arg1, &its_curr)); 12951 12952 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) { 12953 return -TARGET_EFAULT; 12954 } 12955 } 12956 return ret; 12957 #endif 12958 12959 #if defined(TARGET_NR_timerfd_gettime64) && defined(CONFIG_TIMERFD) 12960 case TARGET_NR_timerfd_gettime64: 12961 { 12962 struct itimerspec its_curr; 12963 12964 ret = get_errno(timerfd_gettime(arg1, &its_curr)); 12965 12966 if (arg2 && host_to_target_itimerspec64(arg2, &its_curr)) { 12967 return -TARGET_EFAULT; 12968 } 12969 } 12970 return ret; 12971 #endif 12972 12973 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD) 12974 case TARGET_NR_timerfd_settime: 12975 { 12976 struct itimerspec its_new, its_old, *p_new; 12977 12978 if (arg3) { 12979 if (target_to_host_itimerspec(&its_new, arg3)) { 12980 return -TARGET_EFAULT; 12981 } 12982 p_new = &its_new; 12983 } else { 12984 p_new = NULL; 12985 } 12986 12987 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old)); 12988 12989 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) { 12990 return -TARGET_EFAULT; 12991 } 12992 } 12993 return ret; 12994 #endif 12995 12996 #if defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD) 12997 case TARGET_NR_timerfd_settime64: 12998 { 12999 struct itimerspec its_new, its_old, *p_new; 13000 13001 if (arg3) { 13002 if (target_to_host_itimerspec64(&its_new, arg3)) { 13003 return -TARGET_EFAULT; 13004 } 13005 p_new = &its_new; 13006 } else { 13007 p_new = NULL; 13008 } 13009 13010 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old)); 13011 13012 if (arg4 && host_to_target_itimerspec64(arg4, &its_old)) { 13013 return -TARGET_EFAULT; 13014 } 13015 } 13016 return ret; 13017 #endif 13018 13019 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get) 13020 case TARGET_NR_ioprio_get: 13021 return get_errno(ioprio_get(arg1, arg2)); 13022 #endif 13023 13024 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set) 13025 case TARGET_NR_ioprio_set: 13026 return get_errno(ioprio_set(arg1, arg2, arg3)); 13027 #endif 13028 13029 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS) 13030 case TARGET_NR_setns: 13031 return get_errno(setns(arg1, arg2)); 13032 #endif 13033 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS) 13034 case TARGET_NR_unshare: 13035 return get_errno(unshare(arg1)); 13036 #endif 13037 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp) 13038 case TARGET_NR_kcmp: 13039 return get_errno(kcmp(arg1, arg2, arg3, arg4, arg5)); 13040 #endif 13041 #ifdef TARGET_NR_swapcontext 13042 case TARGET_NR_swapcontext: 13043 /* PowerPC specific. */ 13044 return do_swapcontext(cpu_env, arg1, arg2, arg3); 13045 #endif 13046 #ifdef TARGET_NR_memfd_create 13047 case TARGET_NR_memfd_create: 13048 p = lock_user_string(arg1); 13049 if (!p) { 13050 return -TARGET_EFAULT; 13051 } 13052 ret = get_errno(memfd_create(p, arg2)); 13053 fd_trans_unregister(ret); 13054 unlock_user(p, arg1, 0); 13055 return ret; 13056 #endif 13057 #if defined TARGET_NR_membarrier && defined __NR_membarrier 13058 case TARGET_NR_membarrier: 13059 return get_errno(membarrier(arg1, arg2)); 13060 #endif 13061 13062 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range) 13063 case TARGET_NR_copy_file_range: 13064 { 13065 loff_t inoff, outoff; 13066 loff_t *pinoff = NULL, *poutoff = NULL; 13067 13068 if (arg2) { 13069 if (get_user_u64(inoff, arg2)) { 13070 return -TARGET_EFAULT; 13071 } 13072 pinoff = &inoff; 13073 } 13074 if (arg4) { 13075 if (get_user_u64(outoff, arg4)) { 13076 return -TARGET_EFAULT; 13077 } 13078 poutoff = &outoff; 13079 } 13080 /* Do not sign-extend the count parameter. */ 13081 ret = get_errno(safe_copy_file_range(arg1, pinoff, arg3, poutoff, 13082 (abi_ulong)arg5, arg6)); 13083 if (!is_error(ret) && ret > 0) { 13084 if (arg2) { 13085 if (put_user_u64(inoff, arg2)) { 13086 return -TARGET_EFAULT; 13087 } 13088 } 13089 if (arg4) { 13090 if (put_user_u64(outoff, arg4)) { 13091 return -TARGET_EFAULT; 13092 } 13093 } 13094 } 13095 } 13096 return ret; 13097 #endif 13098 13099 #if defined(TARGET_NR_pivot_root) 13100 case TARGET_NR_pivot_root: 13101 { 13102 void *p2; 13103 p = lock_user_string(arg1); /* new_root */ 13104 p2 = lock_user_string(arg2); /* put_old */ 13105 if (!p || !p2) { 13106 ret = -TARGET_EFAULT; 13107 } else { 13108 ret = get_errno(pivot_root(p, p2)); 13109 } 13110 unlock_user(p2, arg2, 0); 13111 unlock_user(p, arg1, 0); 13112 } 13113 return ret; 13114 #endif 13115 13116 default: 13117 qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num); 13118 return -TARGET_ENOSYS; 13119 } 13120 return ret; 13121 } 13122 13123 abi_long do_syscall(void *cpu_env, int num, abi_long arg1, 13124 abi_long arg2, abi_long arg3, abi_long arg4, 13125 abi_long arg5, abi_long arg6, abi_long arg7, 13126 abi_long arg8) 13127 { 13128 CPUState *cpu = env_cpu(cpu_env); 13129 abi_long ret; 13130 13131 #ifdef DEBUG_ERESTARTSYS 13132 /* Debug-only code for exercising the syscall-restart code paths 13133 * in the per-architecture cpu main loops: restart every syscall 13134 * the guest makes once before letting it through. 13135 */ 13136 { 13137 static bool flag; 13138 flag = !flag; 13139 if (flag) { 13140 return -TARGET_ERESTARTSYS; 13141 } 13142 } 13143 #endif 13144 13145 record_syscall_start(cpu, num, arg1, 13146 arg2, arg3, arg4, arg5, arg6, arg7, arg8); 13147 13148 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 13149 print_syscall(cpu_env, num, arg1, arg2, arg3, arg4, arg5, arg6); 13150 } 13151 13152 ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4, 13153 arg5, arg6, arg7, arg8); 13154 13155 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 13156 print_syscall_ret(cpu_env, num, ret, arg1, arg2, 13157 arg3, arg4, arg5, arg6); 13158 } 13159 13160 record_syscall_return(cpu, num, ret); 13161 return ret; 13162 } 13163