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