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