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