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