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