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