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