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