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