git.maemo.org Git - qemu/blob - 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, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  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 <sys/types.h>
  32 #include <sys/ipc.h>
  33 #include <sys/msg.h>
  34 #include <sys/wait.h>
  35 #include <sys/time.h>
  36 #include <sys/stat.h>
  37 #include <sys/mount.h>
  38 #include <sys/prctl.h>
  39 #include <sys/resource.h>
  40 #include <sys/mman.h>
  41 #include <sys/swap.h>
  42 #include <signal.h>
  43 #include <sched.h>
  44 #include <sys/socket.h>
  45 #include <sys/uio.h>
  46 #include <sys/poll.h>
  47 #include <sys/times.h>
  48 #include <sys/shm.h>
  49 #include <sys/sem.h>
  50 #include <sys/statfs.h>
  51 #include <utime.h>
  52 #include <sys/sysinfo.h>
  53 //#include <sys/user.h>
  54 #include <netinet/ip.h>
  55 #include <netinet/tcp.h>
  56 #include <qemu-common.h>
  57 #ifdef HAVE_GPROF
  58 #include <sys/gmon.h>
  59 #endif
  60
  61 #define termios host_termios
  62 #define winsize host_winsize
  63 #define termio host_termio
  64 #define sgttyb host_sgttyb /* same as target */
  65 #define tchars host_tchars /* same as target */
  66 #define ltchars host_ltchars /* same as target */
  67
  68 #include <linux/termios.h>
  69 #include <linux/unistd.h>
  70 #include <linux/utsname.h>
  71 #include <linux/cdrom.h>
  72 #include <linux/hdreg.h>
  73 #include <linux/soundcard.h>
  74 #include <linux/kd.h>
  75 #include <linux/mtio.h>
  76 #include "linux_loop.h"
  77
  78 #include "qemu.h"
  79 #include "qemu-common.h"
  80
  81 #if defined(USE_NPTL)
  82 #include <linux/futex.h>
  83 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
  84     CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
  85 #else
  86 /* XXX: Hardcode the above values.  */
  87 #define CLONE_NPTL_FLAGS2 0
  88 #endif
  89
  90 //#define DEBUG
  91
  92 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
  93     || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
  94 /* 16 bit uid wrappers emulation */
  95 #define USE_UID16
  96 #endif
  97
  98 //#include <linux/msdos_fs.h>
  99 #define VFAT_IOCTL_READDIR_BOTH         _IOR('r', 1, struct linux_dirent [2])
 100 #define VFAT_IOCTL_READDIR_SHORT        _IOR('r', 2, struct linux_dirent [2])
 101
 102
 103 #undef _syscall0
 104 #undef _syscall1
 105 #undef _syscall2
 106 #undef _syscall3
 107 #undef _syscall4
 108 #undef _syscall5
 109 #undef _syscall6
 110
 111 #define _syscall0(type,name)            \
 112 static type name (void)                 \
 113 {                                       \
 114         return syscall(__NR_##name);    \
 115 }
 116
 117 #define _syscall1(type,name,type1,arg1)         \
 118 static type name (type1 arg1)                   \
 119 {                                               \
 120         return syscall(__NR_##name, arg1);      \
 121 }
 122
 123 #define _syscall2(type,name,type1,arg1,type2,arg2)      \
 124 static type name (type1 arg1,type2 arg2)                \
 125 {                                                       \
 126         return syscall(__NR_##name, arg1, arg2);        \
 127 }
 128
 129 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)   \
 130 static type name (type1 arg1,type2 arg2,type3 arg3)             \
 131 {                                                               \
 132         return syscall(__NR_##name, arg1, arg2, arg3);          \
 133 }
 134
 135 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)        \
 136 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4)                  \
 137 {                                                                               \
 138         return syscall(__NR_##name, arg1, arg2, arg3, arg4);                    \
 139 }
 140
 141 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 142                   type5,arg5)                                                   \
 143 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5)       \
 144 {                                                                               \
 145         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5);              \
 146 }
 147
 148
 149 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 150                   type5,arg5,type6,arg6)                                        \
 151 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,       \
 152                   type6 arg6)                                                   \
 153 {                                                                               \
 154         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6);        \
 155 }
 156
 157
 158 #define __NR_sys_exit __NR_exit
 159 #define __NR_sys_uname __NR_uname
 160 #define __NR_sys_faccessat __NR_faccessat
 161 #define __NR_sys_fchmodat __NR_fchmodat
 162 #define __NR_sys_fchownat __NR_fchownat
 163 #define __NR_sys_fstatat64 __NR_fstatat64
 164 #define __NR_sys_futimesat __NR_futimesat
 165 #define __NR_sys_getcwd1 __NR_getcwd
 166 #define __NR_sys_getdents __NR_getdents
 167 #define __NR_sys_getdents64 __NR_getdents64
 168 #define __NR_sys_getpriority __NR_getpriority
 169 #define __NR_sys_linkat __NR_linkat
 170 #define __NR_sys_mkdirat __NR_mkdirat
 171 #define __NR_sys_mknodat __NR_mknodat
 172 #define __NR_sys_openat __NR_openat
 173 #define __NR_sys_readlinkat __NR_readlinkat
 174 #define __NR_sys_renameat __NR_renameat
 175 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
 176 #define __NR_sys_symlinkat __NR_symlinkat
 177 #define __NR_sys_syslog __NR_syslog
 178 #define __NR_sys_tgkill __NR_tgkill
 179 #define __NR_sys_tkill __NR_tkill
 180 #define __NR_sys_unlinkat __NR_unlinkat
 181 #define __NR_sys_utimensat __NR_utimensat
 182 #define __NR_sys_futex __NR_futex
 183 #define __NR_sys_inotify_init __NR_inotify_init
 184 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
 185 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
 186
 187 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
 188 #define __NR__llseek __NR_lseek
 189 #endif
 190
 191 #ifdef __NR_gettid
 192 _syscall0(int, gettid)
 193 #else
 194 /* This is a replacement for the host gettid() and must return a host
 195    errno. */
 196 static int gettid(void) {
 197     return -ENOSYS;
 198 }
 199 #endif
 200 _syscall1(int,sys_exit,int,status)
 201 _syscall1(int,sys_uname,struct new_utsname *,buf)
 202 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
 203 _syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags)
 204 #endif
 205 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
 206 _syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname,
 207           mode_t,mode,int,flags)
 208 #endif
 209 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16)
 210 _syscall5(int,sys_fchownat,int,dirfd,const char *,pathname,
 211           uid_t,owner,gid_t,group,int,flags)
 212 #endif
 213 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
 214 _syscall4(int,sys_fstatat64,int,dirfd,const char *,pathname,
 215           struct stat *,buf,int,flags)
 216 #endif
 217 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
 218 _syscall3(int,sys_futimesat,int,dirfd,const char *,pathname,
 219          const struct timeval *,times)
 220 #endif
 221 _syscall2(int,sys_getcwd1,char *,buf,size_t,size)
 222 #if TARGET_ABI_BITS == 32
 223 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
 224 #endif
 225 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
 226 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
 227 #endif
 228 _syscall2(int, sys_getpriority, int, which, int, who);
 229 #if !defined (__x86_64__)
 230 _syscall5(int, _llseek,  uint,  fd, ulong, hi, ulong, lo,
 231           loff_t *, res, uint, wh);
 232 #endif
 233 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
 234 _syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath,
 235           int,newdirfd,const char *,newpath,int,flags)
 236 #endif
 237 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
 238 _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode)
 239 #endif
 240 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
 241 _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname,
 242           mode_t,mode,dev_t,dev)
 243 #endif
 244 #if defined(TARGET_NR_openat) && defined(__NR_openat)
 245 _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)
 246 #endif
 247 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
 248 _syscall4(int,sys_readlinkat,int,dirfd,const char *,pathname,
 249           char *,buf,size_t,bufsize)
 250 #endif
 251 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
 252 _syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath,
 253           int,newdirfd,const char *,newpath)
 254 #endif
 255 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
 256 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
 257 _syscall3(int,sys_symlinkat,const char *,oldpath,
 258           int,newdirfd,const char *,newpath)
 259 #endif
 260 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
 261 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
 262 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
 263 #endif
 264 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
 265 _syscall2(int,sys_tkill,int,tid,int,sig)
 266 #endif
 267 #ifdef __NR_exit_group
 268 _syscall1(int,exit_group,int,error_code)
 269 #endif
 270 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
 271 _syscall1(int,set_tid_address,int *,tidptr)
 272 #endif
 273 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
 274 _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)
 275 #endif
 276 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
 277 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
 278           const struct timespec *,tsp,int,flags)
 279 #endif
 280 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
 281 _syscall0(int,sys_inotify_init)
 282 #endif
 283 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
 284 _syscall3(int,sys_inotify_add_watch,int,fd,const char *,pathname,uint32_t,mask)
 285 #endif
 286 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
 287 _syscall2(int,sys_inotify_rm_watch,int,fd,uint32_t,wd)
 288 #endif
 289 #if defined(USE_NPTL)
 290 #if defined(TARGET_NR_futex) && defined(__NR_futex)
 291 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
 292           const struct timespec *,timeout,int *,uaddr2,int,val3)
 293 #endif
 294 #endif
 295
 296 extern int personality(int);
 297 extern int flock(int, int);
 298 extern int setfsuid(int);
 299 extern int setfsgid(int);
 300 extern int setgroups(int, gid_t *);
 301
 302 #define ERRNO_TABLE_SIZE 1200
 303
 304 /* target_to_host_errno_table[] is initialized from
 305  * host_to_target_errno_table[] in syscall_init(). */
 306 static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
 307 };
 308
 309 /*
 310  * This list is the union of errno values overridden in asm-<arch>/errno.h
 311  * minus the errnos that are not actually generic to all archs.
 312  */
 313 static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
 314     [EIDRM]             = TARGET_EIDRM,
 315     [ECHRNG]            = TARGET_ECHRNG,
 316     [EL2NSYNC]          = TARGET_EL2NSYNC,
 317     [EL3HLT]            = TARGET_EL3HLT,
 318     [EL3RST]            = TARGET_EL3RST,
 319     [ELNRNG]            = TARGET_ELNRNG,
 320     [EUNATCH]           = TARGET_EUNATCH,
 321     [ENOCSI]            = TARGET_ENOCSI,
 322     [EL2HLT]            = TARGET_EL2HLT,
 323     [EDEADLK]           = TARGET_EDEADLK,
 324     [ENOLCK]            = TARGET_ENOLCK,
 325     [EBADE]             = TARGET_EBADE,
 326     [EBADR]             = TARGET_EBADR,
 327     [EXFULL]            = TARGET_EXFULL,
 328     [ENOANO]            = TARGET_ENOANO,
 329     [EBADRQC]           = TARGET_EBADRQC,
 330     [EBADSLT]           = TARGET_EBADSLT,
 331     [EBFONT]            = TARGET_EBFONT,
 332     [ENOSTR]            = TARGET_ENOSTR,
 333     [ENODATA]           = TARGET_ENODATA,
 334     [ETIME]             = TARGET_ETIME,
 335     [ENOSR]             = TARGET_ENOSR,
 336     [ENONET]            = TARGET_ENONET,
 337     [ENOPKG]            = TARGET_ENOPKG,
 338     [EREMOTE]           = TARGET_EREMOTE,
 339     [ENOLINK]           = TARGET_ENOLINK,
 340     [EADV]              = TARGET_EADV,
 341     [ESRMNT]            = TARGET_ESRMNT,
 342     [ECOMM]             = TARGET_ECOMM,
 343     [EPROTO]            = TARGET_EPROTO,
 344     [EDOTDOT]           = TARGET_EDOTDOT,
 345     [EMULTIHOP]         = TARGET_EMULTIHOP,
 346     [EBADMSG]           = TARGET_EBADMSG,
 347     [ENAMETOOLONG]      = TARGET_ENAMETOOLONG,
 348     [EOVERFLOW]         = TARGET_EOVERFLOW,
 349     [ENOTUNIQ]          = TARGET_ENOTUNIQ,
 350     [EBADFD]            = TARGET_EBADFD,
 351     [EREMCHG]           = TARGET_EREMCHG,
 352     [ELIBACC]           = TARGET_ELIBACC,
 353     [ELIBBAD]           = TARGET_ELIBBAD,
 354     [ELIBSCN]           = TARGET_ELIBSCN,
 355     [ELIBMAX]           = TARGET_ELIBMAX,
 356     [ELIBEXEC]          = TARGET_ELIBEXEC,
 357     [EILSEQ]            = TARGET_EILSEQ,
 358     [ENOSYS]            = TARGET_ENOSYS,
 359     [ELOOP]             = TARGET_ELOOP,
 360     [ERESTART]          = TARGET_ERESTART,
 361     [ESTRPIPE]          = TARGET_ESTRPIPE,
 362     [ENOTEMPTY]         = TARGET_ENOTEMPTY,
 363     [EUSERS]            = TARGET_EUSERS,
 364     [ENOTSOCK]          = TARGET_ENOTSOCK,
 365     [EDESTADDRREQ]      = TARGET_EDESTADDRREQ,
 366     [EMSGSIZE]          = TARGET_EMSGSIZE,
 367     [EPROTOTYPE]        = TARGET_EPROTOTYPE,
 368     [ENOPROTOOPT]       = TARGET_ENOPROTOOPT,
 369     [EPROTONOSUPPORT]   = TARGET_EPROTONOSUPPORT,
 370     [ESOCKTNOSUPPORT]   = TARGET_ESOCKTNOSUPPORT,
 371     [EOPNOTSUPP]        = TARGET_EOPNOTSUPP,
 372     [EPFNOSUPPORT]      = TARGET_EPFNOSUPPORT,
 373     [EAFNOSUPPORT]      = TARGET_EAFNOSUPPORT,
 374     [EADDRINUSE]        = TARGET_EADDRINUSE,
 375     [EADDRNOTAVAIL]     = TARGET_EADDRNOTAVAIL,
 376     [ENETDOWN]          = TARGET_ENETDOWN,
 377     [ENETUNREACH]       = TARGET_ENETUNREACH,
 378     [ENETRESET]         = TARGET_ENETRESET,
 379     [ECONNABORTED]      = TARGET_ECONNABORTED,
 380     [ECONNRESET]        = TARGET_ECONNRESET,
 381     [ENOBUFS]           = TARGET_ENOBUFS,
 382     [EISCONN]           = TARGET_EISCONN,
 383     [ENOTCONN]          = TARGET_ENOTCONN,
 384     [EUCLEAN]           = TARGET_EUCLEAN,
 385     [ENOTNAM]           = TARGET_ENOTNAM,
 386     [ENAVAIL]           = TARGET_ENAVAIL,
 387     [EISNAM]            = TARGET_EISNAM,
 388     [EREMOTEIO]         = TARGET_EREMOTEIO,
 389     [ESHUTDOWN]         = TARGET_ESHUTDOWN,
 390     [ETOOMANYREFS]      = TARGET_ETOOMANYREFS,
 391     [ETIMEDOUT]         = TARGET_ETIMEDOUT,
 392     [ECONNREFUSED]      = TARGET_ECONNREFUSED,
 393     [EHOSTDOWN]         = TARGET_EHOSTDOWN,
 394     [EHOSTUNREACH]      = TARGET_EHOSTUNREACH,
 395     [EALREADY]          = TARGET_EALREADY,
 396     [EINPROGRESS]       = TARGET_EINPROGRESS,
 397     [ESTALE]            = TARGET_ESTALE,
 398     [ECANCELED]         = TARGET_ECANCELED,
 399     [ENOMEDIUM]         = TARGET_ENOMEDIUM,
 400     [EMEDIUMTYPE]       = TARGET_EMEDIUMTYPE,
 401 #ifdef ENOKEY
 402     [ENOKEY]            = TARGET_ENOKEY,
 403 #endif
 404 #ifdef EKEYEXPIRED
 405     [EKEYEXPIRED]       = TARGET_EKEYEXPIRED,
 406 #endif
 407 #ifdef EKEYREVOKED
 408     [EKEYREVOKED]       = TARGET_EKEYREVOKED,
 409 #endif
 410 #ifdef EKEYREJECTED
 411     [EKEYREJECTED]      = TARGET_EKEYREJECTED,
 412 #endif
 413 #ifdef EOWNERDEAD
 414     [EOWNERDEAD]        = TARGET_EOWNERDEAD,
 415 #endif
 416 #ifdef ENOTRECOVERABLE
 417     [ENOTRECOVERABLE]   = TARGET_ENOTRECOVERABLE,
 418 #endif
 419 };
 420
 421 static inline int host_to_target_errno(int err)
 422 {
 423     if(host_to_target_errno_table[err])
 424         return host_to_target_errno_table[err];
 425     return err;
 426 }
 427
 428 static inline int target_to_host_errno(int err)
 429 {
 430     if (target_to_host_errno_table[err])
 431         return target_to_host_errno_table[err];
 432     return err;
 433 }
 434
 435 static inline abi_long get_errno(abi_long ret)
 436 {
 437     if (ret == -1)
 438         return -host_to_target_errno(errno);
 439     else
 440         return ret;
 441 }
 442
 443 static inline int is_error(abi_long ret)
 444 {
 445     return (abi_ulong)ret >= (abi_ulong)(-4096);
 446 }
 447
 448 char *target_strerror(int err)
 449 {
 450     return strerror(target_to_host_errno(err));
 451 }
 452
 453 static abi_ulong target_brk;
 454 static abi_ulong target_original_brk;
 455
 456 void target_set_brk(abi_ulong new_brk)
 457 {
 458     target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
 459 }
 460
 461 /* do_brk() must return target values and target errnos. */
 462 abi_long do_brk(abi_ulong new_brk)
 463 {
 464     abi_ulong brk_page;
 465     abi_long mapped_addr;
 466     int new_alloc_size;
 467
 468     if (!new_brk)
 469         return target_brk;
 470     if (new_brk < target_original_brk)
 471         return target_brk;
 472
 473     brk_page = HOST_PAGE_ALIGN(target_brk);
 474
 475     /* If the new brk is less than this, set it and we're done... */
 476     if (new_brk < brk_page) {
 477         target_brk = new_brk;
 478         return target_brk;
 479     }
 480
 481     /* We need to allocate more memory after the brk... */
 482     new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
 483     mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
 484                                         PROT_READ|PROT_WRITE,
 485                                         MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));
 486
 487     if (!is_error(mapped_addr))
 488         target_brk = new_brk;
 489
 490     return target_brk;
 491 }
 492
 493 static inline abi_long copy_from_user_fdset(fd_set *fds,
 494                                             abi_ulong target_fds_addr,
 495                                             int n)
 496 {
 497     int i, nw, j, k;
 498     abi_ulong b, *target_fds;
 499
 500     nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
 501     if (!(target_fds = lock_user(VERIFY_READ,
 502                                  target_fds_addr,
 503                                  sizeof(abi_ulong) * nw,
 504                                  1)))
 505         return -TARGET_EFAULT;
 506
 507     FD_ZERO(fds);
 508     k = 0;
 509     for (i = 0; i < nw; i++) {
 510         /* grab the abi_ulong */
 511         __get_user(b, &target_fds[i]);
 512         for (j = 0; j < TARGET_ABI_BITS; j++) {
 513             /* check the bit inside the abi_ulong */
 514             if ((b >> j) & 1)
 515                 FD_SET(k, fds);
 516             k++;
 517         }
 518     }
 519
 520     unlock_user(target_fds, target_fds_addr, 0);
 521
 522     return 0;
 523 }
 524
 525 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
 526                                           const fd_set *fds,
 527                                           int n)
 528 {
 529     int i, nw, j, k;
 530     abi_long v;
 531     abi_ulong *target_fds;
 532
 533     nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
 534     if (!(target_fds = lock_user(VERIFY_WRITE,
 535                                  target_fds_addr,
 536                                  sizeof(abi_ulong) * nw,
 537                                  0)))
 538         return -TARGET_EFAULT;
 539
 540     k = 0;
 541     for (i = 0; i < nw; i++) {
 542         v = 0;
 543         for (j = 0; j < TARGET_ABI_BITS; j++) {
 544             v |= ((FD_ISSET(k, fds) != 0) << j);
 545             k++;
 546         }
 547         __put_user(v, &target_fds[i]);
 548     }
 549
 550     unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
 551
 552     return 0;
 553 }
 554
 555 #if defined(__alpha__)
 556 #define HOST_HZ 1024
 557 #else
 558 #define HOST_HZ 100
 559 #endif
 560
 561 static inline abi_long host_to_target_clock_t(long ticks)
 562 {
 563 #if HOST_HZ == TARGET_HZ
 564     return ticks;
 565 #else
 566     return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
 567 #endif
 568 }
 569
 570 static inline abi_long host_to_target_rusage(abi_ulong target_addr,
 571                                              const struct rusage *rusage)
 572 {
 573     struct target_rusage *target_rusage;
 574
 575     if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
 576         return -TARGET_EFAULT;
 577     target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec);
 578     target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec);
 579     target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec);
 580     target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec);
 581     target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss);
 582     target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss);
 583     target_rusage->ru_idrss = tswapl(rusage->ru_idrss);
 584     target_rusage->ru_isrss = tswapl(rusage->ru_isrss);
 585     target_rusage->ru_minflt = tswapl(rusage->ru_minflt);
 586     target_rusage->ru_majflt = tswapl(rusage->ru_majflt);
 587     target_rusage->ru_nswap = tswapl(rusage->ru_nswap);
 588     target_rusage->ru_inblock = tswapl(rusage->ru_inblock);
 589     target_rusage->ru_oublock = tswapl(rusage->ru_oublock);
 590     target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd);
 591     target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv);
 592     target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals);
 593     target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw);
 594     target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw);
 595     unlock_user_struct(target_rusage, target_addr, 1);
 596
 597     return 0;
 598 }
 599
 600 static inline abi_long copy_from_user_timeval(struct timeval *tv,
 601                                               abi_ulong target_tv_addr)
 602 {
 603     struct target_timeval *target_tv;
 604
 605     if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
 606         return -TARGET_EFAULT;
 607
 608     __get_user(tv->tv_sec, &target_tv->tv_sec);
 609     __get_user(tv->tv_usec, &target_tv->tv_usec);
 610
 611     unlock_user_struct(target_tv, target_tv_addr, 0);
 612
 613     return 0;
 614 }
 615
 616 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
 617                                             const struct timeval *tv)
 618 {
 619     struct target_timeval *target_tv;
 620
 621     if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
 622         return -TARGET_EFAULT;
 623
 624     __put_user(tv->tv_sec, &target_tv->tv_sec);
 625     __put_user(tv->tv_usec, &target_tv->tv_usec);
 626
 627     unlock_user_struct(target_tv, target_tv_addr, 1);
 628
 629     return 0;
 630 }
 631
 632
 633 /* do_select() must return target values and target errnos. */
 634 static abi_long do_select(int n,
 635                           abi_ulong rfd_addr, abi_ulong wfd_addr,
 636                           abi_ulong efd_addr, abi_ulong target_tv_addr)
 637 {
 638     fd_set rfds, wfds, efds;
 639     fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
 640     struct timeval tv, *tv_ptr;
 641     abi_long ret;
 642
 643     if (rfd_addr) {
 644         if (copy_from_user_fdset(&rfds, rfd_addr, n))
 645             return -TARGET_EFAULT;
 646         rfds_ptr = &rfds;
 647     } else {
 648         rfds_ptr = NULL;
 649     }
 650     if (wfd_addr) {
 651         if (copy_from_user_fdset(&wfds, wfd_addr, n))
 652             return -TARGET_EFAULT;
 653         wfds_ptr = &wfds;
 654     } else {
 655         wfds_ptr = NULL;
 656     }
 657     if (efd_addr) {
 658         if (copy_from_user_fdset(&efds, efd_addr, n))
 659             return -TARGET_EFAULT;
 660         efds_ptr = &efds;
 661     } else {
 662         efds_ptr = NULL;
 663     }
 664
 665     if (target_tv_addr) {
 666         if (copy_from_user_timeval(&tv, target_tv_addr))
 667             return -TARGET_EFAULT;
 668         tv_ptr = &tv;
 669     } else {
 670         tv_ptr = NULL;
 671     }
 672
 673     ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
 674
 675     if (!is_error(ret)) {
 676         if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
 677             return -TARGET_EFAULT;
 678         if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
 679             return -TARGET_EFAULT;
 680         if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
 681             return -TARGET_EFAULT;
 682
 683         if (target_tv_addr && copy_to_user_timeval(target_tv_addr, &tv))
 684             return -TARGET_EFAULT;
 685     }
 686
 687     return ret;
 688 }
 689
 690 static inline abi_long target_to_host_sockaddr(struct sockaddr *addr,
 691                                                abi_ulong target_addr,
 692                                                socklen_t len)
 693 {
 694     struct target_sockaddr *target_saddr;
 695
 696     target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
 697     if (!target_saddr)
 698         return -TARGET_EFAULT;
 699     memcpy(addr, target_saddr, len);
 700     addr->sa_family = tswap16(target_saddr->sa_family);
 701     unlock_user(target_saddr, target_addr, 0);
 702
 703     return 0;
 704 }
 705
 706 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
 707                                                struct sockaddr *addr,
 708                                                socklen_t len)
 709 {
 710     struct target_sockaddr *target_saddr;
 711
 712     target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
 713     if (!target_saddr)
 714         return -TARGET_EFAULT;
 715     memcpy(target_saddr, addr, len);
 716     target_saddr->sa_family = tswap16(addr->sa_family);
 717     unlock_user(target_saddr, target_addr, len);
 718
 719     return 0;
 720 }
 721
 722 /* ??? Should this also swap msgh->name?  */
 723 static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
 724                                            struct target_msghdr *target_msgh)
 725 {
 726     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
 727     abi_long msg_controllen;
 728     abi_ulong target_cmsg_addr;
 729     struct target_cmsghdr *target_cmsg;
 730     socklen_t space = 0;
 731
 732     msg_controllen = tswapl(target_msgh->msg_controllen);
 733     if (msg_controllen < sizeof (struct target_cmsghdr))
 734         goto the_end;
 735     target_cmsg_addr = tswapl(target_msgh->msg_control);
 736     target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
 737     if (!target_cmsg)
 738         return -TARGET_EFAULT;
 739
 740     while (cmsg && target_cmsg) {
 741         void *data = CMSG_DATA(cmsg);
 742         void *target_data = TARGET_CMSG_DATA(target_cmsg);
 743
 744         int len = tswapl(target_cmsg->cmsg_len)
 745                   - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
 746
 747         space += CMSG_SPACE(len);
 748         if (space > msgh->msg_controllen) {
 749             space -= CMSG_SPACE(len);
 750             gemu_log("Host cmsg overflow\n");
 751             break;
 752         }
 753
 754         cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
 755         cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
 756         cmsg->cmsg_len = CMSG_LEN(len);
 757
 758         if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
 759             gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
 760             memcpy(data, target_data, len);
 761         } else {
 762             int *fd = (int *)data;
 763             int *target_fd = (int *)target_data;
 764             int i, numfds = len / sizeof(int);
 765
 766             for (i = 0; i < numfds; i++)
 767                 fd[i] = tswap32(target_fd[i]);
 768         }
 769
 770         cmsg = CMSG_NXTHDR(msgh, cmsg);
 771         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
 772     }
 773     unlock_user(target_cmsg, target_cmsg_addr, 0);
 774  the_end:
 775     msgh->msg_controllen = space;
 776     return 0;
 777 }
 778
 779 /* ??? Should this also swap msgh->name?  */
 780 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
 781                                            struct msghdr *msgh)
 782 {
 783     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
 784     abi_long msg_controllen;
 785     abi_ulong target_cmsg_addr;
 786     struct target_cmsghdr *target_cmsg;
 787     socklen_t space = 0;
 788
 789     msg_controllen = tswapl(target_msgh->msg_controllen);
 790     if (msg_controllen < sizeof (struct target_cmsghdr))
 791         goto the_end;
 792     target_cmsg_addr = tswapl(target_msgh->msg_control);
 793     target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
 794     if (!target_cmsg)
 795         return -TARGET_EFAULT;
 796
 797     while (cmsg && target_cmsg) {
 798         void *data = CMSG_DATA(cmsg);
 799         void *target_data = TARGET_CMSG_DATA(target_cmsg);
 800
 801         int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
 802
 803         space += TARGET_CMSG_SPACE(len);
 804         if (space > msg_controllen) {
 805             space -= TARGET_CMSG_SPACE(len);
 806             gemu_log("Target cmsg overflow\n");
 807             break;
 808         }
 809
 810         target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
 811         target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
 812         target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
 813
 814         if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
 815             gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
 816             memcpy(target_data, data, len);
 817         } else {
 818             int *fd = (int *)data;
 819             int *target_fd = (int *)target_data;
 820             int i, numfds = len / sizeof(int);
 821
 822             for (i = 0; i < numfds; i++)
 823                 target_fd[i] = tswap32(fd[i]);
 824         }
 825
 826         cmsg = CMSG_NXTHDR(msgh, cmsg);
 827         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
 828     }
 829     unlock_user(target_cmsg, target_cmsg_addr, space);
 830  the_end:
 831     target_msgh->msg_controllen = tswapl(space);
 832     return 0;
 833 }
 834
 835 /* do_setsockopt() Must return target values and target errnos. */
 836 static abi_long do_setsockopt(int sockfd, int level, int optname,
 837                               abi_ulong optval_addr, socklen_t optlen)
 838 {
 839     abi_long ret;
 840     int val;
 841
 842     switch(level) {
 843     case SOL_TCP:
 844         /* TCP options all take an 'int' value.  */
 845         if (optlen < sizeof(uint32_t))
 846             return -TARGET_EINVAL;
 847
 848         if (get_user_u32(val, optval_addr))
 849             return -TARGET_EFAULT;
 850         ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
 851         break;
 852     case SOL_IP:
 853         switch(optname) {
 854         case IP_TOS:
 855         case IP_TTL:
 856         case IP_HDRINCL:
 857         case IP_ROUTER_ALERT:
 858         case IP_RECVOPTS:
 859         case IP_RETOPTS:
 860         case IP_PKTINFO:
 861         case IP_MTU_DISCOVER:
 862         case IP_RECVERR:
 863         case IP_RECVTOS:
 864 #ifdef IP_FREEBIND
 865         case IP_FREEBIND:
 866 #endif
 867         case IP_MULTICAST_TTL:
 868         case IP_MULTICAST_LOOP:
 869             val = 0;
 870             if (optlen >= sizeof(uint32_t)) {
 871                 if (get_user_u32(val, optval_addr))
 872                     return -TARGET_EFAULT;
 873             } else if (optlen >= 1) {
 874                 if (get_user_u8(val, optval_addr))
 875                     return -TARGET_EFAULT;
 876             }
 877             ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
 878             break;
 879         default:
 880             goto unimplemented;
 881         }
 882         break;
 883     case TARGET_SOL_SOCKET:
 884         switch (optname) {
 885             /* Options with 'int' argument.  */
 886         case TARGET_SO_DEBUG:
 887                 optname = SO_DEBUG;
 888                 break;
 889         case TARGET_SO_REUSEADDR:
 890                 optname = SO_REUSEADDR;
 891                 break;
 892         case TARGET_SO_TYPE:
 893                 optname = SO_TYPE;
 894                 break;
 895         case TARGET_SO_ERROR:
 896                 optname = SO_ERROR;
 897                 break;
 898         case TARGET_SO_DONTROUTE:
 899                 optname = SO_DONTROUTE;
 900                 break;
 901         case TARGET_SO_BROADCAST:
 902                 optname = SO_BROADCAST;
 903                 break;
 904         case TARGET_SO_SNDBUF:
 905                 optname = SO_SNDBUF;
 906                 break;
 907         case TARGET_SO_RCVBUF:
 908                 optname = SO_RCVBUF;
 909                 break;
 910         case TARGET_SO_KEEPALIVE:
 911                 optname = SO_KEEPALIVE;
 912                 break;
 913         case TARGET_SO_OOBINLINE:
 914                 optname = SO_OOBINLINE;
 915                 break;
 916         case TARGET_SO_NO_CHECK:
 917                 optname = SO_NO_CHECK;
 918                 break;
 919         case TARGET_SO_PRIORITY:
 920                 optname = SO_PRIORITY;
 921                 break;
 922 #ifdef SO_BSDCOMPAT
 923         case TARGET_SO_BSDCOMPAT:
 924                 optname = SO_BSDCOMPAT;
 925                 break;
 926 #endif
 927         case TARGET_SO_PASSCRED:
 928                 optname = SO_PASSCRED;
 929                 break;
 930         case TARGET_SO_TIMESTAMP:
 931                 optname = SO_TIMESTAMP;
 932                 break;
 933         case TARGET_SO_RCVLOWAT:
 934                 optname = SO_RCVLOWAT;
 935                 break;
 936         case TARGET_SO_RCVTIMEO:
 937                 optname = SO_RCVTIMEO;
 938                 break;
 939         case TARGET_SO_SNDTIMEO:
 940                 optname = SO_SNDTIMEO;
 941                 break;
 942             break;
 943         default:
 944             goto unimplemented;
 945         }
 946         if (optlen < sizeof(uint32_t))
 947             return -TARGET_EINVAL;
 948
 949         if (get_user_u32(val, optval_addr))
 950             return -TARGET_EFAULT;
 951         ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
 952         break;
 953     default:
 954     unimplemented:
 955         gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
 956         ret = -TARGET_ENOPROTOOPT;
 957     }
 958     return ret;
 959 }
 960
 961 /* do_getsockopt() Must return target values and target errnos. */
 962 static abi_long do_getsockopt(int sockfd, int level, int optname,
 963                               abi_ulong optval_addr, abi_ulong optlen)
 964 {
 965     abi_long ret;
 966     int len, val;
 967     socklen_t lv;
 968
 969     switch(level) {
 970     case TARGET_SOL_SOCKET:
 971         level = SOL_SOCKET;
 972         switch (optname) {
 973         case TARGET_SO_LINGER:
 974         case TARGET_SO_RCVTIMEO:
 975         case TARGET_SO_SNDTIMEO:
 976         case TARGET_SO_PEERCRED:
 977         case TARGET_SO_PEERNAME:
 978             /* These don't just return a single integer */
 979             goto unimplemented;
 980         default:
 981             goto int_case;
 982         }
 983         break;
 984     case SOL_TCP:
 985         /* TCP options all take an 'int' value.  */
 986     int_case:
 987         if (get_user_u32(len, optlen))
 988             return -TARGET_EFAULT;
 989         if (len < 0)
 990             return -TARGET_EINVAL;
 991         lv = sizeof(int);
 992         ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
 993         if (ret < 0)
 994             return ret;
 995         val = tswap32(val);
 996         if (len > lv)
 997             len = lv;
 998         if (len == 4) {
 999             if (put_user_u32(val, optval_addr))
1000                 return -TARGET_EFAULT;
1001         } else {
1002             if (put_user_u8(val, optval_addr))
1003                 return -TARGET_EFAULT;
1004         }
1005         if (put_user_u32(len, optlen))
1006             return -TARGET_EFAULT;
1007         break;
1008     case SOL_IP:
1009         switch(optname) {
1010         case IP_TOS:
1011         case IP_TTL:
1012         case IP_HDRINCL:
1013         case IP_ROUTER_ALERT:
1014         case IP_RECVOPTS:
1015         case IP_RETOPTS:
1016         case IP_PKTINFO:
1017         case IP_MTU_DISCOVER:
1018         case IP_RECVERR:
1019         case IP_RECVTOS:
1020 #ifdef IP_FREEBIND
1021         case IP_FREEBIND:
1022 #endif
1023         case IP_MULTICAST_TTL:
1024         case IP_MULTICAST_LOOP:
1025             if (get_user_u32(len, optlen))
1026                 return -TARGET_EFAULT;
1027             if (len < 0)
1028                 return -TARGET_EINVAL;
1029             lv = sizeof(int);
1030             ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
1031             if (ret < 0)
1032                 return ret;
1033             if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
1034                 len = 1;
1035                 if (put_user_u32(len, optlen)
1036                     || put_user_u8(val, optval_addr))
1037                     return -TARGET_EFAULT;
1038             } else {
1039                 if (len > sizeof(int))
1040                     len = sizeof(int);
1041                 if (put_user_u32(len, optlen)
1042                     || put_user_u32(val, optval_addr))
1043                     return -TARGET_EFAULT;
1044             }
1045             break;
1046         default:
1047             ret = -TARGET_ENOPROTOOPT;
1048             break;
1049         }
1050         break;
1051     default:
1052     unimplemented:
1053         gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1054                  level, optname);
1055         ret = -TARGET_EOPNOTSUPP;
1056         break;
1057     }
1058     return ret;
1059 }
1060
1061 /* FIXME
1062  * lock_iovec()/unlock_iovec() have a return code of 0 for success where
1063  * other lock functions have a return code of 0 for failure.
1064  */
1065 static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
1066                            int count, int copy)
1067 {
1068     struct target_iovec *target_vec;
1069     abi_ulong base;
1070     int i;
1071
1072     target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1073     if (!target_vec)
1074         return -TARGET_EFAULT;
1075     for(i = 0;i < count; i++) {
1076         base = tswapl(target_vec[i].iov_base);
1077         vec[i].iov_len = tswapl(target_vec[i].iov_len);
1078         if (vec[i].iov_len != 0) {
1079             vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
1080             /* Don't check lock_user return value. We must call writev even
1081                if a element has invalid base address. */
1082         } else {
1083             /* zero length pointer is ignored */
1084             vec[i].iov_base = NULL;
1085         }
1086     }
1087     unlock_user (target_vec, target_addr, 0);
1088     return 0;
1089 }
1090
1091 static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
1092                              int count, int copy)
1093 {
1094     struct target_iovec *target_vec;
1095     abi_ulong base;
1096     int i;
1097
1098     target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1099     if (!target_vec)
1100         return -TARGET_EFAULT;
1101     for(i = 0;i < count; i++) {
1102         if (target_vec[i].iov_base) {
1103             base = tswapl(target_vec[i].iov_base);
1104             unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
1105         }
1106     }
1107     unlock_user (target_vec, target_addr, 0);
1108
1109     return 0;
1110 }
1111
1112 /* do_socket() Must return target values and target errnos. */
1113 static abi_long do_socket(int domain, int type, int protocol)
1114 {
1115 #if defined(TARGET_MIPS)
1116     switch(type) {
1117     case TARGET_SOCK_DGRAM:
1118         type = SOCK_DGRAM;
1119         break;
1120     case TARGET_SOCK_STREAM:
1121         type = SOCK_STREAM;
1122         break;
1123     case TARGET_SOCK_RAW:
1124         type = SOCK_RAW;
1125         break;
1126     case TARGET_SOCK_RDM:
1127         type = SOCK_RDM;
1128         break;
1129     case TARGET_SOCK_SEQPACKET:
1130         type = SOCK_SEQPACKET;
1131         break;
1132     case TARGET_SOCK_PACKET:
1133         type = SOCK_PACKET;
1134         break;
1135     }
1136 #endif
1137     if (domain == PF_NETLINK)
1138         return -EAFNOSUPPORT; /* do not NETLINK socket connections possible */
1139     return get_errno(socket(domain, type, protocol));
1140 }
1141
1142 /* do_bind() Must return target values and target errnos. */
1143 static abi_long do_bind(int sockfd, abi_ulong target_addr,
1144                         socklen_t addrlen)
1145 {
1146     void *addr = alloca(addrlen);
1147
1148     target_to_host_sockaddr(addr, target_addr, addrlen);
1149     return get_errno(bind(sockfd, addr, addrlen));
1150 }
1151
1152 /* do_connect() Must return target values and target errnos. */
1153 static abi_long do_connect(int sockfd, abi_ulong target_addr,
1154                            socklen_t addrlen)
1155 {
1156     void *addr = alloca(addrlen);
1157
1158     target_to_host_sockaddr(addr, target_addr, addrlen);
1159     return get_errno(connect(sockfd, addr, addrlen));
1160 }
1161
1162 /* do_sendrecvmsg() Must return target values and target errnos. */
1163 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
1164                                int flags, int send)
1165 {
1166     abi_long ret, len;
1167     struct target_msghdr *msgp;
1168     struct msghdr msg;
1169     int count;
1170     struct iovec *vec;
1171     abi_ulong target_vec;
1172
1173     /* FIXME */
1174     if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
1175                           msgp,
1176                           target_msg,
1177                           send ? 1 : 0))
1178         return -TARGET_EFAULT;
1179     if (msgp->msg_name) {
1180         msg.msg_namelen = tswap32(msgp->msg_namelen);
1181         msg.msg_name = alloca(msg.msg_namelen);
1182         target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name),
1183                                 msg.msg_namelen);
1184     } else {
1185         msg.msg_name = NULL;
1186         msg.msg_namelen = 0;
1187     }
1188     msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
1189     msg.msg_control = alloca(msg.msg_controllen);
1190     msg.msg_flags = tswap32(msgp->msg_flags);
1191
1192     count = tswapl(msgp->msg_iovlen);
1193     vec = alloca(count * sizeof(struct iovec));
1194     target_vec = tswapl(msgp->msg_iov);
1195     lock_iovec(send ? VERIFY_READ : VERIFY_WRITE, vec, target_vec, count, send);
1196     msg.msg_iovlen = count;
1197     msg.msg_iov = vec;
1198
1199     if (send) {
1200         ret = target_to_host_cmsg(&msg, msgp);
1201         if (ret == 0)
1202             ret = get_errno(sendmsg(fd, &msg, flags));
1203     } else {
1204         ret = get_errno(recvmsg(fd, &msg, flags));
1205         if (!is_error(ret)) {
1206             len = ret;
1207             ret = host_to_target_cmsg(msgp, &msg);
1208             if (!is_error(ret))
1209                 ret = len;
1210         }
1211     }
1212     unlock_iovec(vec, target_vec, count, !send);
1213     unlock_user_struct(msgp, target_msg, send ? 0 : 1);
1214     return ret;
1215 }
1216
1217 /* do_accept() Must return target values and target errnos. */
1218 static abi_long do_accept(int fd, abi_ulong target_addr,
1219                           abi_ulong target_addrlen_addr)
1220 {
1221     socklen_t addrlen;
1222     void *addr;
1223     abi_long ret;
1224
1225     if (get_user_u32(addrlen, target_addrlen_addr))
1226         return -TARGET_EFAULT;
1227
1228     addr = alloca(addrlen);
1229
1230     ret = get_errno(accept(fd, addr, &addrlen));
1231     if (!is_error(ret)) {
1232         host_to_target_sockaddr(target_addr, addr, addrlen);
1233         if (put_user_u32(addrlen, target_addrlen_addr))
1234             ret = -TARGET_EFAULT;
1235     }
1236     return ret;
1237 }
1238
1239 /* do_getpeername() Must return target values and target errnos. */
1240 static abi_long do_getpeername(int fd, abi_ulong target_addr,
1241                                abi_ulong target_addrlen_addr)
1242 {
1243     socklen_t addrlen;
1244     void *addr;
1245     abi_long ret;
1246
1247     if (get_user_u32(addrlen, target_addrlen_addr))
1248         return -TARGET_EFAULT;
1249
1250     addr = alloca(addrlen);
1251
1252     ret = get_errno(getpeername(fd, addr, &addrlen));
1253     if (!is_error(ret)) {
1254         host_to_target_sockaddr(target_addr, addr, addrlen);
1255         if (put_user_u32(addrlen, target_addrlen_addr))
1256             ret = -TARGET_EFAULT;
1257     }
1258     return ret;
1259 }
1260
1261 /* do_getsockname() Must return target values and target errnos. */
1262 static abi_long do_getsockname(int fd, abi_ulong target_addr,
1263                                abi_ulong target_addrlen_addr)
1264 {
1265     socklen_t addrlen;
1266     void *addr;
1267     abi_long ret;
1268
1269     if (get_user_u32(addrlen, target_addrlen_addr))
1270         return -TARGET_EFAULT;
1271
1272     addr = alloca(addrlen);
1273
1274     ret = get_errno(getsockname(fd, addr, &addrlen));
1275     if (!is_error(ret)) {
1276         host_to_target_sockaddr(target_addr, addr, addrlen);
1277         if (put_user_u32(addrlen, target_addrlen_addr))
1278             ret = -TARGET_EFAULT;
1279     }
1280     return ret;
1281 }
1282
1283 /* do_socketpair() Must return target values and target errnos. */
1284 static abi_long do_socketpair(int domain, int type, int protocol,
1285                               abi_ulong target_tab_addr)
1286 {
1287     int tab[2];
1288     abi_long ret;
1289
1290     ret = get_errno(socketpair(domain, type, protocol, tab));
1291     if (!is_error(ret)) {
1292         if (put_user_s32(tab[0], target_tab_addr)
1293             || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
1294             ret = -TARGET_EFAULT;
1295     }
1296     return ret;
1297 }
1298
1299 /* do_sendto() Must return target values and target errnos. */
1300 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
1301                           abi_ulong target_addr, socklen_t addrlen)
1302 {
1303     void *addr;
1304     void *host_msg;
1305     abi_long ret;
1306
1307     host_msg = lock_user(VERIFY_READ, msg, len, 1);
1308     if (!host_msg)
1309         return -TARGET_EFAULT;
1310     if (target_addr) {
1311         addr = alloca(addrlen);
1312         target_to_host_sockaddr(addr, target_addr, addrlen);
1313         ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen));
1314     } else {
1315         ret = get_errno(send(fd, host_msg, len, flags));
1316     }
1317     unlock_user(host_msg, msg, 0);
1318     return ret;
1319 }
1320
1321 /* do_recvfrom() Must return target values and target errnos. */
1322 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
1323                             abi_ulong target_addr,
1324                             abi_ulong target_addrlen)
1325 {
1326     socklen_t addrlen;
1327     void *addr;
1328     void *host_msg;
1329     abi_long ret;
1330
1331     host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
1332     if (!host_msg)
1333         return -TARGET_EFAULT;
1334     if (target_addr) {
1335         if (get_user_u32(addrlen, target_addrlen)) {
1336             ret = -TARGET_EFAULT;
1337             goto fail;
1338         }
1339         addr = alloca(addrlen);
1340         ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen));
1341     } else {
1342         addr = NULL; /* To keep compiler quiet.  */
1343         ret = get_errno(recv(fd, host_msg, len, flags));
1344     }
1345     if (!is_error(ret)) {
1346         if (target_addr) {
1347             host_to_target_sockaddr(target_addr, addr, addrlen);
1348             if (put_user_u32(addrlen, target_addrlen)) {
1349                 ret = -TARGET_EFAULT;
1350                 goto fail;
1351             }
1352         }
1353         unlock_user(host_msg, msg, len);
1354     } else {
1355 fail:
1356         unlock_user(host_msg, msg, 0);
1357     }
1358     return ret;
1359 }
1360
1361 #ifdef TARGET_NR_socketcall
1362 /* do_socketcall() Must return target values and target errnos. */
1363 static abi_long do_socketcall(int num, abi_ulong vptr)
1364 {
1365     abi_long ret;
1366     const int n = sizeof(abi_ulong);
1367
1368     switch(num) {
1369     case SOCKOP_socket:
1370         {
1371             int domain, type, protocol;
1372
1373             if (get_user_s32(domain, vptr)
1374                 || get_user_s32(type, vptr + n)
1375                 || get_user_s32(protocol, vptr + 2 * n))
1376                 return -TARGET_EFAULT;
1377
1378             ret = do_socket(domain, type, protocol);
1379         }
1380         break;
1381     case SOCKOP_bind:
1382         {
1383             int sockfd;
1384             abi_ulong target_addr;
1385             socklen_t addrlen;
1386
1387             if (get_user_s32(sockfd, vptr)
1388                 || get_user_ual(target_addr, vptr + n)
1389                 || get_user_u32(addrlen, vptr + 2 * n))
1390                 return -TARGET_EFAULT;
1391
1392             ret = do_bind(sockfd, target_addr, addrlen);
1393         }
1394         break;
1395     case SOCKOP_connect:
1396         {
1397             int sockfd;
1398             abi_ulong target_addr;
1399             socklen_t addrlen;
1400
1401             if (get_user_s32(sockfd, vptr)
1402                 || get_user_ual(target_addr, vptr + n)
1403                 || get_user_u32(addrlen, vptr + 2 * n))
1404                 return -TARGET_EFAULT;
1405
1406             ret = do_connect(sockfd, target_addr, addrlen);
1407         }
1408         break;
1409     case SOCKOP_listen:
1410         {
1411             int sockfd, backlog;
1412
1413             if (get_user_s32(sockfd, vptr)
1414                 || get_user_s32(backlog, vptr + n))
1415                 return -TARGET_EFAULT;
1416
1417             ret = get_errno(listen(sockfd, backlog));
1418         }
1419         break;
1420     case SOCKOP_accept:
1421         {
1422             int sockfd;
1423             abi_ulong target_addr, target_addrlen;
1424
1425             if (get_user_s32(sockfd, vptr)
1426                 || get_user_ual(target_addr, vptr + n)
1427                 || get_user_u32(target_addrlen, vptr + 2 * n))
1428                 return -TARGET_EFAULT;
1429
1430             ret = do_accept(sockfd, target_addr, target_addrlen);
1431         }
1432         break;
1433     case SOCKOP_getsockname:
1434         {
1435             int sockfd;
1436             abi_ulong target_addr, target_addrlen;
1437
1438             if (get_user_s32(sockfd, vptr)
1439                 || get_user_ual(target_addr, vptr + n)
1440                 || get_user_u32(target_addrlen, vptr + 2 * n))
1441                 return -TARGET_EFAULT;
1442
1443             ret = do_getsockname(sockfd, target_addr, target_addrlen);
1444         }
1445         break;
1446     case SOCKOP_getpeername:
1447         {
1448             int sockfd;
1449             abi_ulong target_addr, target_addrlen;
1450
1451             if (get_user_s32(sockfd, vptr)
1452                 || get_user_ual(target_addr, vptr + n)
1453                 || get_user_u32(target_addrlen, vptr + 2 * n))
1454                 return -TARGET_EFAULT;
1455
1456             ret = do_getpeername(sockfd, target_addr, target_addrlen);
1457         }
1458         break;
1459     case SOCKOP_socketpair:
1460         {
1461             int domain, type, protocol;
1462             abi_ulong tab;
1463
1464             if (get_user_s32(domain, vptr)
1465                 || get_user_s32(type, vptr + n)
1466                 || get_user_s32(protocol, vptr + 2 * n)
1467                 || get_user_ual(tab, vptr + 3 * n))
1468                 return -TARGET_EFAULT;
1469
1470             ret = do_socketpair(domain, type, protocol, tab);
1471         }
1472         break;
1473     case SOCKOP_send:
1474         {
1475             int sockfd;
1476             abi_ulong msg;
1477             size_t len;
1478             int flags;
1479
1480             if (get_user_s32(sockfd, vptr)
1481                 || get_user_ual(msg, vptr + n)
1482                 || get_user_ual(len, vptr + 2 * n)
1483                 || get_user_s32(flags, vptr + 3 * n))
1484                 return -TARGET_EFAULT;
1485
1486             ret = do_sendto(sockfd, msg, len, flags, 0, 0);
1487         }
1488         break;
1489     case SOCKOP_recv:
1490         {
1491             int sockfd;
1492             abi_ulong msg;
1493             size_t len;
1494             int flags;
1495
1496             if (get_user_s32(sockfd, vptr)
1497                 || get_user_ual(msg, vptr + n)
1498                 || get_user_ual(len, vptr + 2 * n)
1499                 || get_user_s32(flags, vptr + 3 * n))
1500                 return -TARGET_EFAULT;
1501
1502             ret = do_recvfrom(sockfd, msg, len, flags, 0, 0);
1503         }
1504         break;
1505     case SOCKOP_sendto:
1506         {
1507             int sockfd;
1508             abi_ulong msg;
1509             size_t len;
1510             int flags;
1511             abi_ulong addr;
1512             socklen_t addrlen;
1513
1514             if (get_user_s32(sockfd, vptr)
1515                 || get_user_ual(msg, vptr + n)
1516                 || get_user_ual(len, vptr + 2 * n)
1517                 || get_user_s32(flags, vptr + 3 * n)
1518                 || get_user_ual(addr, vptr + 4 * n)
1519                 || get_user_u32(addrlen, vptr + 5 * n))
1520                 return -TARGET_EFAULT;
1521
1522             ret = do_sendto(sockfd, msg, len, flags, addr, addrlen);
1523         }
1524         break;
1525     case SOCKOP_recvfrom:
1526         {
1527             int sockfd;
1528             abi_ulong msg;
1529             size_t len;
1530             int flags;
1531             abi_ulong addr;
1532             socklen_t addrlen;
1533
1534             if (get_user_s32(sockfd, vptr)
1535                 || get_user_ual(msg, vptr + n)
1536                 || get_user_ual(len, vptr + 2 * n)
1537                 || get_user_s32(flags, vptr + 3 * n)
1538                 || get_user_ual(addr, vptr + 4 * n)
1539                 || get_user_u32(addrlen, vptr + 5 * n))
1540                 return -TARGET_EFAULT;
1541
1542             ret = do_recvfrom(sockfd, msg, len, flags, addr, addrlen);
1543         }
1544         break;
1545     case SOCKOP_shutdown:
1546         {
1547             int sockfd, how;
1548
1549             if (get_user_s32(sockfd, vptr)
1550                 || get_user_s32(how, vptr + n))
1551                 return -TARGET_EFAULT;
1552
1553             ret = get_errno(shutdown(sockfd, how));
1554         }
1555         break;
1556     case SOCKOP_sendmsg:
1557     case SOCKOP_recvmsg:
1558         {
1559             int fd;
1560             abi_ulong target_msg;
1561             int flags;
1562
1563             if (get_user_s32(fd, vptr)
1564                 || get_user_ual(target_msg, vptr + n)
1565                 || get_user_s32(flags, vptr + 2 * n))
1566                 return -TARGET_EFAULT;
1567
1568             ret = do_sendrecvmsg(fd, target_msg, flags,
1569                                  (num == SOCKOP_sendmsg));
1570         }
1571         break;
1572     case SOCKOP_setsockopt:
1573         {
1574             int sockfd;
1575             int level;
1576             int optname;
1577             abi_ulong optval;
1578             socklen_t optlen;
1579
1580             if (get_user_s32(sockfd, vptr)
1581                 || get_user_s32(level, vptr + n)
1582                 || get_user_s32(optname, vptr + 2 * n)
1583                 || get_user_ual(optval, vptr + 3 * n)
1584                 || get_user_u32(optlen, vptr + 4 * n))
1585                 return -TARGET_EFAULT;
1586
1587             ret = do_setsockopt(sockfd, level, optname, optval, optlen);
1588         }
1589         break;
1590     case SOCKOP_getsockopt:
1591         {
1592             int sockfd;
1593             int level;
1594             int optname;
1595             abi_ulong optval;
1596             socklen_t optlen;
1597
1598             if (get_user_s32(sockfd, vptr)
1599                 || get_user_s32(level, vptr + n)
1600                 || get_user_s32(optname, vptr + 2 * n)
1601                 || get_user_ual(optval, vptr + 3 * n)
1602                 || get_user_u32(optlen, vptr + 4 * n))
1603                 return -TARGET_EFAULT;
1604
1605             ret = do_getsockopt(sockfd, level, optname, optval, optlen);
1606         }
1607         break;
1608     default:
1609         gemu_log("Unsupported socketcall: %d\n", num);
1610         ret = -TARGET_ENOSYS;
1611         break;
1612     }
1613     return ret;
1614 }
1615 #endif
1616
1617 #ifdef TARGET_NR_ipc
1618 #define N_SHM_REGIONS   32
1619
1620 static struct shm_region {
1621     abi_ulong   start;
1622     abi_ulong   size;
1623 } shm_regions[N_SHM_REGIONS];
1624 #endif
1625
1626 struct target_ipc_perm
1627 {
1628     abi_long __key;
1629     abi_ulong uid;
1630     abi_ulong gid;
1631     abi_ulong cuid;
1632     abi_ulong cgid;
1633     unsigned short int mode;
1634     unsigned short int __pad1;
1635     unsigned short int __seq;
1636     unsigned short int __pad2;
1637     abi_ulong __unused1;
1638     abi_ulong __unused2;
1639 };
1640
1641 struct target_semid_ds
1642 {
1643   struct target_ipc_perm sem_perm;
1644   abi_ulong sem_otime;
1645   abi_ulong __unused1;
1646   abi_ulong sem_ctime;
1647   abi_ulong __unused2;
1648   abi_ulong sem_nsems;
1649   abi_ulong __unused3;
1650   abi_ulong __unused4;
1651 };
1652
1653 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
1654                                                abi_ulong target_addr)
1655 {
1656     struct target_ipc_perm *target_ip;
1657     struct target_semid_ds *target_sd;
1658
1659     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1660         return -TARGET_EFAULT;
1661     target_ip=&(target_sd->sem_perm);
1662     host_ip->__key = tswapl(target_ip->__key);
1663     host_ip->uid = tswapl(target_ip->uid);
1664     host_ip->gid = tswapl(target_ip->gid);
1665     host_ip->cuid = tswapl(target_ip->cuid);
1666     host_ip->cgid = tswapl(target_ip->cgid);
1667     host_ip->mode = tswapl(target_ip->mode);
1668     unlock_user_struct(target_sd, target_addr, 0);
1669     return 0;
1670 }
1671
1672 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
1673                                                struct ipc_perm *host_ip)
1674 {
1675     struct target_ipc_perm *target_ip;
1676     struct target_semid_ds *target_sd;
1677
1678     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1679         return -TARGET_EFAULT;
1680     target_ip = &(target_sd->sem_perm);
1681     target_ip->__key = tswapl(host_ip->__key);
1682     target_ip->uid = tswapl(host_ip->uid);
1683     target_ip->gid = tswapl(host_ip->gid);
1684     target_ip->cuid = tswapl(host_ip->cuid);
1685     target_ip->cgid = tswapl(host_ip->cgid);
1686     target_ip->mode = tswapl(host_ip->mode);
1687     unlock_user_struct(target_sd, target_addr, 1);
1688     return 0;
1689 }
1690
1691 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
1692                                                abi_ulong target_addr)
1693 {
1694     struct target_semid_ds *target_sd;
1695
1696     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1697         return -TARGET_EFAULT;
1698     target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1699     host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1700     host_sd->sem_otime = tswapl(target_sd->sem_otime);
1701     host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1702     unlock_user_struct(target_sd, target_addr, 0);
1703     return 0;
1704 }
1705
1706 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
1707                                                struct semid_ds *host_sd)
1708 {
1709     struct target_semid_ds *target_sd;
1710
1711     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1712         return -TARGET_EFAULT;
1713     host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1714     target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1715     target_sd->sem_otime = tswapl(host_sd->sem_otime);
1716     target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1717     unlock_user_struct(target_sd, target_addr, 1);
1718     return 0;
1719 }
1720
1721 union semun {
1722         int val;
1723         struct semid_ds *buf;
1724         unsigned short *array;
1725 };
1726
1727 union target_semun {
1728         int val;
1729         abi_long buf;
1730         unsigned short int *array;
1731 };
1732
1733 static inline abi_long target_to_host_semun(int cmd,
1734                                             union semun *host_su,
1735                                             abi_ulong target_addr,
1736                                             struct semid_ds *ds)
1737 {
1738     union target_semun *target_su;
1739
1740     switch( cmd ) {
1741         case IPC_STAT:
1742         case IPC_SET:
1743            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1744                return -TARGET_EFAULT;
1745            target_to_host_semid_ds(ds,target_su->buf);
1746            host_su->buf = ds;
1747            unlock_user_struct(target_su, target_addr, 0);
1748            break;
1749         case GETVAL:
1750         case SETVAL:
1751            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1752                return -TARGET_EFAULT;
1753            host_su->val = tswapl(target_su->val);
1754            unlock_user_struct(target_su, target_addr, 0);
1755            break;
1756         case GETALL:
1757         case SETALL:
1758            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1759                return -TARGET_EFAULT;
1760            *host_su->array = tswap16(*target_su->array);
1761            unlock_user_struct(target_su, target_addr, 0);
1762            break;
1763         default:
1764            gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1765     }
1766     return 0;
1767 }
1768
1769 static inline abi_long host_to_target_semun(int cmd,
1770                                             abi_ulong target_addr,
1771                                             union semun *host_su,
1772                                             struct semid_ds *ds)
1773 {
1774     union target_semun *target_su;
1775
1776     switch( cmd ) {
1777         case IPC_STAT:
1778         case IPC_SET:
1779            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1780                return -TARGET_EFAULT;
1781            host_to_target_semid_ds(target_su->buf,ds);
1782            unlock_user_struct(target_su, target_addr, 1);
1783            break;
1784         case GETVAL:
1785         case SETVAL:
1786            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1787                return -TARGET_EFAULT;
1788            target_su->val = tswapl(host_su->val);
1789            unlock_user_struct(target_su, target_addr, 1);
1790            break;
1791         case GETALL:
1792         case SETALL:
1793            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1794                return -TARGET_EFAULT;
1795            *target_su->array = tswap16(*host_su->array);
1796            unlock_user_struct(target_su, target_addr, 1);
1797            break;
1798         default:
1799            gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1800     }
1801     return 0;
1802 }
1803
1804 static inline abi_long do_semctl(int first, int second, int third,
1805                                  abi_long ptr)
1806 {
1807     union semun arg;
1808     struct semid_ds dsarg;
1809     int cmd = third&0xff;
1810     abi_long ret = 0;
1811
1812     switch( cmd ) {
1813         case GETVAL:
1814             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1815             ret = get_errno(semctl(first, second, cmd, arg));
1816             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1817             break;
1818         case SETVAL:
1819             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1820             ret = get_errno(semctl(first, second, cmd, arg));
1821             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1822             break;
1823         case GETALL:
1824             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1825             ret = get_errno(semctl(first, second, cmd, arg));
1826             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1827             break;
1828         case SETALL:
1829             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1830             ret = get_errno(semctl(first, second, cmd, arg));
1831             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1832             break;
1833         case IPC_STAT:
1834             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1835             ret = get_errno(semctl(first, second, cmd, arg));
1836             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1837             break;
1838         case IPC_SET:
1839             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1840             ret = get_errno(semctl(first, second, cmd, arg));
1841             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1842             break;
1843     default:
1844             ret = get_errno(semctl(first, second, cmd, arg));
1845     }
1846
1847     return ret;
1848 }
1849
1850 struct target_msqid_ds
1851 {
1852     struct target_ipc_perm msg_perm;
1853     abi_ulong msg_stime;
1854 #if TARGET_ABI_BITS == 32
1855     abi_ulong __unused1;
1856 #endif
1857     abi_ulong msg_rtime;
1858 #if TARGET_ABI_BITS == 32
1859     abi_ulong __unused2;
1860 #endif
1861     abi_ulong msg_ctime;
1862 #if TARGET_ABI_BITS == 32
1863     abi_ulong __unused3;
1864 #endif
1865     abi_ulong __msg_cbytes;
1866     abi_ulong msg_qnum;
1867     abi_ulong msg_qbytes;
1868     abi_ulong msg_lspid;
1869     abi_ulong msg_lrpid;
1870     abi_ulong __unused4;
1871     abi_ulong __unused5;
1872 };
1873
1874 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
1875                                                abi_ulong target_addr)
1876 {
1877     struct target_msqid_ds *target_md;
1878
1879     if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
1880         return -TARGET_EFAULT;
1881     if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
1882         return -TARGET_EFAULT;
1883     host_md->msg_stime = tswapl(target_md->msg_stime);
1884     host_md->msg_rtime = tswapl(target_md->msg_rtime);
1885     host_md->msg_ctime = tswapl(target_md->msg_ctime);
1886     host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1887     host_md->msg_qnum = tswapl(target_md->msg_qnum);
1888     host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1889     host_md->msg_lspid = tswapl(target_md->msg_lspid);
1890     host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1891     unlock_user_struct(target_md, target_addr, 0);
1892     return 0;
1893 }
1894
1895 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
1896                                                struct msqid_ds *host_md)
1897 {
1898     struct target_msqid_ds *target_md;
1899
1900     if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
1901         return -TARGET_EFAULT;
1902     if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
1903         return -TARGET_EFAULT;
1904     target_md->msg_stime = tswapl(host_md->msg_stime);
1905     target_md->msg_rtime = tswapl(host_md->msg_rtime);
1906     target_md->msg_ctime = tswapl(host_md->msg_ctime);
1907     target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1908     target_md->msg_qnum = tswapl(host_md->msg_qnum);
1909     target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1910     target_md->msg_lspid = tswapl(host_md->msg_lspid);
1911     target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1912     unlock_user_struct(target_md, target_addr, 1);
1913     return 0;
1914 }
1915
1916 struct target_msginfo {
1917     int msgpool;
1918     int msgmap;
1919     int msgmax;
1920     int msgmnb;
1921     int msgmni;
1922     int msgssz;
1923     int msgtql;
1924     unsigned short int msgseg;
1925 };
1926
1927 static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
1928                                               struct msginfo *host_msginfo)
1929 {
1930     struct target_msginfo *target_msginfo;
1931     if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
1932         return -TARGET_EFAULT;
1933     __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
1934     __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
1935     __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
1936     __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
1937     __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
1938     __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
1939     __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
1940     __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
1941     unlock_user_struct(target_msginfo, target_addr, 1);
1942     return 0;
1943 }
1944
1945 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
1946 {
1947     struct msqid_ds dsarg;
1948     struct msginfo msginfo;
1949     abi_long ret = -TARGET_EINVAL;
1950
1951     cmd &= 0xff;
1952
1953     switch (cmd) {
1954     case IPC_STAT:
1955     case IPC_SET:
1956     case MSG_STAT:
1957         if (target_to_host_msqid_ds(&dsarg,ptr))
1958             return -TARGET_EFAULT;
1959         ret = get_errno(msgctl(msgid, cmd, &dsarg));
1960         if (host_to_target_msqid_ds(ptr,&dsarg))
1961             return -TARGET_EFAULT;
1962         break;
1963     case IPC_RMID:
1964         ret = get_errno(msgctl(msgid, cmd, NULL));
1965         break;
1966     case IPC_INFO:
1967     case MSG_INFO:
1968         ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
1969         if (host_to_target_msginfo(ptr, &msginfo))
1970             return -TARGET_EFAULT;
1971         break;
1972     }
1973
1974     return ret;
1975 }
1976
1977 struct target_msgbuf {
1978     abi_long mtype;
1979     char        mtext[1];
1980 };
1981
1982 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
1983                                  unsigned int msgsz, int msgflg)
1984 {
1985     struct target_msgbuf *target_mb;
1986     struct msgbuf *host_mb;
1987     abi_long ret = 0;
1988
1989     if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
1990         return -TARGET_EFAULT;
1991     host_mb = malloc(msgsz+sizeof(long));
1992     host_mb->mtype = (abi_long) tswapl(target_mb->mtype);
1993     memcpy(host_mb->mtext, target_mb->mtext, msgsz);
1994     ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1995     free(host_mb);
1996     unlock_user_struct(target_mb, msgp, 0);
1997
1998     return ret;
1999 }
2000
2001 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
2002                                  unsigned int msgsz, abi_long msgtyp,
2003                                  int msgflg)
2004 {
2005     struct target_msgbuf *target_mb;
2006     char *target_mtext;
2007     struct msgbuf *host_mb;
2008     abi_long ret = 0;
2009
2010     if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
2011         return -TARGET_EFAULT;
2012
2013     host_mb = malloc(msgsz+sizeof(long));
2014     ret = get_errno(msgrcv(msqid, host_mb, msgsz, tswapl(msgtyp), msgflg));
2015
2016     if (ret > 0) {
2017         abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
2018         target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
2019         if (!target_mtext) {
2020             ret = -TARGET_EFAULT;
2021             goto end;
2022         }
2023         memcpy(target_mb->mtext, host_mb->mtext, ret);
2024         unlock_user(target_mtext, target_mtext_addr, ret);
2025     }
2026
2027     target_mb->mtype = tswapl(host_mb->mtype);
2028     free(host_mb);
2029
2030 end:
2031     if (target_mb)
2032         unlock_user_struct(target_mb, msgp, 1);
2033     return ret;
2034 }
2035
2036 #ifdef TARGET_NR_ipc
2037 /* ??? This only works with linear mappings.  */
2038 /* do_ipc() must return target values and target errnos. */
2039 static abi_long do_ipc(unsigned int call, int first,
2040                        int second, int third,
2041                        abi_long ptr, abi_long fifth)
2042 {
2043     int version;
2044     abi_long ret = 0;
2045     struct shmid_ds shm_info;
2046     int i;
2047
2048     version = call >> 16;
2049     call &= 0xffff;
2050
2051     switch (call) {
2052     case IPCOP_semop:
2053         ret = get_errno(semop(first,(struct sembuf *)g2h(ptr), second));
2054         break;
2055
2056     case IPCOP_semget:
2057         ret = get_errno(semget(first, second, third));
2058         break;
2059
2060     case IPCOP_semctl:
2061         ret = do_semctl(first, second, third, ptr);
2062         break;
2063
2064     case IPCOP_semtimedop:
2065         gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
2066         ret = -TARGET_ENOSYS;
2067         break;
2068
2069     case IPCOP_msgget:
2070         ret = get_errno(msgget(first, second));
2071         break;
2072
2073     case IPCOP_msgsnd:
2074         ret = do_msgsnd(first, ptr, second, third);
2075         break;
2076
2077     case IPCOP_msgctl:
2078         ret = do_msgctl(first, second, ptr);
2079         break;
2080
2081     case IPCOP_msgrcv:
2082         switch (version) {
2083         case 0:
2084             {
2085                 struct target_ipc_kludge {
2086                     abi_long msgp;
2087                     abi_long msgtyp;
2088                 } *tmp;
2089
2090                 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
2091                     ret = -TARGET_EFAULT;
2092                     break;
2093                 }
2094
2095                 ret = do_msgrcv(first, tmp->msgp, second, tmp->msgtyp, third);
2096
2097                 unlock_user_struct(tmp, ptr, 0);
2098                 break;
2099             }
2100         default:
2101             ret = do_msgrcv(first, ptr, second, fifth, third);
2102         }
2103         break;
2104
2105     case IPCOP_shmat:
2106         {
2107             abi_ulong raddr;
2108             void *host_addr;
2109             /* SHM_* flags are the same on all linux platforms */
2110             host_addr = shmat(first, (void *)g2h(ptr), second);
2111             if (host_addr == (void *)-1) {
2112                 ret = get_errno((long)host_addr);
2113                 break;
2114             }
2115             raddr = h2g((unsigned long)host_addr);
2116             /* find out the length of the shared memory segment */
2117
2118             ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
2119             if (is_error(ret)) {
2120                 /* can't get length, bail out */
2121                 shmdt(host_addr);
2122                 break;
2123             }
2124             page_set_flags(raddr, raddr + shm_info.shm_segsz,
2125                            PAGE_VALID | PAGE_READ |
2126                            ((second & SHM_RDONLY)? 0: PAGE_WRITE));
2127             for (i = 0; i < N_SHM_REGIONS; ++i) {
2128                 if (shm_regions[i].start == 0) {
2129                     shm_regions[i].start = raddr;
2130                     shm_regions[i].size = shm_info.shm_segsz;
2131                     break;
2132                 }
2133             }
2134             if (put_user_ual(raddr, third))
2135                 return -TARGET_EFAULT;
2136             ret = 0;
2137         }
2138         break;
2139     case IPCOP_shmdt:
2140         for (i = 0; i < N_SHM_REGIONS; ++i) {
2141             if (shm_regions[i].start == ptr) {
2142                 shm_regions[i].start = 0;
2143                 page_set_flags(ptr, shm_regions[i].size, 0);
2144                 break;
2145             }
2146         }
2147         ret = get_errno(shmdt((void *)g2h(ptr)));
2148         break;
2149
2150     case IPCOP_shmget:
2151         /* IPC_* flag values are the same on all linux platforms */
2152         ret = get_errno(shmget(first, second, third));
2153         break;
2154
2155         /* IPC_* and SHM_* command values are the same on all linux platforms */
2156     case IPCOP_shmctl:
2157         switch(second) {
2158         case IPC_RMID:
2159         case SHM_LOCK:
2160         case SHM_UNLOCK:
2161             ret = get_errno(shmctl(first, second, NULL));
2162             break;
2163         default:
2164             goto unimplemented;
2165         }
2166         break;
2167     default:
2168     unimplemented:
2169         gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
2170         ret = -TARGET_ENOSYS;
2171         break;
2172     }
2173     return ret;
2174 }
2175 #endif
2176
2177 /* kernel structure types definitions */
2178 #define IFNAMSIZ        16
2179
2180 #define STRUCT(name, list...) STRUCT_ ## name,
2181 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
2182 enum {
2183 #include "syscall_types.h"
2184 };
2185 #undef STRUCT
2186 #undef STRUCT_SPECIAL
2187
2188 #define STRUCT(name, list...) static const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2189 #define STRUCT_SPECIAL(name)
2190 #include "syscall_types.h"
2191 #undef STRUCT
2192 #undef STRUCT_SPECIAL
2193
2194 typedef struct IOCTLEntry {
2195     unsigned int target_cmd;
2196     unsigned int host_cmd;
2197     const char *name;
2198     int access;
2199     const argtype arg_type[5];
2200 } IOCTLEntry;
2201
2202 #define IOC_R 0x0001
2203 #define IOC_W 0x0002
2204 #define IOC_RW (IOC_R | IOC_W)
2205
2206 #define MAX_STRUCT_SIZE 4096
2207
2208 static IOCTLEntry ioctl_entries[] = {
2209 #define IOCTL(cmd, access, types...) \
2210     { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2211 #include "ioctls.h"
2212     { 0, 0, },
2213 };
2214
2215 /* ??? Implement proper locking for ioctls.  */
2216 /* do_ioctl() Must return target values and target errnos. */
2217 static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
2218 {
2219     const IOCTLEntry *ie;
2220     const argtype *arg_type;
2221     abi_long ret;
2222     uint8_t buf_temp[MAX_STRUCT_SIZE];
2223     int target_size;
2224     void *argptr;
2225
2226     ie = ioctl_entries;
2227     for(;;) {
2228         if (ie->target_cmd == 0) {
2229             gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
2230             return -TARGET_ENOSYS;
2231         }
2232         if (ie->target_cmd == cmd)
2233             break;
2234         ie++;
2235     }
2236     arg_type = ie->arg_type;
2237 #if defined(DEBUG)
2238     gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
2239 #endif
2240     switch(arg_type[0]) {
2241     case TYPE_NULL:
2242         /* no argument */
2243         ret = get_errno(ioctl(fd, ie->host_cmd));
2244         break;
2245     case TYPE_PTRVOID:
2246     case TYPE_INT:
2247         /* int argment */
2248         ret = get_errno(ioctl(fd, ie->host_cmd, arg));
2249         break;
2250     case TYPE_PTR:
2251         arg_type++;
2252         target_size = thunk_type_size(arg_type, 0);
2253         switch(ie->access) {
2254         case IOC_R:
2255             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2256             if (!is_error(ret)) {
2257                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2258                 if (!argptr)
2259                     return -TARGET_EFAULT;
2260                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2261                 unlock_user(argptr, arg, target_size);
2262             }
2263             break;
2264         case IOC_W:
2265             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2266             if (!argptr)
2267                 return -TARGET_EFAULT;
2268             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2269             unlock_user(argptr, arg, 0);
2270             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2271             break;
2272         default:
2273         case IOC_RW:
2274             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2275             if (!argptr)
2276                 return -TARGET_EFAULT;
2277             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2278             unlock_user(argptr, arg, 0);
2279             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2280             if (!is_error(ret)) {
2281                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2282                 if (!argptr)
2283                     return -TARGET_EFAULT;
2284                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2285                 unlock_user(argptr, arg, target_size);
2286             }
2287             break;
2288         }
2289         break;
2290     default:
2291         gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2292                  (long)cmd, arg_type[0]);
2293         ret = -TARGET_ENOSYS;
2294         break;
2295     }
2296     return ret;
2297 }
2298
2299 static const bitmask_transtbl iflag_tbl[] = {
2300         { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
2301         { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
2302         { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
2303         { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
2304         { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
2305         { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
2306         { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
2307         { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
2308         { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
2309         { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
2310         { TARGET_IXON, TARGET_IXON, IXON, IXON },
2311         { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
2312         { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
2313         { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
2314         { 0, 0, 0, 0 }
2315 };
2316
2317 static const bitmask_transtbl oflag_tbl[] = {
2318         { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
2319         { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
2320         { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
2321         { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
2322         { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
2323         { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
2324         { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
2325         { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
2326         { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
2327         { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
2328         { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
2329         { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
2330         { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
2331         { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
2332         { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
2333         { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
2334         { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
2335         { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
2336         { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
2337         { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
2338         { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
2339         { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
2340         { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
2341         { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
2342         { 0, 0, 0, 0 }
2343 };
2344
2345 static const bitmask_transtbl cflag_tbl[] = {
2346         { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
2347         { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
2348         { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
2349         { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
2350         { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
2351         { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
2352         { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
2353         { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
2354         { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
2355         { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
2356         { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
2357         { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
2358         { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
2359         { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
2360         { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
2361         { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
2362         { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
2363         { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
2364         { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
2365         { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
2366         { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
2367         { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
2368         { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
2369         { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
2370         { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
2371         { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
2372         { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
2373         { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
2374         { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
2375         { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
2376         { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
2377         { 0, 0, 0, 0 }
2378 };
2379
2380 static const bitmask_transtbl lflag_tbl[] = {
2381         { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
2382         { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
2383         { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
2384         { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
2385         { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
2386         { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
2387         { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
2388         { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
2389         { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
2390         { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
2391         { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
2392         { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
2393         { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
2394         { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
2395         { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
2396         { 0, 0, 0, 0 }
2397 };
2398
2399 static void target_to_host_termios (void *dst, const void *src)
2400 {
2401     struct host_termios *host = dst;
2402     const struct target_termios *target = src;
2403
2404     host->c_iflag =
2405         target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
2406     host->c_oflag =
2407         target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
2408     host->c_cflag =
2409         target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
2410     host->c_lflag =
2411         target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
2412     host->c_line = target->c_line;
2413
2414     host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
2415     host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
2416     host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
2417     host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
2418     host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
2419     host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
2420     host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
2421     host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
2422     host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
2423     host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
2424     host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
2425     host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
2426     host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
2427     host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
2428     host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
2429     host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
2430     host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
2431 }
2432
2433 static void host_to_target_termios (void *dst, const void *src)
2434 {
2435     struct target_termios *target = dst;
2436     const struct host_termios *host = src;
2437
2438     target->c_iflag =
2439         tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
2440     target->c_oflag =
2441         tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
2442     target->c_cflag =
2443         tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
2444     target->c_lflag =
2445         tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
2446     target->c_line = host->c_line;
2447
2448     target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
2449     target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
2450     target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
2451     target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
2452     target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
2453     target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
2454     target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
2455     target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
2456     target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
2457     target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
2458     target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
2459     target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
2460     target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
2461     target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
2462     target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
2463     target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
2464     target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
2465 }
2466
2467 static const StructEntry struct_termios_def = {
2468     .convert = { host_to_target_termios, target_to_host_termios },
2469     .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
2470     .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
2471 };
2472
2473 static bitmask_transtbl mmap_flags_tbl[] = {
2474         { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
2475         { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
2476         { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
2477         { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
2478         { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
2479         { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
2480         { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
2481         { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
2482         { 0, 0, 0, 0 }
2483 };
2484
2485 static bitmask_transtbl fcntl_flags_tbl[] = {
2486         { TARGET_O_ACCMODE,   TARGET_O_WRONLY,    O_ACCMODE,   O_WRONLY,    },
2487         { TARGET_O_ACCMODE,   TARGET_O_RDWR,      O_ACCMODE,   O_RDWR,      },
2488         { TARGET_O_CREAT,     TARGET_O_CREAT,     O_CREAT,     O_CREAT,     },
2489         { TARGET_O_EXCL,      TARGET_O_EXCL,      O_EXCL,      O_EXCL,      },
2490         { TARGET_O_NOCTTY,    TARGET_O_NOCTTY,    O_NOCTTY,    O_NOCTTY,    },
2491         { TARGET_O_TRUNC,     TARGET_O_TRUNC,     O_TRUNC,     O_TRUNC,     },
2492         { TARGET_O_APPEND,    TARGET_O_APPEND,    O_APPEND,    O_APPEND,    },
2493         { TARGET_O_NONBLOCK,  TARGET_O_NONBLOCK,  O_NONBLOCK,  O_NONBLOCK,  },
2494         { TARGET_O_SYNC,      TARGET_O_SYNC,      O_SYNC,      O_SYNC,      },
2495         { TARGET_FASYNC,      TARGET_FASYNC,      FASYNC,      FASYNC,      },
2496         { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
2497         { TARGET_O_NOFOLLOW,  TARGET_O_NOFOLLOW,  O_NOFOLLOW,  O_NOFOLLOW,  },
2498         { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
2499 #if defined(O_DIRECT)
2500         { TARGET_O_DIRECT,    TARGET_O_DIRECT,    O_DIRECT,    O_DIRECT,    },
2501 #endif
2502         { 0, 0, 0, 0 }
2503 };
2504
2505 #if defined(TARGET_I386)
2506
2507 /* NOTE: there is really one LDT for all the threads */
2508 static uint8_t *ldt_table;
2509
2510 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
2511 {
2512     int size;
2513     void *p;
2514
2515     if (!ldt_table)
2516         return 0;
2517     size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
2518     if (size > bytecount)
2519         size = bytecount;
2520     p = lock_user(VERIFY_WRITE, ptr, size, 0);
2521     if (!p)
2522         return -TARGET_EFAULT;
2523     /* ??? Should this by byteswapped?  */
2524     memcpy(p, ldt_table, size);
2525     unlock_user(p, ptr, size);
2526     return size;
2527 }
2528
2529 /* XXX: add locking support */
2530 static abi_long write_ldt(CPUX86State *env,
2531                           abi_ulong ptr, unsigned long bytecount, int oldmode)
2532 {
2533     struct target_modify_ldt_ldt_s ldt_info;
2534     struct target_modify_ldt_ldt_s *target_ldt_info;
2535     int seg_32bit, contents, read_exec_only, limit_in_pages;
2536     int seg_not_present, useable, lm;
2537     uint32_t *lp, entry_1, entry_2;
2538
2539     if (bytecount != sizeof(ldt_info))
2540         return -TARGET_EINVAL;
2541     if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
2542         return -TARGET_EFAULT;
2543     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2544     ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2545     ldt_info.limit = tswap32(target_ldt_info->limit);
2546     ldt_info.flags = tswap32(target_ldt_info->flags);
2547     unlock_user_struct(target_ldt_info, ptr, 0);
2548
2549     if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
2550         return -TARGET_EINVAL;
2551     seg_32bit = ldt_info.flags & 1;
2552     contents = (ldt_info.flags >> 1) & 3;
2553     read_exec_only = (ldt_info.flags >> 3) & 1;
2554     limit_in_pages = (ldt_info.flags >> 4) & 1;
2555     seg_not_present = (ldt_info.flags >> 5) & 1;
2556     useable = (ldt_info.flags >> 6) & 1;
2557 #ifdef TARGET_ABI32
2558     lm = 0;
2559 #else
2560     lm = (ldt_info.flags >> 7) & 1;
2561 #endif
2562     if (contents == 3) {
2563         if (oldmode)
2564             return -TARGET_EINVAL;
2565         if (seg_not_present == 0)
2566             return -TARGET_EINVAL;
2567     }
2568     /* allocate the LDT */
2569     if (!ldt_table) {
2570         env->ldt.base = target_mmap(0,
2571                                     TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
2572                                     PROT_READ|PROT_WRITE,
2573                                     MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
2574         if (env->ldt.base == -1)
2575             return -TARGET_ENOMEM;
2576         memset(g2h(env->ldt.base), 0,
2577                TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2578         env->ldt.limit = 0xffff;
2579         ldt_table = g2h(env->ldt.base);
2580     }
2581
2582     /* NOTE: same code as Linux kernel */
2583     /* Allow LDTs to be cleared by the user. */
2584     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2585         if (oldmode ||
2586             (contents == 0              &&
2587              read_exec_only == 1        &&
2588              seg_32bit == 0             &&
2589              limit_in_pages == 0        &&
2590              seg_not_present == 1       &&
2591              useable == 0 )) {
2592             entry_1 = 0;
2593             entry_2 = 0;
2594             goto install;
2595         }
2596     }
2597
2598     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2599         (ldt_info.limit & 0x0ffff);
2600     entry_2 = (ldt_info.base_addr & 0xff000000) |
2601         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2602         (ldt_info.limit & 0xf0000) |
2603         ((read_exec_only ^ 1) << 9) |
2604         (contents << 10) |
2605         ((seg_not_present ^ 1) << 15) |
2606         (seg_32bit << 22) |
2607         (limit_in_pages << 23) |
2608         (lm << 21) |
2609         0x7000;
2610     if (!oldmode)
2611         entry_2 |= (useable << 20);
2612
2613     /* Install the new entry ...  */
2614 install:
2615     lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
2616     lp[0] = tswap32(entry_1);
2617     lp[1] = tswap32(entry_2);
2618     return 0;
2619 }
2620
2621 /* specific and weird i386 syscalls */
2622 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
2623                               unsigned long bytecount)
2624 {
2625     abi_long ret;
2626
2627     switch (func) {
2628     case 0:
2629         ret = read_ldt(ptr, bytecount);
2630         break;
2631     case 1:
2632         ret = write_ldt(env, ptr, bytecount, 1);
2633         break;
2634     case 0x11:
2635         ret = write_ldt(env, ptr, bytecount, 0);
2636         break;
2637     default:
2638         ret = -TARGET_ENOSYS;
2639         break;
2640     }
2641     return ret;
2642 }
2643
2644 #if defined(TARGET_I386) && defined(TARGET_ABI32)
2645 static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
2646 {
2647     uint64_t *gdt_table = g2h(env->gdt.base);
2648     struct target_modify_ldt_ldt_s ldt_info;
2649     struct target_modify_ldt_ldt_s *target_ldt_info;
2650     int seg_32bit, contents, read_exec_only, limit_in_pages;
2651     int seg_not_present, useable, lm;
2652     uint32_t *lp, entry_1, entry_2;
2653     int i;
2654
2655     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2656     if (!target_ldt_info)
2657         return -TARGET_EFAULT;
2658     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2659     ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2660     ldt_info.limit = tswap32(target_ldt_info->limit);
2661     ldt_info.flags = tswap32(target_ldt_info->flags);
2662     if (ldt_info.entry_number == -1) {
2663         for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
2664             if (gdt_table[i] == 0) {
2665                 ldt_info.entry_number = i;
2666                 target_ldt_info->entry_number = tswap32(i);
2667                 break;
2668             }
2669         }
2670     }
2671     unlock_user_struct(target_ldt_info, ptr, 1);
2672
2673     if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
2674         ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
2675            return -TARGET_EINVAL;
2676     seg_32bit = ldt_info.flags & 1;
2677     contents = (ldt_info.flags >> 1) & 3;
2678     read_exec_only = (ldt_info.flags >> 3) & 1;
2679     limit_in_pages = (ldt_info.flags >> 4) & 1;
2680     seg_not_present = (ldt_info.flags >> 5) & 1;
2681     useable = (ldt_info.flags >> 6) & 1;
2682 #ifdef TARGET_ABI32
2683     lm = 0;
2684 #else
2685     lm = (ldt_info.flags >> 7) & 1;
2686 #endif
2687
2688     if (contents == 3) {
2689         if (seg_not_present == 0)
2690             return -TARGET_EINVAL;
2691     }
2692
2693     /* NOTE: same code as Linux kernel */
2694     /* Allow LDTs to be cleared by the user. */
2695     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2696         if ((contents == 0             &&
2697              read_exec_only == 1       &&
2698              seg_32bit == 0            &&
2699              limit_in_pages == 0       &&
2700              seg_not_present == 1      &&
2701              useable == 0 )) {
2702             entry_1 = 0;
2703             entry_2 = 0;
2704             goto install;
2705         }
2706     }
2707
2708     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2709         (ldt_info.limit & 0x0ffff);
2710     entry_2 = (ldt_info.base_addr & 0xff000000) |
2711         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2712         (ldt_info.limit & 0xf0000) |
2713         ((read_exec_only ^ 1) << 9) |
2714         (contents << 10) |
2715         ((seg_not_present ^ 1) << 15) |
2716         (seg_32bit << 22) |
2717         (limit_in_pages << 23) |
2718         (useable << 20) |
2719         (lm << 21) |
2720         0x7000;
2721
2722     /* Install the new entry ...  */
2723 install:
2724     lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
2725     lp[0] = tswap32(entry_1);
2726     lp[1] = tswap32(entry_2);
2727     return 0;
2728 }
2729
2730 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
2731 {
2732     struct target_modify_ldt_ldt_s *target_ldt_info;
2733     uint64_t *gdt_table = g2h(env->gdt.base);
2734     uint32_t base_addr, limit, flags;
2735     int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
2736     int seg_not_present, useable, lm;
2737     uint32_t *lp, entry_1, entry_2;
2738
2739     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2740     if (!target_ldt_info)
2741         return -TARGET_EFAULT;
2742     idx = tswap32(target_ldt_info->entry_number);
2743     if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
2744         idx > TARGET_GDT_ENTRY_TLS_MAX) {
2745         unlock_user_struct(target_ldt_info, ptr, 1);
2746         return -TARGET_EINVAL;
2747     }
2748     lp = (uint32_t *)(gdt_table + idx);
2749     entry_1 = tswap32(lp[0]);
2750     entry_2 = tswap32(lp[1]);
2751
2752     read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
2753     contents = (entry_2 >> 10) & 3;
2754     seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
2755     seg_32bit = (entry_2 >> 22) & 1;
2756     limit_in_pages = (entry_2 >> 23) & 1;
2757     useable = (entry_2 >> 20) & 1;
2758 #ifdef TARGET_ABI32
2759     lm = 0;
2760 #else
2761     lm = (entry_2 >> 21) & 1;
2762 #endif
2763     flags = (seg_32bit << 0) | (contents << 1) |
2764         (read_exec_only << 3) | (limit_in_pages << 4) |
2765         (seg_not_present << 5) | (useable << 6) | (lm << 7);
2766     limit = (entry_1 & 0xffff) | (entry_2  & 0xf0000);
2767     base_addr = (entry_1 >> 16) |
2768         (entry_2 & 0xff000000) |
2769         ((entry_2 & 0xff) << 16);
2770     target_ldt_info->base_addr = tswapl(base_addr);
2771     target_ldt_info->limit = tswap32(limit);
2772     target_ldt_info->flags = tswap32(flags);
2773     unlock_user_struct(target_ldt_info, ptr, 1);
2774     return 0;
2775 }
2776 #endif /* TARGET_I386 && TARGET_ABI32 */
2777
2778 #ifndef TARGET_ABI32
2779 static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
2780 {
2781     abi_long ret;
2782     abi_ulong val;
2783     int idx;
2784
2785     switch(code) {
2786     case TARGET_ARCH_SET_GS:
2787     case TARGET_ARCH_SET_FS:
2788         if (code == TARGET_ARCH_SET_GS)
2789             idx = R_GS;
2790         else
2791             idx = R_FS;
2792         cpu_x86_load_seg(env, idx, 0);
2793         env->segs[idx].base = addr;
2794         break;
2795     case TARGET_ARCH_GET_GS:
2796     case TARGET_ARCH_GET_FS:
2797         if (code == TARGET_ARCH_GET_GS)
2798             idx = R_GS;
2799         else
2800             idx = R_FS;
2801         val = env->segs[idx].base;
2802         if (put_user(val, addr, abi_ulong))
2803             return -TARGET_EFAULT;
2804         break;
2805     default:
2806         ret = -TARGET_EINVAL;
2807         break;
2808     }
2809     return 0;
2810 }
2811 #endif
2812
2813 #endif /* defined(TARGET_I386) */
2814
2815 #if defined(USE_NPTL)
2816
2817 #define NEW_STACK_SIZE PTHREAD_STACK_MIN
2818
2819 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
2820 typedef struct {
2821     CPUState *env;
2822     pthread_mutex_t mutex;
2823     pthread_cond_t cond;
2824     pthread_t thread;
2825     uint32_t tid;
2826     abi_ulong child_tidptr;
2827     abi_ulong parent_tidptr;
2828     sigset_t sigmask;
2829 } new_thread_info;
2830
2831 static void *clone_func(void *arg)
2832 {
2833     new_thread_info *info = arg;
2834     CPUState *env;
2835
2836     env = info->env;
2837     thread_env = env;
2838     info->tid = gettid();
2839     if (info->child_tidptr)
2840         put_user_u32(info->tid, info->child_tidptr);
2841     if (info->parent_tidptr)
2842         put_user_u32(info->tid, info->parent_tidptr);
2843     /* Enable signals.  */
2844     sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
2845     /* Signal to the parent that we're ready.  */
2846     pthread_mutex_lock(&info->mutex);
2847     pthread_cond_broadcast(&info->cond);
2848     pthread_mutex_unlock(&info->mutex);
2849     /* Wait until the parent has finshed initializing the tls state.  */
2850     pthread_mutex_lock(&clone_lock);
2851     pthread_mutex_unlock(&clone_lock);
2852     cpu_loop(env);
2853     /* never exits */
2854     return NULL;
2855 }
2856 #else
2857 /* this stack is the equivalent of the kernel stack associated with a
2858    thread/process */
2859 #define NEW_STACK_SIZE 8192
2860
2861 static int clone_func(void *arg)
2862 {
2863     CPUState *env = arg;
2864     cpu_loop(env);
2865     /* never exits */
2866     return 0;
2867 }
2868 #endif
2869
2870 /* do_fork() Must return host values and target errnos (unlike most
2871    do_*() functions). */
2872 static int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp,
2873                    abi_ulong parent_tidptr, target_ulong newtls,
2874                    abi_ulong child_tidptr)
2875 {
2876     int ret;
2877     TaskState *ts;
2878     uint8_t *new_stack;
2879     CPUState *new_env;
2880 #if defined(USE_NPTL)
2881     unsigned int nptl_flags;
2882     sigset_t sigmask;
2883 #endif
2884
2885     /* Emulate vfork() with fork() */
2886     if (flags & CLONE_VFORK)
2887         flags &= ~(CLONE_VFORK | CLONE_VM);
2888
2889     if (flags & CLONE_VM) {
2890 #if defined(USE_NPTL)
2891         new_thread_info info;
2892         pthread_attr_t attr;
2893 #endif
2894         ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
2895         init_task_state(ts);
2896         new_stack = ts->stack;
2897         /* we create a new CPU instance. */
2898         new_env = cpu_copy(env);
2899         /* Init regs that differ from the parent.  */
2900         cpu_clone_regs(new_env, newsp);
2901         new_env->opaque = ts;
2902 #if defined(USE_NPTL)
2903         nptl_flags = flags;
2904         flags &= ~CLONE_NPTL_FLAGS2;
2905
2906         /* TODO: Implement CLONE_CHILD_CLEARTID.  */
2907         if (nptl_flags & CLONE_SETTLS)
2908             cpu_set_tls (new_env, newtls);
2909
2910         /* Grab a mutex so that thread setup appears atomic.  */
2911         pthread_mutex_lock(&clone_lock);
2912
2913         memset(&info, 0, sizeof(info));
2914         pthread_mutex_init(&info.mutex, NULL);
2915         pthread_mutex_lock(&info.mutex);
2916         pthread_cond_init(&info.cond, NULL);
2917         info.env = new_env;
2918         if (nptl_flags & CLONE_CHILD_SETTID)
2919             info.child_tidptr = child_tidptr;
2920         if (nptl_flags & CLONE_PARENT_SETTID)
2921             info.parent_tidptr = parent_tidptr;
2922
2923         ret = pthread_attr_init(&attr);
2924         ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
2925         /* It is not safe to deliver signals until the child has finished
2926            initializing, so temporarily block all signals.  */
2927         sigfillset(&sigmask);
2928         sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
2929
2930         ret = pthread_create(&info.thread, &attr, clone_func, &info);
2931
2932         sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
2933         pthread_attr_destroy(&attr);
2934         if (ret == 0) {
2935             /* Wait for the child to initialize.  */
2936             pthread_cond_wait(&info.cond, &info.mutex);
2937             ret = info.tid;
2938             if (flags & CLONE_PARENT_SETTID)
2939                 put_user_u32(ret, parent_tidptr);
2940         } else {
2941             ret = -1;
2942         }
2943         pthread_mutex_unlock(&info.mutex);
2944         pthread_cond_destroy(&info.cond);
2945         pthread_mutex_destroy(&info.mutex);
2946         pthread_mutex_unlock(&clone_lock);
2947 #else
2948         if (flags & CLONE_NPTL_FLAGS2)
2949             return -EINVAL;
2950         /* This is probably going to die very quickly, but do it anyway.  */
2951 #ifdef __ia64__
2952         ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2953 #else
2954         ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2955 #endif
2956 #endif
2957     } else {
2958         /* if no CLONE_VM, we consider it is a fork */
2959         if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
2960             return -EINVAL;
2961         fork_start();
2962         ret = fork();
2963 #if defined(USE_NPTL)
2964         /* There is a race condition here.  The parent process could
2965            theoretically read the TID in the child process before the child
2966            tid is set.  This would require using either ptrace
2967            (not implemented) or having *_tidptr to point at a shared memory
2968            mapping.  We can't repeat the spinlock hack used above because
2969            the child process gets its own copy of the lock.  */
2970         if (ret == 0) {
2971             cpu_clone_regs(env, newsp);
2972             fork_end(1);
2973             /* Child Process.  */
2974             if (flags & CLONE_CHILD_SETTID)
2975                 put_user_u32(gettid(), child_tidptr);
2976             if (flags & CLONE_PARENT_SETTID)
2977                 put_user_u32(gettid(), parent_tidptr);
2978             ts = (TaskState *)env->opaque;
2979             if (flags & CLONE_SETTLS)
2980                 cpu_set_tls (env, newtls);
2981             /* TODO: Implement CLONE_CHILD_CLEARTID.  */
2982         } else {
2983             fork_end(0);
2984         }
2985 #else
2986         if (ret == 0) {
2987             cpu_clone_regs(env, newsp);
2988         }
2989 #endif
2990     }
2991     return ret;
2992 }
2993
2994 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
2995 {
2996     struct flock fl;
2997     struct target_flock *target_fl;
2998     struct flock64 fl64;
2999     struct target_flock64 *target_fl64;
3000     abi_long ret;
3001
3002     switch(cmd) {
3003     case TARGET_F_GETLK:
3004         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
3005             return -TARGET_EFAULT;
3006         fl.l_type = tswap16(target_fl->l_type);
3007         fl.l_whence = tswap16(target_fl->l_whence);
3008         fl.l_start = tswapl(target_fl->l_start);
3009         fl.l_len = tswapl(target_fl->l_len);
3010         fl.l_pid = tswapl(target_fl->l_pid);
3011         unlock_user_struct(target_fl, arg, 0);
3012         ret = get_errno(fcntl(fd, cmd, &fl));
3013         if (ret == 0) {
3014             if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0))
3015                 return -TARGET_EFAULT;
3016             target_fl->l_type = tswap16(fl.l_type);
3017             target_fl->l_whence = tswap16(fl.l_whence);
3018             target_fl->l_start = tswapl(fl.l_start);
3019             target_fl->l_len = tswapl(fl.l_len);
3020             target_fl->l_pid = tswapl(fl.l_pid);
3021             unlock_user_struct(target_fl, arg, 1);
3022         }
3023         break;
3024
3025     case TARGET_F_SETLK:
3026     case TARGET_F_SETLKW:
3027         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
3028             return -TARGET_EFAULT;
3029         fl.l_type = tswap16(target_fl->l_type);
3030         fl.l_whence = tswap16(target_fl->l_whence);
3031         fl.l_start = tswapl(target_fl->l_start);
3032         fl.l_len = tswapl(target_fl->l_len);
3033         fl.l_pid = tswapl(target_fl->l_pid);
3034         unlock_user_struct(target_fl, arg, 0);
3035         ret = get_errno(fcntl(fd, cmd, &fl));
3036         break;
3037
3038     case TARGET_F_GETLK64:
3039         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
3040             return -TARGET_EFAULT;
3041         fl64.l_type = tswap16(target_fl64->l_type) >> 1;
3042         fl64.l_whence = tswap16(target_fl64->l_whence);
3043         fl64.l_start = tswapl(target_fl64->l_start);
3044         fl64.l_len = tswapl(target_fl64->l_len);
3045         fl64.l_pid = tswap16(target_fl64->l_pid);
3046         unlock_user_struct(target_fl64, arg, 0);
3047         ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
3048         if (ret == 0) {
3049             if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0))
3050                 return -TARGET_EFAULT;
3051             target_fl64->l_type = tswap16(fl64.l_type) >> 1;
3052             target_fl64->l_whence = tswap16(fl64.l_whence);
3053             target_fl64->l_start = tswapl(fl64.l_start);
3054             target_fl64->l_len = tswapl(fl64.l_len);
3055             target_fl64->l_pid = tswapl(fl64.l_pid);
3056             unlock_user_struct(target_fl64, arg, 1);
3057         }
3058         break;
3059     case TARGET_F_SETLK64:
3060     case TARGET_F_SETLKW64:
3061         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
3062             return -TARGET_EFAULT;
3063         fl64.l_type = tswap16(target_fl64->l_type) >> 1;
3064         fl64.l_whence = tswap16(target_fl64->l_whence);
3065         fl64.l_start = tswapl(target_fl64->l_start);
3066         fl64.l_len = tswapl(target_fl64->l_len);
3067         fl64.l_pid = tswap16(target_fl64->l_pid);
3068         unlock_user_struct(target_fl64, arg, 0);
3069         ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
3070         break;
3071
3072     case F_GETFL:
3073         ret = get_errno(fcntl(fd, cmd, arg));
3074         if (ret >= 0) {
3075             ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
3076         }
3077         break;
3078
3079     case F_SETFL:
3080         ret = get_errno(fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl)));
3081         break;
3082
3083     default:
3084         ret = get_errno(fcntl(fd, cmd, arg));
3085         break;
3086     }
3087     return ret;
3088 }
3089
3090 #ifdef USE_UID16
3091
3092 static inline int high2lowuid(int uid)
3093 {
3094     if (uid > 65535)
3095         return 65534;
3096     else
3097         return uid;
3098 }
3099
3100 static inline int high2lowgid(int gid)
3101 {
3102     if (gid > 65535)
3103         return 65534;
3104     else
3105         return gid;
3106 }
3107
3108 static inline int low2highuid(int uid)
3109 {
3110     if ((int16_t)uid == -1)
3111         return -1;
3112     else
3113         return uid;
3114 }
3115
3116 static inline int low2highgid(int gid)
3117 {
3118     if ((int16_t)gid == -1)
3119         return -1;
3120     else
3121         return gid;
3122 }
3123
3124 #endif /* USE_UID16 */
3125
3126 void syscall_init(void)
3127 {
3128     IOCTLEntry *ie;
3129     const argtype *arg_type;
3130     int size;
3131     int i;
3132
3133 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3134 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
3135 #include "syscall_types.h"
3136 #undef STRUCT
3137 #undef STRUCT_SPECIAL
3138
3139     /* we patch the ioctl size if necessary. We rely on the fact that
3140        no ioctl has all the bits at '1' in the size field */
3141     ie = ioctl_entries;
3142     while (ie->target_cmd != 0) {
3143         if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
3144             TARGET_IOC_SIZEMASK) {
3145             arg_type = ie->arg_type;
3146             if (arg_type[0] != TYPE_PTR) {
3147                 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
3148                         ie->target_cmd);
3149                 exit(1);
3150             }
3151             arg_type++;
3152             size = thunk_type_size(arg_type, 0);
3153             ie->target_cmd = (ie->target_cmd &
3154                               ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
3155                 (size << TARGET_IOC_SIZESHIFT);
3156         }
3157
3158         /* Build target_to_host_errno_table[] table from
3159          * host_to_target_errno_table[]. */
3160         for (i=0; i < ERRNO_TABLE_SIZE; i++)
3161                 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
3162
3163         /* automatic consistency check if same arch */
3164 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
3165     (defined(__x86_64__) && defined(TARGET_X86_64))
3166         if (unlikely(ie->target_cmd != ie->host_cmd)) {
3167             fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
3168                     ie->name, ie->target_cmd, ie->host_cmd);
3169         }
3170 #endif
3171         ie++;
3172     }
3173 }
3174
3175 #if TARGET_ABI_BITS == 32
3176 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
3177 {
3178 #ifdef TARGET_WORDS_BIGENDIAN
3179     return ((uint64_t)word0 << 32) | word1;
3180 #else
3181     return ((uint64_t)word1 << 32) | word0;
3182 #endif
3183 }
3184 #else /* TARGET_ABI_BITS == 32 */
3185 static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
3186 {
3187     return word0;
3188 }
3189 #endif /* TARGET_ABI_BITS != 32 */
3190
3191 #ifdef TARGET_NR_truncate64
3192 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
3193                                          abi_long arg2,
3194                                          abi_long arg3,
3195                                          abi_long arg4)
3196 {
3197 #ifdef TARGET_ARM
3198     if (((CPUARMState *)cpu_env)->eabi)
3199       {
3200         arg2 = arg3;
3201         arg3 = arg4;
3202       }
3203 #endif
3204     return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
3205 }
3206 #endif
3207
3208 #ifdef TARGET_NR_ftruncate64
3209 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
3210                                           abi_long arg2,
3211                                           abi_long arg3,
3212                                           abi_long arg4)
3213 {
3214 #ifdef TARGET_ARM
3215     if (((CPUARMState *)cpu_env)->eabi)
3216       {
3217         arg2 = arg3;
3218         arg3 = arg4;
3219       }
3220 #endif
3221     return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
3222 }
3223 #endif
3224
3225 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
3226                                                abi_ulong target_addr)
3227 {
3228     struct target_timespec *target_ts;
3229
3230     if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
3231         return -TARGET_EFAULT;
3232     host_ts->tv_sec = tswapl(target_ts->tv_sec);
3233     host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
3234     unlock_user_struct(target_ts, target_addr, 0);
3235     return 0;
3236 }
3237
3238 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
3239                                                struct timespec *host_ts)
3240 {
3241     struct target_timespec *target_ts;
3242
3243     if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
3244         return -TARGET_EFAULT;
3245     target_ts->tv_sec = tswapl(host_ts->tv_sec);
3246     target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
3247     unlock_user_struct(target_ts, target_addr, 1);
3248     return 0;
3249 }
3250
3251 #ifdef TARGET_NR_stat64
3252 static inline abi_long host_to_target_stat64(void *cpu_env,
3253                                              abi_ulong target_addr,
3254                                              struct stat *host_st)
3255 {
3256 #ifdef TARGET_ARM
3257     if (((CPUARMState *)cpu_env)->eabi) {
3258         struct target_eabi_stat64 *target_st;
3259
3260         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3261             return -TARGET_EFAULT;
3262         memset(target_st, 0, sizeof(struct target_eabi_stat64));
3263         __put_user(host_st->st_dev, &target_st->st_dev);
3264         __put_user(host_st->st_ino, &target_st->st_ino);
3265 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3266         __put_user(host_st->st_ino, &target_st->__st_ino);
3267 #endif
3268         __put_user(host_st->st_mode, &target_st->st_mode);
3269         __put_user(host_st->st_nlink, &target_st->st_nlink);
3270         __put_user(host_st->st_uid, &target_st->st_uid);
3271         __put_user(host_st->st_gid, &target_st->st_gid);
3272         __put_user(host_st->st_rdev, &target_st->st_rdev);
3273         __put_user(host_st->st_size, &target_st->st_size);
3274         __put_user(host_st->st_blksize, &target_st->st_blksize);
3275         __put_user(host_st->st_blocks, &target_st->st_blocks);
3276         __put_user(host_st->st_atime, &target_st->target_st_atime);
3277         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3278         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3279         unlock_user_struct(target_st, target_addr, 1);
3280     } else
3281 #endif
3282     {
3283         struct target_stat64 *target_st;
3284
3285         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3286             return -TARGET_EFAULT;
3287         memset(target_st, 0, sizeof(struct target_stat64));
3288         __put_user(host_st->st_dev, &target_st->st_dev);
3289         __put_user(host_st->st_ino, &target_st->st_ino);
3290 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3291         __put_user(host_st->st_ino, &target_st->__st_ino);
3292 #endif
3293         __put_user(host_st->st_mode, &target_st->st_mode);
3294         __put_user(host_st->st_nlink, &target_st->st_nlink);
3295         __put_user(host_st->st_uid, &target_st->st_uid);
3296         __put_user(host_st->st_gid, &target_st->st_gid);
3297         __put_user(host_st->st_rdev, &target_st->st_rdev);
3298         /* XXX: better use of kernel struct */
3299         __put_user(host_st->st_size, &target_st->st_size);
3300         __put_user(host_st->st_blksize, &target_st->st_blksize);
3301         __put_user(host_st->st_blocks, &target_st->st_blocks);
3302         __put_user(host_st->st_atime, &target_st->target_st_atime);
3303         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3304         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3305         unlock_user_struct(target_st, target_addr, 1);
3306     }
3307
3308     return 0;
3309 }
3310 #endif
3311
3312 #if defined(USE_NPTL)
3313 /* ??? Using host futex calls even when target atomic operations
3314    are not really atomic probably breaks things.  However implementing
3315    futexes locally would make futexes shared between multiple processes
3316    tricky.  However they're probably useless because guest atomic
3317    operations won't work either.  */
3318 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
3319                     target_ulong uaddr2, int val3)
3320 {
3321     struct timespec ts, *pts;
3322
3323     /* ??? We assume FUTEX_* constants are the same on both host
3324        and target.  */
3325     switch (op) {
3326     case FUTEX_WAIT:
3327         if (timeout) {
3328             pts = &ts;
3329             target_to_host_timespec(pts, timeout);
3330         } else {
3331             pts = NULL;
3332         }
3333         return get_errno(sys_futex(g2h(uaddr), FUTEX_WAIT, tswap32(val),
3334                          pts, NULL, 0));
3335     case FUTEX_WAKE:
3336         return get_errno(sys_futex(g2h(uaddr), FUTEX_WAKE, val, NULL, NULL, 0));
3337     case FUTEX_FD:
3338         return get_errno(sys_futex(g2h(uaddr), FUTEX_FD, val, NULL, NULL, 0));
3339     case FUTEX_REQUEUE:
3340         return get_errno(sys_futex(g2h(uaddr), FUTEX_REQUEUE, val,
3341                          NULL, g2h(uaddr2), 0));
3342     case FUTEX_CMP_REQUEUE:
3343         return get_errno(sys_futex(g2h(uaddr), FUTEX_CMP_REQUEUE, val,
3344                          NULL, g2h(uaddr2), tswap32(val3)));
3345     default:
3346         return -TARGET_ENOSYS;
3347     }
3348 }
3349 #endif
3350
3351 int get_osversion(void)
3352 {
3353     static int osversion;
3354     struct new_utsname buf;
3355     const char *s;
3356     int i, n, tmp;
3357     if (osversion)
3358         return osversion;
3359     if (qemu_uname_release && *qemu_uname_release) {
3360         s = qemu_uname_release;
3361     } else {
3362         if (sys_uname(&buf))
3363             return 0;
3364         s = buf.release;
3365     }
3366     tmp = 0;
3367     for (i = 0; i < 3; i++) {
3368         n = 0;
3369         while (*s >= '0' && *s <= '9') {
3370             n *= 10;
3371             n += *s - '0';
3372             s++;
3373         }
3374         tmp = (tmp << 8) + n;
3375         if (*s == '.')
3376             s++;
3377     }
3378     osversion = tmp;
3379     return osversion;
3380 }
3381
3382 /* do_syscall() should always have a single exit point at the end so
3383    that actions, such as logging of syscall results, can be performed.
3384    All errnos that do_syscall() returns must be -TARGET_<errcode>. */
3385 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
3386                     abi_long arg2, abi_long arg3, abi_long arg4,
3387                     abi_long arg5, abi_long arg6)
3388 {
3389     abi_long ret;
3390     struct stat st;
3391     struct statfs stfs;
3392     void *p;
3393
3394 #ifdef DEBUG
3395     gemu_log("syscall %d", num);
3396 #endif
3397     if(do_strace)
3398         print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
3399
3400     switch(num) {
3401     case TARGET_NR_exit:
3402 #ifdef HAVE_GPROF
3403         _mcleanup();
3404 #endif
3405         gdb_exit(cpu_env, arg1);
3406         /* XXX: should free thread stack and CPU env */
3407         sys_exit(arg1);
3408         ret = 0; /* avoid warning */
3409         break;
3410     case TARGET_NR_read:
3411         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
3412             goto efault;
3413         ret = get_errno(read(arg1, p, arg3));
3414         unlock_user(p, arg2, ret);
3415         break;
3416     case TARGET_NR_write:
3417         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
3418             goto efault;
3419         ret = get_errno(write(arg1, p, arg3));
3420         unlock_user(p, arg2, 0);
3421         break;
3422     case TARGET_NR_open:
3423         if (!(p = lock_user_string(arg1)))
3424             goto efault;
3425         ret = get_errno(open(path(p),
3426                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
3427                              arg3));
3428         unlock_user(p, arg1, 0);
3429         break;
3430 #if defined(TARGET_NR_openat) && defined(__NR_openat)
3431     case TARGET_NR_openat:
3432         if (!(p = lock_user_string(arg2)))
3433             goto efault;
3434         ret = get_errno(sys_openat(arg1,
3435                                    path(p),
3436                                    target_to_host_bitmask(arg3, fcntl_flags_tbl),
3437                                    arg4));
3438         unlock_user(p, arg2, 0);
3439         break;
3440 #endif
3441     case TARGET_NR_close:
3442         ret = get_errno(close(arg1));
3443         break;
3444     case TARGET_NR_brk:
3445         ret = do_brk(arg1);
3446         break;
3447     case TARGET_NR_fork:
3448         ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
3449         break;
3450 #ifdef TARGET_NR_waitpid
3451     case TARGET_NR_waitpid:
3452         {
3453             int status;
3454             ret = get_errno(waitpid(arg1, &status, arg3));
3455             if (!is_error(ret) && arg2
3456                 && put_user_s32(status, arg2))
3457                 goto efault;
3458         }
3459         break;
3460 #endif
3461 #ifdef TARGET_NR_waitid
3462     case TARGET_NR_waitid:
3463         {
3464             siginfo_t info;
3465             info.si_pid = 0;
3466             ret = get_errno(waitid(arg1, arg2, &info, arg4));
3467             if (!is_error(ret) && arg3 && info.si_pid != 0) {
3468                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
3469                     goto efault;
3470                 host_to_target_siginfo(p, &info);
3471                 unlock_user(p, arg3, sizeof(target_siginfo_t));
3472             }
3473         }
3474         break;
3475 #endif
3476 #ifdef TARGET_NR_creat /* not on alpha */
3477     case TARGET_NR_creat:
3478         if (!(p = lock_user_string(arg1)))
3479             goto efault;
3480         ret = get_errno(creat(p, arg2));
3481         unlock_user(p, arg1, 0);
3482         break;
3483 #endif
3484     case TARGET_NR_link:
3485         {
3486             void * p2;
3487             p = lock_user_string(arg1);
3488             p2 = lock_user_string(arg2);
3489             if (!p || !p2)
3490                 ret = -TARGET_EFAULT;
3491             else
3492                 ret = get_errno(link(p, p2));
3493             unlock_user(p2, arg2, 0);
3494             unlock_user(p, arg1, 0);
3495         }
3496         break;
3497 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3498     case TARGET_NR_linkat:
3499         {
3500             void * p2 = NULL;
3501             if (!arg2 || !arg4)
3502                 goto efault;
3503             p  = lock_user_string(arg2);
3504             p2 = lock_user_string(arg4);
3505             if (!p || !p2)
3506                 ret = -TARGET_EFAULT;
3507             else
3508                 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
3509             unlock_user(p, arg2, 0);
3510             unlock_user(p2, arg4, 0);
3511         }
3512         break;
3513 #endif
3514     case TARGET_NR_unlink:
3515         if (!(p = lock_user_string(arg1)))
3516             goto efault;
3517         ret = get_errno(unlink(p));
3518         unlock_user(p, arg1, 0);
3519         break;
3520 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3521     case TARGET_NR_unlinkat:
3522         if (!(p = lock_user_string(arg2)))
3523             goto efault;
3524         ret = get_errno(sys_unlinkat(arg1, p, arg3));
3525         unlock_user(p, arg2, 0);
3526         break;
3527 #endif
3528     case TARGET_NR_execve:
3529         {
3530             char **argp, **envp;
3531             int argc, envc;
3532             abi_ulong gp;
3533             abi_ulong guest_argp;
3534             abi_ulong guest_envp;
3535             abi_ulong addr;
3536             char **q;
3537
3538             argc = 0;
3539             guest_argp = arg2;
3540             for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
3541                 if (get_user_ual(addr, gp))
3542                     goto efault;
3543                 if (!addr)
3544                     break;
3545                 argc++;
3546             }
3547             envc = 0;
3548             guest_envp = arg3;
3549             for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
3550                 if (get_user_ual(addr, gp))
3551                     goto efault;
3552                 if (!addr)
3553                     break;
3554                 envc++;
3555             }
3556
3557             argp = alloca((argc + 1) * sizeof(void *));
3558             envp = alloca((envc + 1) * sizeof(void *));
3559
3560             for (gp = guest_argp, q = argp; gp;
3561                   gp += sizeof(abi_ulong), q++) {
3562                 if (get_user_ual(addr, gp))
3563                     goto execve_efault;
3564                 if (!addr)
3565                     break;
3566                 if (!(*q = lock_user_string(addr)))
3567                     goto execve_efault;
3568             }
3569             *q = NULL;
3570
3571             for (gp = guest_envp, q = envp; gp;
3572                   gp += sizeof(abi_ulong), q++) {
3573                 if (get_user_ual(addr, gp))
3574                     goto execve_efault;
3575                 if (!addr)
3576                     break;
3577                 if (!(*q = lock_user_string(addr)))
3578                     goto execve_efault;
3579             }
3580             *q = NULL;
3581
3582             if (!(p = lock_user_string(arg1)))
3583                 goto execve_efault;
3584             ret = get_errno(execve(p, argp, envp));
3585             unlock_user(p, arg1, 0);
3586
3587             goto execve_end;
3588
3589         execve_efault:
3590             ret = -TARGET_EFAULT;
3591
3592         execve_end:
3593             for (gp = guest_argp, q = argp; *q;
3594                   gp += sizeof(abi_ulong), q++) {
3595                 if (get_user_ual(addr, gp)
3596                     || !addr)
3597                     break;
3598                 unlock_user(*q, addr, 0);
3599             }
3600             for (gp = guest_envp, q = envp; *q;
3601                   gp += sizeof(abi_ulong), q++) {
3602                 if (get_user_ual(addr, gp)
3603                     || !addr)
3604                     break;
3605                 unlock_user(*q, addr, 0);
3606             }
3607         }
3608         break;
3609     case TARGET_NR_chdir:
3610         if (!(p = lock_user_string(arg1)))
3611             goto efault;
3612         ret = get_errno(chdir(p));
3613         unlock_user(p, arg1, 0);
3614         break;
3615 #ifdef TARGET_NR_time
3616     case TARGET_NR_time:
3617         {
3618             time_t host_time;
3619             ret = get_errno(time(&host_time));
3620             if (!is_error(ret)
3621                 && arg1
3622                 && put_user_sal(host_time, arg1))
3623                 goto efault;
3624         }
3625         break;
3626 #endif
3627     case TARGET_NR_mknod:
3628         if (!(p = lock_user_string(arg1)))
3629             goto efault;
3630         ret = get_errno(mknod(p, arg2, arg3));
3631         unlock_user(p, arg1, 0);
3632         break;
3633 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3634     case TARGET_NR_mknodat:
3635         if (!(p = lock_user_string(arg2)))
3636             goto efault;
3637         ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
3638         unlock_user(p, arg2, 0);
3639         break;
3640 #endif
3641     case TARGET_NR_chmod:
3642         if (!(p = lock_user_string(arg1)))
3643             goto efault;
3644         ret = get_errno(chmod(p, arg2));
3645         unlock_user(p, arg1, 0);
3646         break;
3647 #ifdef TARGET_NR_break
3648     case TARGET_NR_break:
3649         goto unimplemented;
3650 #endif
3651 #ifdef TARGET_NR_oldstat
3652     case TARGET_NR_oldstat:
3653         goto unimplemented;
3654 #endif
3655     case TARGET_NR_lseek:
3656         ret = get_errno(lseek(arg1, arg2, arg3));
3657         break;
3658 #ifdef TARGET_NR_getxpid
3659     case TARGET_NR_getxpid:
3660 #else
3661     case TARGET_NR_getpid:
3662 #endif
3663         ret = get_errno(getpid());
3664         break;
3665     case TARGET_NR_mount:
3666                 {
3667                         /* need to look at the data field */
3668                         void *p2, *p3;
3669                         p = lock_user_string(arg1);
3670                         p2 = lock_user_string(arg2);
3671                         p3 = lock_user_string(arg3);
3672                         if (!p || !p2 || !p3)
3673                             ret = -TARGET_EFAULT;
3674                         else
3675                             /* FIXME - arg5 should be locked, but it isn't clear how to
3676                              * do that since it's not guaranteed to be a NULL-terminated
3677                              * string.
3678                              */
3679                             ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
3680                         unlock_user(p, arg1, 0);
3681                         unlock_user(p2, arg2, 0);
3682                         unlock_user(p3, arg3, 0);
3683                         break;
3684                 }
3685 #ifdef TARGET_NR_umount
3686     case TARGET_NR_umount:
3687         if (!(p = lock_user_string(arg1)))
3688             goto efault;
3689         ret = get_errno(umount(p));
3690         unlock_user(p, arg1, 0);
3691         break;
3692 #endif
3693 #ifdef TARGET_NR_stime /* not on alpha */
3694     case TARGET_NR_stime:
3695         {
3696             time_t host_time;
3697             if (get_user_sal(host_time, arg1))
3698                 goto efault;
3699             ret = get_errno(stime(&host_time));
3700         }
3701         break;
3702 #endif
3703     case TARGET_NR_ptrace:
3704         goto unimplemented;
3705 #ifdef TARGET_NR_alarm /* not on alpha */
3706     case TARGET_NR_alarm:
3707         ret = alarm(arg1);
3708         break;
3709 #endif
3710 #ifdef TARGET_NR_oldfstat
3711     case TARGET_NR_oldfstat:
3712         goto unimplemented;
3713 #endif
3714 #ifdef TARGET_NR_pause /* not on alpha */
3715     case TARGET_NR_pause:
3716         ret = get_errno(pause());
3717         break;
3718 #endif
3719 #ifdef TARGET_NR_utime
3720     case TARGET_NR_utime:
3721         {
3722             struct utimbuf tbuf, *host_tbuf;
3723             struct target_utimbuf *target_tbuf;
3724             if (arg2) {
3725                 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
3726                     goto efault;
3727                 tbuf.actime = tswapl(target_tbuf->actime);
3728                 tbuf.modtime = tswapl(target_tbuf->modtime);
3729                 unlock_user_struct(target_tbuf, arg2, 0);
3730                 host_tbuf = &tbuf;
3731             } else {
3732                 host_tbuf = NULL;
3733             }
3734             if (!(p = lock_user_string(arg1)))
3735                 goto efault;
3736             ret = get_errno(utime(p, host_tbuf));
3737             unlock_user(p, arg1, 0);
3738         }
3739         break;
3740 #endif
3741     case TARGET_NR_utimes:
3742         {
3743             struct timeval *tvp, tv[2];
3744             if (arg2) {
3745                 if (copy_from_user_timeval(&tv[0], arg2)
3746                     || copy_from_user_timeval(&tv[1],
3747                                               arg2 + sizeof(struct target_timeval)))
3748                     goto efault;
3749                 tvp = tv;
3750             } else {
3751                 tvp = NULL;
3752             }
3753             if (!(p = lock_user_string(arg1)))
3754                 goto efault;
3755             ret = get_errno(utimes(p, tvp));
3756             unlock_user(p, arg1, 0);
3757         }
3758         break;
3759 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
3760     case TARGET_NR_futimesat:
3761         {
3762             struct timeval *tvp, tv[2];
3763             if (arg3) {
3764                 if (copy_from_user_timeval(&tv[0], arg3)
3765                     || copy_from_user_timeval(&tv[1],
3766                                               arg3 + sizeof(struct target_timeval)))
3767                     goto efault;
3768                 tvp = tv;
3769             } else {
3770                 tvp = NULL;
3771             }
3772             if (!(p = lock_user_string(arg2)))
3773                 goto efault;
3774             ret = get_errno(sys_futimesat(arg1, path(p), tvp));
3775             unlock_user(p, arg2, 0);
3776         }
3777         break;
3778 #endif
3779 #ifdef TARGET_NR_stty
3780     case TARGET_NR_stty:
3781         goto unimplemented;
3782 #endif
3783 #ifdef TARGET_NR_gtty
3784     case TARGET_NR_gtty:
3785         goto unimplemented;
3786 #endif
3787     case TARGET_NR_access:
3788         if (!(p = lock_user_string(arg1)))
3789             goto efault;
3790         ret = get_errno(access(p, arg2));
3791         unlock_user(p, arg1, 0);
3792         break;
3793 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3794     case TARGET_NR_faccessat:
3795         if (!(p = lock_user_string(arg2)))
3796             goto efault;
3797         ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
3798         unlock_user(p, arg2, 0);
3799         break;
3800 #endif
3801 #ifdef TARGET_NR_nice /* not on alpha */
3802     case TARGET_NR_nice:
3803         ret = get_errno(nice(arg1));
3804         break;
3805 #endif
3806 #ifdef TARGET_NR_ftime
3807     case TARGET_NR_ftime:
3808         goto unimplemented;
3809 #endif
3810     case TARGET_NR_sync:
3811         sync();
3812         ret = 0;
3813         break;
3814     case TARGET_NR_kill:
3815         ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
3816         break;
3817     case TARGET_NR_rename:
3818         {
3819             void *p2;
3820             p = lock_user_string(arg1);
3821             p2 = lock_user_string(arg2);
3822             if (!p || !p2)
3823                 ret = -TARGET_EFAULT;
3824             else
3825                 ret = get_errno(rename(p, p2));
3826             unlock_user(p2, arg2, 0);
3827             unlock_user(p, arg1, 0);
3828         }
3829         break;
3830 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3831     case TARGET_NR_renameat:
3832         {
3833             void *p2;
3834             p  = lock_user_string(arg2);
3835             p2 = lock_user_string(arg4);
3836             if (!p || !p2)
3837                 ret = -TARGET_EFAULT;
3838             else
3839                 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
3840             unlock_user(p2, arg4, 0);
3841             unlock_user(p, arg2, 0);
3842         }
3843         break;
3844 #endif
3845     case TARGET_NR_mkdir:
3846         if (!(p = lock_user_string(arg1)))
3847             goto efault;
3848         ret = get_errno(mkdir(p, arg2));
3849         unlock_user(p, arg1, 0);
3850         break;
3851 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3852     case TARGET_NR_mkdirat:
3853         if (!(p = lock_user_string(arg2)))
3854             goto efault;
3855         ret = get_errno(sys_mkdirat(arg1, p, arg3));
3856         unlock_user(p, arg2, 0);
3857         break;
3858 #endif
3859     case TARGET_NR_rmdir:
3860         if (!(p = lock_user_string(arg1)))
3861             goto efault;
3862         ret = get_errno(rmdir(p));
3863         unlock_user(p, arg1, 0);
3864         break;
3865     case TARGET_NR_dup:
3866         ret = get_errno(dup(arg1));
3867         break;
3868     case TARGET_NR_pipe:
3869         {
3870             int host_pipe[2];
3871             ret = get_errno(pipe(host_pipe));
3872             if (!is_error(ret)) {
3873 #if defined(TARGET_MIPS)
3874                 CPUMIPSState *env = (CPUMIPSState*)cpu_env;
3875                 env->active_tc.gpr[3] = host_pipe[1];
3876                 ret = host_pipe[0];
3877 #elif defined(TARGET_SH4)
3878                 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
3879                 ret = host_pipe[0];
3880 #else
3881                 if (put_user_s32(host_pipe[0], arg1)
3882                     || put_user_s32(host_pipe[1], arg1 + sizeof(host_pipe[0])))
3883                     goto efault;
3884 #endif
3885             }
3886         }
3887         break;
3888     case TARGET_NR_times:
3889         {
3890             struct target_tms *tmsp;
3891             struct tms tms;
3892             ret = get_errno(times(&tms));
3893             if (arg1) {
3894                 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
3895                 if (!tmsp)
3896                     goto efault;
3897                 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
3898                 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
3899                 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
3900                 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
3901             }
3902             if (!is_error(ret))
3903                 ret = host_to_target_clock_t(ret);
3904         }
3905         break;
3906 #ifdef TARGET_NR_prof
3907     case TARGET_NR_prof:
3908         goto unimplemented;
3909 #endif
3910 #ifdef TARGET_NR_signal
3911     case TARGET_NR_signal:
3912         goto unimplemented;
3913 #endif
3914     case TARGET_NR_acct:
3915         if (!(p = lock_user_string(arg1)))
3916             goto efault;
3917         ret = get_errno(acct(path(p)));
3918         unlock_user(p, arg1, 0);
3919         break;
3920 #ifdef TARGET_NR_umount2 /* not on alpha */
3921     case TARGET_NR_umount2:
3922         if (!(p = lock_user_string(arg1)))
3923             goto efault;
3924         ret = get_errno(umount2(p, arg2));
3925         unlock_user(p, arg1, 0);
3926         break;
3927 #endif
3928 #ifdef TARGET_NR_lock
3929     case TARGET_NR_lock:
3930         goto unimplemented;
3931 #endif
3932     case TARGET_NR_ioctl:
3933         ret = do_ioctl(arg1, arg2, arg3);
3934         break;
3935     case TARGET_NR_fcntl:
3936         ret = do_fcntl(arg1, arg2, arg3);
3937         break;
3938 #ifdef TARGET_NR_mpx
3939     case TARGET_NR_mpx:
3940         goto unimplemented;
3941 #endif
3942     case TARGET_NR_setpgid:
3943         ret = get_errno(setpgid(arg1, arg2));
3944         break;
3945 #ifdef TARGET_NR_ulimit
3946     case TARGET_NR_ulimit:
3947         goto unimplemented;
3948 #endif
3949 #ifdef TARGET_NR_oldolduname
3950     case TARGET_NR_oldolduname:
3951         goto unimplemented;
3952 #endif
3953     case TARGET_NR_umask:
3954         ret = get_errno(umask(arg1));
3955         break;
3956     case TARGET_NR_chroot:
3957         if (!(p = lock_user_string(arg1)))
3958             goto efault;
3959         ret = get_errno(chroot(p));
3960         unlock_user(p, arg1, 0);
3961         break;
3962     case TARGET_NR_ustat:
3963         goto unimplemented;
3964     case TARGET_NR_dup2:
3965         ret = get_errno(dup2(arg1, arg2));
3966         break;
3967 #ifdef TARGET_NR_getppid /* not on alpha */
3968     case TARGET_NR_getppid:
3969         ret = get_errno(getppid());
3970         break;
3971 #endif
3972     case TARGET_NR_getpgrp:
3973         ret = get_errno(getpgrp());
3974         break;
3975     case TARGET_NR_setsid:
3976         ret = get_errno(setsid());
3977         break;
3978 #ifdef TARGET_NR_sigaction
3979     case TARGET_NR_sigaction:
3980         {
3981 #if !defined(TARGET_MIPS)
3982             struct target_old_sigaction *old_act;
3983             struct target_sigaction act, oact, *pact;
3984             if (arg2) {
3985                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3986                     goto efault;
3987                 act._sa_handler = old_act->_sa_handler;
3988                 target_siginitset(&act.sa_mask, old_act->sa_mask);
3989                 act.sa_flags = old_act->sa_flags;
3990                 act.sa_restorer = old_act->sa_restorer;
3991                 unlock_user_struct(old_act, arg2, 0);
3992                 pact = &act;
3993             } else {
3994                 pact = NULL;
3995             }
3996             ret = get_errno(do_sigaction(arg1, pact, &oact));
3997             if (!is_error(ret) && arg3) {
3998                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3999                     goto efault;
4000                 old_act->_sa_handler = oact._sa_handler;
4001                 old_act->sa_mask = oact.sa_mask.sig[0];
4002                 old_act->sa_flags = oact.sa_flags;
4003                 old_act->sa_restorer = oact.sa_restorer;
4004                 unlock_user_struct(old_act, arg3, 1);
4005             }
4006 #else
4007             struct target_sigaction act, oact, *pact, *old_act;
4008
4009             if (arg2) {
4010                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
4011                     goto efault;
4012                 act._sa_handler = old_act->_sa_handler;
4013                 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
4014                 act.sa_flags = old_act->sa_flags;
4015                 unlock_user_struct(old_act, arg2, 0);
4016                 pact = &act;
4017             } else {
4018                 pact = NULL;
4019             }
4020
4021             ret = get_errno(do_sigaction(arg1, pact, &oact));
4022
4023             if (!is_error(ret) && arg3) {
4024                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
4025                     goto efault;
4026                 old_act->_sa_handler = oact._sa_handler;
4027                 old_act->sa_flags = oact.sa_flags;
4028                 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
4029                 old_act->sa_mask.sig[1] = 0;
4030                 old_act->sa_mask.sig[2] = 0;
4031                 old_act->sa_mask.sig[3] = 0;
4032                 unlock_user_struct(old_act, arg3, 1);
4033             }
4034 #endif
4035         }
4036         break;
4037 #endif
4038     case TARGET_NR_rt_sigaction:
4039         {
4040             struct target_sigaction *act;
4041             struct target_sigaction *oact;
4042
4043             if (arg2) {
4044                 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
4045                     goto efault;
4046             } else
4047                 act = NULL;
4048             if (arg3) {
4049                 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
4050                     ret = -TARGET_EFAULT;
4051                     goto rt_sigaction_fail;
4052                 }
4053             } else
4054                 oact = NULL;
4055             ret = get_errno(do_sigaction(arg1, act, oact));
4056         rt_sigaction_fail:
4057             if (act)
4058                 unlock_user_struct(act, arg2, 0);
4059             if (oact)
4060                 unlock_user_struct(oact, arg3, 1);
4061         }
4062         break;
4063 #ifdef TARGET_NR_sgetmask /* not on alpha */
4064     case TARGET_NR_sgetmask:
4065         {
4066             sigset_t cur_set;
4067             abi_ulong target_set;
4068             sigprocmask(0, NULL, &cur_set);
4069             host_to_target_old_sigset(&target_set, &cur_set);
4070             ret = target_set;
4071         }
4072         break;
4073 #endif
4074 #ifdef TARGET_NR_ssetmask /* not on alpha */
4075     case TARGET_NR_ssetmask:
4076         {
4077             sigset_t set, oset, cur_set;
4078             abi_ulong target_set = arg1;
4079             sigprocmask(0, NULL, &cur_set);
4080             target_to_host_old_sigset(&set, &target_set);
4081             sigorset(&set, &set, &cur_set);
4082             sigprocmask(SIG_SETMASK, &set, &oset);
4083             host_to_target_old_sigset(&target_set, &oset);
4084             ret = target_set;
4085         }
4086         break;
4087 #endif
4088 #ifdef TARGET_NR_sigprocmask
4089     case TARGET_NR_sigprocmask:
4090         {
4091             int how = arg1;
4092             sigset_t set, oldset, *set_ptr;
4093
4094             if (arg2) {
4095                 switch(how) {
4096                 case TARGET_SIG_BLOCK:
4097                     how = SIG_BLOCK;
4098                     break;
4099                 case TARGET_SIG_UNBLOCK:
4100                     how = SIG_UNBLOCK;
4101                     break;
4102                 case TARGET_SIG_SETMASK:
4103                     how = SIG_SETMASK;
4104                     break;
4105                 default:
4106                     ret = -TARGET_EINVAL;
4107                     goto fail;
4108                 }
4109                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4110                     goto efault;
4111                 target_to_host_old_sigset(&set, p);
4112                 unlock_user(p, arg2, 0);
4113                 set_ptr = &set;
4114             } else {
4115                 how = 0;
4116                 set_ptr = NULL;
4117             }
4118             ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
4119             if (!is_error(ret) && arg3) {
4120                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4121                     goto efault;
4122                 host_to_target_old_sigset(p, &oldset);
4123                 unlock_user(p, arg3, sizeof(target_sigset_t));
4124             }
4125         }
4126         break;
4127 #endif
4128     case TARGET_NR_rt_sigprocmask:
4129         {
4130             int how = arg1;
4131             sigset_t set, oldset, *set_ptr;
4132
4133             if (arg2) {
4134                 switch(how) {
4135                 case TARGET_SIG_BLOCK:
4136                     how = SIG_BLOCK;
4137                     break;
4138                 case TARGET_SIG_UNBLOCK:
4139                     how = SIG_UNBLOCK;
4140                     break;
4141                 case TARGET_SIG_SETMASK:
4142                     how = SIG_SETMASK;
4143                     break;
4144                 default:
4145                     ret = -TARGET_EINVAL;
4146                     goto fail;
4147                 }
4148                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4149                     goto efault;
4150                 target_to_host_sigset(&set, p);
4151                 unlock_user(p, arg2, 0);
4152                 set_ptr = &set;
4153             } else {
4154                 how = 0;
4155                 set_ptr = NULL;
4156             }
4157             ret = get_errno(sigprocmask(how, set_ptr, &oldset));
4158             if (!is_error(ret) && arg3) {
4159                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4160                     goto efault;
4161                 host_to_target_sigset(p, &oldset);
4162                 unlock_user(p, arg3, sizeof(target_sigset_t));
4163             }
4164         }
4165         break;
4166 #ifdef TARGET_NR_sigpending
4167     case TARGET_NR_sigpending:
4168         {
4169             sigset_t set;
4170             ret = get_errno(sigpending(&set));
4171             if (!is_error(ret)) {
4172                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4173                     goto efault;
4174                 host_to_target_old_sigset(p, &set);
4175                 unlock_user(p, arg1, sizeof(target_sigset_t));
4176             }
4177         }
4178         break;
4179 #endif
4180     case TARGET_NR_rt_sigpending:
4181         {
4182             sigset_t set;
4183             ret = get_errno(sigpending(&set));
4184             if (!is_error(ret)) {
4185                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4186                     goto efault;
4187                 host_to_target_sigset(p, &set);
4188                 unlock_user(p, arg1, sizeof(target_sigset_t));
4189             }
4190         }
4191         break;
4192 #ifdef TARGET_NR_sigsuspend
4193     case TARGET_NR_sigsuspend:
4194         {
4195             sigset_t set;
4196             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4197                 goto efault;
4198             target_to_host_old_sigset(&set, p);
4199             unlock_user(p, arg1, 0);
4200             ret = get_errno(sigsuspend(&set));
4201         }
4202         break;
4203 #endif
4204     case TARGET_NR_rt_sigsuspend:
4205         {
4206             sigset_t set;
4207             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4208                 goto efault;
4209             target_to_host_sigset(&set, p);
4210             unlock_user(p, arg1, 0);
4211             ret = get_errno(sigsuspend(&set));
4212         }
4213         break;
4214     case TARGET_NR_rt_sigtimedwait:
4215         {
4216             sigset_t set;
4217             struct timespec uts, *puts;
4218             siginfo_t uinfo;
4219
4220             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4221                 goto efault;
4222             target_to_host_sigset(&set, p);
4223             unlock_user(p, arg1, 0);
4224             if (arg3) {
4225                 puts = &uts;
4226                 target_to_host_timespec(puts, arg3);
4227             } else {
4228                 puts = NULL;
4229             }
4230             ret = get_errno(sigtimedwait(&set, &uinfo, puts));
4231             if (!is_error(ret) && arg2) {
4232                 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
4233                     goto efault;
4234                 host_to_target_siginfo(p, &uinfo);
4235                 unlock_user(p, arg2, sizeof(target_siginfo_t));
4236             }
4237         }
4238         break;
4239     case TARGET_NR_rt_sigqueueinfo:
4240         {
4241             siginfo_t uinfo;
4242             if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
4243                 goto efault;
4244             target_to_host_siginfo(&uinfo, p);
4245             unlock_user(p, arg1, 0);
4246             ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
4247         }
4248         break;
4249 #ifdef TARGET_NR_sigreturn
4250     case TARGET_NR_sigreturn:
4251         /* NOTE: ret is eax, so not transcoding must be done */
4252         ret = do_sigreturn(cpu_env);
4253         break;
4254 #endif
4255     case TARGET_NR_rt_sigreturn:
4256         /* NOTE: ret is eax, so not transcoding must be done */
4257         ret = do_rt_sigreturn(cpu_env);
4258         break;
4259     case TARGET_NR_sethostname:
4260         if (!(p = lock_user_string(arg1)))
4261             goto efault;
4262         ret = get_errno(sethostname(p, arg2));
4263         unlock_user(p, arg1, 0);
4264         break;
4265     case TARGET_NR_setrlimit:
4266         {
4267             /* XXX: convert resource ? */
4268             int resource = arg1;
4269             struct target_rlimit *target_rlim;
4270             struct rlimit rlim;
4271             if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
4272                 goto efault;
4273             rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4274             rlim.rlim_max = tswapl(target_rlim->rlim_max);
4275             unlock_user_struct(target_rlim, arg2, 0);
4276             ret = get_errno(setrlimit(resource, &rlim));
4277         }
4278         break;
4279     case TARGET_NR_getrlimit:
4280         {
4281             /* XXX: convert resource ? */
4282             int resource = arg1;
4283             struct target_rlimit *target_rlim;
4284             struct rlimit rlim;
4285
4286             ret = get_errno(getrlimit(resource, &rlim));
4287             if (!is_error(ret)) {
4288                 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
4289                     goto efault;
4290                 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4291                 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4292                 unlock_user_struct(target_rlim, arg2, 1);
4293             }
4294         }
4295         break;
4296     case TARGET_NR_getrusage:
4297         {
4298             struct rusage rusage;
4299             ret = get_errno(getrusage(arg1, &rusage));
4300             if (!is_error(ret)) {
4301                 host_to_target_rusage(arg2, &rusage);
4302             }
4303         }
4304         break;
4305     case TARGET_NR_gettimeofday:
4306         {
4307             struct timeval tv;
4308             ret = get_errno(gettimeofday(&tv, NULL));
4309             if (!is_error(ret)) {
4310                 if (copy_to_user_timeval(arg1, &tv))
4311                     goto efault;
4312             }
4313         }
4314         break;
4315     case TARGET_NR_settimeofday:
4316         {
4317             struct timeval tv;
4318             if (copy_from_user_timeval(&tv, arg1))
4319                 goto efault;
4320             ret = get_errno(settimeofday(&tv, NULL));
4321         }
4322         break;
4323 #ifdef TARGET_NR_select
4324     case TARGET_NR_select:
4325         {
4326             struct target_sel_arg_struct *sel;
4327             abi_ulong inp, outp, exp, tvp;
4328             long nsel;
4329
4330             if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
4331                 goto efault;
4332             nsel = tswapl(sel->n);
4333             inp = tswapl(sel->inp);
4334             outp = tswapl(sel->outp);
4335             exp = tswapl(sel->exp);
4336             tvp = tswapl(sel->tvp);
4337             unlock_user_struct(sel, arg1, 0);
4338             ret = do_select(nsel, inp, outp, exp, tvp);
4339         }
4340         break;
4341 #endif
4342     case TARGET_NR_symlink:
4343         {
4344             void *p2;
4345             p = lock_user_string(arg1);
4346             p2 = lock_user_string(arg2);
4347             if (!p || !p2)
4348                 ret = -TARGET_EFAULT;
4349             else
4350                 ret = get_errno(symlink(p, p2));
4351             unlock_user(p2, arg2, 0);
4352             unlock_user(p, arg1, 0);
4353         }
4354         break;
4355 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4356     case TARGET_NR_symlinkat:
4357         {
4358             void *p2;
4359             p  = lock_user_string(arg1);
4360             p2 = lock_user_string(arg3);
4361             if (!p || !p2)
4362                 ret = -TARGET_EFAULT;
4363             else
4364                 ret = get_errno(sys_symlinkat(p, arg2, p2));
4365             unlock_user(p2, arg3, 0);
4366             unlock_user(p, arg1, 0);
4367         }
4368         break;
4369 #endif
4370 #ifdef TARGET_NR_oldlstat
4371     case TARGET_NR_oldlstat:
4372         goto unimplemented;
4373 #endif
4374     case TARGET_NR_readlink:
4375         {
4376             void *p2;
4377             p = lock_user_string(arg1);
4378             p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
4379             if (!p || !p2)
4380                 ret = -TARGET_EFAULT;
4381             else
4382                 ret = get_errno(readlink(path(p), p2, arg3));
4383             unlock_user(p2, arg2, ret);
4384             unlock_user(p, arg1, 0);
4385         }
4386         break;
4387 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4388     case TARGET_NR_readlinkat:
4389         {
4390             void *p2;
4391             p  = lock_user_string(arg2);
4392             p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
4393             if (!p || !p2)
4394                 ret = -TARGET_EFAULT;
4395             else
4396                 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
4397             unlock_user(p2, arg3, ret);
4398             unlock_user(p, arg2, 0);
4399         }
4400         break;
4401 #endif
4402 #ifdef TARGET_NR_uselib
4403     case TARGET_NR_uselib:
4404         goto unimplemented;
4405 #endif
4406 #ifdef TARGET_NR_swapon
4407     case TARGET_NR_swapon:
4408         if (!(p = lock_user_string(arg1)))
4409             goto efault;
4410         ret = get_errno(swapon(p, arg2));
4411         unlock_user(p, arg1, 0);
4412         break;
4413 #endif
4414     case TARGET_NR_reboot:
4415         goto unimplemented;
4416 #ifdef TARGET_NR_readdir
4417     case TARGET_NR_readdir:
4418         goto unimplemented;
4419 #endif
4420 #ifdef TARGET_NR_mmap
4421     case TARGET_NR_mmap:
4422 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
4423         {
4424             abi_ulong *v;
4425             abi_ulong v1, v2, v3, v4, v5, v6;
4426             if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
4427                 goto efault;
4428             v1 = tswapl(v[0]);
4429             v2 = tswapl(v[1]);
4430             v3 = tswapl(v[2]);
4431             v4 = tswapl(v[3]);
4432             v5 = tswapl(v[4]);
4433             v6 = tswapl(v[5]);
4434             unlock_user(v, arg1, 0);
4435             ret = get_errno(target_mmap(v1, v2, v3,
4436                                         target_to_host_bitmask(v4, mmap_flags_tbl),
4437                                         v5, v6));
4438         }
4439 #else
4440         ret = get_errno(target_mmap(arg1, arg2, arg3,
4441                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
4442                                     arg5,
4443                                     arg6));
4444 #endif
4445         break;
4446 #endif
4447 #ifdef TARGET_NR_mmap2
4448     case TARGET_NR_mmap2:
4449 #ifndef MMAP_SHIFT
4450 #define MMAP_SHIFT 12
4451 #endif
4452         ret = get_errno(target_mmap(arg1, arg2, arg3,
4453                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
4454                                     arg5,
4455                                     arg6 << MMAP_SHIFT));
4456         break;
4457 #endif
4458     case TARGET_NR_munmap:
4459         ret = get_errno(target_munmap(arg1, arg2));
4460         break;
4461     case TARGET_NR_mprotect:
4462         ret = get_errno(target_mprotect(arg1, arg2, arg3));
4463         break;
4464 #ifdef TARGET_NR_mremap
4465     case TARGET_NR_mremap:
4466         ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
4467         break;
4468 #endif
4469         /* ??? msync/mlock/munlock are broken for softmmu.  */
4470 #ifdef TARGET_NR_msync
4471     case TARGET_NR_msync:
4472         ret = get_errno(msync(g2h(arg1), arg2, arg3));
4473         break;
4474 #endif
4475 #ifdef TARGET_NR_mlock
4476     case TARGET_NR_mlock:
4477         ret = get_errno(mlock(g2h(arg1), arg2));
4478         break;
4479 #endif
4480 #ifdef TARGET_NR_munlock
4481     case TARGET_NR_munlock:
4482         ret = get_errno(munlock(g2h(arg1), arg2));
4483         break;
4484 #endif
4485 #ifdef TARGET_NR_mlockall
4486     case TARGET_NR_mlockall:
4487         ret = get_errno(mlockall(arg1));
4488         break;
4489 #endif
4490 #ifdef TARGET_NR_munlockall
4491     case TARGET_NR_munlockall:
4492         ret = get_errno(munlockall());
4493         break;
4494 #endif
4495     case TARGET_NR_truncate:
4496         if (!(p = lock_user_string(arg1)))
4497             goto efault;
4498         ret = get_errno(truncate(p, arg2));
4499         unlock_user(p, arg1, 0);
4500         break;
4501     case TARGET_NR_ftruncate:
4502         ret = get_errno(ftruncate(arg1, arg2));
4503         break;
4504     case TARGET_NR_fchmod:
4505         ret = get_errno(fchmod(arg1, arg2));
4506         break;
4507 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4508     case TARGET_NR_fchmodat:
4509         if (!(p = lock_user_string(arg2)))
4510             goto efault;
4511         ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4));
4512         unlock_user(p, arg2, 0);
4513         break;
4514 #endif
4515     case TARGET_NR_getpriority:
4516         /* libc does special remapping of the return value of
4517          * sys_getpriority() so it's just easiest to call
4518          * sys_getpriority() directly rather than through libc. */
4519         ret = sys_getpriority(arg1, arg2);
4520         break;
4521     case TARGET_NR_setpriority:
4522         ret = get_errno(setpriority(arg1, arg2, arg3));
4523         break;
4524 #ifdef TARGET_NR_profil
4525     case TARGET_NR_profil:
4526         goto unimplemented;
4527 #endif
4528     case TARGET_NR_statfs:
4529         if (!(p = lock_user_string(arg1)))
4530             goto efault;
4531         ret = get_errno(statfs(path(p), &stfs));
4532         unlock_user(p, arg1, 0);
4533     convert_statfs:
4534         if (!is_error(ret)) {
4535             struct target_statfs *target_stfs;
4536
4537             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
4538                 goto efault;
4539             __put_user(stfs.f_type, &target_stfs->f_type);
4540             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4541             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4542             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4543             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4544             __put_user(stfs.f_files, &target_stfs->f_files);
4545             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4546             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4547             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4548             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4549             unlock_user_struct(target_stfs, arg2, 1);
4550         }
4551         break;
4552     case TARGET_NR_fstatfs:
4553         ret = get_errno(fstatfs(arg1, &stfs));
4554         goto convert_statfs;
4555 #ifdef TARGET_NR_statfs64
4556     case TARGET_NR_statfs64:
4557         if (!(p = lock_user_string(arg1)))
4558             goto efault;
4559         ret = get_errno(statfs(path(p), &stfs));
4560         unlock_user(p, arg1, 0);
4561     convert_statfs64:
4562         if (!is_error(ret)) {
4563             struct target_statfs64 *target_stfs;
4564
4565             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
4566                 goto efault;
4567             __put_user(stfs.f_type, &target_stfs->f_type);
4568             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4569             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4570             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4571             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4572             __put_user(stfs.f_files, &target_stfs->f_files);
4573             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4574             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4575             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4576             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4577             unlock_user_struct(target_stfs, arg3, 1);
4578         }
4579         break;
4580     case TARGET_NR_fstatfs64:
4581         ret = get_errno(fstatfs(arg1, &stfs));
4582         goto convert_statfs64;
4583 #endif
4584 #ifdef TARGET_NR_ioperm
4585     case TARGET_NR_ioperm:
4586         goto unimplemented;
4587 #endif
4588 #ifdef TARGET_NR_socketcall
4589     case TARGET_NR_socketcall:
4590         ret = do_socketcall(arg1, arg2);
4591         break;
4592 #endif
4593 #ifdef TARGET_NR_accept
4594     case TARGET_NR_accept:
4595         ret = do_accept(arg1, arg2, arg3);
4596         break;
4597 #endif
4598 #ifdef TARGET_NR_bind
4599     case TARGET_NR_bind:
4600         ret = do_bind(arg1, arg2, arg3);
4601         break;
4602 #endif
4603 #ifdef TARGET_NR_connect
4604     case TARGET_NR_connect:
4605         ret = do_connect(arg1, arg2, arg3);
4606         break;
4607 #endif
4608 #ifdef TARGET_NR_getpeername
4609     case TARGET_NR_getpeername:
4610         ret = do_getpeername(arg1, arg2, arg3);
4611         break;
4612 #endif
4613 #ifdef TARGET_NR_getsockname
4614     case TARGET_NR_getsockname:
4615         ret = do_getsockname(arg1, arg2, arg3);
4616         break;
4617 #endif
4618 #ifdef TARGET_NR_getsockopt
4619     case TARGET_NR_getsockopt:
4620         ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
4621         break;
4622 #endif
4623 #ifdef TARGET_NR_listen
4624     case TARGET_NR_listen:
4625         ret = get_errno(listen(arg1, arg2));
4626         break;
4627 #endif
4628 #ifdef TARGET_NR_recv
4629     case TARGET_NR_recv:
4630         ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
4631         break;
4632 #endif
4633 #ifdef TARGET_NR_recvfrom
4634     case TARGET_NR_recvfrom:
4635         ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
4636         break;
4637 #endif
4638 #ifdef TARGET_NR_recvmsg
4639     case TARGET_NR_recvmsg:
4640         ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
4641         break;
4642 #endif
4643 #ifdef TARGET_NR_send
4644     case TARGET_NR_send:
4645         ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
4646         break;
4647 #endif
4648 #ifdef TARGET_NR_sendmsg
4649     case TARGET_NR_sendmsg:
4650         ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
4651         break;
4652 #endif
4653 #ifdef TARGET_NR_sendto
4654     case TARGET_NR_sendto:
4655         ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
4656         break;
4657 #endif
4658 #ifdef TARGET_NR_shutdown
4659     case TARGET_NR_shutdown:
4660         ret = get_errno(shutdown(arg1, arg2));
4661         break;
4662 #endif
4663 #ifdef TARGET_NR_socket
4664     case TARGET_NR_socket:
4665         ret = do_socket(arg1, arg2, arg3);
4666         break;
4667 #endif
4668 #ifdef TARGET_NR_socketpair
4669     case TARGET_NR_socketpair:
4670         ret = do_socketpair(arg1, arg2, arg3, arg4);
4671         break;
4672 #endif
4673 #ifdef TARGET_NR_setsockopt
4674     case TARGET_NR_setsockopt:
4675         ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
4676         break;
4677 #endif
4678
4679     case TARGET_NR_syslog:
4680         if (!(p = lock_user_string(arg2)))
4681             goto efault;
4682         ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
4683         unlock_user(p, arg2, 0);
4684         break;
4685
4686     case TARGET_NR_setitimer:
4687         {
4688             struct itimerval value, ovalue, *pvalue;
4689
4690             if (arg2) {
4691                 pvalue = &value;
4692                 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
4693                     || copy_from_user_timeval(&pvalue->it_value,
4694                                               arg2 + sizeof(struct target_timeval)))
4695                     goto efault;
4696             } else {
4697                 pvalue = NULL;
4698             }
4699             ret = get_errno(setitimer(arg1, pvalue, &ovalue));
4700             if (!is_error(ret) && arg3) {
4701                 if (copy_to_user_timeval(arg3,
4702                                          &ovalue.it_interval)
4703                     || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
4704                                             &ovalue.it_value))
4705                     goto efault;
4706             }
4707         }
4708         break;
4709     case TARGET_NR_getitimer:
4710         {
4711             struct itimerval value;
4712
4713             ret = get_errno(getitimer(arg1, &value));
4714             if (!is_error(ret) && arg2) {
4715                 if (copy_to_user_timeval(arg2,
4716                                          &value.it_interval)
4717                     || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
4718                                             &value.it_value))
4719                     goto efault;
4720             }
4721         }
4722         break;
4723     case TARGET_NR_stat:
4724         if (!(p = lock_user_string(arg1)))
4725             goto efault;
4726         ret = get_errno(stat(path(p), &st));
4727         unlock_user(p, arg1, 0);
4728         goto do_stat;
4729     case TARGET_NR_lstat:
4730         if (!(p = lock_user_string(arg1)))
4731             goto efault;
4732         ret = get_errno(lstat(path(p), &st));
4733         unlock_user(p, arg1, 0);
4734         goto do_stat;
4735     case TARGET_NR_fstat:
4736         {
4737             ret = get_errno(fstat(arg1, &st));
4738         do_stat:
4739             if (!is_error(ret)) {
4740                 struct target_stat *target_st;
4741
4742                 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
4743                     goto efault;
4744                 __put_user(st.st_dev, &target_st->st_dev);
4745                 __put_user(st.st_ino, &target_st->st_ino);
4746                 __put_user(st.st_mode, &target_st->st_mode);
4747                 __put_user(st.st_uid, &target_st->st_uid);
4748                 __put_user(st.st_gid, &target_st->st_gid);
4749                 __put_user(st.st_nlink, &target_st->st_nlink);
4750                 __put_user(st.st_rdev, &target_st->st_rdev);
4751                 __put_user(st.st_size, &target_st->st_size);
4752                 __put_user(st.st_blksize, &target_st->st_blksize);
4753                 __put_user(st.st_blocks, &target_st->st_blocks);
4754                 __put_user(st.st_atime, &target_st->target_st_atime);
4755                 __put_user(st.st_mtime, &target_st->target_st_mtime);
4756                 __put_user(st.st_ctime, &target_st->target_st_ctime);
4757                 unlock_user_struct(target_st, arg2, 1);
4758             }
4759         }
4760         break;
4761 #ifdef TARGET_NR_olduname
4762     case TARGET_NR_olduname:
4763         goto unimplemented;
4764 #endif
4765 #ifdef TARGET_NR_iopl
4766     case TARGET_NR_iopl:
4767         goto unimplemented;
4768 #endif
4769     case TARGET_NR_vhangup:
4770         ret = get_errno(vhangup());
4771         break;
4772 #ifdef TARGET_NR_idle
4773     case TARGET_NR_idle:
4774         goto unimplemented;
4775 #endif
4776 #ifdef TARGET_NR_syscall
4777     case TARGET_NR_syscall:
4778         ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
4779         break;
4780 #endif
4781     case TARGET_NR_wait4:
4782         {
4783             int status;
4784             abi_long status_ptr = arg2;
4785             struct rusage rusage, *rusage_ptr;
4786             abi_ulong target_rusage = arg4;
4787             if (target_rusage)
4788                 rusage_ptr = &rusage;
4789             else
4790                 rusage_ptr = NULL;
4791             ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
4792             if (!is_error(ret)) {
4793                 if (status_ptr) {
4794                     if (put_user_s32(status, status_ptr))
4795                         goto efault;
4796                 }
4797                 if (target_rusage)
4798                     host_to_target_rusage(target_rusage, &rusage);
4799             }
4800         }
4801         break;
4802 #ifdef TARGET_NR_swapoff
4803     case TARGET_NR_swapoff:
4804         if (!(p = lock_user_string(arg1)))
4805             goto efault;
4806         ret = get_errno(swapoff(p));
4807         unlock_user(p, arg1, 0);
4808         break;
4809 #endif
4810     case TARGET_NR_sysinfo:
4811         {
4812             struct target_sysinfo *target_value;
4813             struct sysinfo value;
4814             ret = get_errno(sysinfo(&value));
4815             if (!is_error(ret) && arg1)
4816             {
4817                 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
4818                     goto efault;
4819                 __put_user(value.uptime, &target_value->uptime);
4820                 __put_user(value.loads[0], &target_value->loads[0]);
4821                 __put_user(value.loads[1], &target_value->loads[1]);
4822                 __put_user(value.loads[2], &target_value->loads[2]);
4823                 __put_user(value.totalram, &target_value->totalram);
4824                 __put_user(value.freeram, &target_value->freeram);
4825                 __put_user(value.sharedram, &target_value->sharedram);
4826                 __put_user(value.bufferram, &target_value->bufferram);
4827                 __put_user(value.totalswap, &target_value->totalswap);
4828                 __put_user(value.freeswap, &target_value->freeswap);
4829                 __put_user(value.procs, &target_value->procs);
4830                 __put_user(value.totalhigh, &target_value->totalhigh);
4831                 __put_user(value.freehigh, &target_value->freehigh);
4832                 __put_user(value.mem_unit, &target_value->mem_unit);
4833                 unlock_user_struct(target_value, arg1, 1);
4834             }
4835         }
4836         break;
4837 #ifdef TARGET_NR_ipc
4838     case TARGET_NR_ipc:
4839         ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
4840         break;
4841 #endif
4842
4843 #ifdef TARGET_NR_msgctl
4844     case TARGET_NR_msgctl:
4845         ret = do_msgctl(arg1, arg2, arg3);
4846         break;
4847 #endif
4848 #ifdef TARGET_NR_msgget
4849     case TARGET_NR_msgget:
4850         ret = get_errno(msgget(arg1, arg2));
4851         break;
4852 #endif
4853 #ifdef TARGET_NR_msgrcv
4854     case TARGET_NR_msgrcv:
4855         ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
4856         break;
4857 #endif
4858 #ifdef TARGET_NR_msgsnd
4859     case TARGET_NR_msgsnd:
4860         ret = do_msgsnd(arg1, arg2, arg3, arg4);
4861         break;
4862 #endif
4863     case TARGET_NR_fsync:
4864         ret = get_errno(fsync(arg1));
4865         break;
4866     case TARGET_NR_clone:
4867 #if defined(TARGET_SH4)
4868         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
4869 #else
4870         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
4871 #endif
4872         break;
4873 #ifdef __NR_exit_group
4874         /* new thread calls */
4875     case TARGET_NR_exit_group:
4876 #ifdef HAVE_GPROF
4877         _mcleanup();
4878 #endif
4879         gdb_exit(cpu_env, arg1);
4880         ret = get_errno(exit_group(arg1));
4881         break;
4882 #endif
4883     case TARGET_NR_setdomainname:
4884         if (!(p = lock_user_string(arg1)))
4885             goto efault;
4886         ret = get_errno(setdomainname(p, arg2));
4887         unlock_user(p, arg1, 0);
4888         break;
4889     case TARGET_NR_uname:
4890         /* no need to transcode because we use the linux syscall */
4891         {
4892             struct new_utsname * buf;
4893
4894             if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
4895                 goto efault;
4896             ret = get_errno(sys_uname(buf));
4897             if (!is_error(ret)) {
4898                 /* Overrite the native machine name with whatever is being
4899                    emulated. */
4900                 strcpy (buf->machine, UNAME_MACHINE);
4901                 /* Allow the user to override the reported release.  */
4902                 if (qemu_uname_release && *qemu_uname_release)
4903                   strcpy (buf->release, qemu_uname_release);
4904             }
4905             unlock_user_struct(buf, arg1, 1);
4906         }
4907         break;
4908 #ifdef TARGET_I386
4909     case TARGET_NR_modify_ldt:
4910         ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
4911         break;
4912 #if !defined(TARGET_X86_64)
4913     case TARGET_NR_vm86old:
4914         goto unimplemented;
4915     case TARGET_NR_vm86:
4916         ret = do_vm86(cpu_env, arg1, arg2);
4917         break;
4918 #endif
4919 #endif
4920     case TARGET_NR_adjtimex:
4921         goto unimplemented;
4922 #ifdef TARGET_NR_create_module
4923     case TARGET_NR_create_module:
4924 #endif
4925     case TARGET_NR_init_module:
4926     case TARGET_NR_delete_module:
4927 #ifdef TARGET_NR_get_kernel_syms
4928     case TARGET_NR_get_kernel_syms:
4929 #endif
4930         goto unimplemented;
4931     case TARGET_NR_quotactl:
4932         goto unimplemented;
4933     case TARGET_NR_getpgid:
4934         ret = get_errno(getpgid(arg1));
4935         break;
4936     case TARGET_NR_fchdir:
4937         ret = get_errno(fchdir(arg1));
4938         break;
4939 #ifdef TARGET_NR_bdflush /* not on x86_64 */
4940     case TARGET_NR_bdflush:
4941         goto unimplemented;
4942 #endif
4943 #ifdef TARGET_NR_sysfs
4944     case TARGET_NR_sysfs:
4945         goto unimplemented;
4946 #endif
4947     case TARGET_NR_personality:
4948         ret = get_errno(personality(arg1));
4949         break;
4950 #ifdef TARGET_NR_afs_syscall
4951     case TARGET_NR_afs_syscall:
4952         goto unimplemented;
4953 #endif
4954 #ifdef TARGET_NR__llseek /* Not on alpha */
4955     case TARGET_NR__llseek:
4956         {
4957 #if defined (__x86_64__)
4958             ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
4959             if (put_user_s64(ret, arg4))
4960                 goto efault;
4961 #else
4962             int64_t res;
4963             ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
4964             if (put_user_s64(res, arg4))
4965                 goto efault;
4966 #endif
4967         }
4968         break;
4969 #endif
4970     case TARGET_NR_getdents:
4971 #if TARGET_ABI_BITS != 32
4972         goto unimplemented;
4973 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4974         {
4975             struct target_dirent *target_dirp;
4976             struct linux_dirent *dirp;
4977             abi_long count = arg3;
4978
4979             dirp = malloc(count);
4980             if (!dirp) {
4981                 ret = -TARGET_ENOMEM;
4982                 goto fail;
4983             }
4984
4985             ret = get_errno(sys_getdents(arg1, dirp, count));
4986             if (!is_error(ret)) {
4987                 struct linux_dirent *de;
4988                 struct target_dirent *tde;
4989                 int len = ret;
4990                 int reclen, treclen;
4991                 int count1, tnamelen;
4992
4993                 count1 = 0;
4994                 de = dirp;
4995                 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4996                     goto efault;
4997                 tde = target_dirp;
4998                 while (len > 0) {
4999                     reclen = de->d_reclen;
5000                     treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
5001                     tde->d_reclen = tswap16(treclen);
5002                     tde->d_ino = tswapl(de->d_ino);
5003                     tde->d_off = tswapl(de->d_off);
5004                     tnamelen = treclen - (2 * sizeof(abi_long) + 2);
5005                     if (tnamelen > 256)
5006                         tnamelen = 256;
5007                     /* XXX: may not be correct */
5008                     pstrcpy(tde->d_name, tnamelen, de->d_name);
5009                     de = (struct linux_dirent *)((char *)de + reclen);
5010                     len -= reclen;
5011                     tde = (struct target_dirent *)((char *)tde + treclen);
5012                     count1 += treclen;
5013                 }
5014                 ret = count1;
5015                 unlock_user(target_dirp, arg2, ret);
5016             }
5017             free(dirp);
5018         }
5019 #else
5020         {
5021             struct linux_dirent *dirp;
5022             abi_long count = arg3;
5023
5024             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5025                 goto efault;
5026             ret = get_errno(sys_getdents(arg1, dirp, count));
5027             if (!is_error(ret)) {
5028                 struct linux_dirent *de;
5029                 int len = ret;
5030                 int reclen;
5031                 de = dirp;
5032                 while (len > 0) {
5033                     reclen = de->d_reclen;
5034                     if (reclen > len)
5035                         break;
5036                     de->d_reclen = tswap16(reclen);
5037                     tswapls(&de->d_ino);
5038                     tswapls(&de->d_off);
5039                     de = (struct linux_dirent *)((char *)de + reclen);
5040                     len -= reclen;
5041                 }
5042             }
5043             unlock_user(dirp, arg2, ret);
5044         }
5045 #endif
5046         break;
5047 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
5048     case TARGET_NR_getdents64:
5049         {
5050             struct linux_dirent64 *dirp;
5051             abi_long count = arg3;
5052             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5053                 goto efault;
5054             ret = get_errno(sys_getdents64(arg1, dirp, count));
5055             if (!is_error(ret)) {
5056                 struct linux_dirent64 *de;
5057                 int len = ret;
5058                 int reclen;
5059                 de = dirp;
5060                 while (len > 0) {
5061                     reclen = de->d_reclen;
5062                     if (reclen > len)
5063                         break;
5064                     de->d_reclen = tswap16(reclen);
5065                     tswap64s((uint64_t *)&de->d_ino);
5066                     tswap64s((uint64_t *)&de->d_off);
5067                     de = (struct linux_dirent64 *)((char *)de + reclen);
5068                     len -= reclen;
5069                 }
5070             }
5071             unlock_user(dirp, arg2, ret);
5072         }
5073         break;
5074 #endif /* TARGET_NR_getdents64 */
5075 #ifdef TARGET_NR__newselect
5076     case TARGET_NR__newselect:
5077         ret = do_select(arg1, arg2, arg3, arg4, arg5);
5078         break;
5079 #endif
5080 #ifdef TARGET_NR_poll
5081     case TARGET_NR_poll:
5082         {
5083             struct target_pollfd *target_pfd;
5084             unsigned int nfds = arg2;
5085             int timeout = arg3;
5086             struct pollfd *pfd;
5087             unsigned int i;
5088
5089             target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
5090             if (!target_pfd)
5091                 goto efault;
5092             pfd = alloca(sizeof(struct pollfd) * nfds);
5093             for(i = 0; i < nfds; i++) {
5094                 pfd[i].fd = tswap32(target_pfd[i].fd);
5095                 pfd[i].events = tswap16(target_pfd[i].events);
5096             }
5097             ret = get_errno(poll(pfd, nfds, timeout));
5098             if (!is_error(ret)) {
5099                 for(i = 0; i < nfds; i++) {
5100                     target_pfd[i].revents = tswap16(pfd[i].revents);
5101                 }
5102                 ret += nfds * (sizeof(struct target_pollfd)
5103                                - sizeof(struct pollfd));
5104             }
5105             unlock_user(target_pfd, arg1, ret);
5106         }
5107         break;
5108 #endif
5109     case TARGET_NR_flock:
5110         /* NOTE: the flock constant seems to be the same for every
5111            Linux platform */
5112         ret = get_errno(flock(arg1, arg2));
5113         break;
5114     case TARGET_NR_readv:
5115         {
5116             int count = arg3;
5117             struct iovec *vec;
5118
5119             vec = alloca(count * sizeof(struct iovec));
5120             if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
5121                 goto efault;
5122             ret = get_errno(readv(arg1, vec, count));
5123             unlock_iovec(vec, arg2, count, 1);
5124         }
5125         break;
5126     case TARGET_NR_writev:
5127         {
5128             int count = arg3;
5129             struct iovec *vec;
5130
5131             vec = alloca(count * sizeof(struct iovec));
5132             if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
5133                 goto efault;
5134             ret = get_errno(writev(arg1, vec, count));
5135             unlock_iovec(vec, arg2, count, 0);
5136         }
5137         break;
5138     case TARGET_NR_getsid:
5139         ret = get_errno(getsid(arg1));
5140         break;
5141 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
5142     case TARGET_NR_fdatasync:
5143         ret = get_errno(fdatasync(arg1));
5144         break;
5145 #endif
5146     case TARGET_NR__sysctl:
5147         /* We don't implement this, but ENOTDIR is always a safe
5148            return value. */
5149         ret = -TARGET_ENOTDIR;
5150         break;
5151     case TARGET_NR_sched_setparam:
5152         {
5153             struct sched_param *target_schp;
5154             struct sched_param schp;
5155
5156             if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
5157                 goto efault;
5158             schp.sched_priority = tswap32(target_schp->sched_priority);
5159             unlock_user_struct(target_schp, arg2, 0);
5160             ret = get_errno(sched_setparam(arg1, &schp));
5161         }
5162         break;
5163     case TARGET_NR_sched_getparam:
5164         {
5165             struct sched_param *target_schp;
5166             struct sched_param schp;
5167             ret = get_errno(sched_getparam(arg1, &schp));
5168             if (!is_error(ret)) {
5169                 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
5170                     goto efault;
5171                 target_schp->sched_priority = tswap32(schp.sched_priority);
5172                 unlock_user_struct(target_schp, arg2, 1);
5173             }
5174         }
5175         break;
5176     case TARGET_NR_sched_setscheduler:
5177         {
5178             struct sched_param *target_schp;
5179             struct sched_param schp;
5180             if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
5181                 goto efault;
5182             schp.sched_priority = tswap32(target_schp->sched_priority);
5183             unlock_user_struct(target_schp, arg3, 0);
5184             ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
5185         }
5186         break;
5187     case TARGET_NR_sched_getscheduler:
5188         ret = get_errno(sched_getscheduler(arg1));
5189         break;
5190     case TARGET_NR_sched_yield:
5191         ret = get_errno(sched_yield());
5192         break;
5193     case TARGET_NR_sched_get_priority_max:
5194         ret = get_errno(sched_get_priority_max(arg1));
5195         break;
5196     case TARGET_NR_sched_get_priority_min:
5197         ret = get_errno(sched_get_priority_min(arg1));
5198         break;
5199     case TARGET_NR_sched_rr_get_interval:
5200         {
5201             struct timespec ts;
5202             ret = get_errno(sched_rr_get_interval(arg1, &ts));
5203             if (!is_error(ret)) {
5204                 host_to_target_timespec(arg2, &ts);
5205             }
5206         }
5207         break;
5208     case TARGET_NR_nanosleep:
5209         {
5210             struct timespec req, rem;
5211             target_to_host_timespec(&req, arg1);
5212             ret = get_errno(nanosleep(&req, &rem));
5213             if (is_error(ret) && arg2) {
5214                 host_to_target_timespec(arg2, &rem);
5215             }
5216         }
5217         break;
5218 #ifdef TARGET_NR_query_module
5219     case TARGET_NR_query_module:
5220         goto unimplemented;
5221 #endif
5222 #ifdef TARGET_NR_nfsservctl
5223     case TARGET_NR_nfsservctl:
5224         goto unimplemented;
5225 #endif
5226     case TARGET_NR_prctl:
5227         switch (arg1)
5228             {
5229             case PR_GET_PDEATHSIG:
5230                 {
5231                     int deathsig;
5232                     ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
5233                     if (!is_error(ret) && arg2
5234                         && put_user_ual(deathsig, arg2))
5235                         goto efault;
5236                 }
5237                 break;
5238             default:
5239                 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
5240                 break;
5241             }
5242         break;
5243 #ifdef TARGET_NR_arch_prctl
5244     case TARGET_NR_arch_prctl:
5245 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5246         ret = do_arch_prctl(cpu_env, arg1, arg2);
5247         break;
5248 #else
5249         goto unimplemented;
5250 #endif
5251 #endif
5252 #ifdef TARGET_NR_pread
5253     case TARGET_NR_pread:
5254 #ifdef TARGET_ARM
5255         if (((CPUARMState *)cpu_env)->eabi)
5256             arg4 = arg5;
5257 #endif
5258         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5259             goto efault;
5260         ret = get_errno(pread(arg1, p, arg3, arg4));
5261         unlock_user(p, arg2, ret);
5262         break;
5263     case TARGET_NR_pwrite:
5264 #ifdef TARGET_ARM
5265         if (((CPUARMState *)cpu_env)->eabi)
5266             arg4 = arg5;
5267 #endif
5268         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5269             goto efault;
5270         ret = get_errno(pwrite(arg1, p, arg3, arg4));
5271         unlock_user(p, arg2, 0);
5272         break;
5273 #endif
5274 #ifdef TARGET_NR_pread64
5275     case TARGET_NR_pread64:
5276         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5277             goto efault;
5278         ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
5279         unlock_user(p, arg2, ret);
5280         break;
5281     case TARGET_NR_pwrite64:
5282         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5283             goto efault;
5284         ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
5285         unlock_user(p, arg2, 0);
5286         break;
5287 #endif
5288     case TARGET_NR_getcwd:
5289         if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
5290             goto efault;
5291         ret = get_errno(sys_getcwd1(p, arg2));
5292         unlock_user(p, arg1, ret);
5293         break;
5294     case TARGET_NR_capget:
5295         goto unimplemented;
5296     case TARGET_NR_capset:
5297         goto unimplemented;
5298     case TARGET_NR_sigaltstack:
5299 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5300     defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
5301         ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
5302         break;
5303 #else
5304         goto unimplemented;
5305 #endif
5306     case TARGET_NR_sendfile:
5307         goto unimplemented;
5308 #ifdef TARGET_NR_getpmsg
5309     case TARGET_NR_getpmsg:
5310         goto unimplemented;
5311 #endif
5312 #ifdef TARGET_NR_putpmsg
5313     case TARGET_NR_putpmsg:
5314         goto unimplemented;
5315 #endif
5316 #ifdef TARGET_NR_vfork
5317     case TARGET_NR_vfork:
5318         ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
5319                         0, 0, 0, 0));
5320         break;
5321 #endif
5322 #ifdef TARGET_NR_ugetrlimit
5323     case TARGET_NR_ugetrlimit:
5324     {
5325         struct rlimit rlim;
5326         ret = get_errno(getrlimit(arg1, &rlim));
5327         if (!is_error(ret)) {
5328             struct target_rlimit *target_rlim;
5329             if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
5330                 goto efault;
5331             target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
5332             target_rlim->rlim_max = tswapl(rlim.rlim_max);
5333             unlock_user_struct(target_rlim, arg2, 1);
5334         }
5335         break;
5336     }
5337 #endif
5338 #ifdef TARGET_NR_truncate64
5339     case TARGET_NR_truncate64:
5340         if (!(p = lock_user_string(arg1)))
5341             goto efault;
5342         ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
5343         unlock_user(p, arg1, 0);
5344         break;
5345 #endif
5346 #ifdef TARGET_NR_ftruncate64
5347     case TARGET_NR_ftruncate64:
5348         ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
5349         break;
5350 #endif
5351 #ifdef TARGET_NR_stat64
5352     case TARGET_NR_stat64:
5353         if (!(p = lock_user_string(arg1)))
5354             goto efault;
5355         ret = get_errno(stat(path(p), &st));
5356         unlock_user(p, arg1, 0);
5357         if (!is_error(ret))
5358             ret = host_to_target_stat64(cpu_env, arg2, &st);
5359         break;
5360 #endif
5361 #ifdef TARGET_NR_lstat64
5362     case TARGET_NR_lstat64:
5363         if (!(p = lock_user_string(arg1)))
5364             goto efault;
5365         ret = get_errno(lstat(path(p), &st));
5366         unlock_user(p, arg1, 0);
5367         if (!is_error(ret))
5368             ret = host_to_target_stat64(cpu_env, arg2, &st);
5369         break;
5370 #endif
5371 #ifdef TARGET_NR_fstat64
5372     case TARGET_NR_fstat64:
5373         ret = get_errno(fstat(arg1, &st));
5374         if (!is_error(ret))
5375             ret = host_to_target_stat64(cpu_env, arg2, &st);
5376         break;
5377 #endif
5378 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
5379     case TARGET_NR_fstatat64:
5380         if (!(p = lock_user_string(arg2)))
5381             goto efault;
5382         ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));
5383         if (!is_error(ret))
5384             ret = host_to_target_stat64(cpu_env, arg3, &st);
5385         break;
5386 #endif
5387 #ifdef USE_UID16
5388     case TARGET_NR_lchown:
5389         if (!(p = lock_user_string(arg1)))
5390             goto efault;
5391         ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
5392         unlock_user(p, arg1, 0);
5393         break;
5394     case TARGET_NR_getuid:
5395         ret = get_errno(high2lowuid(getuid()));
5396         break;
5397     case TARGET_NR_getgid:
5398         ret = get_errno(high2lowgid(getgid()));
5399         break;
5400     case TARGET_NR_geteuid:
5401         ret = get_errno(high2lowuid(geteuid()));
5402         break;
5403     case TARGET_NR_getegid:
5404         ret = get_errno(high2lowgid(getegid()));
5405         break;
5406     case TARGET_NR_setreuid:
5407         ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
5408         break;
5409     case TARGET_NR_setregid:
5410         ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
5411         break;
5412     case TARGET_NR_getgroups:
5413         {
5414             int gidsetsize = arg1;
5415             uint16_t *target_grouplist;
5416             gid_t *grouplist;
5417             int i;
5418
5419             grouplist = alloca(gidsetsize * sizeof(gid_t));
5420             ret = get_errno(getgroups(gidsetsize, grouplist));
5421             if (gidsetsize == 0)
5422                 break;
5423             if (!is_error(ret)) {
5424                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
5425                 if (!target_grouplist)
5426                     goto efault;
5427                 for(i = 0;i < ret; i++)
5428                     target_grouplist[i] = tswap16(grouplist[i]);
5429                 unlock_user(target_grouplist, arg2, gidsetsize * 2);
5430             }
5431         }
5432         break;
5433     case TARGET_NR_setgroups:
5434         {
5435             int gidsetsize = arg1;
5436             uint16_t *target_grouplist;
5437             gid_t *grouplist;
5438             int i;
5439
5440             grouplist = alloca(gidsetsize * sizeof(gid_t));
5441             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
5442             if (!target_grouplist) {
5443                 ret = -TARGET_EFAULT;
5444                 goto fail;
5445             }
5446             for(i = 0;i < gidsetsize; i++)
5447                 grouplist[i] = tswap16(target_grouplist[i]);
5448             unlock_user(target_grouplist, arg2, 0);
5449             ret = get_errno(setgroups(gidsetsize, grouplist));
5450         }
5451         break;
5452     case TARGET_NR_fchown:
5453         ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
5454         break;
5455 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5456     case TARGET_NR_fchownat:
5457         if (!(p = lock_user_string(arg2)))
5458             goto efault;
5459         ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
5460         unlock_user(p, arg2, 0);
5461         break;
5462 #endif
5463 #ifdef TARGET_NR_setresuid
5464     case TARGET_NR_setresuid:
5465         ret = get_errno(setresuid(low2highuid(arg1),
5466                                   low2highuid(arg2),
5467                                   low2highuid(arg3)));
5468         break;
5469 #endif
5470 #ifdef TARGET_NR_getresuid
5471     case TARGET_NR_getresuid:
5472         {
5473             uid_t ruid, euid, suid;
5474             ret = get_errno(getresuid(&ruid, &euid, &suid));
5475             if (!is_error(ret)) {
5476                 if (put_user_u16(high2lowuid(ruid), arg1)
5477                     || put_user_u16(high2lowuid(euid), arg2)
5478                     || put_user_u16(high2lowuid(suid), arg3))
5479                     goto efault;
5480             }
5481         }
5482         break;
5483 #endif
5484 #ifdef TARGET_NR_getresgid
5485     case TARGET_NR_setresgid:
5486         ret = get_errno(setresgid(low2highgid(arg1),
5487                                   low2highgid(arg2),
5488                                   low2highgid(arg3)));
5489         break;
5490 #endif
5491 #ifdef TARGET_NR_getresgid
5492     case TARGET_NR_getresgid:
5493         {
5494             gid_t rgid, egid, sgid;
5495             ret = get_errno(getresgid(&rgid, &egid, &sgid));
5496             if (!is_error(ret)) {
5497                 if (put_user_u16(high2lowgid(rgid), arg1)
5498                     || put_user_u16(high2lowgid(egid), arg2)
5499                     || put_user_u16(high2lowgid(sgid), arg3))
5500                     goto efault;
5501             }
5502         }
5503         break;
5504 #endif
5505     case TARGET_NR_chown:
5506         if (!(p = lock_user_string(arg1)))
5507             goto efault;
5508         ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
5509         unlock_user(p, arg1, 0);
5510         break;
5511     case TARGET_NR_setuid:
5512         ret = get_errno(setuid(low2highuid(arg1)));
5513         break;
5514     case TARGET_NR_setgid:
5515         ret = get_errno(setgid(low2highgid(arg1)));
5516         break;
5517     case TARGET_NR_setfsuid:
5518         ret = get_errno(setfsuid(arg1));
5519         break;
5520     case TARGET_NR_setfsgid:
5521         ret = get_errno(setfsgid(arg1));
5522         break;
5523 #endif /* USE_UID16 */
5524
5525 #ifdef TARGET_NR_lchown32
5526     case TARGET_NR_lchown32:
5527         if (!(p = lock_user_string(arg1)))
5528             goto efault;
5529         ret = get_errno(lchown(p, arg2, arg3));
5530         unlock_user(p, arg1, 0);
5531         break;
5532 #endif
5533 #ifdef TARGET_NR_getuid32
5534     case TARGET_NR_getuid32:
5535         ret = get_errno(getuid());
5536         break;
5537 #endif
5538
5539 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
5540    /* Alpha specific */
5541     case TARGET_NR_getxuid:
5542          {
5543             uid_t euid;
5544             euid=geteuid();
5545             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
5546          }
5547         ret = get_errno(getuid());
5548         break;
5549 #endif
5550 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
5551    /* Alpha specific */
5552     case TARGET_NR_getxgid:
5553          {
5554             uid_t egid;
5555             egid=getegid();
5556             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
5557          }
5558         ret = get_errno(getgid());
5559         break;
5560 #endif
5561
5562 #ifdef TARGET_NR_getgid32
5563     case TARGET_NR_getgid32:
5564         ret = get_errno(getgid());
5565         break;
5566 #endif
5567 #ifdef TARGET_NR_geteuid32
5568     case TARGET_NR_geteuid32:
5569         ret = get_errno(geteuid());
5570         break;
5571 #endif
5572 #ifdef TARGET_NR_getegid32
5573     case TARGET_NR_getegid32:
5574         ret = get_errno(getegid());
5575         break;
5576 #endif
5577 #ifdef TARGET_NR_setreuid32
5578     case TARGET_NR_setreuid32:
5579         ret = get_errno(setreuid(arg1, arg2));
5580         break;
5581 #endif
5582 #ifdef TARGET_NR_setregid32
5583     case TARGET_NR_setregid32:
5584         ret = get_errno(setregid(arg1, arg2));
5585         break;
5586 #endif
5587 #ifdef TARGET_NR_getgroups32
5588     case TARGET_NR_getgroups32:
5589         {
5590             int gidsetsize = arg1;
5591             uint32_t *target_grouplist;
5592             gid_t *grouplist;
5593             int i;
5594
5595             grouplist = alloca(gidsetsize * sizeof(gid_t));
5596             ret = get_errno(getgroups(gidsetsize, grouplist));
5597             if (gidsetsize == 0)
5598                 break;
5599             if (!is_error(ret)) {
5600                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
5601                 if (!target_grouplist) {
5602                     ret = -TARGET_EFAULT;
5603                     goto fail;
5604                 }
5605                 for(i = 0;i < ret; i++)
5606                     target_grouplist[i] = tswap32(grouplist[i]);
5607                 unlock_user(target_grouplist, arg2, gidsetsize * 4);
5608             }
5609         }
5610         break;
5611 #endif
5612 #ifdef TARGET_NR_setgroups32
5613     case TARGET_NR_setgroups32:
5614         {
5615             int gidsetsize = arg1;
5616             uint32_t *target_grouplist;
5617             gid_t *grouplist;
5618             int i;
5619
5620             grouplist = alloca(gidsetsize * sizeof(gid_t));
5621             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
5622             if (!target_grouplist) {
5623                 ret = -TARGET_EFAULT;
5624                 goto fail;
5625             }
5626             for(i = 0;i < gidsetsize; i++)
5627                 grouplist[i] = tswap32(target_grouplist[i]);
5628             unlock_user(target_grouplist, arg2, 0);
5629             ret = get_errno(setgroups(gidsetsize, grouplist));
5630         }
5631         break;
5632 #endif
5633 #ifdef TARGET_NR_fchown32
5634     case TARGET_NR_fchown32:
5635         ret = get_errno(fchown(arg1, arg2, arg3));
5636         break;
5637 #endif
5638 #ifdef TARGET_NR_setresuid32
5639     case TARGET_NR_setresuid32:
5640         ret = get_errno(setresuid(arg1, arg2, arg3));
5641         break;
5642 #endif
5643 #ifdef TARGET_NR_getresuid32
5644     case TARGET_NR_getresuid32:
5645         {
5646             uid_t ruid, euid, suid;
5647             ret = get_errno(getresuid(&ruid, &euid, &suid));
5648             if (!is_error(ret)) {
5649                 if (put_user_u32(ruid, arg1)
5650                     || put_user_u32(euid, arg2)
5651                     || put_user_u32(suid, arg3))
5652                     goto efault;
5653             }
5654         }
5655         break;
5656 #endif
5657 #ifdef TARGET_NR_setresgid32
5658     case TARGET_NR_setresgid32:
5659         ret = get_errno(setresgid(arg1, arg2, arg3));
5660         break;
5661 #endif
5662 #ifdef TARGET_NR_getresgid32
5663     case TARGET_NR_getresgid32:
5664         {
5665             gid_t rgid, egid, sgid;
5666             ret = get_errno(getresgid(&rgid, &egid, &sgid));
5667             if (!is_error(ret)) {
5668                 if (put_user_u32(rgid, arg1)
5669                     || put_user_u32(egid, arg2)
5670                     || put_user_u32(sgid, arg3))
5671                     goto efault;
5672             }
5673         }
5674         break;
5675 #endif
5676 #ifdef TARGET_NR_chown32
5677     case TARGET_NR_chown32:
5678         if (!(p = lock_user_string(arg1)))
5679             goto efault;
5680         ret = get_errno(chown(p, arg2, arg3));
5681         unlock_user(p, arg1, 0);
5682         break;
5683 #endif
5684 #ifdef TARGET_NR_setuid32
5685     case TARGET_NR_setuid32:
5686         ret = get_errno(setuid(arg1));
5687         break;
5688 #endif
5689 #ifdef TARGET_NR_setgid32
5690     case TARGET_NR_setgid32:
5691         ret = get_errno(setgid(arg1));
5692         break;
5693 #endif
5694 #ifdef TARGET_NR_setfsuid32
5695     case TARGET_NR_setfsuid32:
5696         ret = get_errno(setfsuid(arg1));
5697         break;
5698 #endif
5699 #ifdef TARGET_NR_setfsgid32
5700     case TARGET_NR_setfsgid32:
5701         ret = get_errno(setfsgid(arg1));
5702         break;
5703 #endif
5704
5705     case TARGET_NR_pivot_root:
5706         goto unimplemented;
5707 #ifdef TARGET_NR_mincore
5708     case TARGET_NR_mincore:
5709         {
5710             void *a;
5711             ret = -TARGET_EFAULT;
5712             if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
5713                 goto efault;
5714             if (!(p = lock_user_string(arg3)))
5715                 goto mincore_fail;
5716             ret = get_errno(mincore(a, arg2, p));
5717             unlock_user(p, arg3, ret);
5718             mincore_fail:
5719             unlock_user(a, arg1, 0);
5720         }
5721         break;
5722 #endif
5723 #ifdef TARGET_NR_arm_fadvise64_64
5724     case TARGET_NR_arm_fadvise64_64:
5725         {
5726                 /*
5727                  * arm_fadvise64_64 looks like fadvise64_64 but
5728                  * with different argument order
5729                  */
5730                 abi_long temp;
5731                 temp = arg3;
5732                 arg3 = arg4;
5733                 arg4 = temp;
5734         }
5735 #endif
5736 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64)
5737 #ifdef TARGET_NR_fadvise64_64
5738     case TARGET_NR_fadvise64_64:
5739 #endif
5740         /* This is a hint, so ignoring and returning success is ok.  */
5741         ret = get_errno(0);
5742         break;
5743 #endif
5744 #ifdef TARGET_NR_madvise
5745     case TARGET_NR_madvise:
5746         /* A straight passthrough may not be safe because qemu sometimes
5747            turns private flie-backed mappings into anonymous mappings.
5748            This will break MADV_DONTNEED.
5749            This is a hint, so ignoring and returning success is ok.  */
5750         ret = get_errno(0);
5751         break;
5752 #endif
5753 #if TARGET_ABI_BITS == 32
5754     case TARGET_NR_fcntl64:
5755     {
5756         int cmd;
5757         struct flock64 fl;
5758         struct target_flock64 *target_fl;
5759 #ifdef TARGET_ARM
5760         struct target_eabi_flock64 *target_efl;
5761 #endif
5762
5763         switch(arg2){
5764         case TARGET_F_GETLK64:
5765             cmd = F_GETLK64;
5766             break;
5767         case TARGET_F_SETLK64:
5768             cmd = F_SETLK64;
5769             break;
5770         case TARGET_F_SETLKW64:
5771             cmd = F_SETLK64;
5772             break;
5773         default:
5774             cmd = arg2;
5775             break;
5776         }
5777
5778         switch(arg2) {
5779         case TARGET_F_GETLK64:
5780 #ifdef TARGET_ARM
5781             if (((CPUARMState *)cpu_env)->eabi) {
5782                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5783                     goto efault;
5784                 fl.l_type = tswap16(target_efl->l_type);
5785                 fl.l_whence = tswap16(target_efl->l_whence);
5786                 fl.l_start = tswap64(target_efl->l_start);
5787                 fl.l_len = tswap64(target_efl->l_len);
5788                 fl.l_pid = tswapl(target_efl->l_pid);
5789                 unlock_user_struct(target_efl, arg3, 0);
5790             } else
5791 #endif
5792             {
5793                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5794                     goto efault;
5795                 fl.l_type = tswap16(target_fl->l_type);
5796                 fl.l_whence = tswap16(target_fl->l_whence);
5797                 fl.l_start = tswap64(target_fl->l_start);
5798                 fl.l_len = tswap64(target_fl->l_len);
5799                 fl.l_pid = tswapl(target_fl->l_pid);
5800                 unlock_user_struct(target_fl, arg3, 0);
5801             }
5802             ret = get_errno(fcntl(arg1, cmd, &fl));
5803             if (ret == 0) {
5804 #ifdef TARGET_ARM
5805                 if (((CPUARMState *)cpu_env)->eabi) {
5806                     if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
5807                         goto efault;
5808                     target_efl->l_type = tswap16(fl.l_type);
5809                     target_efl->l_whence = tswap16(fl.l_whence);
5810                     target_efl->l_start = tswap64(fl.l_start);
5811                     target_efl->l_len = tswap64(fl.l_len);
5812                     target_efl->l_pid = tswapl(fl.l_pid);
5813                     unlock_user_struct(target_efl, arg3, 1);
5814                 } else
5815 #endif
5816                 {
5817                     if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
5818                         goto efault;
5819                     target_fl->l_type = tswap16(fl.l_type);
5820                     target_fl->l_whence = tswap16(fl.l_whence);
5821                     target_fl->l_start = tswap64(fl.l_start);
5822                     target_fl->l_len = tswap64(fl.l_len);
5823                     target_fl->l_pid = tswapl(fl.l_pid);
5824                     unlock_user_struct(target_fl, arg3, 1);
5825                 }
5826             }
5827             break;
5828
5829         case TARGET_F_SETLK64:
5830         case TARGET_F_SETLKW64:
5831 #ifdef TARGET_ARM
5832             if (((CPUARMState *)cpu_env)->eabi) {
5833                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5834                     goto efault;
5835                 fl.l_type = tswap16(target_efl->l_type);
5836                 fl.l_whence = tswap16(target_efl->l_whence);
5837                 fl.l_start = tswap64(target_efl->l_start);
5838                 fl.l_len = tswap64(target_efl->l_len);
5839                 fl.l_pid = tswapl(target_efl->l_pid);
5840                 unlock_user_struct(target_efl, arg3, 0);
5841             } else
5842 #endif
5843             {
5844                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5845                     goto efault;
5846                 fl.l_type = tswap16(target_fl->l_type);
5847                 fl.l_whence = tswap16(target_fl->l_whence);
5848                 fl.l_start = tswap64(target_fl->l_start);
5849                 fl.l_len = tswap64(target_fl->l_len);
5850                 fl.l_pid = tswapl(target_fl->l_pid);
5851                 unlock_user_struct(target_fl, arg3, 0);
5852             }
5853             ret = get_errno(fcntl(arg1, cmd, &fl));
5854             break;
5855         default:
5856             ret = do_fcntl(arg1, cmd, arg3);
5857             break;
5858         }
5859         break;
5860     }
5861 #endif
5862 #ifdef TARGET_NR_cacheflush
5863     case TARGET_NR_cacheflush:
5864         /* self-modifying code is handled automatically, so nothing needed */
5865         ret = 0;
5866         break;
5867 #endif
5868 #ifdef TARGET_NR_security
5869     case TARGET_NR_security:
5870         goto unimplemented;
5871 #endif
5872 #ifdef TARGET_NR_getpagesize
5873     case TARGET_NR_getpagesize:
5874         ret = TARGET_PAGE_SIZE;
5875         break;
5876 #endif
5877     case TARGET_NR_gettid:
5878         ret = get_errno(gettid());
5879         break;
5880 #ifdef TARGET_NR_readahead
5881     case TARGET_NR_readahead:
5882 #if TARGET_ABI_BITS == 32
5883 #ifdef TARGET_ARM
5884         if (((CPUARMState *)cpu_env)->eabi)
5885         {
5886             arg2 = arg3;
5887             arg3 = arg4;
5888             arg4 = arg5;
5889         }
5890 #endif
5891         ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
5892 #else
5893         ret = get_errno(readahead(arg1, arg2, arg3));
5894 #endif
5895         break;
5896 #endif
5897 #ifdef TARGET_NR_setxattr
5898     case TARGET_NR_setxattr:
5899     case TARGET_NR_lsetxattr:
5900     case TARGET_NR_fsetxattr:
5901     case TARGET_NR_getxattr:
5902     case TARGET_NR_lgetxattr:
5903     case TARGET_NR_fgetxattr:
5904     case TARGET_NR_listxattr:
5905     case TARGET_NR_llistxattr:
5906     case TARGET_NR_flistxattr:
5907     case TARGET_NR_removexattr:
5908     case TARGET_NR_lremovexattr:
5909     case TARGET_NR_fremovexattr:
5910         goto unimplemented_nowarn;
5911 #endif
5912 #ifdef TARGET_NR_set_thread_area
5913     case TARGET_NR_set_thread_area:
5914 #if defined(TARGET_MIPS)
5915       ((CPUMIPSState *) cpu_env)->tls_value = arg1;
5916       ret = 0;
5917       break;
5918 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
5919       ret = do_set_thread_area(cpu_env, arg1);
5920       break;
5921 #else
5922       goto unimplemented_nowarn;
5923 #endif
5924 #endif
5925 #ifdef TARGET_NR_get_thread_area
5926     case TARGET_NR_get_thread_area:
5927 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5928         ret = do_get_thread_area(cpu_env, arg1);
5929 #else
5930         goto unimplemented_nowarn;
5931 #endif
5932 #endif
5933 #ifdef TARGET_NR_getdomainname
5934     case TARGET_NR_getdomainname:
5935         goto unimplemented_nowarn;
5936 #endif
5937
5938 #ifdef TARGET_NR_clock_gettime
5939     case TARGET_NR_clock_gettime:
5940     {
5941         struct timespec ts;
5942         ret = get_errno(clock_gettime(arg1, &ts));
5943         if (!is_error(ret)) {
5944             host_to_target_timespec(arg2, &ts);
5945         }
5946         break;
5947     }
5948 #endif
5949 #ifdef TARGET_NR_clock_getres
5950     case TARGET_NR_clock_getres:
5951     {
5952         struct timespec ts;
5953         ret = get_errno(clock_getres(arg1, &ts));
5954         if (!is_error(ret)) {
5955             host_to_target_timespec(arg2, &ts);
5956         }
5957         break;
5958     }
5959 #endif
5960 #ifdef TARGET_NR_clock_nanosleep
5961     case TARGET_NR_clock_nanosleep:
5962     {
5963         struct timespec ts;
5964         target_to_host_timespec(&ts, arg3);
5965         ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
5966         if (arg4)
5967             host_to_target_timespec(arg4, &ts);
5968         break;
5969     }
5970 #endif
5971
5972 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5973     case TARGET_NR_set_tid_address:
5974         ret = get_errno(set_tid_address((int *)g2h(arg1)));
5975         break;
5976 #endif
5977
5978 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
5979     case TARGET_NR_tkill:
5980         ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
5981         break;
5982 #endif
5983
5984 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
5985     case TARGET_NR_tgkill:
5986         ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
5987                         target_to_host_signal(arg3)));
5988         break;
5989 #endif
5990
5991 #ifdef TARGET_NR_set_robust_list
5992     case TARGET_NR_set_robust_list:
5993         goto unimplemented_nowarn;
5994 #endif
5995
5996 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5997     case TARGET_NR_utimensat:
5998         {
5999             struct timespec ts[2];
6000             target_to_host_timespec(ts, arg3);
6001             target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
6002             if (!arg2)
6003                 ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4));
6004             else {
6005                 if (!(p = lock_user_string(arg2))) {
6006                     ret = -TARGET_EFAULT;
6007                     goto fail;
6008                 }
6009                 ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
6010                 unlock_user(p, arg2, 0);
6011             }
6012         }
6013         break;
6014 #endif
6015 #if defined(USE_NPTL)
6016     case TARGET_NR_futex:
6017         ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
6018         break;
6019 #endif
6020 #ifdef TARGET_NR_inotify_init
6021     case TARGET_NR_inotify_init:
6022         ret = get_errno(sys_inotify_init());
6023         break;
6024 #endif
6025 #ifdef TARGET_NR_inotify_add_watch
6026     case TARGET_NR_inotify_add_watch:
6027         p = lock_user_string(arg2);
6028         ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
6029         unlock_user(p, arg2, 0);
6030         break;
6031 #endif
6032 #ifdef TARGET_NR_inotify_rm_watch
6033     case TARGET_NR_inotify_rm_watch:
6034         ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
6035         break;
6036 #endif
6037
6038     default:
6039     unimplemented:
6040         gemu_log("qemu: Unsupported syscall: %d\n", num);
6041 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
6042     unimplemented_nowarn:
6043 #endif
6044         ret = -TARGET_ENOSYS;
6045         break;
6046     }
6047 fail:
6048 #ifdef DEBUG
6049     gemu_log(" = %ld\n", ret);
6050 #endif
6051     if(do_strace)
6052         print_syscall_ret(num, ret);
6053     return ret;
6054 efault:
6055     ret = -TARGET_EFAULT;
6056     goto fail;
6057 }