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