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