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