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