linux-user/syscall.c

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