linux-user/syscall.c

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