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