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 switch (arg1) { 9439 case TARGET_SIG_BLOCK: 9440 how = SIG_BLOCK; 9441 break; 9442 case TARGET_SIG_UNBLOCK: 9443 how = SIG_UNBLOCK; 9444 break; 9445 case TARGET_SIG_SETMASK: 9446 how = SIG_SETMASK; 9447 break; 9448 default: 9449 return -TARGET_EINVAL; 9450 } 9451 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1))) 9452 return -TARGET_EFAULT; 9453 target_to_host_old_sigset(&set, p); 9454 unlock_user(p, arg2, 0); 9455 set_ptr = &set; 9456 } else { 9457 how = 0; 9458 set_ptr = NULL; 9459 } 9460 ret = do_sigprocmask(how, set_ptr, &oldset); 9461 if (!is_error(ret) && arg3) { 9462 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 9463 return -TARGET_EFAULT; 9464 host_to_target_old_sigset(p, &oldset); 9465 unlock_user(p, arg3, sizeof(target_sigset_t)); 9466 } 9467 #endif 9468 } 9469 return ret; 9470 #endif 9471 case TARGET_NR_rt_sigprocmask: 9472 { 9473 int how = arg1; 9474 sigset_t set, oldset, *set_ptr; 9475 9476 if (arg4 != sizeof(target_sigset_t)) { 9477 return -TARGET_EINVAL; 9478 } 9479 9480 if (arg2) { 9481 p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1); 9482 if (!p) { 9483 return -TARGET_EFAULT; 9484 } 9485 target_to_host_sigset(&set, p); 9486 unlock_user(p, arg2, 0); 9487 set_ptr = &set; 9488 switch(how) { 9489 case TARGET_SIG_BLOCK: 9490 how = SIG_BLOCK; 9491 break; 9492 case TARGET_SIG_UNBLOCK: 9493 how = SIG_UNBLOCK; 9494 break; 9495 case TARGET_SIG_SETMASK: 9496 how = SIG_SETMASK; 9497 break; 9498 default: 9499 return -TARGET_EINVAL; 9500 } 9501 } else { 9502 how = 0; 9503 set_ptr = NULL; 9504 } 9505 ret = do_sigprocmask(how, set_ptr, &oldset); 9506 if (!is_error(ret) && arg3) { 9507 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 9508 return -TARGET_EFAULT; 9509 host_to_target_sigset(p, &oldset); 9510 unlock_user(p, arg3, sizeof(target_sigset_t)); 9511 } 9512 } 9513 return ret; 9514 #ifdef TARGET_NR_sigpending 9515 case TARGET_NR_sigpending: 9516 { 9517 sigset_t set; 9518 ret = get_errno(sigpending(&set)); 9519 if (!is_error(ret)) { 9520 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 9521 return -TARGET_EFAULT; 9522 host_to_target_old_sigset(p, &set); 9523 unlock_user(p, arg1, sizeof(target_sigset_t)); 9524 } 9525 } 9526 return ret; 9527 #endif 9528 case TARGET_NR_rt_sigpending: 9529 { 9530 sigset_t set; 9531 9532 /* Yes, this check is >, not != like most. We follow the kernel's 9533 * logic and it does it like this because it implements 9534 * NR_sigpending through the same code path, and in that case 9535 * the old_sigset_t is smaller in size. 9536 */ 9537 if (arg2 > sizeof(target_sigset_t)) { 9538 return -TARGET_EINVAL; 9539 } 9540 9541 ret = get_errno(sigpending(&set)); 9542 if (!is_error(ret)) { 9543 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 9544 return -TARGET_EFAULT; 9545 host_to_target_sigset(p, &set); 9546 unlock_user(p, arg1, sizeof(target_sigset_t)); 9547 } 9548 } 9549 return ret; 9550 #ifdef TARGET_NR_sigsuspend 9551 case TARGET_NR_sigsuspend: 9552 { 9553 TaskState *ts = cpu->opaque; 9554 #if defined(TARGET_ALPHA) 9555 abi_ulong mask = arg1; 9556 target_to_host_old_sigset(&ts->sigsuspend_mask, &mask); 9557 #else 9558 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9559 return -TARGET_EFAULT; 9560 target_to_host_old_sigset(&ts->sigsuspend_mask, p); 9561 unlock_user(p, arg1, 0); 9562 #endif 9563 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask, 9564 SIGSET_T_SIZE)); 9565 if (ret != -QEMU_ERESTARTSYS) { 9566 ts->in_sigsuspend = 1; 9567 } 9568 } 9569 return ret; 9570 #endif 9571 case TARGET_NR_rt_sigsuspend: 9572 { 9573 TaskState *ts = cpu->opaque; 9574 9575 if (arg2 != sizeof(target_sigset_t)) { 9576 return -TARGET_EINVAL; 9577 } 9578 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9579 return -TARGET_EFAULT; 9580 target_to_host_sigset(&ts->sigsuspend_mask, p); 9581 unlock_user(p, arg1, 0); 9582 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask, 9583 SIGSET_T_SIZE)); 9584 if (ret != -QEMU_ERESTARTSYS) { 9585 ts->in_sigsuspend = 1; 9586 } 9587 } 9588 return ret; 9589 #ifdef TARGET_NR_rt_sigtimedwait 9590 case TARGET_NR_rt_sigtimedwait: 9591 { 9592 sigset_t set; 9593 struct timespec uts, *puts; 9594 siginfo_t uinfo; 9595 9596 if (arg4 != sizeof(target_sigset_t)) { 9597 return -TARGET_EINVAL; 9598 } 9599 9600 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 9601 return -TARGET_EFAULT; 9602 target_to_host_sigset(&set, p); 9603 unlock_user(p, arg1, 0); 9604 if (arg3) { 9605 puts = &uts; 9606 if (target_to_host_timespec(puts, arg3)) { 9607 return -TARGET_EFAULT; 9608 } 9609 } else { 9610 puts = NULL; 9611 } 9612 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts, 9613 SIGSET_T_SIZE)); 9614 if (!is_error(ret)) { 9615 if (arg2) { 9616 p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 9617 0); 9618 if (!p) { 9619 return -TARGET_EFAULT; 9620 } 9621 host_to_target_siginfo(p, &uinfo); 9622 unlock_user(p, arg2, sizeof(target_siginfo_t)); 9623 } 9624 ret = host_to_target_signal(ret); 9625 } 9626 } 9627 return ret; 9628 #endif 9629 #ifdef TARGET_NR_rt_sigtimedwait_time64 9630 case TARGET_NR_rt_sigtimedwait_time64: 9631 { 9632 sigset_t set; 9633 struct timespec uts, *puts; 9634 siginfo_t uinfo; 9635 9636 if (arg4 != sizeof(target_sigset_t)) { 9637 return -TARGET_EINVAL; 9638 } 9639 9640 p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1); 9641 if (!p) { 9642 return -TARGET_EFAULT; 9643 } 9644 target_to_host_sigset(&set, p); 9645 unlock_user(p, arg1, 0); 9646 if (arg3) { 9647 puts = &uts; 9648 if (target_to_host_timespec64(puts, arg3)) { 9649 return -TARGET_EFAULT; 9650 } 9651 } else { 9652 puts = NULL; 9653 } 9654 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts, 9655 SIGSET_T_SIZE)); 9656 if (!is_error(ret)) { 9657 if (arg2) { 9658 p = lock_user(VERIFY_WRITE, arg2, 9659 sizeof(target_siginfo_t), 0); 9660 if (!p) { 9661 return -TARGET_EFAULT; 9662 } 9663 host_to_target_siginfo(p, &uinfo); 9664 unlock_user(p, arg2, sizeof(target_siginfo_t)); 9665 } 9666 ret = host_to_target_signal(ret); 9667 } 9668 } 9669 return ret; 9670 #endif 9671 case TARGET_NR_rt_sigqueueinfo: 9672 { 9673 siginfo_t uinfo; 9674 9675 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1); 9676 if (!p) { 9677 return -TARGET_EFAULT; 9678 } 9679 target_to_host_siginfo(&uinfo, p); 9680 unlock_user(p, arg3, 0); 9681 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo)); 9682 } 9683 return ret; 9684 case TARGET_NR_rt_tgsigqueueinfo: 9685 { 9686 siginfo_t uinfo; 9687 9688 p = lock_user(VERIFY_READ, arg4, sizeof(target_siginfo_t), 1); 9689 if (!p) { 9690 return -TARGET_EFAULT; 9691 } 9692 target_to_host_siginfo(&uinfo, p); 9693 unlock_user(p, arg4, 0); 9694 ret = get_errno(sys_rt_tgsigqueueinfo(arg1, arg2, arg3, &uinfo)); 9695 } 9696 return ret; 9697 #ifdef TARGET_NR_sigreturn 9698 case TARGET_NR_sigreturn: 9699 if (block_signals()) { 9700 return -QEMU_ERESTARTSYS; 9701 } 9702 return do_sigreturn(cpu_env); 9703 #endif 9704 case TARGET_NR_rt_sigreturn: 9705 if (block_signals()) { 9706 return -QEMU_ERESTARTSYS; 9707 } 9708 return do_rt_sigreturn(cpu_env); 9709 case TARGET_NR_sethostname: 9710 if (!(p = lock_user_string(arg1))) 9711 return -TARGET_EFAULT; 9712 ret = get_errno(sethostname(p, arg2)); 9713 unlock_user(p, arg1, 0); 9714 return ret; 9715 #ifdef TARGET_NR_setrlimit 9716 case TARGET_NR_setrlimit: 9717 { 9718 int resource = target_to_host_resource(arg1); 9719 struct target_rlimit *target_rlim; 9720 struct rlimit rlim; 9721 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) 9722 return -TARGET_EFAULT; 9723 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur); 9724 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max); 9725 unlock_user_struct(target_rlim, arg2, 0); 9726 /* 9727 * If we just passed through resource limit settings for memory then 9728 * they would also apply to QEMU's own allocations, and QEMU will 9729 * crash or hang or die if its allocations fail. Ideally we would 9730 * track the guest allocations in QEMU and apply the limits ourselves. 9731 * For now, just tell the guest the call succeeded but don't actually 9732 * limit anything. 9733 */ 9734 if (resource != RLIMIT_AS && 9735 resource != RLIMIT_DATA && 9736 resource != RLIMIT_STACK) { 9737 return get_errno(setrlimit(resource, &rlim)); 9738 } else { 9739 return 0; 9740 } 9741 } 9742 #endif 9743 #ifdef TARGET_NR_getrlimit 9744 case TARGET_NR_getrlimit: 9745 { 9746 int resource = target_to_host_resource(arg1); 9747 struct target_rlimit *target_rlim; 9748 struct rlimit rlim; 9749 9750 ret = get_errno(getrlimit(resource, &rlim)); 9751 if (!is_error(ret)) { 9752 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 9753 return -TARGET_EFAULT; 9754 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur); 9755 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max); 9756 unlock_user_struct(target_rlim, arg2, 1); 9757 } 9758 } 9759 return ret; 9760 #endif 9761 case TARGET_NR_getrusage: 9762 { 9763 struct rusage rusage; 9764 ret = get_errno(getrusage(arg1, &rusage)); 9765 if (!is_error(ret)) { 9766 ret = host_to_target_rusage(arg2, &rusage); 9767 } 9768 } 9769 return ret; 9770 #if defined(TARGET_NR_gettimeofday) 9771 case TARGET_NR_gettimeofday: 9772 { 9773 struct timeval tv; 9774 struct timezone tz; 9775 9776 ret = get_errno(gettimeofday(&tv, &tz)); 9777 if (!is_error(ret)) { 9778 if (arg1 && copy_to_user_timeval(arg1, &tv)) { 9779 return -TARGET_EFAULT; 9780 } 9781 if (arg2 && copy_to_user_timezone(arg2, &tz)) { 9782 return -TARGET_EFAULT; 9783 } 9784 } 9785 } 9786 return ret; 9787 #endif 9788 #if defined(TARGET_NR_settimeofday) 9789 case TARGET_NR_settimeofday: 9790 { 9791 struct timeval tv, *ptv = NULL; 9792 struct timezone tz, *ptz = NULL; 9793 9794 if (arg1) { 9795 if (copy_from_user_timeval(&tv, arg1)) { 9796 return -TARGET_EFAULT; 9797 } 9798 ptv = &tv; 9799 } 9800 9801 if (arg2) { 9802 if (copy_from_user_timezone(&tz, arg2)) { 9803 return -TARGET_EFAULT; 9804 } 9805 ptz = &tz; 9806 } 9807 9808 return get_errno(settimeofday(ptv, ptz)); 9809 } 9810 #endif 9811 #if defined(TARGET_NR_select) 9812 case TARGET_NR_select: 9813 #if defined(TARGET_WANT_NI_OLD_SELECT) 9814 /* some architectures used to have old_select here 9815 * but now ENOSYS it. 9816 */ 9817 ret = -TARGET_ENOSYS; 9818 #elif defined(TARGET_WANT_OLD_SYS_SELECT) 9819 ret = do_old_select(arg1); 9820 #else 9821 ret = do_select(arg1, arg2, arg3, arg4, arg5); 9822 #endif 9823 return ret; 9824 #endif 9825 #ifdef TARGET_NR_pselect6 9826 case TARGET_NR_pselect6: 9827 return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false); 9828 #endif 9829 #ifdef TARGET_NR_pselect6_time64 9830 case TARGET_NR_pselect6_time64: 9831 return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true); 9832 #endif 9833 #ifdef TARGET_NR_symlink 9834 case TARGET_NR_symlink: 9835 { 9836 void *p2; 9837 p = lock_user_string(arg1); 9838 p2 = lock_user_string(arg2); 9839 if (!p || !p2) 9840 ret = -TARGET_EFAULT; 9841 else 9842 ret = get_errno(symlink(p, p2)); 9843 unlock_user(p2, arg2, 0); 9844 unlock_user(p, arg1, 0); 9845 } 9846 return ret; 9847 #endif 9848 #if defined(TARGET_NR_symlinkat) 9849 case TARGET_NR_symlinkat: 9850 { 9851 void *p2; 9852 p = lock_user_string(arg1); 9853 p2 = lock_user_string(arg3); 9854 if (!p || !p2) 9855 ret = -TARGET_EFAULT; 9856 else 9857 ret = get_errno(symlinkat(p, arg2, p2)); 9858 unlock_user(p2, arg3, 0); 9859 unlock_user(p, arg1, 0); 9860 } 9861 return ret; 9862 #endif 9863 #ifdef TARGET_NR_readlink 9864 case TARGET_NR_readlink: 9865 { 9866 void *p2; 9867 p = lock_user_string(arg1); 9868 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0); 9869 if (!p || !p2) { 9870 ret = -TARGET_EFAULT; 9871 } else if (!arg3) { 9872 /* Short circuit this for the magic exe check. */ 9873 ret = -TARGET_EINVAL; 9874 } else if (is_proc_myself((const char *)p, "exe")) { 9875 char real[PATH_MAX], *temp; 9876 temp = realpath(exec_path, real); 9877 /* Return value is # of bytes that we wrote to the buffer. */ 9878 if (temp == NULL) { 9879 ret = get_errno(-1); 9880 } else { 9881 /* Don't worry about sign mismatch as earlier mapping 9882 * logic would have thrown a bad address error. */ 9883 ret = MIN(strlen(real), arg3); 9884 /* We cannot NUL terminate the string. */ 9885 memcpy(p2, real, ret); 9886 } 9887 } else { 9888 ret = get_errno(readlink(path(p), p2, arg3)); 9889 } 9890 unlock_user(p2, arg2, ret); 9891 unlock_user(p, arg1, 0); 9892 } 9893 return ret; 9894 #endif 9895 #if defined(TARGET_NR_readlinkat) 9896 case TARGET_NR_readlinkat: 9897 { 9898 void *p2; 9899 p = lock_user_string(arg2); 9900 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0); 9901 if (!p || !p2) { 9902 ret = -TARGET_EFAULT; 9903 } else if (is_proc_myself((const char *)p, "exe")) { 9904 char real[PATH_MAX], *temp; 9905 temp = realpath(exec_path, real); 9906 ret = temp == NULL ? get_errno(-1) : strlen(real) ; 9907 snprintf((char *)p2, arg4, "%s", real); 9908 } else { 9909 ret = get_errno(readlinkat(arg1, path(p), p2, arg4)); 9910 } 9911 unlock_user(p2, arg3, ret); 9912 unlock_user(p, arg2, 0); 9913 } 9914 return ret; 9915 #endif 9916 #ifdef TARGET_NR_swapon 9917 case TARGET_NR_swapon: 9918 if (!(p = lock_user_string(arg1))) 9919 return -TARGET_EFAULT; 9920 ret = get_errno(swapon(p, arg2)); 9921 unlock_user(p, arg1, 0); 9922 return ret; 9923 #endif 9924 case TARGET_NR_reboot: 9925 if (arg3 == LINUX_REBOOT_CMD_RESTART2) { 9926 /* arg4 must be ignored in all other cases */ 9927 p = lock_user_string(arg4); 9928 if (!p) { 9929 return -TARGET_EFAULT; 9930 } 9931 ret = get_errno(reboot(arg1, arg2, arg3, p)); 9932 unlock_user(p, arg4, 0); 9933 } else { 9934 ret = get_errno(reboot(arg1, arg2, arg3, NULL)); 9935 } 9936 return ret; 9937 #ifdef TARGET_NR_mmap 9938 case TARGET_NR_mmap: 9939 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \ 9940 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \ 9941 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \ 9942 || defined(TARGET_S390X) 9943 { 9944 abi_ulong *v; 9945 abi_ulong v1, v2, v3, v4, v5, v6; 9946 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1))) 9947 return -TARGET_EFAULT; 9948 v1 = tswapal(v[0]); 9949 v2 = tswapal(v[1]); 9950 v3 = tswapal(v[2]); 9951 v4 = tswapal(v[3]); 9952 v5 = tswapal(v[4]); 9953 v6 = tswapal(v[5]); 9954 unlock_user(v, arg1, 0); 9955 ret = get_errno(target_mmap(v1, v2, v3, 9956 target_to_host_bitmask(v4, mmap_flags_tbl), 9957 v5, v6)); 9958 } 9959 #else 9960 /* mmap pointers are always untagged */ 9961 ret = get_errno(target_mmap(arg1, arg2, arg3, 9962 target_to_host_bitmask(arg4, mmap_flags_tbl), 9963 arg5, 9964 arg6)); 9965 #endif 9966 return ret; 9967 #endif 9968 #ifdef TARGET_NR_mmap2 9969 case TARGET_NR_mmap2: 9970 #ifndef MMAP_SHIFT 9971 #define MMAP_SHIFT 12 9972 #endif 9973 ret = target_mmap(arg1, arg2, arg3, 9974 target_to_host_bitmask(arg4, mmap_flags_tbl), 9975 arg5, arg6 << MMAP_SHIFT); 9976 return get_errno(ret); 9977 #endif 9978 case TARGET_NR_munmap: 9979 arg1 = cpu_untagged_addr(cpu, arg1); 9980 return get_errno(target_munmap(arg1, arg2)); 9981 case TARGET_NR_mprotect: 9982 arg1 = cpu_untagged_addr(cpu, arg1); 9983 { 9984 TaskState *ts = cpu->opaque; 9985 /* Special hack to detect libc making the stack executable. */ 9986 if ((arg3 & PROT_GROWSDOWN) 9987 && arg1 >= ts->info->stack_limit 9988 && arg1 <= ts->info->start_stack) { 9989 arg3 &= ~PROT_GROWSDOWN; 9990 arg2 = arg2 + arg1 - ts->info->stack_limit; 9991 arg1 = ts->info->stack_limit; 9992 } 9993 } 9994 return get_errno(target_mprotect(arg1, arg2, arg3)); 9995 #ifdef TARGET_NR_mremap 9996 case TARGET_NR_mremap: 9997 arg1 = cpu_untagged_addr(cpu, arg1); 9998 /* mremap new_addr (arg5) is always untagged */ 9999 return get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5)); 10000 #endif 10001 /* ??? msync/mlock/munlock are broken for softmmu. */ 10002 #ifdef TARGET_NR_msync 10003 case TARGET_NR_msync: 10004 return get_errno(msync(g2h(cpu, arg1), arg2, arg3)); 10005 #endif 10006 #ifdef TARGET_NR_mlock 10007 case TARGET_NR_mlock: 10008 return get_errno(mlock(g2h(cpu, arg1), arg2)); 10009 #endif 10010 #ifdef TARGET_NR_munlock 10011 case TARGET_NR_munlock: 10012 return get_errno(munlock(g2h(cpu, arg1), arg2)); 10013 #endif 10014 #ifdef TARGET_NR_mlockall 10015 case TARGET_NR_mlockall: 10016 return get_errno(mlockall(target_to_host_mlockall_arg(arg1))); 10017 #endif 10018 #ifdef TARGET_NR_munlockall 10019 case TARGET_NR_munlockall: 10020 return get_errno(munlockall()); 10021 #endif 10022 #ifdef TARGET_NR_truncate 10023 case TARGET_NR_truncate: 10024 if (!(p = lock_user_string(arg1))) 10025 return -TARGET_EFAULT; 10026 ret = get_errno(truncate(p, arg2)); 10027 unlock_user(p, arg1, 0); 10028 return ret; 10029 #endif 10030 #ifdef TARGET_NR_ftruncate 10031 case TARGET_NR_ftruncate: 10032 return get_errno(ftruncate(arg1, arg2)); 10033 #endif 10034 case TARGET_NR_fchmod: 10035 return get_errno(fchmod(arg1, arg2)); 10036 #if defined(TARGET_NR_fchmodat) 10037 case TARGET_NR_fchmodat: 10038 if (!(p = lock_user_string(arg2))) 10039 return -TARGET_EFAULT; 10040 ret = get_errno(fchmodat(arg1, p, arg3, 0)); 10041 unlock_user(p, arg2, 0); 10042 return ret; 10043 #endif 10044 case TARGET_NR_getpriority: 10045 /* Note that negative values are valid for getpriority, so we must 10046 differentiate based on errno settings. */ 10047 errno = 0; 10048 ret = getpriority(arg1, arg2); 10049 if (ret == -1 && errno != 0) { 10050 return -host_to_target_errno(errno); 10051 } 10052 #ifdef TARGET_ALPHA 10053 /* Return value is the unbiased priority. Signal no error. */ 10054 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; 10055 #else 10056 /* Return value is a biased priority to avoid negative numbers. */ 10057 ret = 20 - ret; 10058 #endif 10059 return ret; 10060 case TARGET_NR_setpriority: 10061 return get_errno(setpriority(arg1, arg2, arg3)); 10062 #ifdef TARGET_NR_statfs 10063 case TARGET_NR_statfs: 10064 if (!(p = lock_user_string(arg1))) { 10065 return -TARGET_EFAULT; 10066 } 10067 ret = get_errno(statfs(path(p), &stfs)); 10068 unlock_user(p, arg1, 0); 10069 convert_statfs: 10070 if (!is_error(ret)) { 10071 struct target_statfs *target_stfs; 10072 10073 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0)) 10074 return -TARGET_EFAULT; 10075 __put_user(stfs.f_type, &target_stfs->f_type); 10076 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 10077 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 10078 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 10079 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 10080 __put_user(stfs.f_files, &target_stfs->f_files); 10081 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 10082 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 10083 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 10084 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 10085 __put_user(stfs.f_frsize, &target_stfs->f_frsize); 10086 #ifdef _STATFS_F_FLAGS 10087 __put_user(stfs.f_flags, &target_stfs->f_flags); 10088 #else 10089 __put_user(0, &target_stfs->f_flags); 10090 #endif 10091 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare)); 10092 unlock_user_struct(target_stfs, arg2, 1); 10093 } 10094 return ret; 10095 #endif 10096 #ifdef TARGET_NR_fstatfs 10097 case TARGET_NR_fstatfs: 10098 ret = get_errno(fstatfs(arg1, &stfs)); 10099 goto convert_statfs; 10100 #endif 10101 #ifdef TARGET_NR_statfs64 10102 case TARGET_NR_statfs64: 10103 if (!(p = lock_user_string(arg1))) { 10104 return -TARGET_EFAULT; 10105 } 10106 ret = get_errno(statfs(path(p), &stfs)); 10107 unlock_user(p, arg1, 0); 10108 convert_statfs64: 10109 if (!is_error(ret)) { 10110 struct target_statfs64 *target_stfs; 10111 10112 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0)) 10113 return -TARGET_EFAULT; 10114 __put_user(stfs.f_type, &target_stfs->f_type); 10115 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 10116 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 10117 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 10118 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 10119 __put_user(stfs.f_files, &target_stfs->f_files); 10120 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 10121 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 10122 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 10123 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 10124 __put_user(stfs.f_frsize, &target_stfs->f_frsize); 10125 #ifdef _STATFS_F_FLAGS 10126 __put_user(stfs.f_flags, &target_stfs->f_flags); 10127 #else 10128 __put_user(0, &target_stfs->f_flags); 10129 #endif 10130 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare)); 10131 unlock_user_struct(target_stfs, arg3, 1); 10132 } 10133 return ret; 10134 case TARGET_NR_fstatfs64: 10135 ret = get_errno(fstatfs(arg1, &stfs)); 10136 goto convert_statfs64; 10137 #endif 10138 #ifdef TARGET_NR_socketcall 10139 case TARGET_NR_socketcall: 10140 return do_socketcall(arg1, arg2); 10141 #endif 10142 #ifdef TARGET_NR_accept 10143 case TARGET_NR_accept: 10144 return do_accept4(arg1, arg2, arg3, 0); 10145 #endif 10146 #ifdef TARGET_NR_accept4 10147 case TARGET_NR_accept4: 10148 return do_accept4(arg1, arg2, arg3, arg4); 10149 #endif 10150 #ifdef TARGET_NR_bind 10151 case TARGET_NR_bind: 10152 return do_bind(arg1, arg2, arg3); 10153 #endif 10154 #ifdef TARGET_NR_connect 10155 case TARGET_NR_connect: 10156 return do_connect(arg1, arg2, arg3); 10157 #endif 10158 #ifdef TARGET_NR_getpeername 10159 case TARGET_NR_getpeername: 10160 return do_getpeername(arg1, arg2, arg3); 10161 #endif 10162 #ifdef TARGET_NR_getsockname 10163 case TARGET_NR_getsockname: 10164 return do_getsockname(arg1, arg2, arg3); 10165 #endif 10166 #ifdef TARGET_NR_getsockopt 10167 case TARGET_NR_getsockopt: 10168 return do_getsockopt(arg1, arg2, arg3, arg4, arg5); 10169 #endif 10170 #ifdef TARGET_NR_listen 10171 case TARGET_NR_listen: 10172 return get_errno(listen(arg1, arg2)); 10173 #endif 10174 #ifdef TARGET_NR_recv 10175 case TARGET_NR_recv: 10176 return do_recvfrom(arg1, arg2, arg3, arg4, 0, 0); 10177 #endif 10178 #ifdef TARGET_NR_recvfrom 10179 case TARGET_NR_recvfrom: 10180 return do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); 10181 #endif 10182 #ifdef TARGET_NR_recvmsg 10183 case TARGET_NR_recvmsg: 10184 return do_sendrecvmsg(arg1, arg2, arg3, 0); 10185 #endif 10186 #ifdef TARGET_NR_send 10187 case TARGET_NR_send: 10188 return do_sendto(arg1, arg2, arg3, arg4, 0, 0); 10189 #endif 10190 #ifdef TARGET_NR_sendmsg 10191 case TARGET_NR_sendmsg: 10192 return do_sendrecvmsg(arg1, arg2, arg3, 1); 10193 #endif 10194 #ifdef TARGET_NR_sendmmsg 10195 case TARGET_NR_sendmmsg: 10196 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1); 10197 #endif 10198 #ifdef TARGET_NR_recvmmsg 10199 case TARGET_NR_recvmmsg: 10200 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0); 10201 #endif 10202 #ifdef TARGET_NR_sendto 10203 case TARGET_NR_sendto: 10204 return do_sendto(arg1, arg2, arg3, arg4, arg5, arg6); 10205 #endif 10206 #ifdef TARGET_NR_shutdown 10207 case TARGET_NR_shutdown: 10208 return get_errno(shutdown(arg1, arg2)); 10209 #endif 10210 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom) 10211 case TARGET_NR_getrandom: 10212 p = lock_user(VERIFY_WRITE, arg1, arg2, 0); 10213 if (!p) { 10214 return -TARGET_EFAULT; 10215 } 10216 ret = get_errno(getrandom(p, arg2, arg3)); 10217 unlock_user(p, arg1, ret); 10218 return ret; 10219 #endif 10220 #ifdef TARGET_NR_socket 10221 case TARGET_NR_socket: 10222 return do_socket(arg1, arg2, arg3); 10223 #endif 10224 #ifdef TARGET_NR_socketpair 10225 case TARGET_NR_socketpair: 10226 return do_socketpair(arg1, arg2, arg3, arg4); 10227 #endif 10228 #ifdef TARGET_NR_setsockopt 10229 case TARGET_NR_setsockopt: 10230 return do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5); 10231 #endif 10232 #if defined(TARGET_NR_syslog) 10233 case TARGET_NR_syslog: 10234 { 10235 int len = arg2; 10236 10237 switch (arg1) { 10238 case TARGET_SYSLOG_ACTION_CLOSE: /* Close log */ 10239 case TARGET_SYSLOG_ACTION_OPEN: /* Open log */ 10240 case TARGET_SYSLOG_ACTION_CLEAR: /* Clear ring buffer */ 10241 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging */ 10242 case TARGET_SYSLOG_ACTION_CONSOLE_ON: /* Enable logging */ 10243 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */ 10244 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: /* Number of chars */ 10245 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: /* Size of the buffer */ 10246 return get_errno(sys_syslog((int)arg1, NULL, (int)arg3)); 10247 case TARGET_SYSLOG_ACTION_READ: /* Read from log */ 10248 case TARGET_SYSLOG_ACTION_READ_CLEAR: /* Read/clear msgs */ 10249 case TARGET_SYSLOG_ACTION_READ_ALL: /* Read last messages */ 10250 { 10251 if (len < 0) { 10252 return -TARGET_EINVAL; 10253 } 10254 if (len == 0) { 10255 return 0; 10256 } 10257 p = lock_user(VERIFY_WRITE, arg2, arg3, 0); 10258 if (!p) { 10259 return -TARGET_EFAULT; 10260 } 10261 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3)); 10262 unlock_user(p, arg2, arg3); 10263 } 10264 return ret; 10265 default: 10266 return -TARGET_EINVAL; 10267 } 10268 } 10269 break; 10270 #endif 10271 case TARGET_NR_setitimer: 10272 { 10273 struct itimerval value, ovalue, *pvalue; 10274 10275 if (arg2) { 10276 pvalue = &value; 10277 if (copy_from_user_timeval(&pvalue->it_interval, arg2) 10278 || copy_from_user_timeval(&pvalue->it_value, 10279 arg2 + sizeof(struct target_timeval))) 10280 return -TARGET_EFAULT; 10281 } else { 10282 pvalue = NULL; 10283 } 10284 ret = get_errno(setitimer(arg1, pvalue, &ovalue)); 10285 if (!is_error(ret) && arg3) { 10286 if (copy_to_user_timeval(arg3, 10287 &ovalue.it_interval) 10288 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval), 10289 &ovalue.it_value)) 10290 return -TARGET_EFAULT; 10291 } 10292 } 10293 return ret; 10294 case TARGET_NR_getitimer: 10295 { 10296 struct itimerval value; 10297 10298 ret = get_errno(getitimer(arg1, &value)); 10299 if (!is_error(ret) && arg2) { 10300 if (copy_to_user_timeval(arg2, 10301 &value.it_interval) 10302 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval), 10303 &value.it_value)) 10304 return -TARGET_EFAULT; 10305 } 10306 } 10307 return ret; 10308 #ifdef TARGET_NR_stat 10309 case TARGET_NR_stat: 10310 if (!(p = lock_user_string(arg1))) { 10311 return -TARGET_EFAULT; 10312 } 10313 ret = get_errno(stat(path(p), &st)); 10314 unlock_user(p, arg1, 0); 10315 goto do_stat; 10316 #endif 10317 #ifdef TARGET_NR_lstat 10318 case TARGET_NR_lstat: 10319 if (!(p = lock_user_string(arg1))) { 10320 return -TARGET_EFAULT; 10321 } 10322 ret = get_errno(lstat(path(p), &st)); 10323 unlock_user(p, arg1, 0); 10324 goto do_stat; 10325 #endif 10326 #ifdef TARGET_NR_fstat 10327 case TARGET_NR_fstat: 10328 { 10329 ret = get_errno(fstat(arg1, &st)); 10330 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat) 10331 do_stat: 10332 #endif 10333 if (!is_error(ret)) { 10334 struct target_stat *target_st; 10335 10336 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0)) 10337 return -TARGET_EFAULT; 10338 memset(target_st, 0, sizeof(*target_st)); 10339 __put_user(st.st_dev, &target_st->st_dev); 10340 __put_user(st.st_ino, &target_st->st_ino); 10341 __put_user(st.st_mode, &target_st->st_mode); 10342 __put_user(st.st_uid, &target_st->st_uid); 10343 __put_user(st.st_gid, &target_st->st_gid); 10344 __put_user(st.st_nlink, &target_st->st_nlink); 10345 __put_user(st.st_rdev, &target_st->st_rdev); 10346 __put_user(st.st_size, &target_st->st_size); 10347 __put_user(st.st_blksize, &target_st->st_blksize); 10348 __put_user(st.st_blocks, &target_st->st_blocks); 10349 __put_user(st.st_atime, &target_st->target_st_atime); 10350 __put_user(st.st_mtime, &target_st->target_st_mtime); 10351 __put_user(st.st_ctime, &target_st->target_st_ctime); 10352 #if defined(HAVE_STRUCT_STAT_ST_ATIM) && defined(TARGET_STAT_HAVE_NSEC) 10353 __put_user(st.st_atim.tv_nsec, 10354 &target_st->target_st_atime_nsec); 10355 __put_user(st.st_mtim.tv_nsec, 10356 &target_st->target_st_mtime_nsec); 10357 __put_user(st.st_ctim.tv_nsec, 10358 &target_st->target_st_ctime_nsec); 10359 #endif 10360 unlock_user_struct(target_st, arg2, 1); 10361 } 10362 } 10363 return ret; 10364 #endif 10365 case TARGET_NR_vhangup: 10366 return get_errno(vhangup()); 10367 #ifdef TARGET_NR_syscall 10368 case TARGET_NR_syscall: 10369 return do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5, 10370 arg6, arg7, arg8, 0); 10371 #endif 10372 #if defined(TARGET_NR_wait4) 10373 case TARGET_NR_wait4: 10374 { 10375 int status; 10376 abi_long status_ptr = arg2; 10377 struct rusage rusage, *rusage_ptr; 10378 abi_ulong target_rusage = arg4; 10379 abi_long rusage_err; 10380 if (target_rusage) 10381 rusage_ptr = &rusage; 10382 else 10383 rusage_ptr = NULL; 10384 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr)); 10385 if (!is_error(ret)) { 10386 if (status_ptr && ret) { 10387 status = host_to_target_waitstatus(status); 10388 if (put_user_s32(status, status_ptr)) 10389 return -TARGET_EFAULT; 10390 } 10391 if (target_rusage) { 10392 rusage_err = host_to_target_rusage(target_rusage, &rusage); 10393 if (rusage_err) { 10394 ret = rusage_err; 10395 } 10396 } 10397 } 10398 } 10399 return ret; 10400 #endif 10401 #ifdef TARGET_NR_swapoff 10402 case TARGET_NR_swapoff: 10403 if (!(p = lock_user_string(arg1))) 10404 return -TARGET_EFAULT; 10405 ret = get_errno(swapoff(p)); 10406 unlock_user(p, arg1, 0); 10407 return ret; 10408 #endif 10409 case TARGET_NR_sysinfo: 10410 { 10411 struct target_sysinfo *target_value; 10412 struct sysinfo value; 10413 ret = get_errno(sysinfo(&value)); 10414 if (!is_error(ret) && arg1) 10415 { 10416 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0)) 10417 return -TARGET_EFAULT; 10418 __put_user(value.uptime, &target_value->uptime); 10419 __put_user(value.loads[0], &target_value->loads[0]); 10420 __put_user(value.loads[1], &target_value->loads[1]); 10421 __put_user(value.loads[2], &target_value->loads[2]); 10422 __put_user(value.totalram, &target_value->totalram); 10423 __put_user(value.freeram, &target_value->freeram); 10424 __put_user(value.sharedram, &target_value->sharedram); 10425 __put_user(value.bufferram, &target_value->bufferram); 10426 __put_user(value.totalswap, &target_value->totalswap); 10427 __put_user(value.freeswap, &target_value->freeswap); 10428 __put_user(value.procs, &target_value->procs); 10429 __put_user(value.totalhigh, &target_value->totalhigh); 10430 __put_user(value.freehigh, &target_value->freehigh); 10431 __put_user(value.mem_unit, &target_value->mem_unit); 10432 unlock_user_struct(target_value, arg1, 1); 10433 } 10434 } 10435 return ret; 10436 #ifdef TARGET_NR_ipc 10437 case TARGET_NR_ipc: 10438 return do_ipc(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6); 10439 #endif 10440 #ifdef TARGET_NR_semget 10441 case TARGET_NR_semget: 10442 return get_errno(semget(arg1, arg2, arg3)); 10443 #endif 10444 #ifdef TARGET_NR_semop 10445 case TARGET_NR_semop: 10446 return do_semtimedop(arg1, arg2, arg3, 0, false); 10447 #endif 10448 #ifdef TARGET_NR_semtimedop 10449 case TARGET_NR_semtimedop: 10450 return do_semtimedop(arg1, arg2, arg3, arg4, false); 10451 #endif 10452 #ifdef TARGET_NR_semtimedop_time64 10453 case TARGET_NR_semtimedop_time64: 10454 return do_semtimedop(arg1, arg2, arg3, arg4, true); 10455 #endif 10456 #ifdef TARGET_NR_semctl 10457 case TARGET_NR_semctl: 10458 return do_semctl(arg1, arg2, arg3, arg4); 10459 #endif 10460 #ifdef TARGET_NR_msgctl 10461 case TARGET_NR_msgctl: 10462 return do_msgctl(arg1, arg2, arg3); 10463 #endif 10464 #ifdef TARGET_NR_msgget 10465 case TARGET_NR_msgget: 10466 return get_errno(msgget(arg1, arg2)); 10467 #endif 10468 #ifdef TARGET_NR_msgrcv 10469 case TARGET_NR_msgrcv: 10470 return do_msgrcv(arg1, arg2, arg3, arg4, arg5); 10471 #endif 10472 #ifdef TARGET_NR_msgsnd 10473 case TARGET_NR_msgsnd: 10474 return do_msgsnd(arg1, arg2, arg3, arg4); 10475 #endif 10476 #ifdef TARGET_NR_shmget 10477 case TARGET_NR_shmget: 10478 return get_errno(shmget(arg1, arg2, arg3)); 10479 #endif 10480 #ifdef TARGET_NR_shmctl 10481 case TARGET_NR_shmctl: 10482 return do_shmctl(arg1, arg2, arg3); 10483 #endif 10484 #ifdef TARGET_NR_shmat 10485 case TARGET_NR_shmat: 10486 return do_shmat(cpu_env, arg1, arg2, arg3); 10487 #endif 10488 #ifdef TARGET_NR_shmdt 10489 case TARGET_NR_shmdt: 10490 return do_shmdt(arg1); 10491 #endif 10492 case TARGET_NR_fsync: 10493 return get_errno(fsync(arg1)); 10494 case TARGET_NR_clone: 10495 /* Linux manages to have three different orderings for its 10496 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines 10497 * match the kernel's CONFIG_CLONE_* settings. 10498 * Microblaze is further special in that it uses a sixth 10499 * implicit argument to clone for the TLS pointer. 10500 */ 10501 #if defined(TARGET_MICROBLAZE) 10502 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5)); 10503 #elif defined(TARGET_CLONE_BACKWARDS) 10504 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5)); 10505 #elif defined(TARGET_CLONE_BACKWARDS2) 10506 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4)); 10507 #else 10508 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4)); 10509 #endif 10510 return ret; 10511 #ifdef __NR_exit_group 10512 /* new thread calls */ 10513 case TARGET_NR_exit_group: 10514 preexit_cleanup(cpu_env, arg1); 10515 return get_errno(exit_group(arg1)); 10516 #endif 10517 case TARGET_NR_setdomainname: 10518 if (!(p = lock_user_string(arg1))) 10519 return -TARGET_EFAULT; 10520 ret = get_errno(setdomainname(p, arg2)); 10521 unlock_user(p, arg1, 0); 10522 return ret; 10523 case TARGET_NR_uname: 10524 /* no need to transcode because we use the linux syscall */ 10525 { 10526 struct new_utsname * buf; 10527 10528 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0)) 10529 return -TARGET_EFAULT; 10530 ret = get_errno(sys_uname(buf)); 10531 if (!is_error(ret)) { 10532 /* Overwrite the native machine name with whatever is being 10533 emulated. */ 10534 g_strlcpy(buf->machine, cpu_to_uname_machine(cpu_env), 10535 sizeof(buf->machine)); 10536 /* Allow the user to override the reported release. */ 10537 if (qemu_uname_release && *qemu_uname_release) { 10538 g_strlcpy(buf->release, qemu_uname_release, 10539 sizeof(buf->release)); 10540 } 10541 } 10542 unlock_user_struct(buf, arg1, 1); 10543 } 10544 return ret; 10545 #ifdef TARGET_I386 10546 case TARGET_NR_modify_ldt: 10547 return do_modify_ldt(cpu_env, arg1, arg2, arg3); 10548 #if !defined(TARGET_X86_64) 10549 case TARGET_NR_vm86: 10550 return do_vm86(cpu_env, arg1, arg2); 10551 #endif 10552 #endif 10553 #if defined(TARGET_NR_adjtimex) 10554 case TARGET_NR_adjtimex: 10555 { 10556 struct timex host_buf; 10557 10558 if (target_to_host_timex(&host_buf, arg1) != 0) { 10559 return -TARGET_EFAULT; 10560 } 10561 ret = get_errno(adjtimex(&host_buf)); 10562 if (!is_error(ret)) { 10563 if (host_to_target_timex(arg1, &host_buf) != 0) { 10564 return -TARGET_EFAULT; 10565 } 10566 } 10567 } 10568 return ret; 10569 #endif 10570 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME) 10571 case TARGET_NR_clock_adjtime: 10572 { 10573 struct timex htx, *phtx = &htx; 10574 10575 if (target_to_host_timex(phtx, arg2) != 0) { 10576 return -TARGET_EFAULT; 10577 } 10578 ret = get_errno(clock_adjtime(arg1, phtx)); 10579 if (!is_error(ret) && phtx) { 10580 if (host_to_target_timex(arg2, phtx) != 0) { 10581 return -TARGET_EFAULT; 10582 } 10583 } 10584 } 10585 return ret; 10586 #endif 10587 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME) 10588 case TARGET_NR_clock_adjtime64: 10589 { 10590 struct timex htx; 10591 10592 if (target_to_host_timex64(&htx, arg2) != 0) { 10593 return -TARGET_EFAULT; 10594 } 10595 ret = get_errno(clock_adjtime(arg1, &htx)); 10596 if (!is_error(ret) && host_to_target_timex64(arg2, &htx)) { 10597 return -TARGET_EFAULT; 10598 } 10599 } 10600 return ret; 10601 #endif 10602 case TARGET_NR_getpgid: 10603 return get_errno(getpgid(arg1)); 10604 case TARGET_NR_fchdir: 10605 return get_errno(fchdir(arg1)); 10606 case TARGET_NR_personality: 10607 return get_errno(personality(arg1)); 10608 #ifdef TARGET_NR__llseek /* Not on alpha */ 10609 case TARGET_NR__llseek: 10610 { 10611 int64_t res; 10612 #if !defined(__NR_llseek) 10613 res = lseek(arg1, ((uint64_t)arg2 << 32) | (abi_ulong)arg3, arg5); 10614 if (res == -1) { 10615 ret = get_errno(res); 10616 } else { 10617 ret = 0; 10618 } 10619 #else 10620 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); 10621 #endif 10622 if ((ret == 0) && put_user_s64(res, arg4)) { 10623 return -TARGET_EFAULT; 10624 } 10625 } 10626 return ret; 10627 #endif 10628 #ifdef TARGET_NR_getdents 10629 case TARGET_NR_getdents: 10630 return do_getdents(arg1, arg2, arg3); 10631 #endif /* TARGET_NR_getdents */ 10632 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) 10633 case TARGET_NR_getdents64: 10634 return do_getdents64(arg1, arg2, arg3); 10635 #endif /* TARGET_NR_getdents64 */ 10636 #if defined(TARGET_NR__newselect) 10637 case TARGET_NR__newselect: 10638 return do_select(arg1, arg2, arg3, arg4, arg5); 10639 #endif 10640 #ifdef TARGET_NR_poll 10641 case TARGET_NR_poll: 10642 return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false); 10643 #endif 10644 #ifdef TARGET_NR_ppoll 10645 case TARGET_NR_ppoll: 10646 return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false); 10647 #endif 10648 #ifdef TARGET_NR_ppoll_time64 10649 case TARGET_NR_ppoll_time64: 10650 return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true); 10651 #endif 10652 case TARGET_NR_flock: 10653 /* NOTE: the flock constant seems to be the same for every 10654 Linux platform */ 10655 return get_errno(safe_flock(arg1, arg2)); 10656 case TARGET_NR_readv: 10657 { 10658 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0); 10659 if (vec != NULL) { 10660 ret = get_errno(safe_readv(arg1, vec, arg3)); 10661 unlock_iovec(vec, arg2, arg3, 1); 10662 } else { 10663 ret = -host_to_target_errno(errno); 10664 } 10665 } 10666 return ret; 10667 case TARGET_NR_writev: 10668 { 10669 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 10670 if (vec != NULL) { 10671 ret = get_errno(safe_writev(arg1, vec, arg3)); 10672 unlock_iovec(vec, arg2, arg3, 0); 10673 } else { 10674 ret = -host_to_target_errno(errno); 10675 } 10676 } 10677 return ret; 10678 #if defined(TARGET_NR_preadv) 10679 case TARGET_NR_preadv: 10680 { 10681 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0); 10682 if (vec != NULL) { 10683 unsigned long low, high; 10684 10685 target_to_host_low_high(arg4, arg5, &low, &high); 10686 ret = get_errno(safe_preadv(arg1, vec, arg3, low, high)); 10687 unlock_iovec(vec, arg2, arg3, 1); 10688 } else { 10689 ret = -host_to_target_errno(errno); 10690 } 10691 } 10692 return ret; 10693 #endif 10694 #if defined(TARGET_NR_pwritev) 10695 case TARGET_NR_pwritev: 10696 { 10697 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 10698 if (vec != NULL) { 10699 unsigned long low, high; 10700 10701 target_to_host_low_high(arg4, arg5, &low, &high); 10702 ret = get_errno(safe_pwritev(arg1, vec, arg3, low, high)); 10703 unlock_iovec(vec, arg2, arg3, 0); 10704 } else { 10705 ret = -host_to_target_errno(errno); 10706 } 10707 } 10708 return ret; 10709 #endif 10710 case TARGET_NR_getsid: 10711 return get_errno(getsid(arg1)); 10712 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */ 10713 case TARGET_NR_fdatasync: 10714 return get_errno(fdatasync(arg1)); 10715 #endif 10716 case TARGET_NR_sched_getaffinity: 10717 { 10718 unsigned int mask_size; 10719 unsigned long *mask; 10720 10721 /* 10722 * sched_getaffinity needs multiples of ulong, so need to take 10723 * care of mismatches between target ulong and host ulong sizes. 10724 */ 10725 if (arg2 & (sizeof(abi_ulong) - 1)) { 10726 return -TARGET_EINVAL; 10727 } 10728 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1); 10729 10730 mask = alloca(mask_size); 10731 memset(mask, 0, mask_size); 10732 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask)); 10733 10734 if (!is_error(ret)) { 10735 if (ret > arg2) { 10736 /* More data returned than the caller's buffer will fit. 10737 * This only happens if sizeof(abi_long) < sizeof(long) 10738 * and the caller passed us a buffer holding an odd number 10739 * of abi_longs. If the host kernel is actually using the 10740 * extra 4 bytes then fail EINVAL; otherwise we can just 10741 * ignore them and only copy the interesting part. 10742 */ 10743 int numcpus = sysconf(_SC_NPROCESSORS_CONF); 10744 if (numcpus > arg2 * 8) { 10745 return -TARGET_EINVAL; 10746 } 10747 ret = arg2; 10748 } 10749 10750 if (host_to_target_cpu_mask(mask, mask_size, arg3, ret)) { 10751 return -TARGET_EFAULT; 10752 } 10753 } 10754 } 10755 return ret; 10756 case TARGET_NR_sched_setaffinity: 10757 { 10758 unsigned int mask_size; 10759 unsigned long *mask; 10760 10761 /* 10762 * sched_setaffinity needs multiples of ulong, so need to take 10763 * care of mismatches between target ulong and host ulong sizes. 10764 */ 10765 if (arg2 & (sizeof(abi_ulong) - 1)) { 10766 return -TARGET_EINVAL; 10767 } 10768 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1); 10769 mask = alloca(mask_size); 10770 10771 ret = target_to_host_cpu_mask(mask, mask_size, arg3, arg2); 10772 if (ret) { 10773 return ret; 10774 } 10775 10776 return get_errno(sys_sched_setaffinity(arg1, mask_size, mask)); 10777 } 10778 case TARGET_NR_getcpu: 10779 { 10780 unsigned cpu, node; 10781 ret = get_errno(sys_getcpu(arg1 ? &cpu : NULL, 10782 arg2 ? &node : NULL, 10783 NULL)); 10784 if (is_error(ret)) { 10785 return ret; 10786 } 10787 if (arg1 && put_user_u32(cpu, arg1)) { 10788 return -TARGET_EFAULT; 10789 } 10790 if (arg2 && put_user_u32(node, arg2)) { 10791 return -TARGET_EFAULT; 10792 } 10793 } 10794 return ret; 10795 case TARGET_NR_sched_setparam: 10796 { 10797 struct target_sched_param *target_schp; 10798 struct sched_param schp; 10799 10800 if (arg2 == 0) { 10801 return -TARGET_EINVAL; 10802 } 10803 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) { 10804 return -TARGET_EFAULT; 10805 } 10806 schp.sched_priority = tswap32(target_schp->sched_priority); 10807 unlock_user_struct(target_schp, arg2, 0); 10808 return get_errno(sys_sched_setparam(arg1, &schp)); 10809 } 10810 case TARGET_NR_sched_getparam: 10811 { 10812 struct target_sched_param *target_schp; 10813 struct sched_param schp; 10814 10815 if (arg2 == 0) { 10816 return -TARGET_EINVAL; 10817 } 10818 ret = get_errno(sys_sched_getparam(arg1, &schp)); 10819 if (!is_error(ret)) { 10820 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) { 10821 return -TARGET_EFAULT; 10822 } 10823 target_schp->sched_priority = tswap32(schp.sched_priority); 10824 unlock_user_struct(target_schp, arg2, 1); 10825 } 10826 } 10827 return ret; 10828 case TARGET_NR_sched_setscheduler: 10829 { 10830 struct target_sched_param *target_schp; 10831 struct sched_param schp; 10832 if (arg3 == 0) { 10833 return -TARGET_EINVAL; 10834 } 10835 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) { 10836 return -TARGET_EFAULT; 10837 } 10838 schp.sched_priority = tswap32(target_schp->sched_priority); 10839 unlock_user_struct(target_schp, arg3, 0); 10840 return get_errno(sys_sched_setscheduler(arg1, arg2, &schp)); 10841 } 10842 case TARGET_NR_sched_getscheduler: 10843 return get_errno(sys_sched_getscheduler(arg1)); 10844 case TARGET_NR_sched_getattr: 10845 { 10846 struct target_sched_attr *target_scha; 10847 struct sched_attr scha; 10848 if (arg2 == 0) { 10849 return -TARGET_EINVAL; 10850 } 10851 if (arg3 > sizeof(scha)) { 10852 arg3 = sizeof(scha); 10853 } 10854 ret = get_errno(sys_sched_getattr(arg1, &scha, arg3, arg4)); 10855 if (!is_error(ret)) { 10856 target_scha = lock_user(VERIFY_WRITE, arg2, arg3, 0); 10857 if (!target_scha) { 10858 return -TARGET_EFAULT; 10859 } 10860 target_scha->size = tswap32(scha.size); 10861 target_scha->sched_policy = tswap32(scha.sched_policy); 10862 target_scha->sched_flags = tswap64(scha.sched_flags); 10863 target_scha->sched_nice = tswap32(scha.sched_nice); 10864 target_scha->sched_priority = tswap32(scha.sched_priority); 10865 target_scha->sched_runtime = tswap64(scha.sched_runtime); 10866 target_scha->sched_deadline = tswap64(scha.sched_deadline); 10867 target_scha->sched_period = tswap64(scha.sched_period); 10868 if (scha.size > offsetof(struct sched_attr, sched_util_min)) { 10869 target_scha->sched_util_min = tswap32(scha.sched_util_min); 10870 target_scha->sched_util_max = tswap32(scha.sched_util_max); 10871 } 10872 unlock_user(target_scha, arg2, arg3); 10873 } 10874 return ret; 10875 } 10876 case TARGET_NR_sched_setattr: 10877 { 10878 struct target_sched_attr *target_scha; 10879 struct sched_attr scha; 10880 uint32_t size; 10881 int zeroed; 10882 if (arg2 == 0) { 10883 return -TARGET_EINVAL; 10884 } 10885 if (get_user_u32(size, arg2)) { 10886 return -TARGET_EFAULT; 10887 } 10888 if (!size) { 10889 size = offsetof(struct target_sched_attr, sched_util_min); 10890 } 10891 if (size < offsetof(struct target_sched_attr, sched_util_min)) { 10892 if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { 10893 return -TARGET_EFAULT; 10894 } 10895 return -TARGET_E2BIG; 10896 } 10897 10898 zeroed = check_zeroed_user(arg2, sizeof(struct target_sched_attr), size); 10899 if (zeroed < 0) { 10900 return zeroed; 10901 } else if (zeroed == 0) { 10902 if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { 10903 return -TARGET_EFAULT; 10904 } 10905 return -TARGET_E2BIG; 10906 } 10907 if (size > sizeof(struct target_sched_attr)) { 10908 size = sizeof(struct target_sched_attr); 10909 } 10910 10911 target_scha = lock_user(VERIFY_READ, arg2, size, 1); 10912 if (!target_scha) { 10913 return -TARGET_EFAULT; 10914 } 10915 scha.size = size; 10916 scha.sched_policy = tswap32(target_scha->sched_policy); 10917 scha.sched_flags = tswap64(target_scha->sched_flags); 10918 scha.sched_nice = tswap32(target_scha->sched_nice); 10919 scha.sched_priority = tswap32(target_scha->sched_priority); 10920 scha.sched_runtime = tswap64(target_scha->sched_runtime); 10921 scha.sched_deadline = tswap64(target_scha->sched_deadline); 10922 scha.sched_period = tswap64(target_scha->sched_period); 10923 if (size > offsetof(struct target_sched_attr, sched_util_min)) { 10924 scha.sched_util_min = tswap32(target_scha->sched_util_min); 10925 scha.sched_util_max = tswap32(target_scha->sched_util_max); 10926 } 10927 unlock_user(target_scha, arg2, 0); 10928 return get_errno(sys_sched_setattr(arg1, &scha, arg3)); 10929 } 10930 case TARGET_NR_sched_yield: 10931 return get_errno(sched_yield()); 10932 case TARGET_NR_sched_get_priority_max: 10933 return get_errno(sched_get_priority_max(arg1)); 10934 case TARGET_NR_sched_get_priority_min: 10935 return get_errno(sched_get_priority_min(arg1)); 10936 #ifdef TARGET_NR_sched_rr_get_interval 10937 case TARGET_NR_sched_rr_get_interval: 10938 { 10939 struct timespec ts; 10940 ret = get_errno(sched_rr_get_interval(arg1, &ts)); 10941 if (!is_error(ret)) { 10942 ret = host_to_target_timespec(arg2, &ts); 10943 } 10944 } 10945 return ret; 10946 #endif 10947 #ifdef TARGET_NR_sched_rr_get_interval_time64 10948 case TARGET_NR_sched_rr_get_interval_time64: 10949 { 10950 struct timespec ts; 10951 ret = get_errno(sched_rr_get_interval(arg1, &ts)); 10952 if (!is_error(ret)) { 10953 ret = host_to_target_timespec64(arg2, &ts); 10954 } 10955 } 10956 return ret; 10957 #endif 10958 #if defined(TARGET_NR_nanosleep) 10959 case TARGET_NR_nanosleep: 10960 { 10961 struct timespec req, rem; 10962 target_to_host_timespec(&req, arg1); 10963 ret = get_errno(safe_nanosleep(&req, &rem)); 10964 if (is_error(ret) && arg2) { 10965 host_to_target_timespec(arg2, &rem); 10966 } 10967 } 10968 return ret; 10969 #endif 10970 case TARGET_NR_prctl: 10971 return do_prctl(cpu_env, arg1, arg2, arg3, arg4, arg5); 10972 break; 10973 #ifdef TARGET_NR_arch_prctl 10974 case TARGET_NR_arch_prctl: 10975 return do_arch_prctl(cpu_env, arg1, arg2); 10976 #endif 10977 #ifdef TARGET_NR_pread64 10978 case TARGET_NR_pread64: 10979 if (regpairs_aligned(cpu_env, num)) { 10980 arg4 = arg5; 10981 arg5 = arg6; 10982 } 10983 if (arg2 == 0 && arg3 == 0) { 10984 /* Special-case NULL buffer and zero length, which should succeed */ 10985 p = 0; 10986 } else { 10987 p = lock_user(VERIFY_WRITE, arg2, arg3, 0); 10988 if (!p) { 10989 return -TARGET_EFAULT; 10990 } 10991 } 10992 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5))); 10993 unlock_user(p, arg2, ret); 10994 return ret; 10995 case TARGET_NR_pwrite64: 10996 if (regpairs_aligned(cpu_env, num)) { 10997 arg4 = arg5; 10998 arg5 = arg6; 10999 } 11000 if (arg2 == 0 && arg3 == 0) { 11001 /* Special-case NULL buffer and zero length, which should succeed */ 11002 p = 0; 11003 } else { 11004 p = lock_user(VERIFY_READ, arg2, arg3, 1); 11005 if (!p) { 11006 return -TARGET_EFAULT; 11007 } 11008 } 11009 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5))); 11010 unlock_user(p, arg2, 0); 11011 return ret; 11012 #endif 11013 case TARGET_NR_getcwd: 11014 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0))) 11015 return -TARGET_EFAULT; 11016 ret = get_errno(sys_getcwd1(p, arg2)); 11017 unlock_user(p, arg1, ret); 11018 return ret; 11019 case TARGET_NR_capget: 11020 case TARGET_NR_capset: 11021 { 11022 struct target_user_cap_header *target_header; 11023 struct target_user_cap_data *target_data = NULL; 11024 struct __user_cap_header_struct header; 11025 struct __user_cap_data_struct data[2]; 11026 struct __user_cap_data_struct *dataptr = NULL; 11027 int i, target_datalen; 11028 int data_items = 1; 11029 11030 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) { 11031 return -TARGET_EFAULT; 11032 } 11033 header.version = tswap32(target_header->version); 11034 header.pid = tswap32(target_header->pid); 11035 11036 if (header.version != _LINUX_CAPABILITY_VERSION) { 11037 /* Version 2 and up takes pointer to two user_data structs */ 11038 data_items = 2; 11039 } 11040 11041 target_datalen = sizeof(*target_data) * data_items; 11042 11043 if (arg2) { 11044 if (num == TARGET_NR_capget) { 11045 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0); 11046 } else { 11047 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1); 11048 } 11049 if (!target_data) { 11050 unlock_user_struct(target_header, arg1, 0); 11051 return -TARGET_EFAULT; 11052 } 11053 11054 if (num == TARGET_NR_capset) { 11055 for (i = 0; i < data_items; i++) { 11056 data[i].effective = tswap32(target_data[i].effective); 11057 data[i].permitted = tswap32(target_data[i].permitted); 11058 data[i].inheritable = tswap32(target_data[i].inheritable); 11059 } 11060 } 11061 11062 dataptr = data; 11063 } 11064 11065 if (num == TARGET_NR_capget) { 11066 ret = get_errno(capget(&header, dataptr)); 11067 } else { 11068 ret = get_errno(capset(&header, dataptr)); 11069 } 11070 11071 /* The kernel always updates version for both capget and capset */ 11072 target_header->version = tswap32(header.version); 11073 unlock_user_struct(target_header, arg1, 1); 11074 11075 if (arg2) { 11076 if (num == TARGET_NR_capget) { 11077 for (i = 0; i < data_items; i++) { 11078 target_data[i].effective = tswap32(data[i].effective); 11079 target_data[i].permitted = tswap32(data[i].permitted); 11080 target_data[i].inheritable = tswap32(data[i].inheritable); 11081 } 11082 unlock_user(target_data, arg2, target_datalen); 11083 } else { 11084 unlock_user(target_data, arg2, 0); 11085 } 11086 } 11087 return ret; 11088 } 11089 case TARGET_NR_sigaltstack: 11090 return do_sigaltstack(arg1, arg2, cpu_env); 11091 11092 #ifdef CONFIG_SENDFILE 11093 #ifdef TARGET_NR_sendfile 11094 case TARGET_NR_sendfile: 11095 { 11096 off_t *offp = NULL; 11097 off_t off; 11098 if (arg3) { 11099 ret = get_user_sal(off, arg3); 11100 if (is_error(ret)) { 11101 return ret; 11102 } 11103 offp = &off; 11104 } 11105 ret = get_errno(sendfile(arg1, arg2, offp, arg4)); 11106 if (!is_error(ret) && arg3) { 11107 abi_long ret2 = put_user_sal(off, arg3); 11108 if (is_error(ret2)) { 11109 ret = ret2; 11110 } 11111 } 11112 return ret; 11113 } 11114 #endif 11115 #ifdef TARGET_NR_sendfile64 11116 case TARGET_NR_sendfile64: 11117 { 11118 off_t *offp = NULL; 11119 off_t off; 11120 if (arg3) { 11121 ret = get_user_s64(off, arg3); 11122 if (is_error(ret)) { 11123 return ret; 11124 } 11125 offp = &off; 11126 } 11127 ret = get_errno(sendfile(arg1, arg2, offp, arg4)); 11128 if (!is_error(ret) && arg3) { 11129 abi_long ret2 = put_user_s64(off, arg3); 11130 if (is_error(ret2)) { 11131 ret = ret2; 11132 } 11133 } 11134 return ret; 11135 } 11136 #endif 11137 #endif 11138 #ifdef TARGET_NR_vfork 11139 case TARGET_NR_vfork: 11140 return get_errno(do_fork(cpu_env, 11141 CLONE_VFORK | CLONE_VM | TARGET_SIGCHLD, 11142 0, 0, 0, 0)); 11143 #endif 11144 #ifdef TARGET_NR_ugetrlimit 11145 case TARGET_NR_ugetrlimit: 11146 { 11147 struct rlimit rlim; 11148 int resource = target_to_host_resource(arg1); 11149 ret = get_errno(getrlimit(resource, &rlim)); 11150 if (!is_error(ret)) { 11151 struct target_rlimit *target_rlim; 11152 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 11153 return -TARGET_EFAULT; 11154 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur); 11155 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max); 11156 unlock_user_struct(target_rlim, arg2, 1); 11157 } 11158 return ret; 11159 } 11160 #endif 11161 #ifdef TARGET_NR_truncate64 11162 case TARGET_NR_truncate64: 11163 if (!(p = lock_user_string(arg1))) 11164 return -TARGET_EFAULT; 11165 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4); 11166 unlock_user(p, arg1, 0); 11167 return ret; 11168 #endif 11169 #ifdef TARGET_NR_ftruncate64 11170 case TARGET_NR_ftruncate64: 11171 return target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4); 11172 #endif 11173 #ifdef TARGET_NR_stat64 11174 case TARGET_NR_stat64: 11175 if (!(p = lock_user_string(arg1))) { 11176 return -TARGET_EFAULT; 11177 } 11178 ret = get_errno(stat(path(p), &st)); 11179 unlock_user(p, arg1, 0); 11180 if (!is_error(ret)) 11181 ret = host_to_target_stat64(cpu_env, arg2, &st); 11182 return ret; 11183 #endif 11184 #ifdef TARGET_NR_lstat64 11185 case TARGET_NR_lstat64: 11186 if (!(p = lock_user_string(arg1))) { 11187 return -TARGET_EFAULT; 11188 } 11189 ret = get_errno(lstat(path(p), &st)); 11190 unlock_user(p, arg1, 0); 11191 if (!is_error(ret)) 11192 ret = host_to_target_stat64(cpu_env, arg2, &st); 11193 return ret; 11194 #endif 11195 #ifdef TARGET_NR_fstat64 11196 case TARGET_NR_fstat64: 11197 ret = get_errno(fstat(arg1, &st)); 11198 if (!is_error(ret)) 11199 ret = host_to_target_stat64(cpu_env, arg2, &st); 11200 return ret; 11201 #endif 11202 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) 11203 #ifdef TARGET_NR_fstatat64 11204 case TARGET_NR_fstatat64: 11205 #endif 11206 #ifdef TARGET_NR_newfstatat 11207 case TARGET_NR_newfstatat: 11208 #endif 11209 if (!(p = lock_user_string(arg2))) { 11210 return -TARGET_EFAULT; 11211 } 11212 ret = get_errno(fstatat(arg1, path(p), &st, arg4)); 11213 unlock_user(p, arg2, 0); 11214 if (!is_error(ret)) 11215 ret = host_to_target_stat64(cpu_env, arg3, &st); 11216 return ret; 11217 #endif 11218 #if defined(TARGET_NR_statx) 11219 case TARGET_NR_statx: 11220 { 11221 struct target_statx *target_stx; 11222 int dirfd = arg1; 11223 int flags = arg3; 11224 11225 p = lock_user_string(arg2); 11226 if (p == NULL) { 11227 return -TARGET_EFAULT; 11228 } 11229 #if defined(__NR_statx) 11230 { 11231 /* 11232 * It is assumed that struct statx is architecture independent. 11233 */ 11234 struct target_statx host_stx; 11235 int mask = arg4; 11236 11237 ret = get_errno(sys_statx(dirfd, p, flags, mask, &host_stx)); 11238 if (!is_error(ret)) { 11239 if (host_to_target_statx(&host_stx, arg5) != 0) { 11240 unlock_user(p, arg2, 0); 11241 return -TARGET_EFAULT; 11242 } 11243 } 11244 11245 if (ret != -TARGET_ENOSYS) { 11246 unlock_user(p, arg2, 0); 11247 return ret; 11248 } 11249 } 11250 #endif 11251 ret = get_errno(fstatat(dirfd, path(p), &st, flags)); 11252 unlock_user(p, arg2, 0); 11253 11254 if (!is_error(ret)) { 11255 if (!lock_user_struct(VERIFY_WRITE, target_stx, arg5, 0)) { 11256 return -TARGET_EFAULT; 11257 } 11258 memset(target_stx, 0, sizeof(*target_stx)); 11259 __put_user(major(st.st_dev), &target_stx->stx_dev_major); 11260 __put_user(minor(st.st_dev), &target_stx->stx_dev_minor); 11261 __put_user(st.st_ino, &target_stx->stx_ino); 11262 __put_user(st.st_mode, &target_stx->stx_mode); 11263 __put_user(st.st_uid, &target_stx->stx_uid); 11264 __put_user(st.st_gid, &target_stx->stx_gid); 11265 __put_user(st.st_nlink, &target_stx->stx_nlink); 11266 __put_user(major(st.st_rdev), &target_stx->stx_rdev_major); 11267 __put_user(minor(st.st_rdev), &target_stx->stx_rdev_minor); 11268 __put_user(st.st_size, &target_stx->stx_size); 11269 __put_user(st.st_blksize, &target_stx->stx_blksize); 11270 __put_user(st.st_blocks, &target_stx->stx_blocks); 11271 __put_user(st.st_atime, &target_stx->stx_atime.tv_sec); 11272 __put_user(st.st_mtime, &target_stx->stx_mtime.tv_sec); 11273 __put_user(st.st_ctime, &target_stx->stx_ctime.tv_sec); 11274 unlock_user_struct(target_stx, arg5, 1); 11275 } 11276 } 11277 return ret; 11278 #endif 11279 #ifdef TARGET_NR_lchown 11280 case TARGET_NR_lchown: 11281 if (!(p = lock_user_string(arg1))) 11282 return -TARGET_EFAULT; 11283 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3))); 11284 unlock_user(p, arg1, 0); 11285 return ret; 11286 #endif 11287 #ifdef TARGET_NR_getuid 11288 case TARGET_NR_getuid: 11289 return get_errno(high2lowuid(getuid())); 11290 #endif 11291 #ifdef TARGET_NR_getgid 11292 case TARGET_NR_getgid: 11293 return get_errno(high2lowgid(getgid())); 11294 #endif 11295 #ifdef TARGET_NR_geteuid 11296 case TARGET_NR_geteuid: 11297 return get_errno(high2lowuid(geteuid())); 11298 #endif 11299 #ifdef TARGET_NR_getegid 11300 case TARGET_NR_getegid: 11301 return get_errno(high2lowgid(getegid())); 11302 #endif 11303 case TARGET_NR_setreuid: 11304 return get_errno(setreuid(low2highuid(arg1), low2highuid(arg2))); 11305 case TARGET_NR_setregid: 11306 return get_errno(setregid(low2highgid(arg1), low2highgid(arg2))); 11307 case TARGET_NR_getgroups: 11308 { 11309 int gidsetsize = arg1; 11310 target_id *target_grouplist; 11311 gid_t *grouplist; 11312 int i; 11313 11314 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11315 ret = get_errno(getgroups(gidsetsize, grouplist)); 11316 if (gidsetsize == 0) 11317 return ret; 11318 if (!is_error(ret)) { 11319 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0); 11320 if (!target_grouplist) 11321 return -TARGET_EFAULT; 11322 for(i = 0;i < ret; i++) 11323 target_grouplist[i] = tswapid(high2lowgid(grouplist[i])); 11324 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id)); 11325 } 11326 } 11327 return ret; 11328 case TARGET_NR_setgroups: 11329 { 11330 int gidsetsize = arg1; 11331 target_id *target_grouplist; 11332 gid_t *grouplist = NULL; 11333 int i; 11334 if (gidsetsize) { 11335 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11336 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1); 11337 if (!target_grouplist) { 11338 return -TARGET_EFAULT; 11339 } 11340 for (i = 0; i < gidsetsize; i++) { 11341 grouplist[i] = low2highgid(tswapid(target_grouplist[i])); 11342 } 11343 unlock_user(target_grouplist, arg2, 0); 11344 } 11345 return get_errno(setgroups(gidsetsize, grouplist)); 11346 } 11347 case TARGET_NR_fchown: 11348 return get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3))); 11349 #if defined(TARGET_NR_fchownat) 11350 case TARGET_NR_fchownat: 11351 if (!(p = lock_user_string(arg2))) 11352 return -TARGET_EFAULT; 11353 ret = get_errno(fchownat(arg1, p, low2highuid(arg3), 11354 low2highgid(arg4), arg5)); 11355 unlock_user(p, arg2, 0); 11356 return ret; 11357 #endif 11358 #ifdef TARGET_NR_setresuid 11359 case TARGET_NR_setresuid: 11360 return get_errno(sys_setresuid(low2highuid(arg1), 11361 low2highuid(arg2), 11362 low2highuid(arg3))); 11363 #endif 11364 #ifdef TARGET_NR_getresuid 11365 case TARGET_NR_getresuid: 11366 { 11367 uid_t ruid, euid, suid; 11368 ret = get_errno(getresuid(&ruid, &euid, &suid)); 11369 if (!is_error(ret)) { 11370 if (put_user_id(high2lowuid(ruid), arg1) 11371 || put_user_id(high2lowuid(euid), arg2) 11372 || put_user_id(high2lowuid(suid), arg3)) 11373 return -TARGET_EFAULT; 11374 } 11375 } 11376 return ret; 11377 #endif 11378 #ifdef TARGET_NR_getresgid 11379 case TARGET_NR_setresgid: 11380 return get_errno(sys_setresgid(low2highgid(arg1), 11381 low2highgid(arg2), 11382 low2highgid(arg3))); 11383 #endif 11384 #ifdef TARGET_NR_getresgid 11385 case TARGET_NR_getresgid: 11386 { 11387 gid_t rgid, egid, sgid; 11388 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 11389 if (!is_error(ret)) { 11390 if (put_user_id(high2lowgid(rgid), arg1) 11391 || put_user_id(high2lowgid(egid), arg2) 11392 || put_user_id(high2lowgid(sgid), arg3)) 11393 return -TARGET_EFAULT; 11394 } 11395 } 11396 return ret; 11397 #endif 11398 #ifdef TARGET_NR_chown 11399 case TARGET_NR_chown: 11400 if (!(p = lock_user_string(arg1))) 11401 return -TARGET_EFAULT; 11402 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3))); 11403 unlock_user(p, arg1, 0); 11404 return ret; 11405 #endif 11406 case TARGET_NR_setuid: 11407 return get_errno(sys_setuid(low2highuid(arg1))); 11408 case TARGET_NR_setgid: 11409 return get_errno(sys_setgid(low2highgid(arg1))); 11410 case TARGET_NR_setfsuid: 11411 return get_errno(setfsuid(arg1)); 11412 case TARGET_NR_setfsgid: 11413 return get_errno(setfsgid(arg1)); 11414 11415 #ifdef TARGET_NR_lchown32 11416 case TARGET_NR_lchown32: 11417 if (!(p = lock_user_string(arg1))) 11418 return -TARGET_EFAULT; 11419 ret = get_errno(lchown(p, arg2, arg3)); 11420 unlock_user(p, arg1, 0); 11421 return ret; 11422 #endif 11423 #ifdef TARGET_NR_getuid32 11424 case TARGET_NR_getuid32: 11425 return get_errno(getuid()); 11426 #endif 11427 11428 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA) 11429 /* Alpha specific */ 11430 case TARGET_NR_getxuid: 11431 { 11432 uid_t euid; 11433 euid=geteuid(); 11434 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid; 11435 } 11436 return get_errno(getuid()); 11437 #endif 11438 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA) 11439 /* Alpha specific */ 11440 case TARGET_NR_getxgid: 11441 { 11442 uid_t egid; 11443 egid=getegid(); 11444 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid; 11445 } 11446 return get_errno(getgid()); 11447 #endif 11448 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA) 11449 /* Alpha specific */ 11450 case TARGET_NR_osf_getsysinfo: 11451 ret = -TARGET_EOPNOTSUPP; 11452 switch (arg1) { 11453 case TARGET_GSI_IEEE_FP_CONTROL: 11454 { 11455 uint64_t fpcr = cpu_alpha_load_fpcr(cpu_env); 11456 uint64_t swcr = ((CPUAlphaState *)cpu_env)->swcr; 11457 11458 swcr &= ~SWCR_STATUS_MASK; 11459 swcr |= (fpcr >> 35) & SWCR_STATUS_MASK; 11460 11461 if (put_user_u64 (swcr, arg2)) 11462 return -TARGET_EFAULT; 11463 ret = 0; 11464 } 11465 break; 11466 11467 /* case GSI_IEEE_STATE_AT_SIGNAL: 11468 -- Not implemented in linux kernel. 11469 case GSI_UACPROC: 11470 -- Retrieves current unaligned access state; not much used. 11471 case GSI_PROC_TYPE: 11472 -- Retrieves implver information; surely not used. 11473 case GSI_GET_HWRPB: 11474 -- Grabs a copy of the HWRPB; surely not used. 11475 */ 11476 } 11477 return ret; 11478 #endif 11479 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA) 11480 /* Alpha specific */ 11481 case TARGET_NR_osf_setsysinfo: 11482 ret = -TARGET_EOPNOTSUPP; 11483 switch (arg1) { 11484 case TARGET_SSI_IEEE_FP_CONTROL: 11485 { 11486 uint64_t swcr, fpcr; 11487 11488 if (get_user_u64 (swcr, arg2)) { 11489 return -TARGET_EFAULT; 11490 } 11491 11492 /* 11493 * The kernel calls swcr_update_status to update the 11494 * status bits from the fpcr at every point that it 11495 * could be queried. Therefore, we store the status 11496 * bits only in FPCR. 11497 */ 11498 ((CPUAlphaState *)cpu_env)->swcr 11499 = swcr & (SWCR_TRAP_ENABLE_MASK | SWCR_MAP_MASK); 11500 11501 fpcr = cpu_alpha_load_fpcr(cpu_env); 11502 fpcr &= ((uint64_t)FPCR_DYN_MASK << 32); 11503 fpcr |= alpha_ieee_swcr_to_fpcr(swcr); 11504 cpu_alpha_store_fpcr(cpu_env, fpcr); 11505 ret = 0; 11506 } 11507 break; 11508 11509 case TARGET_SSI_IEEE_RAISE_EXCEPTION: 11510 { 11511 uint64_t exc, fpcr, fex; 11512 11513 if (get_user_u64(exc, arg2)) { 11514 return -TARGET_EFAULT; 11515 } 11516 exc &= SWCR_STATUS_MASK; 11517 fpcr = cpu_alpha_load_fpcr(cpu_env); 11518 11519 /* Old exceptions are not signaled. */ 11520 fex = alpha_ieee_fpcr_to_swcr(fpcr); 11521 fex = exc & ~fex; 11522 fex >>= SWCR_STATUS_TO_EXCSUM_SHIFT; 11523 fex &= ((CPUArchState *)cpu_env)->swcr; 11524 11525 /* Update the hardware fpcr. */ 11526 fpcr |= alpha_ieee_swcr_to_fpcr(exc); 11527 cpu_alpha_store_fpcr(cpu_env, fpcr); 11528 11529 if (fex) { 11530 int si_code = TARGET_FPE_FLTUNK; 11531 target_siginfo_t info; 11532 11533 if (fex & SWCR_TRAP_ENABLE_DNO) { 11534 si_code = TARGET_FPE_FLTUND; 11535 } 11536 if (fex & SWCR_TRAP_ENABLE_INE) { 11537 si_code = TARGET_FPE_FLTRES; 11538 } 11539 if (fex & SWCR_TRAP_ENABLE_UNF) { 11540 si_code = TARGET_FPE_FLTUND; 11541 } 11542 if (fex & SWCR_TRAP_ENABLE_OVF) { 11543 si_code = TARGET_FPE_FLTOVF; 11544 } 11545 if (fex & SWCR_TRAP_ENABLE_DZE) { 11546 si_code = TARGET_FPE_FLTDIV; 11547 } 11548 if (fex & SWCR_TRAP_ENABLE_INV) { 11549 si_code = TARGET_FPE_FLTINV; 11550 } 11551 11552 info.si_signo = SIGFPE; 11553 info.si_errno = 0; 11554 info.si_code = si_code; 11555 info._sifields._sigfault._addr 11556 = ((CPUArchState *)cpu_env)->pc; 11557 queue_signal((CPUArchState *)cpu_env, info.si_signo, 11558 QEMU_SI_FAULT, &info); 11559 } 11560 ret = 0; 11561 } 11562 break; 11563 11564 /* case SSI_NVPAIRS: 11565 -- Used with SSIN_UACPROC to enable unaligned accesses. 11566 case SSI_IEEE_STATE_AT_SIGNAL: 11567 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL: 11568 -- Not implemented in linux kernel 11569 */ 11570 } 11571 return ret; 11572 #endif 11573 #ifdef TARGET_NR_osf_sigprocmask 11574 /* Alpha specific. */ 11575 case TARGET_NR_osf_sigprocmask: 11576 { 11577 abi_ulong mask; 11578 int how; 11579 sigset_t set, oldset; 11580 11581 switch(arg1) { 11582 case TARGET_SIG_BLOCK: 11583 how = SIG_BLOCK; 11584 break; 11585 case TARGET_SIG_UNBLOCK: 11586 how = SIG_UNBLOCK; 11587 break; 11588 case TARGET_SIG_SETMASK: 11589 how = SIG_SETMASK; 11590 break; 11591 default: 11592 return -TARGET_EINVAL; 11593 } 11594 mask = arg2; 11595 target_to_host_old_sigset(&set, &mask); 11596 ret = do_sigprocmask(how, &set, &oldset); 11597 if (!ret) { 11598 host_to_target_old_sigset(&mask, &oldset); 11599 ret = mask; 11600 } 11601 } 11602 return ret; 11603 #endif 11604 11605 #ifdef TARGET_NR_getgid32 11606 case TARGET_NR_getgid32: 11607 return get_errno(getgid()); 11608 #endif 11609 #ifdef TARGET_NR_geteuid32 11610 case TARGET_NR_geteuid32: 11611 return get_errno(geteuid()); 11612 #endif 11613 #ifdef TARGET_NR_getegid32 11614 case TARGET_NR_getegid32: 11615 return get_errno(getegid()); 11616 #endif 11617 #ifdef TARGET_NR_setreuid32 11618 case TARGET_NR_setreuid32: 11619 return get_errno(setreuid(arg1, arg2)); 11620 #endif 11621 #ifdef TARGET_NR_setregid32 11622 case TARGET_NR_setregid32: 11623 return get_errno(setregid(arg1, arg2)); 11624 #endif 11625 #ifdef TARGET_NR_getgroups32 11626 case TARGET_NR_getgroups32: 11627 { 11628 int gidsetsize = arg1; 11629 uint32_t *target_grouplist; 11630 gid_t *grouplist; 11631 int i; 11632 11633 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11634 ret = get_errno(getgroups(gidsetsize, grouplist)); 11635 if (gidsetsize == 0) 11636 return ret; 11637 if (!is_error(ret)) { 11638 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0); 11639 if (!target_grouplist) { 11640 return -TARGET_EFAULT; 11641 } 11642 for(i = 0;i < ret; i++) 11643 target_grouplist[i] = tswap32(grouplist[i]); 11644 unlock_user(target_grouplist, arg2, gidsetsize * 4); 11645 } 11646 } 11647 return ret; 11648 #endif 11649 #ifdef TARGET_NR_setgroups32 11650 case TARGET_NR_setgroups32: 11651 { 11652 int gidsetsize = arg1; 11653 uint32_t *target_grouplist; 11654 gid_t *grouplist; 11655 int i; 11656 11657 grouplist = alloca(gidsetsize * sizeof(gid_t)); 11658 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1); 11659 if (!target_grouplist) { 11660 return -TARGET_EFAULT; 11661 } 11662 for(i = 0;i < gidsetsize; i++) 11663 grouplist[i] = tswap32(target_grouplist[i]); 11664 unlock_user(target_grouplist, arg2, 0); 11665 return get_errno(setgroups(gidsetsize, grouplist)); 11666 } 11667 #endif 11668 #ifdef TARGET_NR_fchown32 11669 case TARGET_NR_fchown32: 11670 return get_errno(fchown(arg1, arg2, arg3)); 11671 #endif 11672 #ifdef TARGET_NR_setresuid32 11673 case TARGET_NR_setresuid32: 11674 return get_errno(sys_setresuid(arg1, arg2, arg3)); 11675 #endif 11676 #ifdef TARGET_NR_getresuid32 11677 case TARGET_NR_getresuid32: 11678 { 11679 uid_t ruid, euid, suid; 11680 ret = get_errno(getresuid(&ruid, &euid, &suid)); 11681 if (!is_error(ret)) { 11682 if (put_user_u32(ruid, arg1) 11683 || put_user_u32(euid, arg2) 11684 || put_user_u32(suid, arg3)) 11685 return -TARGET_EFAULT; 11686 } 11687 } 11688 return ret; 11689 #endif 11690 #ifdef TARGET_NR_setresgid32 11691 case TARGET_NR_setresgid32: 11692 return get_errno(sys_setresgid(arg1, arg2, arg3)); 11693 #endif 11694 #ifdef TARGET_NR_getresgid32 11695 case TARGET_NR_getresgid32: 11696 { 11697 gid_t rgid, egid, sgid; 11698 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 11699 if (!is_error(ret)) { 11700 if (put_user_u32(rgid, arg1) 11701 || put_user_u32(egid, arg2) 11702 || put_user_u32(sgid, arg3)) 11703 return -TARGET_EFAULT; 11704 } 11705 } 11706 return ret; 11707 #endif 11708 #ifdef TARGET_NR_chown32 11709 case TARGET_NR_chown32: 11710 if (!(p = lock_user_string(arg1))) 11711 return -TARGET_EFAULT; 11712 ret = get_errno(chown(p, arg2, arg3)); 11713 unlock_user(p, arg1, 0); 11714 return ret; 11715 #endif 11716 #ifdef TARGET_NR_setuid32 11717 case TARGET_NR_setuid32: 11718 return get_errno(sys_setuid(arg1)); 11719 #endif 11720 #ifdef TARGET_NR_setgid32 11721 case TARGET_NR_setgid32: 11722 return get_errno(sys_setgid(arg1)); 11723 #endif 11724 #ifdef TARGET_NR_setfsuid32 11725 case TARGET_NR_setfsuid32: 11726 return get_errno(setfsuid(arg1)); 11727 #endif 11728 #ifdef TARGET_NR_setfsgid32 11729 case TARGET_NR_setfsgid32: 11730 return get_errno(setfsgid(arg1)); 11731 #endif 11732 #ifdef TARGET_NR_mincore 11733 case TARGET_NR_mincore: 11734 { 11735 void *a = lock_user(VERIFY_READ, arg1, arg2, 0); 11736 if (!a) { 11737 return -TARGET_ENOMEM; 11738 } 11739 p = lock_user_string(arg3); 11740 if (!p) { 11741 ret = -TARGET_EFAULT; 11742 } else { 11743 ret = get_errno(mincore(a, arg2, p)); 11744 unlock_user(p, arg3, ret); 11745 } 11746 unlock_user(a, arg1, 0); 11747 } 11748 return ret; 11749 #endif 11750 #ifdef TARGET_NR_arm_fadvise64_64 11751 case TARGET_NR_arm_fadvise64_64: 11752 /* arm_fadvise64_64 looks like fadvise64_64 but 11753 * with different argument order: fd, advice, offset, len 11754 * rather than the usual fd, offset, len, advice. 11755 * Note that offset and len are both 64-bit so appear as 11756 * pairs of 32-bit registers. 11757 */ 11758 ret = posix_fadvise(arg1, target_offset64(arg3, arg4), 11759 target_offset64(arg5, arg6), arg2); 11760 return -host_to_target_errno(ret); 11761 #endif 11762 11763 #if TARGET_ABI_BITS == 32 11764 11765 #ifdef TARGET_NR_fadvise64_64 11766 case TARGET_NR_fadvise64_64: 11767 #if defined(TARGET_PPC) || defined(TARGET_XTENSA) 11768 /* 6 args: fd, advice, offset (high, low), len (high, low) */ 11769 ret = arg2; 11770 arg2 = arg3; 11771 arg3 = arg4; 11772 arg4 = arg5; 11773 arg5 = arg6; 11774 arg6 = ret; 11775 #else 11776 /* 6 args: fd, offset (high, low), len (high, low), advice */ 11777 if (regpairs_aligned(cpu_env, num)) { 11778 /* offset is in (3,4), len in (5,6) and advice in 7 */ 11779 arg2 = arg3; 11780 arg3 = arg4; 11781 arg4 = arg5; 11782 arg5 = arg6; 11783 arg6 = arg7; 11784 } 11785 #endif 11786 ret = posix_fadvise(arg1, target_offset64(arg2, arg3), 11787 target_offset64(arg4, arg5), arg6); 11788 return -host_to_target_errno(ret); 11789 #endif 11790 11791 #ifdef TARGET_NR_fadvise64 11792 case TARGET_NR_fadvise64: 11793 /* 5 args: fd, offset (high, low), len, advice */ 11794 if (regpairs_aligned(cpu_env, num)) { 11795 /* offset is in (3,4), len in 5 and advice in 6 */ 11796 arg2 = arg3; 11797 arg3 = arg4; 11798 arg4 = arg5; 11799 arg5 = arg6; 11800 } 11801 ret = posix_fadvise(arg1, target_offset64(arg2, arg3), arg4, arg5); 11802 return -host_to_target_errno(ret); 11803 #endif 11804 11805 #else /* not a 32-bit ABI */ 11806 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64) 11807 #ifdef TARGET_NR_fadvise64_64 11808 case TARGET_NR_fadvise64_64: 11809 #endif 11810 #ifdef TARGET_NR_fadvise64 11811 case TARGET_NR_fadvise64: 11812 #endif 11813 #ifdef TARGET_S390X 11814 switch (arg4) { 11815 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */ 11816 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */ 11817 case 6: arg4 = POSIX_FADV_DONTNEED; break; 11818 case 7: arg4 = POSIX_FADV_NOREUSE; break; 11819 default: break; 11820 } 11821 #endif 11822 return -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4)); 11823 #endif 11824 #endif /* end of 64-bit ABI fadvise handling */ 11825 11826 #ifdef TARGET_NR_madvise 11827 case TARGET_NR_madvise: 11828 /* A straight passthrough may not be safe because qemu sometimes 11829 turns private file-backed mappings into anonymous mappings. 11830 This will break MADV_DONTNEED. 11831 This is a hint, so ignoring and returning success is ok. */ 11832 return 0; 11833 #endif 11834 #ifdef TARGET_NR_fcntl64 11835 case TARGET_NR_fcntl64: 11836 { 11837 int cmd; 11838 struct flock64 fl; 11839 from_flock64_fn *copyfrom = copy_from_user_flock64; 11840 to_flock64_fn *copyto = copy_to_user_flock64; 11841 11842 #ifdef TARGET_ARM 11843 if (!((CPUARMState *)cpu_env)->eabi) { 11844 copyfrom = copy_from_user_oabi_flock64; 11845 copyto = copy_to_user_oabi_flock64; 11846 } 11847 #endif 11848 11849 cmd = target_to_host_fcntl_cmd(arg2); 11850 if (cmd == -TARGET_EINVAL) { 11851 return cmd; 11852 } 11853 11854 switch(arg2) { 11855 case TARGET_F_GETLK64: 11856 ret = copyfrom(&fl, arg3); 11857 if (ret) { 11858 break; 11859 } 11860 ret = get_errno(safe_fcntl(arg1, cmd, &fl)); 11861 if (ret == 0) { 11862 ret = copyto(arg3, &fl); 11863 } 11864 break; 11865 11866 case TARGET_F_SETLK64: 11867 case TARGET_F_SETLKW64: 11868 ret = copyfrom(&fl, arg3); 11869 if (ret) { 11870 break; 11871 } 11872 ret = get_errno(safe_fcntl(arg1, cmd, &fl)); 11873 break; 11874 default: 11875 ret = do_fcntl(arg1, arg2, arg3); 11876 break; 11877 } 11878 return ret; 11879 } 11880 #endif 11881 #ifdef TARGET_NR_cacheflush 11882 case TARGET_NR_cacheflush: 11883 /* self-modifying code is handled automatically, so nothing needed */ 11884 return 0; 11885 #endif 11886 #ifdef TARGET_NR_getpagesize 11887 case TARGET_NR_getpagesize: 11888 return TARGET_PAGE_SIZE; 11889 #endif 11890 case TARGET_NR_gettid: 11891 return get_errno(sys_gettid()); 11892 #ifdef TARGET_NR_readahead 11893 case TARGET_NR_readahead: 11894 #if TARGET_ABI_BITS == 32 11895 if (regpairs_aligned(cpu_env, num)) { 11896 arg2 = arg3; 11897 arg3 = arg4; 11898 arg4 = arg5; 11899 } 11900 ret = get_errno(readahead(arg1, target_offset64(arg2, arg3) , arg4)); 11901 #else 11902 ret = get_errno(readahead(arg1, arg2, arg3)); 11903 #endif 11904 return ret; 11905 #endif 11906 #ifdef CONFIG_ATTR 11907 #ifdef TARGET_NR_setxattr 11908 case TARGET_NR_listxattr: 11909 case TARGET_NR_llistxattr: 11910 { 11911 void *p, *b = 0; 11912 if (arg2) { 11913 b = lock_user(VERIFY_WRITE, arg2, arg3, 0); 11914 if (!b) { 11915 return -TARGET_EFAULT; 11916 } 11917 } 11918 p = lock_user_string(arg1); 11919 if (p) { 11920 if (num == TARGET_NR_listxattr) { 11921 ret = get_errno(listxattr(p, b, arg3)); 11922 } else { 11923 ret = get_errno(llistxattr(p, b, arg3)); 11924 } 11925 } else { 11926 ret = -TARGET_EFAULT; 11927 } 11928 unlock_user(p, arg1, 0); 11929 unlock_user(b, arg2, arg3); 11930 return ret; 11931 } 11932 case TARGET_NR_flistxattr: 11933 { 11934 void *b = 0; 11935 if (arg2) { 11936 b = lock_user(VERIFY_WRITE, arg2, arg3, 0); 11937 if (!b) { 11938 return -TARGET_EFAULT; 11939 } 11940 } 11941 ret = get_errno(flistxattr(arg1, b, arg3)); 11942 unlock_user(b, arg2, arg3); 11943 return ret; 11944 } 11945 case TARGET_NR_setxattr: 11946 case TARGET_NR_lsetxattr: 11947 { 11948 void *p, *n, *v = 0; 11949 if (arg3) { 11950 v = lock_user(VERIFY_READ, arg3, arg4, 1); 11951 if (!v) { 11952 return -TARGET_EFAULT; 11953 } 11954 } 11955 p = lock_user_string(arg1); 11956 n = lock_user_string(arg2); 11957 if (p && n) { 11958 if (num == TARGET_NR_setxattr) { 11959 ret = get_errno(setxattr(p, n, v, arg4, arg5)); 11960 } else { 11961 ret = get_errno(lsetxattr(p, n, v, arg4, arg5)); 11962 } 11963 } else { 11964 ret = -TARGET_EFAULT; 11965 } 11966 unlock_user(p, arg1, 0); 11967 unlock_user(n, arg2, 0); 11968 unlock_user(v, arg3, 0); 11969 } 11970 return ret; 11971 case TARGET_NR_fsetxattr: 11972 { 11973 void *n, *v = 0; 11974 if (arg3) { 11975 v = lock_user(VERIFY_READ, arg3, arg4, 1); 11976 if (!v) { 11977 return -TARGET_EFAULT; 11978 } 11979 } 11980 n = lock_user_string(arg2); 11981 if (n) { 11982 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5)); 11983 } else { 11984 ret = -TARGET_EFAULT; 11985 } 11986 unlock_user(n, arg2, 0); 11987 unlock_user(v, arg3, 0); 11988 } 11989 return ret; 11990 case TARGET_NR_getxattr: 11991 case TARGET_NR_lgetxattr: 11992 { 11993 void *p, *n, *v = 0; 11994 if (arg3) { 11995 v = lock_user(VERIFY_WRITE, arg3, arg4, 0); 11996 if (!v) { 11997 return -TARGET_EFAULT; 11998 } 11999 } 12000 p = lock_user_string(arg1); 12001 n = lock_user_string(arg2); 12002 if (p && n) { 12003 if (num == TARGET_NR_getxattr) { 12004 ret = get_errno(getxattr(p, n, v, arg4)); 12005 } else { 12006 ret = get_errno(lgetxattr(p, n, v, arg4)); 12007 } 12008 } else { 12009 ret = -TARGET_EFAULT; 12010 } 12011 unlock_user(p, arg1, 0); 12012 unlock_user(n, arg2, 0); 12013 unlock_user(v, arg3, arg4); 12014 } 12015 return ret; 12016 case TARGET_NR_fgetxattr: 12017 { 12018 void *n, *v = 0; 12019 if (arg3) { 12020 v = lock_user(VERIFY_WRITE, arg3, arg4, 0); 12021 if (!v) { 12022 return -TARGET_EFAULT; 12023 } 12024 } 12025 n = lock_user_string(arg2); 12026 if (n) { 12027 ret = get_errno(fgetxattr(arg1, n, v, arg4)); 12028 } else { 12029 ret = -TARGET_EFAULT; 12030 } 12031 unlock_user(n, arg2, 0); 12032 unlock_user(v, arg3, arg4); 12033 } 12034 return ret; 12035 case TARGET_NR_removexattr: 12036 case TARGET_NR_lremovexattr: 12037 { 12038 void *p, *n; 12039 p = lock_user_string(arg1); 12040 n = lock_user_string(arg2); 12041 if (p && n) { 12042 if (num == TARGET_NR_removexattr) { 12043 ret = get_errno(removexattr(p, n)); 12044 } else { 12045 ret = get_errno(lremovexattr(p, n)); 12046 } 12047 } else { 12048 ret = -TARGET_EFAULT; 12049 } 12050 unlock_user(p, arg1, 0); 12051 unlock_user(n, arg2, 0); 12052 } 12053 return ret; 12054 case TARGET_NR_fremovexattr: 12055 { 12056 void *n; 12057 n = lock_user_string(arg2); 12058 if (n) { 12059 ret = get_errno(fremovexattr(arg1, n)); 12060 } else { 12061 ret = -TARGET_EFAULT; 12062 } 12063 unlock_user(n, arg2, 0); 12064 } 12065 return ret; 12066 #endif 12067 #endif /* CONFIG_ATTR */ 12068 #ifdef TARGET_NR_set_thread_area 12069 case TARGET_NR_set_thread_area: 12070 #if defined(TARGET_MIPS) 12071 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1; 12072 return 0; 12073 #elif defined(TARGET_CRIS) 12074 if (arg1 & 0xff) 12075 ret = -TARGET_EINVAL; 12076 else { 12077 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1; 12078 ret = 0; 12079 } 12080 return ret; 12081 #elif defined(TARGET_I386) && defined(TARGET_ABI32) 12082 return do_set_thread_area(cpu_env, arg1); 12083 #elif defined(TARGET_M68K) 12084 { 12085 TaskState *ts = cpu->opaque; 12086 ts->tp_value = arg1; 12087 return 0; 12088 } 12089 #else 12090 return -TARGET_ENOSYS; 12091 #endif 12092 #endif 12093 #ifdef TARGET_NR_get_thread_area 12094 case TARGET_NR_get_thread_area: 12095 #if defined(TARGET_I386) && defined(TARGET_ABI32) 12096 return do_get_thread_area(cpu_env, arg1); 12097 #elif defined(TARGET_M68K) 12098 { 12099 TaskState *ts = cpu->opaque; 12100 return ts->tp_value; 12101 } 12102 #else 12103 return -TARGET_ENOSYS; 12104 #endif 12105 #endif 12106 #ifdef TARGET_NR_getdomainname 12107 case TARGET_NR_getdomainname: 12108 return -TARGET_ENOSYS; 12109 #endif 12110 12111 #ifdef TARGET_NR_clock_settime 12112 case TARGET_NR_clock_settime: 12113 { 12114 struct timespec ts; 12115 12116 ret = target_to_host_timespec(&ts, arg2); 12117 if (!is_error(ret)) { 12118 ret = get_errno(clock_settime(arg1, &ts)); 12119 } 12120 return ret; 12121 } 12122 #endif 12123 #ifdef TARGET_NR_clock_settime64 12124 case TARGET_NR_clock_settime64: 12125 { 12126 struct timespec ts; 12127 12128 ret = target_to_host_timespec64(&ts, arg2); 12129 if (!is_error(ret)) { 12130 ret = get_errno(clock_settime(arg1, &ts)); 12131 } 12132 return ret; 12133 } 12134 #endif 12135 #ifdef TARGET_NR_clock_gettime 12136 case TARGET_NR_clock_gettime: 12137 { 12138 struct timespec ts; 12139 ret = get_errno(clock_gettime(arg1, &ts)); 12140 if (!is_error(ret)) { 12141 ret = host_to_target_timespec(arg2, &ts); 12142 } 12143 return ret; 12144 } 12145 #endif 12146 #ifdef TARGET_NR_clock_gettime64 12147 case TARGET_NR_clock_gettime64: 12148 { 12149 struct timespec ts; 12150 ret = get_errno(clock_gettime(arg1, &ts)); 12151 if (!is_error(ret)) { 12152 ret = host_to_target_timespec64(arg2, &ts); 12153 } 12154 return ret; 12155 } 12156 #endif 12157 #ifdef TARGET_NR_clock_getres 12158 case TARGET_NR_clock_getres: 12159 { 12160 struct timespec ts; 12161 ret = get_errno(clock_getres(arg1, &ts)); 12162 if (!is_error(ret)) { 12163 host_to_target_timespec(arg2, &ts); 12164 } 12165 return ret; 12166 } 12167 #endif 12168 #ifdef TARGET_NR_clock_getres_time64 12169 case TARGET_NR_clock_getres_time64: 12170 { 12171 struct timespec ts; 12172 ret = get_errno(clock_getres(arg1, &ts)); 12173 if (!is_error(ret)) { 12174 host_to_target_timespec64(arg2, &ts); 12175 } 12176 return ret; 12177 } 12178 #endif 12179 #ifdef TARGET_NR_clock_nanosleep 12180 case TARGET_NR_clock_nanosleep: 12181 { 12182 struct timespec ts; 12183 if (target_to_host_timespec(&ts, arg3)) { 12184 return -TARGET_EFAULT; 12185 } 12186 ret = get_errno(safe_clock_nanosleep(arg1, arg2, 12187 &ts, arg4 ? &ts : NULL)); 12188 /* 12189 * if the call is interrupted by a signal handler, it fails 12190 * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not 12191 * TIMER_ABSTIME, it returns the remaining unslept time in arg4. 12192 */ 12193 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME && 12194 host_to_target_timespec(arg4, &ts)) { 12195 return -TARGET_EFAULT; 12196 } 12197 12198 return ret; 12199 } 12200 #endif 12201 #ifdef TARGET_NR_clock_nanosleep_time64 12202 case TARGET_NR_clock_nanosleep_time64: 12203 { 12204 struct timespec ts; 12205 12206 if (target_to_host_timespec64(&ts, arg3)) { 12207 return -TARGET_EFAULT; 12208 } 12209 12210 ret = get_errno(safe_clock_nanosleep(arg1, arg2, 12211 &ts, arg4 ? &ts : NULL)); 12212 12213 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME && 12214 host_to_target_timespec64(arg4, &ts)) { 12215 return -TARGET_EFAULT; 12216 } 12217 return ret; 12218 } 12219 #endif 12220 12221 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) 12222 case TARGET_NR_set_tid_address: 12223 return get_errno(set_tid_address((int *)g2h(cpu, arg1))); 12224 #endif 12225 12226 case TARGET_NR_tkill: 12227 return get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2))); 12228 12229 case TARGET_NR_tgkill: 12230 return get_errno(safe_tgkill((int)arg1, (int)arg2, 12231 target_to_host_signal(arg3))); 12232 12233 #ifdef TARGET_NR_set_robust_list 12234 case TARGET_NR_set_robust_list: 12235 case TARGET_NR_get_robust_list: 12236 /* The ABI for supporting robust futexes has userspace pass 12237 * the kernel a pointer to a linked list which is updated by 12238 * userspace after the syscall; the list is walked by the kernel 12239 * when the thread exits. Since the linked list in QEMU guest 12240 * memory isn't a valid linked list for the host and we have 12241 * no way to reliably intercept the thread-death event, we can't 12242 * support these. Silently return ENOSYS so that guest userspace 12243 * falls back to a non-robust futex implementation (which should 12244 * be OK except in the corner case of the guest crashing while 12245 * holding a mutex that is shared with another process via 12246 * shared memory). 12247 */ 12248 return -TARGET_ENOSYS; 12249 #endif 12250 12251 #if defined(TARGET_NR_utimensat) 12252 case TARGET_NR_utimensat: 12253 { 12254 struct timespec *tsp, ts[2]; 12255 if (!arg3) { 12256 tsp = NULL; 12257 } else { 12258 if (target_to_host_timespec(ts, arg3)) { 12259 return -TARGET_EFAULT; 12260 } 12261 if (target_to_host_timespec(ts + 1, arg3 + 12262 sizeof(struct target_timespec))) { 12263 return -TARGET_EFAULT; 12264 } 12265 tsp = ts; 12266 } 12267 if (!arg2) 12268 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4)); 12269 else { 12270 if (!(p = lock_user_string(arg2))) { 12271 return -TARGET_EFAULT; 12272 } 12273 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4)); 12274 unlock_user(p, arg2, 0); 12275 } 12276 } 12277 return ret; 12278 #endif 12279 #ifdef TARGET_NR_utimensat_time64 12280 case TARGET_NR_utimensat_time64: 12281 { 12282 struct timespec *tsp, ts[2]; 12283 if (!arg3) { 12284 tsp = NULL; 12285 } else { 12286 if (target_to_host_timespec64(ts, arg3)) { 12287 return -TARGET_EFAULT; 12288 } 12289 if (target_to_host_timespec64(ts + 1, arg3 + 12290 sizeof(struct target__kernel_timespec))) { 12291 return -TARGET_EFAULT; 12292 } 12293 tsp = ts; 12294 } 12295 if (!arg2) 12296 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4)); 12297 else { 12298 p = lock_user_string(arg2); 12299 if (!p) { 12300 return -TARGET_EFAULT; 12301 } 12302 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4)); 12303 unlock_user(p, arg2, 0); 12304 } 12305 } 12306 return ret; 12307 #endif 12308 #ifdef TARGET_NR_futex 12309 case TARGET_NR_futex: 12310 return do_futex(cpu, arg1, arg2, arg3, arg4, arg5, arg6); 12311 #endif 12312 #ifdef TARGET_NR_futex_time64 12313 case TARGET_NR_futex_time64: 12314 return do_futex_time64(cpu, arg1, arg2, arg3, arg4, arg5, arg6); 12315 #endif 12316 #ifdef CONFIG_INOTIFY 12317 #if defined(TARGET_NR_inotify_init) 12318 case TARGET_NR_inotify_init: 12319 ret = get_errno(inotify_init()); 12320 if (ret >= 0) { 12321 fd_trans_register(ret, &target_inotify_trans); 12322 } 12323 return ret; 12324 #endif 12325 #if defined(TARGET_NR_inotify_init1) && defined(CONFIG_INOTIFY1) 12326 case TARGET_NR_inotify_init1: 12327 ret = get_errno(inotify_init1(target_to_host_bitmask(arg1, 12328 fcntl_flags_tbl))); 12329 if (ret >= 0) { 12330 fd_trans_register(ret, &target_inotify_trans); 12331 } 12332 return ret; 12333 #endif 12334 #if defined(TARGET_NR_inotify_add_watch) 12335 case TARGET_NR_inotify_add_watch: 12336 p = lock_user_string(arg2); 12337 ret = get_errno(inotify_add_watch(arg1, path(p), arg3)); 12338 unlock_user(p, arg2, 0); 12339 return ret; 12340 #endif 12341 #if defined(TARGET_NR_inotify_rm_watch) 12342 case TARGET_NR_inotify_rm_watch: 12343 return get_errno(inotify_rm_watch(arg1, arg2)); 12344 #endif 12345 #endif 12346 12347 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open) 12348 case TARGET_NR_mq_open: 12349 { 12350 struct mq_attr posix_mq_attr; 12351 struct mq_attr *pposix_mq_attr; 12352 int host_flags; 12353 12354 host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl); 12355 pposix_mq_attr = NULL; 12356 if (arg4) { 12357 if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) { 12358 return -TARGET_EFAULT; 12359 } 12360 pposix_mq_attr = &posix_mq_attr; 12361 } 12362 p = lock_user_string(arg1 - 1); 12363 if (!p) { 12364 return -TARGET_EFAULT; 12365 } 12366 ret = get_errno(mq_open(p, host_flags, arg3, pposix_mq_attr)); 12367 unlock_user (p, arg1, 0); 12368 } 12369 return ret; 12370 12371 case TARGET_NR_mq_unlink: 12372 p = lock_user_string(arg1 - 1); 12373 if (!p) { 12374 return -TARGET_EFAULT; 12375 } 12376 ret = get_errno(mq_unlink(p)); 12377 unlock_user (p, arg1, 0); 12378 return ret; 12379 12380 #ifdef TARGET_NR_mq_timedsend 12381 case TARGET_NR_mq_timedsend: 12382 { 12383 struct timespec ts; 12384 12385 p = lock_user (VERIFY_READ, arg2, arg3, 1); 12386 if (arg5 != 0) { 12387 if (target_to_host_timespec(&ts, arg5)) { 12388 return -TARGET_EFAULT; 12389 } 12390 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts)); 12391 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) { 12392 return -TARGET_EFAULT; 12393 } 12394 } else { 12395 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL)); 12396 } 12397 unlock_user (p, arg2, arg3); 12398 } 12399 return ret; 12400 #endif 12401 #ifdef TARGET_NR_mq_timedsend_time64 12402 case TARGET_NR_mq_timedsend_time64: 12403 { 12404 struct timespec ts; 12405 12406 p = lock_user(VERIFY_READ, arg2, arg3, 1); 12407 if (arg5 != 0) { 12408 if (target_to_host_timespec64(&ts, arg5)) { 12409 return -TARGET_EFAULT; 12410 } 12411 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts)); 12412 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) { 12413 return -TARGET_EFAULT; 12414 } 12415 } else { 12416 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL)); 12417 } 12418 unlock_user(p, arg2, arg3); 12419 } 12420 return ret; 12421 #endif 12422 12423 #ifdef TARGET_NR_mq_timedreceive 12424 case TARGET_NR_mq_timedreceive: 12425 { 12426 struct timespec ts; 12427 unsigned int prio; 12428 12429 p = lock_user (VERIFY_READ, arg2, arg3, 1); 12430 if (arg5 != 0) { 12431 if (target_to_host_timespec(&ts, arg5)) { 12432 return -TARGET_EFAULT; 12433 } 12434 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12435 &prio, &ts)); 12436 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) { 12437 return -TARGET_EFAULT; 12438 } 12439 } else { 12440 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12441 &prio, NULL)); 12442 } 12443 unlock_user (p, arg2, arg3); 12444 if (arg4 != 0) 12445 put_user_u32(prio, arg4); 12446 } 12447 return ret; 12448 #endif 12449 #ifdef TARGET_NR_mq_timedreceive_time64 12450 case TARGET_NR_mq_timedreceive_time64: 12451 { 12452 struct timespec ts; 12453 unsigned int prio; 12454 12455 p = lock_user(VERIFY_READ, arg2, arg3, 1); 12456 if (arg5 != 0) { 12457 if (target_to_host_timespec64(&ts, arg5)) { 12458 return -TARGET_EFAULT; 12459 } 12460 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12461 &prio, &ts)); 12462 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) { 12463 return -TARGET_EFAULT; 12464 } 12465 } else { 12466 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3, 12467 &prio, NULL)); 12468 } 12469 unlock_user(p, arg2, arg3); 12470 if (arg4 != 0) { 12471 put_user_u32(prio, arg4); 12472 } 12473 } 12474 return ret; 12475 #endif 12476 12477 /* Not implemented for now... */ 12478 /* case TARGET_NR_mq_notify: */ 12479 /* break; */ 12480 12481 case TARGET_NR_mq_getsetattr: 12482 { 12483 struct mq_attr posix_mq_attr_in, posix_mq_attr_out; 12484 ret = 0; 12485 if (arg2 != 0) { 12486 copy_from_user_mq_attr(&posix_mq_attr_in, arg2); 12487 ret = get_errno(mq_setattr(arg1, &posix_mq_attr_in, 12488 &posix_mq_attr_out)); 12489 } else if (arg3 != 0) { 12490 ret = get_errno(mq_getattr(arg1, &posix_mq_attr_out)); 12491 } 12492 if (ret == 0 && arg3 != 0) { 12493 copy_to_user_mq_attr(arg3, &posix_mq_attr_out); 12494 } 12495 } 12496 return ret; 12497 #endif 12498 12499 #ifdef CONFIG_SPLICE 12500 #ifdef TARGET_NR_tee 12501 case TARGET_NR_tee: 12502 { 12503 ret = get_errno(tee(arg1,arg2,arg3,arg4)); 12504 } 12505 return ret; 12506 #endif 12507 #ifdef TARGET_NR_splice 12508 case TARGET_NR_splice: 12509 { 12510 loff_t loff_in, loff_out; 12511 loff_t *ploff_in = NULL, *ploff_out = NULL; 12512 if (arg2) { 12513 if (get_user_u64(loff_in, arg2)) { 12514 return -TARGET_EFAULT; 12515 } 12516 ploff_in = &loff_in; 12517 } 12518 if (arg4) { 12519 if (get_user_u64(loff_out, arg4)) { 12520 return -TARGET_EFAULT; 12521 } 12522 ploff_out = &loff_out; 12523 } 12524 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6)); 12525 if (arg2) { 12526 if (put_user_u64(loff_in, arg2)) { 12527 return -TARGET_EFAULT; 12528 } 12529 } 12530 if (arg4) { 12531 if (put_user_u64(loff_out, arg4)) { 12532 return -TARGET_EFAULT; 12533 } 12534 } 12535 } 12536 return ret; 12537 #endif 12538 #ifdef TARGET_NR_vmsplice 12539 case TARGET_NR_vmsplice: 12540 { 12541 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1); 12542 if (vec != NULL) { 12543 ret = get_errno(vmsplice(arg1, vec, arg3, arg4)); 12544 unlock_iovec(vec, arg2, arg3, 0); 12545 } else { 12546 ret = -host_to_target_errno(errno); 12547 } 12548 } 12549 return ret; 12550 #endif 12551 #endif /* CONFIG_SPLICE */ 12552 #ifdef CONFIG_EVENTFD 12553 #if defined(TARGET_NR_eventfd) 12554 case TARGET_NR_eventfd: 12555 ret = get_errno(eventfd(arg1, 0)); 12556 if (ret >= 0) { 12557 fd_trans_register(ret, &target_eventfd_trans); 12558 } 12559 return ret; 12560 #endif 12561 #if defined(TARGET_NR_eventfd2) 12562 case TARGET_NR_eventfd2: 12563 { 12564 int host_flags = arg2 & (~(TARGET_O_NONBLOCK_MASK | TARGET_O_CLOEXEC)); 12565 if (arg2 & TARGET_O_NONBLOCK) { 12566 host_flags |= O_NONBLOCK; 12567 } 12568 if (arg2 & TARGET_O_CLOEXEC) { 12569 host_flags |= O_CLOEXEC; 12570 } 12571 ret = get_errno(eventfd(arg1, host_flags)); 12572 if (ret >= 0) { 12573 fd_trans_register(ret, &target_eventfd_trans); 12574 } 12575 return ret; 12576 } 12577 #endif 12578 #endif /* CONFIG_EVENTFD */ 12579 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate) 12580 case TARGET_NR_fallocate: 12581 #if TARGET_ABI_BITS == 32 12582 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4), 12583 target_offset64(arg5, arg6))); 12584 #else 12585 ret = get_errno(fallocate(arg1, arg2, arg3, arg4)); 12586 #endif 12587 return ret; 12588 #endif 12589 #if defined(CONFIG_SYNC_FILE_RANGE) 12590 #if defined(TARGET_NR_sync_file_range) 12591 case TARGET_NR_sync_file_range: 12592 #if TARGET_ABI_BITS == 32 12593 #if defined(TARGET_MIPS) 12594 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4), 12595 target_offset64(arg5, arg6), arg7)); 12596 #else 12597 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3), 12598 target_offset64(arg4, arg5), arg6)); 12599 #endif /* !TARGET_MIPS */ 12600 #else 12601 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4)); 12602 #endif 12603 return ret; 12604 #endif 12605 #if defined(TARGET_NR_sync_file_range2) || \ 12606 defined(TARGET_NR_arm_sync_file_range) 12607 #if defined(TARGET_NR_sync_file_range2) 12608 case TARGET_NR_sync_file_range2: 12609 #endif 12610 #if defined(TARGET_NR_arm_sync_file_range) 12611 case TARGET_NR_arm_sync_file_range: 12612 #endif 12613 /* This is like sync_file_range but the arguments are reordered */ 12614 #if TARGET_ABI_BITS == 32 12615 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4), 12616 target_offset64(arg5, arg6), arg2)); 12617 #else 12618 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2)); 12619 #endif 12620 return ret; 12621 #endif 12622 #endif 12623 #if defined(TARGET_NR_signalfd4) 12624 case TARGET_NR_signalfd4: 12625 return do_signalfd4(arg1, arg2, arg4); 12626 #endif 12627 #if defined(TARGET_NR_signalfd) 12628 case TARGET_NR_signalfd: 12629 return do_signalfd4(arg1, arg2, 0); 12630 #endif 12631 #if defined(CONFIG_EPOLL) 12632 #if defined(TARGET_NR_epoll_create) 12633 case TARGET_NR_epoll_create: 12634 return get_errno(epoll_create(arg1)); 12635 #endif 12636 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1) 12637 case TARGET_NR_epoll_create1: 12638 return get_errno(epoll_create1(target_to_host_bitmask(arg1, fcntl_flags_tbl))); 12639 #endif 12640 #if defined(TARGET_NR_epoll_ctl) 12641 case TARGET_NR_epoll_ctl: 12642 { 12643 struct epoll_event ep; 12644 struct epoll_event *epp = 0; 12645 if (arg4) { 12646 if (arg2 != EPOLL_CTL_DEL) { 12647 struct target_epoll_event *target_ep; 12648 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) { 12649 return -TARGET_EFAULT; 12650 } 12651 ep.events = tswap32(target_ep->events); 12652 /* 12653 * The epoll_data_t union is just opaque data to the kernel, 12654 * so we transfer all 64 bits across and need not worry what 12655 * actual data type it is. 12656 */ 12657 ep.data.u64 = tswap64(target_ep->data.u64); 12658 unlock_user_struct(target_ep, arg4, 0); 12659 } 12660 /* 12661 * before kernel 2.6.9, EPOLL_CTL_DEL operation required a 12662 * non-null pointer, even though this argument is ignored. 12663 * 12664 */ 12665 epp = &ep; 12666 } 12667 return get_errno(epoll_ctl(arg1, arg2, arg3, epp)); 12668 } 12669 #endif 12670 12671 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait) 12672 #if defined(TARGET_NR_epoll_wait) 12673 case TARGET_NR_epoll_wait: 12674 #endif 12675 #if defined(TARGET_NR_epoll_pwait) 12676 case TARGET_NR_epoll_pwait: 12677 #endif 12678 { 12679 struct target_epoll_event *target_ep; 12680 struct epoll_event *ep; 12681 int epfd = arg1; 12682 int maxevents = arg3; 12683 int timeout = arg4; 12684 12685 if (maxevents <= 0 || maxevents > TARGET_EP_MAX_EVENTS) { 12686 return -TARGET_EINVAL; 12687 } 12688 12689 target_ep = lock_user(VERIFY_WRITE, arg2, 12690 maxevents * sizeof(struct target_epoll_event), 1); 12691 if (!target_ep) { 12692 return -TARGET_EFAULT; 12693 } 12694 12695 ep = g_try_new(struct epoll_event, maxevents); 12696 if (!ep) { 12697 unlock_user(target_ep, arg2, 0); 12698 return -TARGET_ENOMEM; 12699 } 12700 12701 switch (num) { 12702 #if defined(TARGET_NR_epoll_pwait) 12703 case TARGET_NR_epoll_pwait: 12704 { 12705 target_sigset_t *target_set; 12706 sigset_t _set, *set = &_set; 12707 12708 if (arg5) { 12709 if (arg6 != sizeof(target_sigset_t)) { 12710 ret = -TARGET_EINVAL; 12711 break; 12712 } 12713 12714 target_set = lock_user(VERIFY_READ, arg5, 12715 sizeof(target_sigset_t), 1); 12716 if (!target_set) { 12717 ret = -TARGET_EFAULT; 12718 break; 12719 } 12720 target_to_host_sigset(set, target_set); 12721 unlock_user(target_set, arg5, 0); 12722 } else { 12723 set = NULL; 12724 } 12725 12726 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout, 12727 set, SIGSET_T_SIZE)); 12728 break; 12729 } 12730 #endif 12731 #if defined(TARGET_NR_epoll_wait) 12732 case TARGET_NR_epoll_wait: 12733 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout, 12734 NULL, 0)); 12735 break; 12736 #endif 12737 default: 12738 ret = -TARGET_ENOSYS; 12739 } 12740 if (!is_error(ret)) { 12741 int i; 12742 for (i = 0; i < ret; i++) { 12743 target_ep[i].events = tswap32(ep[i].events); 12744 target_ep[i].data.u64 = tswap64(ep[i].data.u64); 12745 } 12746 unlock_user(target_ep, arg2, 12747 ret * sizeof(struct target_epoll_event)); 12748 } else { 12749 unlock_user(target_ep, arg2, 0); 12750 } 12751 g_free(ep); 12752 return ret; 12753 } 12754 #endif 12755 #endif 12756 #ifdef TARGET_NR_prlimit64 12757 case TARGET_NR_prlimit64: 12758 { 12759 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */ 12760 struct target_rlimit64 *target_rnew, *target_rold; 12761 struct host_rlimit64 rnew, rold, *rnewp = 0; 12762 int resource = target_to_host_resource(arg2); 12763 12764 if (arg3 && (resource != RLIMIT_AS && 12765 resource != RLIMIT_DATA && 12766 resource != RLIMIT_STACK)) { 12767 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) { 12768 return -TARGET_EFAULT; 12769 } 12770 rnew.rlim_cur = tswap64(target_rnew->rlim_cur); 12771 rnew.rlim_max = tswap64(target_rnew->rlim_max); 12772 unlock_user_struct(target_rnew, arg3, 0); 12773 rnewp = &rnew; 12774 } 12775 12776 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0)); 12777 if (!is_error(ret) && arg4) { 12778 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) { 12779 return -TARGET_EFAULT; 12780 } 12781 target_rold->rlim_cur = tswap64(rold.rlim_cur); 12782 target_rold->rlim_max = tswap64(rold.rlim_max); 12783 unlock_user_struct(target_rold, arg4, 1); 12784 } 12785 return ret; 12786 } 12787 #endif 12788 #ifdef TARGET_NR_gethostname 12789 case TARGET_NR_gethostname: 12790 { 12791 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0); 12792 if (name) { 12793 ret = get_errno(gethostname(name, arg2)); 12794 unlock_user(name, arg1, arg2); 12795 } else { 12796 ret = -TARGET_EFAULT; 12797 } 12798 return ret; 12799 } 12800 #endif 12801 #ifdef TARGET_NR_atomic_cmpxchg_32 12802 case TARGET_NR_atomic_cmpxchg_32: 12803 { 12804 /* should use start_exclusive from main.c */ 12805 abi_ulong mem_value; 12806 if (get_user_u32(mem_value, arg6)) { 12807 target_siginfo_t info; 12808 info.si_signo = SIGSEGV; 12809 info.si_errno = 0; 12810 info.si_code = TARGET_SEGV_MAPERR; 12811 info._sifields._sigfault._addr = arg6; 12812 queue_signal((CPUArchState *)cpu_env, info.si_signo, 12813 QEMU_SI_FAULT, &info); 12814 ret = 0xdeadbeef; 12815 12816 } 12817 if (mem_value == arg2) 12818 put_user_u32(arg1, arg6); 12819 return mem_value; 12820 } 12821 #endif 12822 #ifdef TARGET_NR_atomic_barrier 12823 case TARGET_NR_atomic_barrier: 12824 /* Like the kernel implementation and the 12825 qemu arm barrier, no-op this? */ 12826 return 0; 12827 #endif 12828 12829 #ifdef TARGET_NR_timer_create 12830 case TARGET_NR_timer_create: 12831 { 12832 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */ 12833 12834 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL; 12835 12836 int clkid = arg1; 12837 int timer_index = next_free_host_timer(); 12838 12839 if (timer_index < 0) { 12840 ret = -TARGET_EAGAIN; 12841 } else { 12842 timer_t *phtimer = g_posix_timers + timer_index; 12843 12844 if (arg2) { 12845 phost_sevp = &host_sevp; 12846 ret = target_to_host_sigevent(phost_sevp, arg2); 12847 if (ret != 0) { 12848 return ret; 12849 } 12850 } 12851 12852 ret = get_errno(timer_create(clkid, phost_sevp, phtimer)); 12853 if (ret) { 12854 phtimer = NULL; 12855 } else { 12856 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) { 12857 return -TARGET_EFAULT; 12858 } 12859 } 12860 } 12861 return ret; 12862 } 12863 #endif 12864 12865 #ifdef TARGET_NR_timer_settime 12866 case TARGET_NR_timer_settime: 12867 { 12868 /* args: timer_t timerid, int flags, const struct itimerspec *new_value, 12869 * struct itimerspec * old_value */ 12870 target_timer_t timerid = get_timer_id(arg1); 12871 12872 if (timerid < 0) { 12873 ret = timerid; 12874 } else if (arg3 == 0) { 12875 ret = -TARGET_EINVAL; 12876 } else { 12877 timer_t htimer = g_posix_timers[timerid]; 12878 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},}; 12879 12880 if (target_to_host_itimerspec(&hspec_new, arg3)) { 12881 return -TARGET_EFAULT; 12882 } 12883 ret = get_errno( 12884 timer_settime(htimer, arg2, &hspec_new, &hspec_old)); 12885 if (arg4 && host_to_target_itimerspec(arg4, &hspec_old)) { 12886 return -TARGET_EFAULT; 12887 } 12888 } 12889 return ret; 12890 } 12891 #endif 12892 12893 #ifdef TARGET_NR_timer_settime64 12894 case TARGET_NR_timer_settime64: 12895 { 12896 target_timer_t timerid = get_timer_id(arg1); 12897 12898 if (timerid < 0) { 12899 ret = timerid; 12900 } else if (arg3 == 0) { 12901 ret = -TARGET_EINVAL; 12902 } else { 12903 timer_t htimer = g_posix_timers[timerid]; 12904 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},}; 12905 12906 if (target_to_host_itimerspec64(&hspec_new, arg3)) { 12907 return -TARGET_EFAULT; 12908 } 12909 ret = get_errno( 12910 timer_settime(htimer, arg2, &hspec_new, &hspec_old)); 12911 if (arg4 && host_to_target_itimerspec64(arg4, &hspec_old)) { 12912 return -TARGET_EFAULT; 12913 } 12914 } 12915 return ret; 12916 } 12917 #endif 12918 12919 #ifdef TARGET_NR_timer_gettime 12920 case TARGET_NR_timer_gettime: 12921 { 12922 /* args: timer_t timerid, struct itimerspec *curr_value */ 12923 target_timer_t timerid = get_timer_id(arg1); 12924 12925 if (timerid < 0) { 12926 ret = timerid; 12927 } else if (!arg2) { 12928 ret = -TARGET_EFAULT; 12929 } else { 12930 timer_t htimer = g_posix_timers[timerid]; 12931 struct itimerspec hspec; 12932 ret = get_errno(timer_gettime(htimer, &hspec)); 12933 12934 if (host_to_target_itimerspec(arg2, &hspec)) { 12935 ret = -TARGET_EFAULT; 12936 } 12937 } 12938 return ret; 12939 } 12940 #endif 12941 12942 #ifdef TARGET_NR_timer_gettime64 12943 case TARGET_NR_timer_gettime64: 12944 { 12945 /* args: timer_t timerid, struct itimerspec64 *curr_value */ 12946 target_timer_t timerid = get_timer_id(arg1); 12947 12948 if (timerid < 0) { 12949 ret = timerid; 12950 } else if (!arg2) { 12951 ret = -TARGET_EFAULT; 12952 } else { 12953 timer_t htimer = g_posix_timers[timerid]; 12954 struct itimerspec hspec; 12955 ret = get_errno(timer_gettime(htimer, &hspec)); 12956 12957 if (host_to_target_itimerspec64(arg2, &hspec)) { 12958 ret = -TARGET_EFAULT; 12959 } 12960 } 12961 return ret; 12962 } 12963 #endif 12964 12965 #ifdef TARGET_NR_timer_getoverrun 12966 case TARGET_NR_timer_getoverrun: 12967 { 12968 /* args: timer_t timerid */ 12969 target_timer_t timerid = get_timer_id(arg1); 12970 12971 if (timerid < 0) { 12972 ret = timerid; 12973 } else { 12974 timer_t htimer = g_posix_timers[timerid]; 12975 ret = get_errno(timer_getoverrun(htimer)); 12976 } 12977 return ret; 12978 } 12979 #endif 12980 12981 #ifdef TARGET_NR_timer_delete 12982 case TARGET_NR_timer_delete: 12983 { 12984 /* args: timer_t timerid */ 12985 target_timer_t timerid = get_timer_id(arg1); 12986 12987 if (timerid < 0) { 12988 ret = timerid; 12989 } else { 12990 timer_t htimer = g_posix_timers[timerid]; 12991 ret = get_errno(timer_delete(htimer)); 12992 g_posix_timers[timerid] = 0; 12993 } 12994 return ret; 12995 } 12996 #endif 12997 12998 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD) 12999 case TARGET_NR_timerfd_create: 13000 return get_errno(timerfd_create(arg1, 13001 target_to_host_bitmask(arg2, fcntl_flags_tbl))); 13002 #endif 13003 13004 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD) 13005 case TARGET_NR_timerfd_gettime: 13006 { 13007 struct itimerspec its_curr; 13008 13009 ret = get_errno(timerfd_gettime(arg1, &its_curr)); 13010 13011 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) { 13012 return -TARGET_EFAULT; 13013 } 13014 } 13015 return ret; 13016 #endif 13017 13018 #if defined(TARGET_NR_timerfd_gettime64) && defined(CONFIG_TIMERFD) 13019 case TARGET_NR_timerfd_gettime64: 13020 { 13021 struct itimerspec its_curr; 13022 13023 ret = get_errno(timerfd_gettime(arg1, &its_curr)); 13024 13025 if (arg2 && host_to_target_itimerspec64(arg2, &its_curr)) { 13026 return -TARGET_EFAULT; 13027 } 13028 } 13029 return ret; 13030 #endif 13031 13032 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD) 13033 case TARGET_NR_timerfd_settime: 13034 { 13035 struct itimerspec its_new, its_old, *p_new; 13036 13037 if (arg3) { 13038 if (target_to_host_itimerspec(&its_new, arg3)) { 13039 return -TARGET_EFAULT; 13040 } 13041 p_new = &its_new; 13042 } else { 13043 p_new = NULL; 13044 } 13045 13046 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old)); 13047 13048 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) { 13049 return -TARGET_EFAULT; 13050 } 13051 } 13052 return ret; 13053 #endif 13054 13055 #if defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD) 13056 case TARGET_NR_timerfd_settime64: 13057 { 13058 struct itimerspec its_new, its_old, *p_new; 13059 13060 if (arg3) { 13061 if (target_to_host_itimerspec64(&its_new, arg3)) { 13062 return -TARGET_EFAULT; 13063 } 13064 p_new = &its_new; 13065 } else { 13066 p_new = NULL; 13067 } 13068 13069 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old)); 13070 13071 if (arg4 && host_to_target_itimerspec64(arg4, &its_old)) { 13072 return -TARGET_EFAULT; 13073 } 13074 } 13075 return ret; 13076 #endif 13077 13078 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get) 13079 case TARGET_NR_ioprio_get: 13080 return get_errno(ioprio_get(arg1, arg2)); 13081 #endif 13082 13083 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set) 13084 case TARGET_NR_ioprio_set: 13085 return get_errno(ioprio_set(arg1, arg2, arg3)); 13086 #endif 13087 13088 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS) 13089 case TARGET_NR_setns: 13090 return get_errno(setns(arg1, arg2)); 13091 #endif 13092 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS) 13093 case TARGET_NR_unshare: 13094 return get_errno(unshare(arg1)); 13095 #endif 13096 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp) 13097 case TARGET_NR_kcmp: 13098 return get_errno(kcmp(arg1, arg2, arg3, arg4, arg5)); 13099 #endif 13100 #ifdef TARGET_NR_swapcontext 13101 case TARGET_NR_swapcontext: 13102 /* PowerPC specific. */ 13103 return do_swapcontext(cpu_env, arg1, arg2, arg3); 13104 #endif 13105 #ifdef TARGET_NR_memfd_create 13106 case TARGET_NR_memfd_create: 13107 p = lock_user_string(arg1); 13108 if (!p) { 13109 return -TARGET_EFAULT; 13110 } 13111 ret = get_errno(memfd_create(p, arg2)); 13112 fd_trans_unregister(ret); 13113 unlock_user(p, arg1, 0); 13114 return ret; 13115 #endif 13116 #if defined TARGET_NR_membarrier && defined __NR_membarrier 13117 case TARGET_NR_membarrier: 13118 return get_errno(membarrier(arg1, arg2)); 13119 #endif 13120 13121 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range) 13122 case TARGET_NR_copy_file_range: 13123 { 13124 loff_t inoff, outoff; 13125 loff_t *pinoff = NULL, *poutoff = NULL; 13126 13127 if (arg2) { 13128 if (get_user_u64(inoff, arg2)) { 13129 return -TARGET_EFAULT; 13130 } 13131 pinoff = &inoff; 13132 } 13133 if (arg4) { 13134 if (get_user_u64(outoff, arg4)) { 13135 return -TARGET_EFAULT; 13136 } 13137 poutoff = &outoff; 13138 } 13139 /* Do not sign-extend the count parameter. */ 13140 ret = get_errno(safe_copy_file_range(arg1, pinoff, arg3, poutoff, 13141 (abi_ulong)arg5, arg6)); 13142 if (!is_error(ret) && ret > 0) { 13143 if (arg2) { 13144 if (put_user_u64(inoff, arg2)) { 13145 return -TARGET_EFAULT; 13146 } 13147 } 13148 if (arg4) { 13149 if (put_user_u64(outoff, arg4)) { 13150 return -TARGET_EFAULT; 13151 } 13152 } 13153 } 13154 } 13155 return ret; 13156 #endif 13157 13158 #if defined(TARGET_NR_pivot_root) 13159 case TARGET_NR_pivot_root: 13160 { 13161 void *p2; 13162 p = lock_user_string(arg1); /* new_root */ 13163 p2 = lock_user_string(arg2); /* put_old */ 13164 if (!p || !p2) { 13165 ret = -TARGET_EFAULT; 13166 } else { 13167 ret = get_errno(pivot_root(p, p2)); 13168 } 13169 unlock_user(p2, arg2, 0); 13170 unlock_user(p, arg1, 0); 13171 } 13172 return ret; 13173 #endif 13174 13175 default: 13176 qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num); 13177 return -TARGET_ENOSYS; 13178 } 13179 return ret; 13180 } 13181 13182 abi_long do_syscall(void *cpu_env, int num, abi_long arg1, 13183 abi_long arg2, abi_long arg3, abi_long arg4, 13184 abi_long arg5, abi_long arg6, abi_long arg7, 13185 abi_long arg8) 13186 { 13187 CPUState *cpu = env_cpu(cpu_env); 13188 abi_long ret; 13189 13190 #ifdef DEBUG_ERESTARTSYS 13191 /* Debug-only code for exercising the syscall-restart code paths 13192 * in the per-architecture cpu main loops: restart every syscall 13193 * the guest makes once before letting it through. 13194 */ 13195 { 13196 static bool flag; 13197 flag = !flag; 13198 if (flag) { 13199 return -QEMU_ERESTARTSYS; 13200 } 13201 } 13202 #endif 13203 13204 record_syscall_start(cpu, num, arg1, 13205 arg2, arg3, arg4, arg5, arg6, arg7, arg8); 13206 13207 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 13208 print_syscall(cpu_env, num, arg1, arg2, arg3, arg4, arg5, arg6); 13209 } 13210 13211 ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4, 13212 arg5, arg6, arg7, arg8); 13213 13214 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 13215 print_syscall_ret(cpu_env, num, ret, arg1, arg2, 13216 arg3, arg4, arg5, arg6); 13217 } 13218 13219 record_syscall_return(cpu, num, ret); 13220 return ret; 13221 } 13222