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