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