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