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