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