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