vcs.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 #define N_SHM_REGIONS   32
1618
1619 static struct shm_region {
1620     abi_ulong   start;
1621     abi_ulong   size;
1622 } shm_regions[N_SHM_REGIONS];
1623
1624 struct target_ipc_perm
1625 {
1626     abi_long __key;
1627     abi_ulong uid;
1628     abi_ulong gid;
1629     abi_ulong cuid;
1630     abi_ulong cgid;
1631     unsigned short int mode;
1632     unsigned short int __pad1;
1633     unsigned short int __seq;
1634     unsigned short int __pad2;
1635     abi_ulong __unused1;
1636     abi_ulong __unused2;
1637 };
1638
1639 struct target_semid_ds
1640 {
1641   struct target_ipc_perm sem_perm;
1642   abi_ulong sem_otime;
1643   abi_ulong __unused1;
1644   abi_ulong sem_ctime;
1645   abi_ulong __unused2;
1646   abi_ulong sem_nsems;
1647   abi_ulong __unused3;
1648   abi_ulong __unused4;
1649 };
1650
1651 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
1652                                                abi_ulong target_addr)
1653 {
1654     struct target_ipc_perm *target_ip;
1655     struct target_semid_ds *target_sd;
1656
1657     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1658         return -TARGET_EFAULT;
1659     target_ip=&(target_sd->sem_perm);
1660     host_ip->__key = tswapl(target_ip->__key);
1661     host_ip->uid = tswapl(target_ip->uid);
1662     host_ip->gid = tswapl(target_ip->gid);
1663     host_ip->cuid = tswapl(target_ip->cuid);
1664     host_ip->cgid = tswapl(target_ip->cgid);
1665     host_ip->mode = tswapl(target_ip->mode);
1666     unlock_user_struct(target_sd, target_addr, 0);
1667     return 0;
1668 }
1669
1670 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
1671                                                struct ipc_perm *host_ip)
1672 {
1673     struct target_ipc_perm *target_ip;
1674     struct target_semid_ds *target_sd;
1675
1676     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1677         return -TARGET_EFAULT;
1678     target_ip = &(target_sd->sem_perm);
1679     target_ip->__key = tswapl(host_ip->__key);
1680     target_ip->uid = tswapl(host_ip->uid);
1681     target_ip->gid = tswapl(host_ip->gid);
1682     target_ip->cuid = tswapl(host_ip->cuid);
1683     target_ip->cgid = tswapl(host_ip->cgid);
1684     target_ip->mode = tswapl(host_ip->mode);
1685     unlock_user_struct(target_sd, target_addr, 1);
1686     return 0;
1687 }
1688
1689 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
1690                                                abi_ulong target_addr)
1691 {
1692     struct target_semid_ds *target_sd;
1693
1694     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1695         return -TARGET_EFAULT;
1696     target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1697     host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1698     host_sd->sem_otime = tswapl(target_sd->sem_otime);
1699     host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1700     unlock_user_struct(target_sd, target_addr, 0);
1701     return 0;
1702 }
1703
1704 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
1705                                                struct semid_ds *host_sd)
1706 {
1707     struct target_semid_ds *target_sd;
1708
1709     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1710         return -TARGET_EFAULT;
1711     host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1712     target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1713     target_sd->sem_otime = tswapl(host_sd->sem_otime);
1714     target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1715     unlock_user_struct(target_sd, target_addr, 1);
1716     return 0;
1717 }
1718
1719 union semun {
1720         int val;
1721         struct semid_ds *buf;
1722         unsigned short *array;
1723 };
1724
1725 union target_semun {
1726         int val;
1727         abi_long buf;
1728         unsigned short int *array;
1729 };
1730
1731 static inline abi_long target_to_host_semun(int cmd,
1732                                             union semun *host_su,
1733                                             abi_ulong target_addr,
1734                                             struct semid_ds *ds)
1735 {
1736     union target_semun *target_su;
1737
1738     switch( cmd ) {
1739         case IPC_STAT:
1740         case IPC_SET:
1741            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1742                return -TARGET_EFAULT;
1743            target_to_host_semid_ds(ds,target_su->buf);
1744            host_su->buf = ds;
1745            unlock_user_struct(target_su, target_addr, 0);
1746            break;
1747         case GETVAL:
1748         case SETVAL:
1749            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1750                return -TARGET_EFAULT;
1751            host_su->val = tswapl(target_su->val);
1752            unlock_user_struct(target_su, target_addr, 0);
1753            break;
1754         case GETALL:
1755         case SETALL:
1756            if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1757                return -TARGET_EFAULT;
1758            *host_su->array = tswap16(*target_su->array);
1759            unlock_user_struct(target_su, target_addr, 0);
1760            break;
1761         default:
1762            gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1763     }
1764     return 0;
1765 }
1766
1767 static inline abi_long host_to_target_semun(int cmd,
1768                                             abi_ulong target_addr,
1769                                             union semun *host_su,
1770                                             struct semid_ds *ds)
1771 {
1772     union target_semun *target_su;
1773
1774     switch( cmd ) {
1775         case IPC_STAT:
1776         case IPC_SET:
1777            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1778                return -TARGET_EFAULT;
1779            host_to_target_semid_ds(target_su->buf,ds);
1780            unlock_user_struct(target_su, target_addr, 1);
1781            break;
1782         case GETVAL:
1783         case SETVAL:
1784            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1785                return -TARGET_EFAULT;
1786            target_su->val = tswapl(host_su->val);
1787            unlock_user_struct(target_su, target_addr, 1);
1788            break;
1789         case GETALL:
1790         case SETALL:
1791            if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1792                return -TARGET_EFAULT;
1793            *target_su->array = tswap16(*host_su->array);
1794            unlock_user_struct(target_su, target_addr, 1);
1795            break;
1796         default:
1797            gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1798     }
1799     return 0;
1800 }
1801
1802 static inline abi_long do_semctl(int first, int second, int third,
1803                                  abi_long ptr)
1804 {
1805     union semun arg;
1806     struct semid_ds dsarg;
1807     int cmd = third&0xff;
1808     abi_long ret = 0;
1809
1810     switch( cmd ) {
1811         case GETVAL:
1812             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1813             ret = get_errno(semctl(first, second, cmd, arg));
1814             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1815             break;
1816         case SETVAL:
1817             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1818             ret = get_errno(semctl(first, second, cmd, arg));
1819             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1820             break;
1821         case GETALL:
1822             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1823             ret = get_errno(semctl(first, second, cmd, arg));
1824             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1825             break;
1826         case SETALL:
1827             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1828             ret = get_errno(semctl(first, second, cmd, arg));
1829             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1830             break;
1831         case IPC_STAT:
1832             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1833             ret = get_errno(semctl(first, second, cmd, arg));
1834             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1835             break;
1836         case IPC_SET:
1837             target_to_host_semun(cmd,&arg,ptr,&dsarg);
1838             ret = get_errno(semctl(first, second, cmd, arg));
1839             host_to_target_semun(cmd,ptr,&arg,&dsarg);
1840             break;
1841     default:
1842             ret = get_errno(semctl(first, second, cmd, arg));
1843     }
1844
1845     return ret;
1846 }
1847
1848 struct target_msqid_ds
1849 {
1850     struct target_ipc_perm msg_perm;
1851     abi_ulong msg_stime;
1852 #if TARGET_ABI_BITS == 32
1853     abi_ulong __unused1;
1854 #endif
1855     abi_ulong msg_rtime;
1856 #if TARGET_ABI_BITS == 32
1857     abi_ulong __unused2;
1858 #endif
1859     abi_ulong msg_ctime;
1860 #if TARGET_ABI_BITS == 32
1861     abi_ulong __unused3;
1862 #endif
1863     abi_ulong __msg_cbytes;
1864     abi_ulong msg_qnum;
1865     abi_ulong msg_qbytes;
1866     abi_ulong msg_lspid;
1867     abi_ulong msg_lrpid;
1868     abi_ulong __unused4;
1869     abi_ulong __unused5;
1870 };
1871
1872 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
1873                                                abi_ulong target_addr)
1874 {
1875     struct target_msqid_ds *target_md;
1876
1877     if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
1878         return -TARGET_EFAULT;
1879     if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
1880         return -TARGET_EFAULT;
1881     host_md->msg_stime = tswapl(target_md->msg_stime);
1882     host_md->msg_rtime = tswapl(target_md->msg_rtime);
1883     host_md->msg_ctime = tswapl(target_md->msg_ctime);
1884     host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1885     host_md->msg_qnum = tswapl(target_md->msg_qnum);
1886     host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1887     host_md->msg_lspid = tswapl(target_md->msg_lspid);
1888     host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1889     unlock_user_struct(target_md, target_addr, 0);
1890     return 0;
1891 }
1892
1893 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
1894                                                struct msqid_ds *host_md)
1895 {
1896     struct target_msqid_ds *target_md;
1897
1898     if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
1899         return -TARGET_EFAULT;
1900     if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
1901         return -TARGET_EFAULT;
1902     target_md->msg_stime = tswapl(host_md->msg_stime);
1903     target_md->msg_rtime = tswapl(host_md->msg_rtime);
1904     target_md->msg_ctime = tswapl(host_md->msg_ctime);
1905     target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1906     target_md->msg_qnum = tswapl(host_md->msg_qnum);
1907     target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1908     target_md->msg_lspid = tswapl(host_md->msg_lspid);
1909     target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1910     unlock_user_struct(target_md, target_addr, 1);
1911     return 0;
1912 }
1913
1914 struct target_msginfo {
1915     int msgpool;
1916     int msgmap;
1917     int msgmax;
1918     int msgmnb;
1919     int msgmni;
1920     int msgssz;
1921     int msgtql;
1922     unsigned short int msgseg;
1923 };
1924
1925 static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
1926                                               struct msginfo *host_msginfo)
1927 {
1928     struct target_msginfo *target_msginfo;
1929     if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
1930         return -TARGET_EFAULT;
1931     __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
1932     __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
1933     __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
1934     __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
1935     __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
1936     __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
1937     __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
1938     __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
1939     unlock_user_struct(target_msginfo, target_addr, 1);
1940     return 0;
1941 }
1942
1943 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
1944 {
1945     struct msqid_ds dsarg;
1946     struct msginfo msginfo;
1947     abi_long ret = -TARGET_EINVAL;
1948
1949     cmd &= 0xff;
1950
1951     switch (cmd) {
1952     case IPC_STAT:
1953     case IPC_SET:
1954     case MSG_STAT:
1955         if (target_to_host_msqid_ds(&dsarg,ptr))
1956             return -TARGET_EFAULT;
1957         ret = get_errno(msgctl(msgid, cmd, &dsarg));
1958         if (host_to_target_msqid_ds(ptr,&dsarg))
1959             return -TARGET_EFAULT;
1960         break;
1961     case IPC_RMID:
1962         ret = get_errno(msgctl(msgid, cmd, NULL));
1963         break;
1964     case IPC_INFO:
1965     case MSG_INFO:
1966         ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
1967         if (host_to_target_msginfo(ptr, &msginfo))
1968             return -TARGET_EFAULT;
1969         break;
1970     }
1971
1972     return ret;
1973 }
1974
1975 struct target_msgbuf {
1976     abi_long mtype;
1977     char        mtext[1];
1978 };
1979
1980 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
1981                                  unsigned int msgsz, int msgflg)
1982 {
1983     struct target_msgbuf *target_mb;
1984     struct msgbuf *host_mb;
1985     abi_long ret = 0;
1986
1987     if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
1988         return -TARGET_EFAULT;
1989     host_mb = malloc(msgsz+sizeof(long));
1990     host_mb->mtype = (abi_long) tswapl(target_mb->mtype);
1991     memcpy(host_mb->mtext, target_mb->mtext, msgsz);
1992     ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1993     free(host_mb);
1994     unlock_user_struct(target_mb, msgp, 0);
1995
1996     return ret;
1997 }
1998
1999 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
2000                                  unsigned int msgsz, abi_long msgtyp,
2001                                  int msgflg)
2002 {
2003     struct target_msgbuf *target_mb;
2004     char *target_mtext;
2005     struct msgbuf *host_mb;
2006     abi_long ret = 0;
2007
2008     if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
2009         return -TARGET_EFAULT;
2010
2011     host_mb = malloc(msgsz+sizeof(long));
2012     ret = get_errno(msgrcv(msqid, host_mb, msgsz, tswapl(msgtyp), msgflg));
2013
2014     if (ret > 0) {
2015         abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
2016         target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
2017         if (!target_mtext) {
2018             ret = -TARGET_EFAULT;
2019             goto end;
2020         }
2021         memcpy(target_mb->mtext, host_mb->mtext, ret);
2022         unlock_user(target_mtext, target_mtext_addr, ret);
2023     }
2024
2025     target_mb->mtype = tswapl(host_mb->mtype);
2026     free(host_mb);
2027
2028 end:
2029     if (target_mb)
2030         unlock_user_struct(target_mb, msgp, 1);
2031     return ret;
2032 }
2033
2034 #ifdef TARGET_NR_ipc
2035 /* ??? This only works with linear mappings.  */
2036 /* do_ipc() must return target values and target errnos. */
2037 static abi_long do_ipc(unsigned int call, int first,
2038                        int second, int third,
2039                        abi_long ptr, abi_long fifth)
2040 {
2041     int version;
2042     abi_long ret = 0;
2043     struct shmid_ds shm_info;
2044     int i;
2045
2046     version = call >> 16;
2047     call &= 0xffff;
2048
2049     switch (call) {
2050     case IPCOP_semop:
2051         ret = get_errno(semop(first,(struct sembuf *)g2h(ptr), second));
2052         break;
2053
2054     case IPCOP_semget:
2055         ret = get_errno(semget(first, second, third));
2056         break;
2057
2058     case IPCOP_semctl:
2059         ret = do_semctl(first, second, third, ptr);
2060         break;
2061
2062     case IPCOP_semtimedop:
2063         gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
2064         ret = -TARGET_ENOSYS;
2065         break;
2066
2067     case IPCOP_msgget:
2068         ret = get_errno(msgget(first, second));
2069         break;
2070
2071     case IPCOP_msgsnd:
2072         ret = do_msgsnd(first, ptr, second, third);
2073         break;
2074
2075     case IPCOP_msgctl:
2076         ret = do_msgctl(first, second, ptr);
2077         break;
2078
2079     case IPCOP_msgrcv:
2080         switch (version) {
2081         case 0:
2082             {
2083                 struct target_ipc_kludge {
2084                     abi_long msgp;
2085                     abi_long msgtyp;
2086                 } *tmp;
2087
2088                 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
2089                     ret = -TARGET_EFAULT;
2090                     break;
2091                 }
2092
2093                 ret = do_msgrcv(first, tmp->msgp, second, tmp->msgtyp, third);
2094
2095                 unlock_user_struct(tmp, ptr, 0);
2096                 break;
2097             }
2098         default:
2099             ret = do_msgrcv(first, ptr, second, fifth, third);
2100         }
2101         break;
2102
2103     case IPCOP_shmat:
2104         {
2105             abi_ulong raddr;
2106             void *host_addr;
2107             /* SHM_* flags are the same on all linux platforms */
2108             host_addr = shmat(first, (void *)g2h(ptr), second);
2109             if (host_addr == (void *)-1) {
2110                 ret = get_errno((long)host_addr);
2111                 break;
2112             }
2113             raddr = h2g((unsigned long)host_addr);
2114             /* find out the length of the shared memory segment */
2115
2116             ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
2117             if (is_error(ret)) {
2118                 /* can't get length, bail out */
2119                 shmdt(host_addr);
2120                 break;
2121             }
2122             page_set_flags(raddr, raddr + shm_info.shm_segsz,
2123                            PAGE_VALID | PAGE_READ |
2124                            ((second & SHM_RDONLY)? 0: PAGE_WRITE));
2125             for (i = 0; i < N_SHM_REGIONS; ++i) {
2126                 if (shm_regions[i].start == 0) {
2127                     shm_regions[i].start = raddr;
2128                     shm_regions[i].size = shm_info.shm_segsz;
2129                     break;
2130                 }
2131             }
2132             if (put_user_ual(raddr, third))
2133                 return -TARGET_EFAULT;
2134             ret = 0;
2135         }
2136         break;
2137     case IPCOP_shmdt:
2138         for (i = 0; i < N_SHM_REGIONS; ++i) {
2139             if (shm_regions[i].start == ptr) {
2140                 shm_regions[i].start = 0;
2141                 page_set_flags(ptr, shm_regions[i].size, 0);
2142                 break;
2143             }
2144         }
2145         ret = get_errno(shmdt((void *)g2h(ptr)));
2146         break;
2147
2148     case IPCOP_shmget:
2149         /* IPC_* flag values are the same on all linux platforms */
2150         ret = get_errno(shmget(first, second, third));
2151         break;
2152
2153         /* IPC_* and SHM_* command values are the same on all linux platforms */
2154     case IPCOP_shmctl:
2155         switch(second) {
2156         case IPC_RMID:
2157         case SHM_LOCK:
2158         case SHM_UNLOCK:
2159             ret = get_errno(shmctl(first, second, NULL));
2160             break;
2161         default:
2162             goto unimplemented;
2163         }
2164         break;
2165     default:
2166     unimplemented:
2167         gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
2168         ret = -TARGET_ENOSYS;
2169         break;
2170     }
2171     return ret;
2172 }
2173 #endif
2174
2175 /* kernel structure types definitions */
2176 #define IFNAMSIZ        16
2177
2178 #define STRUCT(name, list...) STRUCT_ ## name,
2179 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
2180 enum {
2181 #include "syscall_types.h"
2182 };
2183 #undef STRUCT
2184 #undef STRUCT_SPECIAL
2185
2186 #define STRUCT(name, list...) static const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2187 #define STRUCT_SPECIAL(name)
2188 #include "syscall_types.h"
2189 #undef STRUCT
2190 #undef STRUCT_SPECIAL
2191
2192 typedef struct IOCTLEntry {
2193     unsigned int target_cmd;
2194     unsigned int host_cmd;
2195     const char *name;
2196     int access;
2197     const argtype arg_type[5];
2198 } IOCTLEntry;
2199
2200 #define IOC_R 0x0001
2201 #define IOC_W 0x0002
2202 #define IOC_RW (IOC_R | IOC_W)
2203
2204 #define MAX_STRUCT_SIZE 4096
2205
2206 static IOCTLEntry ioctl_entries[] = {
2207 #define IOCTL(cmd, access, types...) \
2208     { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2209 #include "ioctls.h"
2210     { 0, 0, },
2211 };
2212
2213 /* ??? Implement proper locking for ioctls.  */
2214 /* do_ioctl() Must return target values and target errnos. */
2215 static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
2216 {
2217     const IOCTLEntry *ie;
2218     const argtype *arg_type;
2219     abi_long ret;
2220     uint8_t buf_temp[MAX_STRUCT_SIZE];
2221     int target_size;
2222     void *argptr;
2223
2224     ie = ioctl_entries;
2225     for(;;) {
2226         if (ie->target_cmd == 0) {
2227             gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
2228             return -TARGET_ENOSYS;
2229         }
2230         if (ie->target_cmd == cmd)
2231             break;
2232         ie++;
2233     }
2234     arg_type = ie->arg_type;
2235 #if defined(DEBUG)
2236     gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
2237 #endif
2238     switch(arg_type[0]) {
2239     case TYPE_NULL:
2240         /* no argument */
2241         ret = get_errno(ioctl(fd, ie->host_cmd));
2242         break;
2243     case TYPE_PTRVOID:
2244     case TYPE_INT:
2245         /* int argment */
2246         ret = get_errno(ioctl(fd, ie->host_cmd, arg));
2247         break;
2248     case TYPE_PTR:
2249         arg_type++;
2250         target_size = thunk_type_size(arg_type, 0);
2251         switch(ie->access) {
2252         case IOC_R:
2253             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2254             if (!is_error(ret)) {
2255                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2256                 if (!argptr)
2257                     return -TARGET_EFAULT;
2258                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2259                 unlock_user(argptr, arg, target_size);
2260             }
2261             break;
2262         case IOC_W:
2263             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2264             if (!argptr)
2265                 return -TARGET_EFAULT;
2266             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2267             unlock_user(argptr, arg, 0);
2268             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2269             break;
2270         default:
2271         case IOC_RW:
2272             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2273             if (!argptr)
2274                 return -TARGET_EFAULT;
2275             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2276             unlock_user(argptr, arg, 0);
2277             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2278             if (!is_error(ret)) {
2279                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2280                 if (!argptr)
2281                     return -TARGET_EFAULT;
2282                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2283                 unlock_user(argptr, arg, target_size);
2284             }
2285             break;
2286         }
2287         break;
2288     default:
2289         gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2290                  (long)cmd, arg_type[0]);
2291         ret = -TARGET_ENOSYS;
2292         break;
2293     }
2294     return ret;
2295 }
2296
2297 static const bitmask_transtbl iflag_tbl[] = {
2298         { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
2299         { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
2300         { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
2301         { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
2302         { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
2303         { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
2304         { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
2305         { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
2306         { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
2307         { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
2308         { TARGET_IXON, TARGET_IXON, IXON, IXON },
2309         { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
2310         { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
2311         { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
2312         { 0, 0, 0, 0 }
2313 };
2314
2315 static const bitmask_transtbl oflag_tbl[] = {
2316         { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
2317         { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
2318         { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
2319         { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
2320         { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
2321         { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
2322         { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
2323         { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
2324         { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
2325         { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
2326         { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
2327         { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
2328         { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
2329         { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
2330         { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
2331         { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
2332         { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
2333         { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
2334         { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
2335         { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
2336         { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
2337         { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
2338         { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
2339         { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
2340         { 0, 0, 0, 0 }
2341 };
2342
2343 static const bitmask_transtbl cflag_tbl[] = {
2344         { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
2345         { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
2346         { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
2347         { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
2348         { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
2349         { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
2350         { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
2351         { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
2352         { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
2353         { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
2354         { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
2355         { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
2356         { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
2357         { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
2358         { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
2359         { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
2360         { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
2361         { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
2362         { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
2363         { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
2364         { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
2365         { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
2366         { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
2367         { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
2368         { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
2369         { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
2370         { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
2371         { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
2372         { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
2373         { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
2374         { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
2375         { 0, 0, 0, 0 }
2376 };
2377
2378 static const bitmask_transtbl lflag_tbl[] = {
2379         { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
2380         { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
2381         { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
2382         { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
2383         { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
2384         { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
2385         { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
2386         { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
2387         { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
2388         { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
2389         { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
2390         { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
2391         { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
2392         { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
2393         { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
2394         { 0, 0, 0, 0 }
2395 };
2396
2397 static void target_to_host_termios (void *dst, const void *src)
2398 {
2399     struct host_termios *host = dst;
2400     const struct target_termios *target = src;
2401
2402     host->c_iflag =
2403         target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
2404     host->c_oflag =
2405         target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
2406     host->c_cflag =
2407         target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
2408     host->c_lflag =
2409         target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
2410     host->c_line = target->c_line;
2411
2412     host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
2413     host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
2414     host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
2415     host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
2416     host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
2417     host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
2418     host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
2419     host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
2420     host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
2421     host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
2422     host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
2423     host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
2424     host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
2425     host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
2426     host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
2427     host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
2428     host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
2429 }
2430
2431 static void host_to_target_termios (void *dst, const void *src)
2432 {
2433     struct target_termios *target = dst;
2434     const struct host_termios *host = src;
2435
2436     target->c_iflag =
2437         tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
2438     target->c_oflag =
2439         tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
2440     target->c_cflag =
2441         tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
2442     target->c_lflag =
2443         tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
2444     target->c_line = host->c_line;
2445
2446     target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
2447     target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
2448     target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
2449     target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
2450     target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
2451     target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
2452     target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
2453     target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
2454     target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
2455     target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
2456     target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
2457     target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
2458     target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
2459     target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
2460     target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
2461     target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
2462     target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
2463 }
2464
2465 static const StructEntry struct_termios_def = {
2466     .convert = { host_to_target_termios, target_to_host_termios },
2467     .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
2468     .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
2469 };
2470
2471 static bitmask_transtbl mmap_flags_tbl[] = {
2472         { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
2473         { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
2474         { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
2475         { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
2476         { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
2477         { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
2478         { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
2479         { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
2480         { 0, 0, 0, 0 }
2481 };
2482
2483 static bitmask_transtbl fcntl_flags_tbl[] = {
2484         { TARGET_O_ACCMODE,   TARGET_O_WRONLY,    O_ACCMODE,   O_WRONLY,    },
2485         { TARGET_O_ACCMODE,   TARGET_O_RDWR,      O_ACCMODE,   O_RDWR,      },
2486         { TARGET_O_CREAT,     TARGET_O_CREAT,     O_CREAT,     O_CREAT,     },
2487         { TARGET_O_EXCL,      TARGET_O_EXCL,      O_EXCL,      O_EXCL,      },
2488         { TARGET_O_NOCTTY,    TARGET_O_NOCTTY,    O_NOCTTY,    O_NOCTTY,    },
2489         { TARGET_O_TRUNC,     TARGET_O_TRUNC,     O_TRUNC,     O_TRUNC,     },
2490         { TARGET_O_APPEND,    TARGET_O_APPEND,    O_APPEND,    O_APPEND,    },
2491         { TARGET_O_NONBLOCK,  TARGET_O_NONBLOCK,  O_NONBLOCK,  O_NONBLOCK,  },
2492         { TARGET_O_SYNC,      TARGET_O_SYNC,      O_SYNC,      O_SYNC,      },
2493         { TARGET_FASYNC,      TARGET_FASYNC,      FASYNC,      FASYNC,      },
2494         { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
2495         { TARGET_O_NOFOLLOW,  TARGET_O_NOFOLLOW,  O_NOFOLLOW,  O_NOFOLLOW,  },
2496         { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
2497 #if defined(O_DIRECT)
2498         { TARGET_O_DIRECT,    TARGET_O_DIRECT,    O_DIRECT,    O_DIRECT,    },
2499 #endif
2500         { 0, 0, 0, 0 }
2501 };
2502
2503 #if defined(TARGET_I386)
2504
2505 /* NOTE: there is really one LDT for all the threads */
2506 static uint8_t *ldt_table;
2507
2508 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
2509 {
2510     int size;
2511     void *p;
2512
2513     if (!ldt_table)
2514         return 0;
2515     size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
2516     if (size > bytecount)
2517         size = bytecount;
2518     p = lock_user(VERIFY_WRITE, ptr, size, 0);
2519     if (!p)
2520         return -TARGET_EFAULT;
2521     /* ??? Should this by byteswapped?  */
2522     memcpy(p, ldt_table, size);
2523     unlock_user(p, ptr, size);
2524     return size;
2525 }
2526
2527 /* XXX: add locking support */
2528 static abi_long write_ldt(CPUX86State *env,
2529                           abi_ulong ptr, unsigned long bytecount, int oldmode)
2530 {
2531     struct target_modify_ldt_ldt_s ldt_info;
2532     struct target_modify_ldt_ldt_s *target_ldt_info;
2533     int seg_32bit, contents, read_exec_only, limit_in_pages;
2534     int seg_not_present, useable, lm;
2535     uint32_t *lp, entry_1, entry_2;
2536
2537     if (bytecount != sizeof(ldt_info))
2538         return -TARGET_EINVAL;
2539     if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
2540         return -TARGET_EFAULT;
2541     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2542     ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2543     ldt_info.limit = tswap32(target_ldt_info->limit);
2544     ldt_info.flags = tswap32(target_ldt_info->flags);
2545     unlock_user_struct(target_ldt_info, ptr, 0);
2546
2547     if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
2548         return -TARGET_EINVAL;
2549     seg_32bit = ldt_info.flags & 1;
2550     contents = (ldt_info.flags >> 1) & 3;
2551     read_exec_only = (ldt_info.flags >> 3) & 1;
2552     limit_in_pages = (ldt_info.flags >> 4) & 1;
2553     seg_not_present = (ldt_info.flags >> 5) & 1;
2554     useable = (ldt_info.flags >> 6) & 1;
2555 #ifdef TARGET_ABI32
2556     lm = 0;
2557 #else
2558     lm = (ldt_info.flags >> 7) & 1;
2559 #endif
2560     if (contents == 3) {
2561         if (oldmode)
2562             return -TARGET_EINVAL;
2563         if (seg_not_present == 0)
2564             return -TARGET_EINVAL;
2565     }
2566     /* allocate the LDT */
2567     if (!ldt_table) {
2568         ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2569         if (!ldt_table)
2570             return -TARGET_ENOMEM;
2571         memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2572         env->ldt.base = h2g((unsigned long)ldt_table);
2573         env->ldt.limit = 0xffff;
2574     }
2575
2576     /* NOTE: same code as Linux kernel */
2577     /* Allow LDTs to be cleared by the user. */
2578     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2579         if (oldmode ||
2580             (contents == 0              &&
2581              read_exec_only == 1        &&
2582              seg_32bit == 0             &&
2583              limit_in_pages == 0        &&
2584              seg_not_present == 1       &&
2585              useable == 0 )) {
2586             entry_1 = 0;
2587             entry_2 = 0;
2588             goto install;
2589         }
2590     }
2591
2592     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2593         (ldt_info.limit & 0x0ffff);
2594     entry_2 = (ldt_info.base_addr & 0xff000000) |
2595         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2596         (ldt_info.limit & 0xf0000) |
2597         ((read_exec_only ^ 1) << 9) |
2598         (contents << 10) |
2599         ((seg_not_present ^ 1) << 15) |
2600         (seg_32bit << 22) |
2601         (limit_in_pages << 23) |
2602         (lm << 21) |
2603         0x7000;
2604     if (!oldmode)
2605         entry_2 |= (useable << 20);
2606
2607     /* Install the new entry ...  */
2608 install:
2609     lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
2610     lp[0] = tswap32(entry_1);
2611     lp[1] = tswap32(entry_2);
2612     return 0;
2613 }
2614
2615 /* specific and weird i386 syscalls */
2616 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
2617                               unsigned long bytecount)
2618 {
2619     abi_long ret;
2620
2621     switch (func) {
2622     case 0:
2623         ret = read_ldt(ptr, bytecount);
2624         break;
2625     case 1:
2626         ret = write_ldt(env, ptr, bytecount, 1);
2627         break;
2628     case 0x11:
2629         ret = write_ldt(env, ptr, bytecount, 0);
2630         break;
2631     default:
2632         ret = -TARGET_ENOSYS;
2633         break;
2634     }
2635     return ret;
2636 }
2637
2638 #if defined(TARGET_I386) && defined(TARGET_ABI32)
2639 static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
2640 {
2641     uint64_t *gdt_table = g2h(env->gdt.base);
2642     struct target_modify_ldt_ldt_s ldt_info;
2643     struct target_modify_ldt_ldt_s *target_ldt_info;
2644     int seg_32bit, contents, read_exec_only, limit_in_pages;
2645     int seg_not_present, useable, lm;
2646     uint32_t *lp, entry_1, entry_2;
2647     int i;
2648
2649     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2650     if (!target_ldt_info)
2651         return -TARGET_EFAULT;
2652     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2653     ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2654     ldt_info.limit = tswap32(target_ldt_info->limit);
2655     ldt_info.flags = tswap32(target_ldt_info->flags);
2656     if (ldt_info.entry_number == -1) {
2657         for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
2658             if (gdt_table[i] == 0) {
2659                 ldt_info.entry_number = i;
2660                 target_ldt_info->entry_number = tswap32(i);
2661                 break;
2662             }
2663         }
2664     }
2665     unlock_user_struct(target_ldt_info, ptr, 1);
2666
2667     if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
2668         ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
2669            return -TARGET_EINVAL;
2670     seg_32bit = ldt_info.flags & 1;
2671     contents = (ldt_info.flags >> 1) & 3;
2672     read_exec_only = (ldt_info.flags >> 3) & 1;
2673     limit_in_pages = (ldt_info.flags >> 4) & 1;
2674     seg_not_present = (ldt_info.flags >> 5) & 1;
2675     useable = (ldt_info.flags >> 6) & 1;
2676 #ifdef TARGET_ABI32
2677     lm = 0;
2678 #else
2679     lm = (ldt_info.flags >> 7) & 1;
2680 #endif
2681
2682     if (contents == 3) {
2683         if (seg_not_present == 0)
2684             return -TARGET_EINVAL;
2685     }
2686
2687     /* NOTE: same code as Linux kernel */
2688     /* Allow LDTs to be cleared by the user. */
2689     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2690         if ((contents == 0             &&
2691              read_exec_only == 1       &&
2692              seg_32bit == 0            &&
2693              limit_in_pages == 0       &&
2694              seg_not_present == 1      &&
2695              useable == 0 )) {
2696             entry_1 = 0;
2697             entry_2 = 0;
2698             goto install;
2699         }
2700     }
2701
2702     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2703         (ldt_info.limit & 0x0ffff);
2704     entry_2 = (ldt_info.base_addr & 0xff000000) |
2705         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2706         (ldt_info.limit & 0xf0000) |
2707         ((read_exec_only ^ 1) << 9) |
2708         (contents << 10) |
2709         ((seg_not_present ^ 1) << 15) |
2710         (seg_32bit << 22) |
2711         (limit_in_pages << 23) |
2712         (useable << 20) |
2713         (lm << 21) |
2714         0x7000;
2715
2716     /* Install the new entry ...  */
2717 install:
2718     lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
2719     lp[0] = tswap32(entry_1);
2720     lp[1] = tswap32(entry_2);
2721     return 0;
2722 }
2723
2724 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
2725 {
2726     struct target_modify_ldt_ldt_s *target_ldt_info;
2727     uint64_t *gdt_table = g2h(env->gdt.base);
2728     uint32_t base_addr, limit, flags;
2729     int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
2730     int seg_not_present, useable, lm;
2731     uint32_t *lp, entry_1, entry_2;
2732
2733     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2734     if (!target_ldt_info)
2735         return -TARGET_EFAULT;
2736     idx = tswap32(target_ldt_info->entry_number);
2737     if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
2738         idx > TARGET_GDT_ENTRY_TLS_MAX) {
2739         unlock_user_struct(target_ldt_info, ptr, 1);
2740         return -TARGET_EINVAL;
2741     }
2742     lp = (uint32_t *)(gdt_table + idx);
2743     entry_1 = tswap32(lp[0]);
2744     entry_2 = tswap32(lp[1]);
2745
2746     read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
2747     contents = (entry_2 >> 10) & 3;
2748     seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
2749     seg_32bit = (entry_2 >> 22) & 1;
2750     limit_in_pages = (entry_2 >> 23) & 1;
2751     useable = (entry_2 >> 20) & 1;
2752 #ifdef TARGET_ABI32
2753     lm = 0;
2754 #else
2755     lm = (entry_2 >> 21) & 1;
2756 #endif
2757     flags = (seg_32bit << 0) | (contents << 1) |
2758         (read_exec_only << 3) | (limit_in_pages << 4) |
2759         (seg_not_present << 5) | (useable << 6) | (lm << 7);
2760     limit = (entry_1 & 0xffff) | (entry_2  & 0xf0000);
2761     base_addr = (entry_1 >> 16) |
2762         (entry_2 & 0xff000000) |
2763         ((entry_2 & 0xff) << 16);
2764     target_ldt_info->base_addr = tswapl(base_addr);
2765     target_ldt_info->limit = tswap32(limit);
2766     target_ldt_info->flags = tswap32(flags);
2767     unlock_user_struct(target_ldt_info, ptr, 1);
2768     return 0;
2769 }
2770 #endif /* TARGET_I386 && TARGET_ABI32 */
2771
2772 #ifndef TARGET_ABI32
2773 static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
2774 {
2775     abi_long ret;
2776     abi_ulong val;
2777     int idx;
2778
2779     switch(code) {
2780     case TARGET_ARCH_SET_GS:
2781     case TARGET_ARCH_SET_FS:
2782         if (code == TARGET_ARCH_SET_GS)
2783             idx = R_GS;
2784         else
2785             idx = R_FS;
2786         cpu_x86_load_seg(env, idx, 0);
2787         env->segs[idx].base = addr;
2788         break;
2789     case TARGET_ARCH_GET_GS:
2790     case TARGET_ARCH_GET_FS:
2791         if (code == TARGET_ARCH_GET_GS)
2792             idx = R_GS;
2793         else
2794             idx = R_FS;
2795         val = env->segs[idx].base;
2796         if (put_user(val, addr, abi_ulong))
2797             return -TARGET_EFAULT;
2798         break;
2799     default:
2800         ret = -TARGET_EINVAL;
2801         break;
2802     }
2803     return 0;
2804 }
2805 #endif
2806
2807 #endif /* defined(TARGET_I386) */
2808
2809 #if defined(USE_NPTL)
2810
2811 #define NEW_STACK_SIZE PTHREAD_STACK_MIN
2812
2813 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
2814 typedef struct {
2815     CPUState *env;
2816     pthread_mutex_t mutex;
2817     pthread_cond_t cond;
2818     pthread_t thread;
2819     uint32_t tid;
2820     abi_ulong child_tidptr;
2821     abi_ulong parent_tidptr;
2822     sigset_t sigmask;
2823 } new_thread_info;
2824
2825 static void *clone_func(void *arg)
2826 {
2827     new_thread_info *info = arg;
2828     CPUState *env;
2829
2830     env = info->env;
2831     thread_env = env;
2832     info->tid = gettid();
2833     if (info->child_tidptr)
2834         put_user_u32(info->tid, info->child_tidptr);
2835     if (info->parent_tidptr)
2836         put_user_u32(info->tid, info->parent_tidptr);
2837     /* Enable signals.  */
2838     sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
2839     /* Signal to the parent that we're ready.  */
2840     pthread_mutex_lock(&info->mutex);
2841     pthread_cond_broadcast(&info->cond);
2842     pthread_mutex_unlock(&info->mutex);
2843     /* Wait until the parent has finshed initializing the tls state.  */
2844     pthread_mutex_lock(&clone_lock);
2845     pthread_mutex_unlock(&clone_lock);
2846     cpu_loop(env);
2847     /* never exits */
2848     return NULL;
2849 }
2850 #else
2851 /* this stack is the equivalent of the kernel stack associated with a
2852    thread/process */
2853 #define NEW_STACK_SIZE 8192
2854
2855 static int clone_func(void *arg)
2856 {
2857     CPUState *env = arg;
2858     cpu_loop(env);
2859     /* never exits */
2860     return 0;
2861 }
2862 #endif
2863
2864 /* do_fork() Must return host values and target errnos (unlike most
2865    do_*() functions). */
2866 static int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp,
2867                    abi_ulong parent_tidptr, target_ulong newtls,
2868                    abi_ulong child_tidptr)
2869 {
2870     int ret;
2871     TaskState *ts;
2872     uint8_t *new_stack;
2873     CPUState *new_env;
2874 #if defined(USE_NPTL)
2875     unsigned int nptl_flags;
2876     sigset_t sigmask;
2877 #endif
2878
2879     /* Emulate vfork() with fork() */
2880     if (flags & CLONE_VFORK)
2881         flags &= ~(CLONE_VFORK | CLONE_VM);
2882
2883     if (flags & CLONE_VM) {
2884 #if defined(USE_NPTL)
2885         new_thread_info info;
2886         pthread_attr_t attr;
2887 #endif
2888         ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
2889         init_task_state(ts);
2890         new_stack = ts->stack;
2891         /* we create a new CPU instance. */
2892         new_env = cpu_copy(env);
2893         /* Init regs that differ from the parent.  */
2894         cpu_clone_regs(new_env, newsp);
2895         new_env->opaque = ts;
2896 #if defined(USE_NPTL)
2897         nptl_flags = flags;
2898         flags &= ~CLONE_NPTL_FLAGS2;
2899
2900         /* TODO: Implement CLONE_CHILD_CLEARTID.  */
2901         if (nptl_flags & CLONE_SETTLS)
2902             cpu_set_tls (new_env, newtls);
2903
2904         /* Grab a mutex so that thread setup appears atomic.  */
2905         pthread_mutex_lock(&clone_lock);
2906
2907         memset(&info, 0, sizeof(info));
2908         pthread_mutex_init(&info.mutex, NULL);
2909         pthread_mutex_lock(&info.mutex);
2910         pthread_cond_init(&info.cond, NULL);
2911         info.env = new_env;
2912         if (nptl_flags & CLONE_CHILD_SETTID)
2913             info.child_tidptr = child_tidptr;
2914         if (nptl_flags & CLONE_PARENT_SETTID)
2915             info.parent_tidptr = parent_tidptr;
2916
2917         ret = pthread_attr_init(&attr);
2918         ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
2919         /* It is not safe to deliver signals until the child has finished
2920            initializing, so temporarily block all signals.  */
2921         sigfillset(&sigmask);
2922         sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
2923
2924         ret = pthread_create(&info.thread, &attr, clone_func, &info);
2925
2926         sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
2927         pthread_attr_destroy(&attr);
2928         if (ret == 0) {
2929             /* Wait for the child to initialize.  */
2930             pthread_cond_wait(&info.cond, &info.mutex);
2931             ret = info.tid;
2932             if (flags & CLONE_PARENT_SETTID)
2933                 put_user_u32(ret, parent_tidptr);
2934         } else {
2935             ret = -1;
2936         }
2937         pthread_mutex_unlock(&info.mutex);
2938         pthread_cond_destroy(&info.cond);
2939         pthread_mutex_destroy(&info.mutex);
2940         pthread_mutex_unlock(&clone_lock);
2941 #else
2942         if (flags & CLONE_NPTL_FLAGS2)
2943             return -EINVAL;
2944         /* This is probably going to die very quickly, but do it anyway.  */
2945 #ifdef __ia64__
2946         ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2947 #else
2948         ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2949 #endif
2950 #endif
2951     } else {
2952         /* if no CLONE_VM, we consider it is a fork */
2953         if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
2954             return -EINVAL;
2955         fork_start();
2956         ret = fork();
2957 #if defined(USE_NPTL)
2958         /* There is a race condition here.  The parent process could
2959            theoretically read the TID in the child process before the child
2960            tid is set.  This would require using either ptrace
2961            (not implemented) or having *_tidptr to point at a shared memory
2962            mapping.  We can't repeat the spinlock hack used above because
2963            the child process gets its own copy of the lock.  */
2964         if (ret == 0) {
2965             cpu_clone_regs(env, newsp);
2966             fork_end(1);
2967             /* Child Process.  */
2968             if (flags & CLONE_CHILD_SETTID)
2969                 put_user_u32(gettid(), child_tidptr);
2970             if (flags & CLONE_PARENT_SETTID)
2971                 put_user_u32(gettid(), parent_tidptr);
2972             ts = (TaskState *)env->opaque;
2973             if (flags & CLONE_SETTLS)
2974                 cpu_set_tls (env, newtls);
2975             /* TODO: Implement CLONE_CHILD_CLEARTID.  */
2976         } else {
2977             fork_end(0);
2978         }
2979 #else
2980         if (ret == 0) {
2981             cpu_clone_regs(env, newsp);
2982         }
2983 #endif
2984     }
2985     return ret;
2986 }
2987
2988 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
2989 {
2990     struct flock fl;
2991     struct target_flock *target_fl;
2992     struct flock64 fl64;
2993     struct target_flock64 *target_fl64;
2994     abi_long ret;
2995
2996     switch(cmd) {
2997     case TARGET_F_GETLK:
2998         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
2999             return -TARGET_EFAULT;
3000         fl.l_type = tswap16(target_fl->l_type);
3001         fl.l_whence = tswap16(target_fl->l_whence);
3002         fl.l_start = tswapl(target_fl->l_start);
3003         fl.l_len = tswapl(target_fl->l_len);
3004         fl.l_pid = tswapl(target_fl->l_pid);
3005         unlock_user_struct(target_fl, arg, 0);
3006         ret = get_errno(fcntl(fd, cmd, &fl));
3007         if (ret == 0) {
3008             if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0))
3009                 return -TARGET_EFAULT;
3010             target_fl->l_type = tswap16(fl.l_type);
3011             target_fl->l_whence = tswap16(fl.l_whence);
3012             target_fl->l_start = tswapl(fl.l_start);
3013             target_fl->l_len = tswapl(fl.l_len);
3014             target_fl->l_pid = tswapl(fl.l_pid);
3015             unlock_user_struct(target_fl, arg, 1);
3016         }
3017         break;
3018
3019     case TARGET_F_SETLK:
3020     case TARGET_F_SETLKW:
3021         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
3022             return -TARGET_EFAULT;
3023         fl.l_type = tswap16(target_fl->l_type);
3024         fl.l_whence = tswap16(target_fl->l_whence);
3025         fl.l_start = tswapl(target_fl->l_start);
3026         fl.l_len = tswapl(target_fl->l_len);
3027         fl.l_pid = tswapl(target_fl->l_pid);
3028         unlock_user_struct(target_fl, arg, 0);
3029         ret = get_errno(fcntl(fd, cmd, &fl));
3030         break;
3031
3032     case TARGET_F_GETLK64:
3033         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
3034             return -TARGET_EFAULT;
3035         fl64.l_type = tswap16(target_fl64->l_type) >> 1;
3036         fl64.l_whence = tswap16(target_fl64->l_whence);
3037         fl64.l_start = tswapl(target_fl64->l_start);
3038         fl64.l_len = tswapl(target_fl64->l_len);
3039         fl64.l_pid = tswap16(target_fl64->l_pid);
3040         unlock_user_struct(target_fl64, arg, 0);
3041         ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
3042         if (ret == 0) {
3043             if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0))
3044                 return -TARGET_EFAULT;
3045             target_fl64->l_type = tswap16(fl64.l_type) >> 1;
3046             target_fl64->l_whence = tswap16(fl64.l_whence);
3047             target_fl64->l_start = tswapl(fl64.l_start);
3048             target_fl64->l_len = tswapl(fl64.l_len);
3049             target_fl64->l_pid = tswapl(fl64.l_pid);
3050             unlock_user_struct(target_fl64, arg, 1);
3051         }
3052         break;
3053     case TARGET_F_SETLK64:
3054     case TARGET_F_SETLKW64:
3055         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
3056             return -TARGET_EFAULT;
3057         fl64.l_type = tswap16(target_fl64->l_type) >> 1;
3058         fl64.l_whence = tswap16(target_fl64->l_whence);
3059         fl64.l_start = tswapl(target_fl64->l_start);
3060         fl64.l_len = tswapl(target_fl64->l_len);
3061         fl64.l_pid = tswap16(target_fl64->l_pid);
3062         unlock_user_struct(target_fl64, arg, 0);
3063         ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
3064         break;
3065
3066     case F_GETFL:
3067         ret = get_errno(fcntl(fd, cmd, arg));
3068         if (ret >= 0) {
3069             ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
3070         }
3071         break;
3072
3073     case F_SETFL:
3074         ret = get_errno(fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl)));
3075         break;
3076
3077     default:
3078         ret = get_errno(fcntl(fd, cmd, arg));
3079         break;
3080     }
3081     return ret;
3082 }
3083
3084 #ifdef USE_UID16
3085
3086 static inline int high2lowuid(int uid)
3087 {
3088     if (uid > 65535)
3089         return 65534;
3090     else
3091         return uid;
3092 }
3093
3094 static inline int high2lowgid(int gid)
3095 {
3096     if (gid > 65535)
3097         return 65534;
3098     else
3099         return gid;
3100 }
3101
3102 static inline int low2highuid(int uid)
3103 {
3104     if ((int16_t)uid == -1)
3105         return -1;
3106     else
3107         return uid;
3108 }
3109
3110 static inline int low2highgid(int gid)
3111 {
3112     if ((int16_t)gid == -1)
3113         return -1;
3114     else
3115         return gid;
3116 }
3117
3118 #endif /* USE_UID16 */
3119
3120 void syscall_init(void)
3121 {
3122     IOCTLEntry *ie;
3123     const argtype *arg_type;
3124     int size;
3125     int i;
3126
3127 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3128 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
3129 #include "syscall_types.h"
3130 #undef STRUCT
3131 #undef STRUCT_SPECIAL
3132
3133     /* we patch the ioctl size if necessary. We rely on the fact that
3134        no ioctl has all the bits at '1' in the size field */
3135     ie = ioctl_entries;
3136     while (ie->target_cmd != 0) {
3137         if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
3138             TARGET_IOC_SIZEMASK) {
3139             arg_type = ie->arg_type;
3140             if (arg_type[0] != TYPE_PTR) {
3141                 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
3142                         ie->target_cmd);
3143                 exit(1);
3144             }
3145             arg_type++;
3146             size = thunk_type_size(arg_type, 0);
3147             ie->target_cmd = (ie->target_cmd &
3148                               ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
3149                 (size << TARGET_IOC_SIZESHIFT);
3150         }
3151
3152         /* Build target_to_host_errno_table[] table from
3153          * host_to_target_errno_table[]. */
3154         for (i=0; i < ERRNO_TABLE_SIZE; i++)
3155                 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
3156
3157         /* automatic consistency check if same arch */
3158 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
3159     (defined(__x86_64__) && defined(TARGET_X86_64))
3160         if (unlikely(ie->target_cmd != ie->host_cmd)) {
3161             fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
3162                     ie->name, ie->target_cmd, ie->host_cmd);
3163         }
3164 #endif
3165         ie++;
3166     }
3167 }
3168
3169 #if TARGET_ABI_BITS == 32
3170 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
3171 {
3172 #ifdef TARGET_WORDS_BIGENDIAN
3173     return ((uint64_t)word0 << 32) | word1;
3174 #else
3175     return ((uint64_t)word1 << 32) | word0;
3176 #endif
3177 }
3178 #else /* TARGET_ABI_BITS == 32 */
3179 static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
3180 {
3181     return word0;
3182 }
3183 #endif /* TARGET_ABI_BITS != 32 */
3184
3185 #ifdef TARGET_NR_truncate64
3186 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
3187                                          abi_long arg2,
3188                                          abi_long arg3,
3189                                          abi_long arg4)
3190 {
3191 #ifdef TARGET_ARM
3192     if (((CPUARMState *)cpu_env)->eabi)
3193       {
3194         arg2 = arg3;
3195         arg3 = arg4;
3196       }
3197 #endif
3198     return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
3199 }
3200 #endif
3201
3202 #ifdef TARGET_NR_ftruncate64
3203 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
3204                                           abi_long arg2,
3205                                           abi_long arg3,
3206                                           abi_long arg4)
3207 {
3208 #ifdef TARGET_ARM
3209     if (((CPUARMState *)cpu_env)->eabi)
3210       {
3211         arg2 = arg3;
3212         arg3 = arg4;
3213       }
3214 #endif
3215     return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
3216 }
3217 #endif
3218
3219 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
3220                                                abi_ulong target_addr)
3221 {
3222     struct target_timespec *target_ts;
3223
3224     if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
3225         return -TARGET_EFAULT;
3226     host_ts->tv_sec = tswapl(target_ts->tv_sec);
3227     host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
3228     unlock_user_struct(target_ts, target_addr, 0);
3229     return 0;
3230 }
3231
3232 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
3233                                                struct timespec *host_ts)
3234 {
3235     struct target_timespec *target_ts;
3236
3237     if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
3238         return -TARGET_EFAULT;
3239     target_ts->tv_sec = tswapl(host_ts->tv_sec);
3240     target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
3241     unlock_user_struct(target_ts, target_addr, 1);
3242     return 0;
3243 }
3244
3245 #ifdef TARGET_NR_stat64
3246 static inline abi_long host_to_target_stat64(void *cpu_env,
3247                                              abi_ulong target_addr,
3248                                              struct stat *host_st)
3249 {
3250 #ifdef TARGET_ARM
3251     if (((CPUARMState *)cpu_env)->eabi) {
3252         struct target_eabi_stat64 *target_st;
3253
3254         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3255             return -TARGET_EFAULT;
3256         memset(target_st, 0, sizeof(struct target_eabi_stat64));
3257         __put_user(host_st->st_dev, &target_st->st_dev);
3258         __put_user(host_st->st_ino, &target_st->st_ino);
3259 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3260         __put_user(host_st->st_ino, &target_st->__st_ino);
3261 #endif
3262         __put_user(host_st->st_mode, &target_st->st_mode);
3263         __put_user(host_st->st_nlink, &target_st->st_nlink);
3264         __put_user(host_st->st_uid, &target_st->st_uid);
3265         __put_user(host_st->st_gid, &target_st->st_gid);
3266         __put_user(host_st->st_rdev, &target_st->st_rdev);
3267         __put_user(host_st->st_size, &target_st->st_size);
3268         __put_user(host_st->st_blksize, &target_st->st_blksize);
3269         __put_user(host_st->st_blocks, &target_st->st_blocks);
3270         __put_user(host_st->st_atime, &target_st->target_st_atime);
3271         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3272         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3273         unlock_user_struct(target_st, target_addr, 1);
3274     } else
3275 #endif
3276     {
3277         struct target_stat64 *target_st;
3278
3279         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3280             return -TARGET_EFAULT;
3281         memset(target_st, 0, sizeof(struct target_stat64));
3282         __put_user(host_st->st_dev, &target_st->st_dev);
3283         __put_user(host_st->st_ino, &target_st->st_ino);
3284 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3285         __put_user(host_st->st_ino, &target_st->__st_ino);
3286 #endif
3287         __put_user(host_st->st_mode, &target_st->st_mode);
3288         __put_user(host_st->st_nlink, &target_st->st_nlink);
3289         __put_user(host_st->st_uid, &target_st->st_uid);
3290         __put_user(host_st->st_gid, &target_st->st_gid);
3291         __put_user(host_st->st_rdev, &target_st->st_rdev);
3292         /* XXX: better use of kernel struct */
3293         __put_user(host_st->st_size, &target_st->st_size);
3294         __put_user(host_st->st_blksize, &target_st->st_blksize);
3295         __put_user(host_st->st_blocks, &target_st->st_blocks);
3296         __put_user(host_st->st_atime, &target_st->target_st_atime);
3297         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3298         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3299         unlock_user_struct(target_st, target_addr, 1);
3300     }
3301
3302     return 0;
3303 }
3304 #endif
3305
3306 #if defined(USE_NPTL)
3307 /* ??? Using host futex calls even when target atomic operations
3308    are not really atomic probably breaks things.  However implementing
3309    futexes locally would make futexes shared between multiple processes
3310    tricky.  However they're probably useless because guest atomic
3311    operations won't work either.  */
3312 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
3313                     target_ulong uaddr2, int val3)
3314 {
3315     struct timespec ts, *pts;
3316
3317     /* ??? We assume FUTEX_* constants are the same on both host
3318        and target.  */
3319     switch (op) {
3320     case FUTEX_WAIT:
3321         if (timeout) {
3322             pts = &ts;
3323             target_to_host_timespec(pts, timeout);
3324         } else {
3325             pts = NULL;
3326         }
3327         return get_errno(sys_futex(g2h(uaddr), FUTEX_WAIT, tswap32(val),
3328                          pts, NULL, 0));
3329     case FUTEX_WAKE:
3330         return get_errno(sys_futex(g2h(uaddr), FUTEX_WAKE, val, NULL, NULL, 0));
3331     case FUTEX_FD:
3332         return get_errno(sys_futex(g2h(uaddr), FUTEX_FD, val, NULL, NULL, 0));
3333     case FUTEX_REQUEUE:
3334         return get_errno(sys_futex(g2h(uaddr), FUTEX_REQUEUE, val,
3335                          NULL, g2h(uaddr2), 0));
3336     case FUTEX_CMP_REQUEUE:
3337         return get_errno(sys_futex(g2h(uaddr), FUTEX_CMP_REQUEUE, val,
3338                          NULL, g2h(uaddr2), tswap32(val3)));
3339     default:
3340         return -TARGET_ENOSYS;
3341     }
3342 }
3343 #endif
3344
3345 int get_osversion(void)
3346 {
3347     static int osversion;
3348     struct new_utsname buf;
3349     const char *s;
3350     int i, n, tmp;
3351     if (osversion)
3352         return osversion;
3353     if (qemu_uname_release && *qemu_uname_release) {
3354         s = qemu_uname_release;
3355     } else {
3356         if (sys_uname(&buf))
3357             return 0;
3358         s = buf.release;
3359     }
3360     tmp = 0;
3361     for (i = 0; i < 3; i++) {
3362         n = 0;
3363         while (*s >= '0' && *s <= '9') {
3364             n *= 10;
3365             n += *s - '0';
3366             s++;
3367         }
3368         tmp = (tmp << 8) + n;
3369         if (*s == '.')
3370             s++;
3371     }
3372     osversion = tmp;
3373     return osversion;
3374 }
3375
3376 /* do_syscall() should always have a single exit point at the end so
3377    that actions, such as logging of syscall results, can be performed.
3378    All errnos that do_syscall() returns must be -TARGET_<errcode>. */
3379 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
3380                     abi_long arg2, abi_long arg3, abi_long arg4,
3381                     abi_long arg5, abi_long arg6)
3382 {
3383     abi_long ret;
3384     struct stat st;
3385     struct statfs stfs;
3386     void *p;
3387
3388 #ifdef DEBUG
3389     gemu_log("syscall %d", num);
3390 #endif
3391     if(do_strace)
3392         print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
3393
3394     switch(num) {
3395     case TARGET_NR_exit:
3396 #ifdef HAVE_GPROF
3397         _mcleanup();
3398 #endif
3399         gdb_exit(cpu_env, arg1);
3400         /* XXX: should free thread stack and CPU env */
3401         sys_exit(arg1);
3402         ret = 0; /* avoid warning */
3403         break;
3404     case TARGET_NR_read:
3405         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
3406             goto efault;
3407         ret = get_errno(read(arg1, p, arg3));
3408         unlock_user(p, arg2, ret);
3409         break;
3410     case TARGET_NR_write:
3411         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
3412             goto efault;
3413         ret = get_errno(write(arg1, p, arg3));
3414         unlock_user(p, arg2, 0);
3415         break;
3416     case TARGET_NR_open:
3417         if (!(p = lock_user_string(arg1)))
3418             goto efault;
3419         ret = get_errno(open(path(p),
3420                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
3421                              arg3));
3422         unlock_user(p, arg1, 0);
3423         break;
3424 #if defined(TARGET_NR_openat) && defined(__NR_openat)
3425     case TARGET_NR_openat:
3426         if (!(p = lock_user_string(arg2)))
3427             goto efault;
3428         ret = get_errno(sys_openat(arg1,
3429                                    path(p),
3430                                    target_to_host_bitmask(arg3, fcntl_flags_tbl),
3431                                    arg4));
3432         unlock_user(p, arg2, 0);
3433         break;
3434 #endif
3435     case TARGET_NR_close:
3436         ret = get_errno(close(arg1));
3437         break;
3438     case TARGET_NR_brk:
3439         ret = do_brk(arg1);
3440         break;
3441     case TARGET_NR_fork:
3442         ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
3443         break;
3444 #ifdef TARGET_NR_waitpid
3445     case TARGET_NR_waitpid:
3446         {
3447             int status;
3448             ret = get_errno(waitpid(arg1, &status, arg3));
3449             if (!is_error(ret) && arg2
3450                 && put_user_s32(status, arg2))
3451                 goto efault;
3452         }
3453         break;
3454 #endif
3455 #ifdef TARGET_NR_waitid
3456     case TARGET_NR_waitid:
3457         {
3458             siginfo_t info;
3459             info.si_pid = 0;
3460             ret = get_errno(waitid(arg1, arg2, &info, arg4));
3461             if (!is_error(ret) && arg3 && info.si_pid != 0) {
3462                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
3463                     goto efault;
3464                 host_to_target_siginfo(p, &info);
3465                 unlock_user(p, arg3, sizeof(target_siginfo_t));
3466             }
3467         }
3468         break;
3469 #endif
3470 #ifdef TARGET_NR_creat /* not on alpha */
3471     case TARGET_NR_creat:
3472         if (!(p = lock_user_string(arg1)))
3473             goto efault;
3474         ret = get_errno(creat(p, arg2));
3475         unlock_user(p, arg1, 0);
3476         break;
3477 #endif
3478     case TARGET_NR_link:
3479         {
3480             void * p2;
3481             p = lock_user_string(arg1);
3482             p2 = lock_user_string(arg2);
3483             if (!p || !p2)
3484                 ret = -TARGET_EFAULT;
3485             else
3486                 ret = get_errno(link(p, p2));
3487             unlock_user(p2, arg2, 0);
3488             unlock_user(p, arg1, 0);
3489         }
3490         break;
3491 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3492     case TARGET_NR_linkat:
3493         {
3494             void * p2 = NULL;
3495             if (!arg2 || !arg4)
3496                 goto efault;
3497             p  = lock_user_string(arg2);
3498             p2 = lock_user_string(arg4);
3499             if (!p || !p2)
3500                 ret = -TARGET_EFAULT;
3501             else
3502                 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
3503             unlock_user(p, arg2, 0);
3504             unlock_user(p2, arg4, 0);
3505         }
3506         break;
3507 #endif
3508     case TARGET_NR_unlink:
3509         if (!(p = lock_user_string(arg1)))
3510             goto efault;
3511         ret = get_errno(unlink(p));
3512         unlock_user(p, arg1, 0);
3513         break;
3514 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3515     case TARGET_NR_unlinkat:
3516         if (!(p = lock_user_string(arg2)))
3517             goto efault;
3518         ret = get_errno(sys_unlinkat(arg1, p, arg3));
3519         unlock_user(p, arg2, 0);
3520         break;
3521 #endif
3522     case TARGET_NR_execve:
3523         {
3524             char **argp, **envp;
3525             int argc, envc;
3526             abi_ulong gp;
3527             abi_ulong guest_argp;
3528             abi_ulong guest_envp;
3529             abi_ulong addr;
3530             char **q;
3531
3532             argc = 0;
3533             guest_argp = arg2;
3534             for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
3535                 if (get_user_ual(addr, gp))
3536                     goto efault;
3537                 if (!addr)
3538                     break;
3539                 argc++;
3540             }
3541             envc = 0;
3542             guest_envp = arg3;
3543             for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
3544                 if (get_user_ual(addr, gp))
3545                     goto efault;
3546                 if (!addr)
3547                     break;
3548                 envc++;
3549             }
3550
3551             argp = alloca((argc + 1) * sizeof(void *));
3552             envp = alloca((envc + 1) * sizeof(void *));
3553
3554             for (gp = guest_argp, q = argp; gp;
3555                   gp += sizeof(abi_ulong), q++) {
3556                 if (get_user_ual(addr, gp))
3557                     goto execve_efault;
3558                 if (!addr)
3559                     break;
3560                 if (!(*q = lock_user_string(addr)))
3561                     goto execve_efault;
3562             }
3563             *q = NULL;
3564
3565             for (gp = guest_envp, q = envp; gp;
3566                   gp += sizeof(abi_ulong), q++) {
3567                 if (get_user_ual(addr, gp))
3568                     goto execve_efault;
3569                 if (!addr)
3570                     break;
3571                 if (!(*q = lock_user_string(addr)))
3572                     goto execve_efault;
3573             }
3574             *q = NULL;
3575
3576             if (!(p = lock_user_string(arg1)))
3577                 goto execve_efault;
3578             ret = get_errno(execve(p, argp, envp));
3579             unlock_user(p, arg1, 0);
3580
3581             goto execve_end;
3582
3583         execve_efault:
3584             ret = -TARGET_EFAULT;
3585
3586         execve_end:
3587             for (gp = guest_argp, q = argp; *q;
3588                   gp += sizeof(abi_ulong), q++) {
3589                 if (get_user_ual(addr, gp)
3590                     || !addr)
3591                     break;
3592                 unlock_user(*q, addr, 0);
3593             }
3594             for (gp = guest_envp, q = envp; *q;
3595                   gp += sizeof(abi_ulong), q++) {
3596                 if (get_user_ual(addr, gp)
3597                     || !addr)
3598                     break;
3599                 unlock_user(*q, addr, 0);
3600             }
3601         }
3602         break;
3603     case TARGET_NR_chdir:
3604         if (!(p = lock_user_string(arg1)))
3605             goto efault;
3606         ret = get_errno(chdir(p));
3607         unlock_user(p, arg1, 0);
3608         break;
3609 #ifdef TARGET_NR_time
3610     case TARGET_NR_time:
3611         {
3612             time_t host_time;
3613             ret = get_errno(time(&host_time));
3614             if (!is_error(ret)
3615                 && arg1
3616                 && put_user_sal(host_time, arg1))
3617                 goto efault;
3618         }
3619         break;
3620 #endif
3621     case TARGET_NR_mknod:
3622         if (!(p = lock_user_string(arg1)))
3623             goto efault;
3624         ret = get_errno(mknod(p, arg2, arg3));
3625         unlock_user(p, arg1, 0);
3626         break;
3627 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3628     case TARGET_NR_mknodat:
3629         if (!(p = lock_user_string(arg2)))
3630             goto efault;
3631         ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
3632         unlock_user(p, arg2, 0);
3633         break;
3634 #endif
3635     case TARGET_NR_chmod:
3636         if (!(p = lock_user_string(arg1)))
3637             goto efault;
3638         ret = get_errno(chmod(p, arg2));
3639         unlock_user(p, arg1, 0);
3640         break;
3641 #ifdef TARGET_NR_break
3642     case TARGET_NR_break:
3643         goto unimplemented;
3644 #endif
3645 #ifdef TARGET_NR_oldstat
3646     case TARGET_NR_oldstat:
3647         goto unimplemented;
3648 #endif
3649     case TARGET_NR_lseek:
3650         ret = get_errno(lseek(arg1, arg2, arg3));
3651         break;
3652 #ifdef TARGET_NR_getxpid
3653     case TARGET_NR_getxpid:
3654 #else
3655     case TARGET_NR_getpid:
3656 #endif
3657         ret = get_errno(getpid());
3658         break;
3659     case TARGET_NR_mount:
3660                 {
3661                         /* need to look at the data field */
3662                         void *p2, *p3;
3663                         p = lock_user_string(arg1);
3664                         p2 = lock_user_string(arg2);
3665                         p3 = lock_user_string(arg3);
3666                         if (!p || !p2 || !p3)
3667                             ret = -TARGET_EFAULT;
3668                         else
3669                             /* FIXME - arg5 should be locked, but it isn't clear how to
3670                              * do that since it's not guaranteed to be a NULL-terminated
3671                              * string.
3672                              */
3673                             ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
3674                         unlock_user(p, arg1, 0);
3675                         unlock_user(p2, arg2, 0);
3676                         unlock_user(p3, arg3, 0);
3677                         break;
3678                 }
3679 #ifdef TARGET_NR_umount
3680     case TARGET_NR_umount:
3681         if (!(p = lock_user_string(arg1)))
3682             goto efault;
3683         ret = get_errno(umount(p));
3684         unlock_user(p, arg1, 0);
3685         break;
3686 #endif
3687 #ifdef TARGET_NR_stime /* not on alpha */
3688     case TARGET_NR_stime:
3689         {
3690             time_t host_time;
3691             if (get_user_sal(host_time, arg1))
3692                 goto efault;
3693             ret = get_errno(stime(&host_time));
3694         }
3695         break;
3696 #endif
3697     case TARGET_NR_ptrace:
3698         goto unimplemented;
3699 #ifdef TARGET_NR_alarm /* not on alpha */
3700     case TARGET_NR_alarm:
3701         ret = alarm(arg1);
3702         break;
3703 #endif
3704 #ifdef TARGET_NR_oldfstat
3705     case TARGET_NR_oldfstat:
3706         goto unimplemented;
3707 #endif
3708 #ifdef TARGET_NR_pause /* not on alpha */
3709     case TARGET_NR_pause:
3710         ret = get_errno(pause());
3711         break;
3712 #endif
3713 #ifdef TARGET_NR_utime
3714     case TARGET_NR_utime:
3715         {
3716             struct utimbuf tbuf, *host_tbuf;
3717             struct target_utimbuf *target_tbuf;
3718             if (arg2) {
3719                 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
3720                     goto efault;
3721                 tbuf.actime = tswapl(target_tbuf->actime);
3722                 tbuf.modtime = tswapl(target_tbuf->modtime);
3723                 unlock_user_struct(target_tbuf, arg2, 0);
3724                 host_tbuf = &tbuf;
3725             } else {
3726                 host_tbuf = NULL;
3727             }
3728             if (!(p = lock_user_string(arg1)))
3729                 goto efault;
3730             ret = get_errno(utime(p, host_tbuf));
3731             unlock_user(p, arg1, 0);
3732         }
3733         break;
3734 #endif
3735     case TARGET_NR_utimes:
3736         {
3737             struct timeval *tvp, tv[2];
3738             if (arg2) {
3739                 if (copy_from_user_timeval(&tv[0], arg2)
3740                     || copy_from_user_timeval(&tv[1],
3741                                               arg2 + sizeof(struct target_timeval)))
3742                     goto efault;
3743                 tvp = tv;
3744             } else {
3745                 tvp = NULL;
3746             }
3747             if (!(p = lock_user_string(arg1)))
3748                 goto efault;
3749             ret = get_errno(utimes(p, tvp));
3750             unlock_user(p, arg1, 0);
3751         }
3752         break;
3753 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
3754     case TARGET_NR_futimesat:
3755         {
3756             struct timeval *tvp, tv[2];
3757             if (arg3) {
3758                 if (copy_from_user_timeval(&tv[0], arg3)
3759                     || copy_from_user_timeval(&tv[1],
3760                                               arg3 + sizeof(struct target_timeval)))
3761                     goto efault;
3762                 tvp = tv;
3763             } else {
3764                 tvp = NULL;
3765             }
3766             if (!(p = lock_user_string(arg2)))
3767                 goto efault;
3768             ret = get_errno(sys_futimesat(arg1, path(p), tvp));
3769             unlock_user(p, arg2, 0);
3770         }
3771         break;
3772 #endif
3773 #ifdef TARGET_NR_stty
3774     case TARGET_NR_stty:
3775         goto unimplemented;
3776 #endif
3777 #ifdef TARGET_NR_gtty
3778     case TARGET_NR_gtty:
3779         goto unimplemented;
3780 #endif
3781     case TARGET_NR_access:
3782         if (!(p = lock_user_string(arg1)))
3783             goto efault;
3784         ret = get_errno(access(p, arg2));
3785         unlock_user(p, arg1, 0);
3786         break;
3787 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3788     case TARGET_NR_faccessat:
3789         if (!(p = lock_user_string(arg2)))
3790             goto efault;
3791         ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
3792         unlock_user(p, arg2, 0);
3793         break;
3794 #endif
3795 #ifdef TARGET_NR_nice /* not on alpha */
3796     case TARGET_NR_nice:
3797         ret = get_errno(nice(arg1));
3798         break;
3799 #endif
3800 #ifdef TARGET_NR_ftime
3801     case TARGET_NR_ftime:
3802         goto unimplemented;
3803 #endif
3804     case TARGET_NR_sync:
3805         sync();
3806         ret = 0;
3807         break;
3808     case TARGET_NR_kill:
3809         ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
3810         break;
3811     case TARGET_NR_rename:
3812         {
3813             void *p2;
3814             p = lock_user_string(arg1);
3815             p2 = lock_user_string(arg2);
3816             if (!p || !p2)
3817                 ret = -TARGET_EFAULT;
3818             else
3819                 ret = get_errno(rename(p, p2));
3820             unlock_user(p2, arg2, 0);
3821             unlock_user(p, arg1, 0);
3822         }
3823         break;
3824 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3825     case TARGET_NR_renameat:
3826         {
3827             void *p2;
3828             p  = lock_user_string(arg2);
3829             p2 = lock_user_string(arg4);
3830             if (!p || !p2)
3831                 ret = -TARGET_EFAULT;
3832             else
3833                 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
3834             unlock_user(p2, arg4, 0);
3835             unlock_user(p, arg2, 0);
3836         }
3837         break;
3838 #endif
3839     case TARGET_NR_mkdir:
3840         if (!(p = lock_user_string(arg1)))
3841             goto efault;
3842         ret = get_errno(mkdir(p, arg2));
3843         unlock_user(p, arg1, 0);
3844         break;
3845 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3846     case TARGET_NR_mkdirat:
3847         if (!(p = lock_user_string(arg2)))
3848             goto efault;
3849         ret = get_errno(sys_mkdirat(arg1, p, arg3));
3850         unlock_user(p, arg2, 0);
3851         break;
3852 #endif
3853     case TARGET_NR_rmdir:
3854         if (!(p = lock_user_string(arg1)))
3855             goto efault;
3856         ret = get_errno(rmdir(p));
3857         unlock_user(p, arg1, 0);
3858         break;
3859     case TARGET_NR_dup:
3860         ret = get_errno(dup(arg1));
3861         break;
3862     case TARGET_NR_pipe:
3863         {
3864             int host_pipe[2];
3865             ret = get_errno(pipe(host_pipe));
3866             if (!is_error(ret)) {
3867 #if defined(TARGET_MIPS)
3868                 CPUMIPSState *env = (CPUMIPSState*)cpu_env;
3869                 env->active_tc.gpr[3] = host_pipe[1];
3870                 ret = host_pipe[0];
3871 #elif defined(TARGET_SH4)
3872                 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
3873                 ret = host_pipe[0];
3874 #else
3875                 if (put_user_s32(host_pipe[0], arg1)
3876                     || put_user_s32(host_pipe[1], arg1 + sizeof(host_pipe[0])))
3877                     goto efault;
3878 #endif
3879             }
3880         }
3881         break;
3882     case TARGET_NR_times:
3883         {
3884             struct target_tms *tmsp;
3885             struct tms tms;
3886             ret = get_errno(times(&tms));
3887             if (arg1) {
3888                 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
3889                 if (!tmsp)
3890                     goto efault;
3891                 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
3892                 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
3893                 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
3894                 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
3895             }
3896             if (!is_error(ret))
3897                 ret = host_to_target_clock_t(ret);
3898         }
3899         break;
3900 #ifdef TARGET_NR_prof
3901     case TARGET_NR_prof:
3902         goto unimplemented;
3903 #endif
3904 #ifdef TARGET_NR_signal
3905     case TARGET_NR_signal:
3906         goto unimplemented;
3907 #endif
3908     case TARGET_NR_acct:
3909         if (!(p = lock_user_string(arg1)))
3910             goto efault;
3911         ret = get_errno(acct(path(p)));
3912         unlock_user(p, arg1, 0);
3913         break;
3914 #ifdef TARGET_NR_umount2 /* not on alpha */
3915     case TARGET_NR_umount2:
3916         if (!(p = lock_user_string(arg1)))
3917             goto efault;
3918         ret = get_errno(umount2(p, arg2));
3919         unlock_user(p, arg1, 0);
3920         break;
3921 #endif
3922 #ifdef TARGET_NR_lock
3923     case TARGET_NR_lock:
3924         goto unimplemented;
3925 #endif
3926     case TARGET_NR_ioctl:
3927         ret = do_ioctl(arg1, arg2, arg3);
3928         break;
3929     case TARGET_NR_fcntl:
3930         ret = do_fcntl(arg1, arg2, arg3);
3931         break;
3932 #ifdef TARGET_NR_mpx
3933     case TARGET_NR_mpx:
3934         goto unimplemented;
3935 #endif
3936     case TARGET_NR_setpgid:
3937         ret = get_errno(setpgid(arg1, arg2));
3938         break;
3939 #ifdef TARGET_NR_ulimit
3940     case TARGET_NR_ulimit:
3941         goto unimplemented;
3942 #endif
3943 #ifdef TARGET_NR_oldolduname
3944     case TARGET_NR_oldolduname:
3945         goto unimplemented;
3946 #endif
3947     case TARGET_NR_umask:
3948         ret = get_errno(umask(arg1));
3949         break;
3950     case TARGET_NR_chroot:
3951         if (!(p = lock_user_string(arg1)))
3952             goto efault;
3953         ret = get_errno(chroot(p));
3954         unlock_user(p, arg1, 0);
3955         break;
3956     case TARGET_NR_ustat:
3957         goto unimplemented;
3958     case TARGET_NR_dup2:
3959         ret = get_errno(dup2(arg1, arg2));
3960         break;
3961 #ifdef TARGET_NR_getppid /* not on alpha */
3962     case TARGET_NR_getppid:
3963         ret = get_errno(getppid());
3964         break;
3965 #endif
3966     case TARGET_NR_getpgrp:
3967         ret = get_errno(getpgrp());
3968         break;
3969     case TARGET_NR_setsid:
3970         ret = get_errno(setsid());
3971         break;
3972 #ifdef TARGET_NR_sigaction
3973     case TARGET_NR_sigaction:
3974         {
3975 #if !defined(TARGET_MIPS)
3976             struct target_old_sigaction *old_act;
3977             struct target_sigaction act, oact, *pact;
3978             if (arg2) {
3979                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3980                     goto efault;
3981                 act._sa_handler = old_act->_sa_handler;
3982                 target_siginitset(&act.sa_mask, old_act->sa_mask);
3983                 act.sa_flags = old_act->sa_flags;
3984                 act.sa_restorer = old_act->sa_restorer;
3985                 unlock_user_struct(old_act, arg2, 0);
3986                 pact = &act;
3987             } else {
3988                 pact = NULL;
3989             }
3990             ret = get_errno(do_sigaction(arg1, pact, &oact));
3991             if (!is_error(ret) && arg3) {
3992                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3993                     goto efault;
3994                 old_act->_sa_handler = oact._sa_handler;
3995                 old_act->sa_mask = oact.sa_mask.sig[0];
3996                 old_act->sa_flags = oact.sa_flags;
3997                 old_act->sa_restorer = oact.sa_restorer;
3998                 unlock_user_struct(old_act, arg3, 1);
3999             }
4000 #else
4001             struct target_sigaction act, oact, *pact, *old_act;
4002
4003             if (arg2) {
4004                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
4005                     goto efault;
4006                 act._sa_handler = old_act->_sa_handler;
4007                 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
4008                 act.sa_flags = old_act->sa_flags;
4009                 unlock_user_struct(old_act, arg2, 0);
4010                 pact = &act;
4011             } else {
4012                 pact = NULL;
4013             }
4014
4015             ret = get_errno(do_sigaction(arg1, pact, &oact));
4016
4017             if (!is_error(ret) && arg3) {
4018                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
4019                     goto efault;
4020                 old_act->_sa_handler = oact._sa_handler;
4021                 old_act->sa_flags = oact.sa_flags;
4022                 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
4023                 old_act->sa_mask.sig[1] = 0;
4024                 old_act->sa_mask.sig[2] = 0;
4025                 old_act->sa_mask.sig[3] = 0;
4026                 unlock_user_struct(old_act, arg3, 1);
4027             }
4028 #endif
4029         }
4030         break;
4031 #endif
4032     case TARGET_NR_rt_sigaction:
4033         {
4034             struct target_sigaction *act;
4035             struct target_sigaction *oact;
4036
4037             if (arg2) {
4038                 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
4039                     goto efault;
4040             } else
4041                 act = NULL;
4042             if (arg3) {
4043                 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
4044                     ret = -TARGET_EFAULT;
4045                     goto rt_sigaction_fail;
4046                 }
4047             } else
4048                 oact = NULL;
4049             ret = get_errno(do_sigaction(arg1, act, oact));
4050         rt_sigaction_fail:
4051             if (act)
4052                 unlock_user_struct(act, arg2, 0);
4053             if (oact)
4054                 unlock_user_struct(oact, arg3, 1);
4055         }
4056         break;
4057 #ifdef TARGET_NR_sgetmask /* not on alpha */
4058     case TARGET_NR_sgetmask:
4059         {
4060             sigset_t cur_set;
4061             abi_ulong target_set;
4062             sigprocmask(0, NULL, &cur_set);
4063             host_to_target_old_sigset(&target_set, &cur_set);
4064             ret = target_set;
4065         }
4066         break;
4067 #endif
4068 #ifdef TARGET_NR_ssetmask /* not on alpha */
4069     case TARGET_NR_ssetmask:
4070         {
4071             sigset_t set, oset, cur_set;
4072             abi_ulong target_set = arg1;
4073             sigprocmask(0, NULL, &cur_set);
4074             target_to_host_old_sigset(&set, &target_set);
4075             sigorset(&set, &set, &cur_set);
4076             sigprocmask(SIG_SETMASK, &set, &oset);
4077             host_to_target_old_sigset(&target_set, &oset);
4078             ret = target_set;
4079         }
4080         break;
4081 #endif
4082 #ifdef TARGET_NR_sigprocmask
4083     case TARGET_NR_sigprocmask:
4084         {
4085             int how = arg1;
4086             sigset_t set, oldset, *set_ptr;
4087
4088             if (arg2) {
4089                 switch(how) {
4090                 case TARGET_SIG_BLOCK:
4091                     how = SIG_BLOCK;
4092                     break;
4093                 case TARGET_SIG_UNBLOCK:
4094                     how = SIG_UNBLOCK;
4095                     break;
4096                 case TARGET_SIG_SETMASK:
4097                     how = SIG_SETMASK;
4098                     break;
4099                 default:
4100                     ret = -TARGET_EINVAL;
4101                     goto fail;
4102                 }
4103                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4104                     goto efault;
4105                 target_to_host_old_sigset(&set, p);
4106                 unlock_user(p, arg2, 0);
4107                 set_ptr = &set;
4108             } else {
4109                 how = 0;
4110                 set_ptr = NULL;
4111             }
4112             ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
4113             if (!is_error(ret) && arg3) {
4114                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4115                     goto efault;
4116                 host_to_target_old_sigset(p, &oldset);
4117                 unlock_user(p, arg3, sizeof(target_sigset_t));
4118             }
4119         }
4120         break;
4121 #endif
4122     case TARGET_NR_rt_sigprocmask:
4123         {
4124             int how = arg1;
4125             sigset_t set, oldset, *set_ptr;
4126
4127             if (arg2) {
4128                 switch(how) {
4129                 case TARGET_SIG_BLOCK:
4130                     how = SIG_BLOCK;
4131                     break;
4132                 case TARGET_SIG_UNBLOCK:
4133                     how = SIG_UNBLOCK;
4134                     break;
4135                 case TARGET_SIG_SETMASK:
4136                     how = SIG_SETMASK;
4137                     break;
4138                 default:
4139                     ret = -TARGET_EINVAL;
4140                     goto fail;
4141                 }
4142                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4143                     goto efault;
4144                 target_to_host_sigset(&set, p);
4145                 unlock_user(p, arg2, 0);
4146                 set_ptr = &set;
4147             } else {
4148                 how = 0;
4149                 set_ptr = NULL;
4150             }
4151             ret = get_errno(sigprocmask(how, set_ptr, &oldset));
4152             if (!is_error(ret) && arg3) {
4153                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4154                     goto efault;
4155                 host_to_target_sigset(p, &oldset);
4156                 unlock_user(p, arg3, sizeof(target_sigset_t));
4157             }
4158         }
4159         break;
4160 #ifdef TARGET_NR_sigpending
4161     case TARGET_NR_sigpending:
4162         {
4163             sigset_t set;
4164             ret = get_errno(sigpending(&set));
4165             if (!is_error(ret)) {
4166                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4167                     goto efault;
4168                 host_to_target_old_sigset(p, &set);
4169                 unlock_user(p, arg1, sizeof(target_sigset_t));
4170             }
4171         }
4172         break;
4173 #endif
4174     case TARGET_NR_rt_sigpending:
4175         {
4176             sigset_t set;
4177             ret = get_errno(sigpending(&set));
4178             if (!is_error(ret)) {
4179                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4180                     goto efault;
4181                 host_to_target_sigset(p, &set);
4182                 unlock_user(p, arg1, sizeof(target_sigset_t));
4183             }
4184         }
4185         break;
4186 #ifdef TARGET_NR_sigsuspend
4187     case TARGET_NR_sigsuspend:
4188         {
4189             sigset_t set;
4190             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4191                 goto efault;
4192             target_to_host_old_sigset(&set, p);
4193             unlock_user(p, arg1, 0);
4194             ret = get_errno(sigsuspend(&set));
4195         }
4196         break;
4197 #endif
4198     case TARGET_NR_rt_sigsuspend:
4199         {
4200             sigset_t set;
4201             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4202                 goto efault;
4203             target_to_host_sigset(&set, p);
4204             unlock_user(p, arg1, 0);
4205             ret = get_errno(sigsuspend(&set));
4206         }
4207         break;
4208     case TARGET_NR_rt_sigtimedwait:
4209         {
4210             sigset_t set;
4211             struct timespec uts, *puts;
4212             siginfo_t uinfo;
4213
4214             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4215                 goto efault;
4216             target_to_host_sigset(&set, p);
4217             unlock_user(p, arg1, 0);
4218             if (arg3) {
4219                 puts = &uts;
4220                 target_to_host_timespec(puts, arg3);
4221             } else {
4222                 puts = NULL;
4223             }
4224             ret = get_errno(sigtimedwait(&set, &uinfo, puts));
4225             if (!is_error(ret) && arg2) {
4226                 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
4227                     goto efault;
4228                 host_to_target_siginfo(p, &uinfo);
4229                 unlock_user(p, arg2, sizeof(target_siginfo_t));
4230             }
4231         }
4232         break;
4233     case TARGET_NR_rt_sigqueueinfo:
4234         {
4235             siginfo_t uinfo;
4236             if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
4237                 goto efault;
4238             target_to_host_siginfo(&uinfo, p);
4239             unlock_user(p, arg1, 0);
4240             ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
4241         }
4242         break;
4243 #ifdef TARGET_NR_sigreturn
4244     case TARGET_NR_sigreturn:
4245         /* NOTE: ret is eax, so not transcoding must be done */
4246         ret = do_sigreturn(cpu_env);
4247         break;
4248 #endif
4249     case TARGET_NR_rt_sigreturn:
4250         /* NOTE: ret is eax, so not transcoding must be done */
4251         ret = do_rt_sigreturn(cpu_env);
4252         break;
4253     case TARGET_NR_sethostname:
4254         if (!(p = lock_user_string(arg1)))
4255             goto efault;
4256         ret = get_errno(sethostname(p, arg2));
4257         unlock_user(p, arg1, 0);
4258         break;
4259     case TARGET_NR_setrlimit:
4260         {
4261             /* XXX: convert resource ? */
4262             int resource = arg1;
4263             struct target_rlimit *target_rlim;
4264             struct rlimit rlim;
4265             if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
4266                 goto efault;
4267             rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4268             rlim.rlim_max = tswapl(target_rlim->rlim_max);
4269             unlock_user_struct(target_rlim, arg2, 0);
4270             ret = get_errno(setrlimit(resource, &rlim));
4271         }
4272         break;
4273     case TARGET_NR_getrlimit:
4274         {
4275             /* XXX: convert resource ? */
4276             int resource = arg1;
4277             struct target_rlimit *target_rlim;
4278             struct rlimit rlim;
4279
4280             ret = get_errno(getrlimit(resource, &rlim));
4281             if (!is_error(ret)) {
4282                 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
4283                     goto efault;
4284                 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4285                 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4286                 unlock_user_struct(target_rlim, arg2, 1);
4287             }
4288         }
4289         break;
4290     case TARGET_NR_getrusage:
4291         {
4292             struct rusage rusage;
4293             ret = get_errno(getrusage(arg1, &rusage));
4294             if (!is_error(ret)) {
4295                 host_to_target_rusage(arg2, &rusage);
4296             }
4297         }
4298         break;
4299     case TARGET_NR_gettimeofday:
4300         {
4301             struct timeval tv;
4302             ret = get_errno(gettimeofday(&tv, NULL));
4303             if (!is_error(ret)) {
4304                 if (copy_to_user_timeval(arg1, &tv))
4305                     goto efault;
4306             }
4307         }
4308         break;
4309     case TARGET_NR_settimeofday:
4310         {
4311             struct timeval tv;
4312             if (copy_from_user_timeval(&tv, arg1))
4313                 goto efault;
4314             ret = get_errno(settimeofday(&tv, NULL));
4315         }
4316         break;
4317 #ifdef TARGET_NR_select
4318     case TARGET_NR_select:
4319         {
4320             struct target_sel_arg_struct *sel;
4321             abi_ulong inp, outp, exp, tvp;
4322             long nsel;
4323
4324             if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
4325                 goto efault;
4326             nsel = tswapl(sel->n);
4327             inp = tswapl(sel->inp);
4328             outp = tswapl(sel->outp);
4329             exp = tswapl(sel->exp);
4330             tvp = tswapl(sel->tvp);
4331             unlock_user_struct(sel, arg1, 0);
4332             ret = do_select(nsel, inp, outp, exp, tvp);
4333         }
4334         break;
4335 #endif
4336     case TARGET_NR_symlink:
4337         {
4338             void *p2;
4339             p = lock_user_string(arg1);
4340             p2 = lock_user_string(arg2);
4341             if (!p || !p2)
4342                 ret = -TARGET_EFAULT;
4343             else
4344                 ret = get_errno(symlink(p, p2));
4345             unlock_user(p2, arg2, 0);
4346             unlock_user(p, arg1, 0);
4347         }
4348         break;
4349 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4350     case TARGET_NR_symlinkat:
4351         {
4352             void *p2;
4353             p  = lock_user_string(arg1);
4354             p2 = lock_user_string(arg3);
4355             if (!p || !p2)
4356                 ret = -TARGET_EFAULT;
4357             else
4358                 ret = get_errno(sys_symlinkat(p, arg2, p2));
4359             unlock_user(p2, arg3, 0);
4360             unlock_user(p, arg1, 0);
4361         }
4362         break;
4363 #endif
4364 #ifdef TARGET_NR_oldlstat
4365     case TARGET_NR_oldlstat:
4366         goto unimplemented;
4367 #endif
4368     case TARGET_NR_readlink:
4369         {
4370             void *p2;
4371             p = lock_user_string(arg1);
4372             p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
4373             if (!p || !p2)
4374                 ret = -TARGET_EFAULT;
4375             else
4376                 ret = get_errno(readlink(path(p), p2, arg3));
4377             unlock_user(p2, arg2, ret);
4378             unlock_user(p, arg1, 0);
4379         }
4380         break;
4381 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4382     case TARGET_NR_readlinkat:
4383         {
4384             void *p2;
4385             p  = lock_user_string(arg2);
4386             p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
4387             if (!p || !p2)
4388                 ret = -TARGET_EFAULT;
4389             else
4390                 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
4391             unlock_user(p2, arg3, ret);
4392             unlock_user(p, arg2, 0);
4393         }
4394         break;
4395 #endif
4396 #ifdef TARGET_NR_uselib
4397     case TARGET_NR_uselib:
4398         goto unimplemented;
4399 #endif
4400 #ifdef TARGET_NR_swapon
4401     case TARGET_NR_swapon:
4402         if (!(p = lock_user_string(arg1)))
4403             goto efault;
4404         ret = get_errno(swapon(p, arg2));
4405         unlock_user(p, arg1, 0);
4406         break;
4407 #endif
4408     case TARGET_NR_reboot:
4409         goto unimplemented;
4410 #ifdef TARGET_NR_readdir
4411     case TARGET_NR_readdir:
4412         goto unimplemented;
4413 #endif
4414 #ifdef TARGET_NR_mmap
4415     case TARGET_NR_mmap:
4416 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
4417         {
4418             abi_ulong *v;
4419             abi_ulong v1, v2, v3, v4, v5, v6;
4420             if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
4421                 goto efault;
4422             v1 = tswapl(v[0]);
4423             v2 = tswapl(v[1]);
4424             v3 = tswapl(v[2]);
4425             v4 = tswapl(v[3]);
4426             v5 = tswapl(v[4]);
4427             v6 = tswapl(v[5]);
4428             unlock_user(v, arg1, 0);
4429             ret = get_errno(target_mmap(v1, v2, v3,
4430                                         target_to_host_bitmask(v4, mmap_flags_tbl),
4431                                         v5, v6));
4432         }
4433 #else
4434         ret = get_errno(target_mmap(arg1, arg2, arg3,
4435                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
4436                                     arg5,
4437                                     arg6));
4438 #endif
4439         break;
4440 #endif
4441 #ifdef TARGET_NR_mmap2
4442     case TARGET_NR_mmap2:
4443 #ifndef MMAP_SHIFT
4444 #define MMAP_SHIFT 12
4445 #endif
4446         ret = get_errno(target_mmap(arg1, arg2, arg3,
4447                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
4448                                     arg5,
4449                                     arg6 << MMAP_SHIFT));
4450         break;
4451 #endif
4452     case TARGET_NR_munmap:
4453         ret = get_errno(target_munmap(arg1, arg2));
4454         break;
4455     case TARGET_NR_mprotect:
4456         ret = get_errno(target_mprotect(arg1, arg2, arg3));
4457         break;
4458 #ifdef TARGET_NR_mremap
4459     case TARGET_NR_mremap:
4460         ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
4461         break;
4462 #endif
4463         /* ??? msync/mlock/munlock are broken for softmmu.  */
4464 #ifdef TARGET_NR_msync
4465     case TARGET_NR_msync:
4466         ret = get_errno(msync(g2h(arg1), arg2, arg3));
4467         break;
4468 #endif
4469 #ifdef TARGET_NR_mlock
4470     case TARGET_NR_mlock:
4471         ret = get_errno(mlock(g2h(arg1), arg2));
4472         break;
4473 #endif
4474 #ifdef TARGET_NR_munlock
4475     case TARGET_NR_munlock:
4476         ret = get_errno(munlock(g2h(arg1), arg2));
4477         break;
4478 #endif
4479 #ifdef TARGET_NR_mlockall
4480     case TARGET_NR_mlockall:
4481         ret = get_errno(mlockall(arg1));
4482         break;
4483 #endif
4484 #ifdef TARGET_NR_munlockall
4485     case TARGET_NR_munlockall:
4486         ret = get_errno(munlockall());
4487         break;
4488 #endif
4489     case TARGET_NR_truncate:
4490         if (!(p = lock_user_string(arg1)))
4491             goto efault;
4492         ret = get_errno(truncate(p, arg2));
4493         unlock_user(p, arg1, 0);
4494         break;
4495     case TARGET_NR_ftruncate:
4496         ret = get_errno(ftruncate(arg1, arg2));
4497         break;
4498     case TARGET_NR_fchmod:
4499         ret = get_errno(fchmod(arg1, arg2));
4500         break;
4501 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4502     case TARGET_NR_fchmodat:
4503         if (!(p = lock_user_string(arg2)))
4504             goto efault;
4505         ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4));
4506         unlock_user(p, arg2, 0);
4507         break;
4508 #endif
4509     case TARGET_NR_getpriority:
4510         /* libc does special remapping of the return value of
4511          * sys_getpriority() so it's just easiest to call
4512          * sys_getpriority() directly rather than through libc. */
4513         ret = sys_getpriority(arg1, arg2);
4514         break;
4515     case TARGET_NR_setpriority:
4516         ret = get_errno(setpriority(arg1, arg2, arg3));
4517         break;
4518 #ifdef TARGET_NR_profil
4519     case TARGET_NR_profil:
4520         goto unimplemented;
4521 #endif
4522     case TARGET_NR_statfs:
4523         if (!(p = lock_user_string(arg1)))
4524             goto efault;
4525         ret = get_errno(statfs(path(p), &stfs));
4526         unlock_user(p, arg1, 0);
4527     convert_statfs:
4528         if (!is_error(ret)) {
4529             struct target_statfs *target_stfs;
4530
4531             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
4532                 goto efault;
4533             __put_user(stfs.f_type, &target_stfs->f_type);
4534             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4535             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4536             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4537             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4538             __put_user(stfs.f_files, &target_stfs->f_files);
4539             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4540             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4541             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4542             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4543             unlock_user_struct(target_stfs, arg2, 1);
4544         }
4545         break;
4546     case TARGET_NR_fstatfs:
4547         ret = get_errno(fstatfs(arg1, &stfs));
4548         goto convert_statfs;
4549 #ifdef TARGET_NR_statfs64
4550     case TARGET_NR_statfs64:
4551         if (!(p = lock_user_string(arg1)))
4552             goto efault;
4553         ret = get_errno(statfs(path(p), &stfs));
4554         unlock_user(p, arg1, 0);
4555     convert_statfs64:
4556         if (!is_error(ret)) {
4557             struct target_statfs64 *target_stfs;
4558
4559             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
4560                 goto efault;
4561             __put_user(stfs.f_type, &target_stfs->f_type);
4562             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4563             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4564             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4565             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4566             __put_user(stfs.f_files, &target_stfs->f_files);
4567             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4568             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4569             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4570             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4571             unlock_user_struct(target_stfs, arg3, 1);
4572         }
4573         break;
4574     case TARGET_NR_fstatfs64:
4575         ret = get_errno(fstatfs(arg1, &stfs));
4576         goto convert_statfs64;
4577 #endif
4578 #ifdef TARGET_NR_ioperm
4579     case TARGET_NR_ioperm:
4580         goto unimplemented;
4581 #endif
4582 #ifdef TARGET_NR_socketcall
4583     case TARGET_NR_socketcall:
4584         ret = do_socketcall(arg1, arg2);
4585         break;
4586 #endif
4587 #ifdef TARGET_NR_accept
4588     case TARGET_NR_accept:
4589         ret = do_accept(arg1, arg2, arg3);
4590         break;
4591 #endif
4592 #ifdef TARGET_NR_bind
4593     case TARGET_NR_bind:
4594         ret = do_bind(arg1, arg2, arg3);
4595         break;
4596 #endif
4597 #ifdef TARGET_NR_connect
4598     case TARGET_NR_connect:
4599         ret = do_connect(arg1, arg2, arg3);
4600         break;
4601 #endif
4602 #ifdef TARGET_NR_getpeername
4603     case TARGET_NR_getpeername:
4604         ret = do_getpeername(arg1, arg2, arg3);
4605         break;
4606 #endif
4607 #ifdef TARGET_NR_getsockname
4608     case TARGET_NR_getsockname:
4609         ret = do_getsockname(arg1, arg2, arg3);
4610         break;
4611 #endif
4612 #ifdef TARGET_NR_getsockopt
4613     case TARGET_NR_getsockopt:
4614         ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
4615         break;
4616 #endif
4617 #ifdef TARGET_NR_listen
4618     case TARGET_NR_listen:
4619         ret = get_errno(listen(arg1, arg2));
4620         break;
4621 #endif
4622 #ifdef TARGET_NR_recv
4623     case TARGET_NR_recv:
4624         ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
4625         break;
4626 #endif
4627 #ifdef TARGET_NR_recvfrom
4628     case TARGET_NR_recvfrom:
4629         ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
4630         break;
4631 #endif
4632 #ifdef TARGET_NR_recvmsg
4633     case TARGET_NR_recvmsg:
4634         ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
4635         break;
4636 #endif
4637 #ifdef TARGET_NR_send
4638     case TARGET_NR_send:
4639         ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
4640         break;
4641 #endif
4642 #ifdef TARGET_NR_sendmsg
4643     case TARGET_NR_sendmsg:
4644         ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
4645         break;
4646 #endif
4647 #ifdef TARGET_NR_sendto
4648     case TARGET_NR_sendto:
4649         ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
4650         break;
4651 #endif
4652 #ifdef TARGET_NR_shutdown
4653     case TARGET_NR_shutdown:
4654         ret = get_errno(shutdown(arg1, arg2));
4655         break;
4656 #endif
4657 #ifdef TARGET_NR_socket
4658     case TARGET_NR_socket:
4659         ret = do_socket(arg1, arg2, arg3);
4660         break;
4661 #endif
4662 #ifdef TARGET_NR_socketpair
4663     case TARGET_NR_socketpair:
4664         ret = do_socketpair(arg1, arg2, arg3, arg4);
4665         break;
4666 #endif
4667 #ifdef TARGET_NR_setsockopt
4668     case TARGET_NR_setsockopt:
4669         ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
4670         break;
4671 #endif
4672
4673     case TARGET_NR_syslog:
4674         if (!(p = lock_user_string(arg2)))
4675             goto efault;
4676         ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
4677         unlock_user(p, arg2, 0);
4678         break;
4679
4680     case TARGET_NR_setitimer:
4681         {
4682             struct itimerval value, ovalue, *pvalue;
4683
4684             if (arg2) {
4685                 pvalue = &value;
4686                 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
4687                     || copy_from_user_timeval(&pvalue->it_value,
4688                                               arg2 + sizeof(struct target_timeval)))
4689                     goto efault;
4690             } else {
4691                 pvalue = NULL;
4692             }
4693             ret = get_errno(setitimer(arg1, pvalue, &ovalue));
4694             if (!is_error(ret) && arg3) {
4695                 if (copy_to_user_timeval(arg3,
4696                                          &ovalue.it_interval)
4697                     || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
4698                                             &ovalue.it_value))
4699                     goto efault;
4700             }
4701         }
4702         break;
4703     case TARGET_NR_getitimer:
4704         {
4705             struct itimerval value;
4706
4707             ret = get_errno(getitimer(arg1, &value));
4708             if (!is_error(ret) && arg2) {
4709                 if (copy_to_user_timeval(arg2,
4710                                          &value.it_interval)
4711                     || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
4712                                             &value.it_value))
4713                     goto efault;
4714             }
4715         }
4716         break;
4717     case TARGET_NR_stat:
4718         if (!(p = lock_user_string(arg1)))
4719             goto efault;
4720         ret = get_errno(stat(path(p), &st));
4721         unlock_user(p, arg1, 0);
4722         goto do_stat;
4723     case TARGET_NR_lstat:
4724         if (!(p = lock_user_string(arg1)))
4725             goto efault;
4726         ret = get_errno(lstat(path(p), &st));
4727         unlock_user(p, arg1, 0);
4728         goto do_stat;
4729     case TARGET_NR_fstat:
4730         {
4731             ret = get_errno(fstat(arg1, &st));
4732         do_stat:
4733             if (!is_error(ret)) {
4734                 struct target_stat *target_st;
4735
4736                 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
4737                     goto efault;
4738                 __put_user(st.st_dev, &target_st->st_dev);
4739                 __put_user(st.st_ino, &target_st->st_ino);
4740                 __put_user(st.st_mode, &target_st->st_mode);
4741                 __put_user(st.st_uid, &target_st->st_uid);
4742                 __put_user(st.st_gid, &target_st->st_gid);
4743                 __put_user(st.st_nlink, &target_st->st_nlink);
4744                 __put_user(st.st_rdev, &target_st->st_rdev);
4745                 __put_user(st.st_size, &target_st->st_size);
4746                 __put_user(st.st_blksize, &target_st->st_blksize);
4747                 __put_user(st.st_blocks, &target_st->st_blocks);
4748                 __put_user(st.st_atime, &target_st->target_st_atime);
4749                 __put_user(st.st_mtime, &target_st->target_st_mtime);
4750                 __put_user(st.st_ctime, &target_st->target_st_ctime);
4751                 unlock_user_struct(target_st, arg2, 1);
4752             }
4753         }
4754         break;
4755 #ifdef TARGET_NR_olduname
4756     case TARGET_NR_olduname:
4757         goto unimplemented;
4758 #endif
4759 #ifdef TARGET_NR_iopl
4760     case TARGET_NR_iopl:
4761         goto unimplemented;
4762 #endif
4763     case TARGET_NR_vhangup:
4764         ret = get_errno(vhangup());
4765         break;
4766 #ifdef TARGET_NR_idle
4767     case TARGET_NR_idle:
4768         goto unimplemented;
4769 #endif
4770 #ifdef TARGET_NR_syscall
4771     case TARGET_NR_syscall:
4772         ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
4773         break;
4774 #endif
4775     case TARGET_NR_wait4:
4776         {
4777             int status;
4778             abi_long status_ptr = arg2;
4779             struct rusage rusage, *rusage_ptr;
4780             abi_ulong target_rusage = arg4;
4781             if (target_rusage)
4782                 rusage_ptr = &rusage;
4783             else
4784                 rusage_ptr = NULL;
4785             ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
4786             if (!is_error(ret)) {
4787                 if (status_ptr) {
4788                     if (put_user_s32(status, status_ptr))
4789                         goto efault;
4790                 }
4791                 if (target_rusage)
4792                     host_to_target_rusage(target_rusage, &rusage);
4793             }
4794         }
4795         break;
4796 #ifdef TARGET_NR_swapoff
4797     case TARGET_NR_swapoff:
4798         if (!(p = lock_user_string(arg1)))
4799             goto efault;
4800         ret = get_errno(swapoff(p));
4801         unlock_user(p, arg1, 0);
4802         break;
4803 #endif
4804     case TARGET_NR_sysinfo:
4805         {
4806             struct target_sysinfo *target_value;
4807             struct sysinfo value;
4808             ret = get_errno(sysinfo(&value));
4809             if (!is_error(ret) && arg1)
4810             {
4811                 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
4812                     goto efault;
4813                 __put_user(value.uptime, &target_value->uptime);
4814                 __put_user(value.loads[0], &target_value->loads[0]);
4815                 __put_user(value.loads[1], &target_value->loads[1]);
4816                 __put_user(value.loads[2], &target_value->loads[2]);
4817                 __put_user(value.totalram, &target_value->totalram);
4818                 __put_user(value.freeram, &target_value->freeram);
4819                 __put_user(value.sharedram, &target_value->sharedram);
4820                 __put_user(value.bufferram, &target_value->bufferram);
4821                 __put_user(value.totalswap, &target_value->totalswap);
4822                 __put_user(value.freeswap, &target_value->freeswap);
4823                 __put_user(value.procs, &target_value->procs);
4824                 __put_user(value.totalhigh, &target_value->totalhigh);
4825                 __put_user(value.freehigh, &target_value->freehigh);
4826                 __put_user(value.mem_unit, &target_value->mem_unit);
4827                 unlock_user_struct(target_value, arg1, 1);
4828             }
4829         }
4830         break;
4831 #ifdef TARGET_NR_ipc
4832     case TARGET_NR_ipc:
4833         ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
4834         break;
4835 #endif
4836
4837 #ifdef TARGET_NR_msgctl
4838     case TARGET_NR_msgctl:
4839         ret = do_msgctl(arg1, arg2, arg3);
4840         break;
4841 #endif
4842 #ifdef TARGET_NR_msgget
4843     case TARGET_NR_msgget:
4844         ret = get_errno(msgget(arg1, arg2));
4845         break;
4846 #endif
4847 #ifdef TARGET_NR_msgrcv
4848     case TARGET_NR_msgrcv:
4849         ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
4850         break;
4851 #endif
4852 #ifdef TARGET_NR_msgsnd
4853     case TARGET_NR_msgsnd:
4854         ret = do_msgsnd(arg1, arg2, arg3, arg4);
4855         break;
4856 #endif
4857     case TARGET_NR_fsync:
4858         ret = get_errno(fsync(arg1));
4859         break;
4860     case TARGET_NR_clone:
4861 #if defined(TARGET_SH4)
4862         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
4863 #else
4864         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
4865 #endif
4866         break;
4867 #ifdef __NR_exit_group
4868         /* new thread calls */
4869     case TARGET_NR_exit_group:
4870 #ifdef HAVE_GPROF
4871         _mcleanup();
4872 #endif
4873         gdb_exit(cpu_env, arg1);
4874         ret = get_errno(exit_group(arg1));
4875         break;
4876 #endif
4877     case TARGET_NR_setdomainname:
4878         if (!(p = lock_user_string(arg1)))
4879             goto efault;
4880         ret = get_errno(setdomainname(p, arg2));
4881         unlock_user(p, arg1, 0);
4882         break;
4883     case TARGET_NR_uname:
4884         /* no need to transcode because we use the linux syscall */
4885         {
4886             struct new_utsname * buf;
4887
4888             if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
4889                 goto efault;
4890             ret = get_errno(sys_uname(buf));
4891             if (!is_error(ret)) {
4892                 /* Overrite the native machine name with whatever is being
4893                    emulated. */
4894                 strcpy (buf->machine, UNAME_MACHINE);
4895                 /* Allow the user to override the reported release.  */
4896                 if (qemu_uname_release && *qemu_uname_release)
4897                   strcpy (buf->release, qemu_uname_release);
4898             }
4899             unlock_user_struct(buf, arg1, 1);
4900         }
4901         break;
4902 #ifdef TARGET_I386
4903     case TARGET_NR_modify_ldt:
4904         ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
4905         break;
4906 #if !defined(TARGET_X86_64)
4907     case TARGET_NR_vm86old:
4908         goto unimplemented;
4909     case TARGET_NR_vm86:
4910         ret = do_vm86(cpu_env, arg1, arg2);
4911         break;
4912 #endif
4913 #endif
4914     case TARGET_NR_adjtimex:
4915         goto unimplemented;
4916 #ifdef TARGET_NR_create_module
4917     case TARGET_NR_create_module:
4918 #endif
4919     case TARGET_NR_init_module:
4920     case TARGET_NR_delete_module:
4921 #ifdef TARGET_NR_get_kernel_syms
4922     case TARGET_NR_get_kernel_syms:
4923 #endif
4924         goto unimplemented;
4925     case TARGET_NR_quotactl:
4926         goto unimplemented;
4927     case TARGET_NR_getpgid:
4928         ret = get_errno(getpgid(arg1));
4929         break;
4930     case TARGET_NR_fchdir:
4931         ret = get_errno(fchdir(arg1));
4932         break;
4933 #ifdef TARGET_NR_bdflush /* not on x86_64 */
4934     case TARGET_NR_bdflush:
4935         goto unimplemented;
4936 #endif
4937 #ifdef TARGET_NR_sysfs
4938     case TARGET_NR_sysfs:
4939         goto unimplemented;
4940 #endif
4941     case TARGET_NR_personality:
4942         ret = get_errno(personality(arg1));
4943         break;
4944 #ifdef TARGET_NR_afs_syscall
4945     case TARGET_NR_afs_syscall:
4946         goto unimplemented;
4947 #endif
4948 #ifdef TARGET_NR__llseek /* Not on alpha */
4949     case TARGET_NR__llseek:
4950         {
4951 #if defined (__x86_64__)
4952             ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
4953             if (put_user_s64(ret, arg4))
4954                 goto efault;
4955 #else
4956             int64_t res;
4957             ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
4958             if (put_user_s64(res, arg4))
4959                 goto efault;
4960 #endif
4961         }
4962         break;
4963 #endif
4964     case TARGET_NR_getdents:
4965 #if TARGET_ABI_BITS != 32
4966         goto unimplemented;
4967 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4968         {
4969             struct target_dirent *target_dirp;
4970             struct linux_dirent *dirp;
4971             abi_long count = arg3;
4972
4973             dirp = malloc(count);
4974             if (!dirp) {
4975                 ret = -TARGET_ENOMEM;
4976                 goto fail;
4977             }
4978
4979             ret = get_errno(sys_getdents(arg1, dirp, count));
4980             if (!is_error(ret)) {
4981                 struct linux_dirent *de;
4982                 struct target_dirent *tde;
4983                 int len = ret;
4984                 int reclen, treclen;
4985                 int count1, tnamelen;
4986
4987                 count1 = 0;
4988                 de = dirp;
4989                 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4990                     goto efault;
4991                 tde = target_dirp;
4992                 while (len > 0) {
4993                     reclen = de->d_reclen;
4994                     treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
4995                     tde->d_reclen = tswap16(treclen);
4996                     tde->d_ino = tswapl(de->d_ino);
4997                     tde->d_off = tswapl(de->d_off);
4998                     tnamelen = treclen - (2 * sizeof(abi_long) + 2);
4999                     if (tnamelen > 256)
5000                         tnamelen = 256;
5001                     /* XXX: may not be correct */
5002                     pstrcpy(tde->d_name, tnamelen, de->d_name);
5003                     de = (struct linux_dirent *)((char *)de + reclen);
5004                     len -= reclen;
5005                     tde = (struct target_dirent *)((char *)tde + treclen);
5006                     count1 += treclen;
5007                 }
5008                 ret = count1;
5009                 unlock_user(target_dirp, arg2, ret);
5010             }
5011             free(dirp);
5012         }
5013 #else
5014         {
5015             struct linux_dirent *dirp;
5016             abi_long count = arg3;
5017
5018             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5019                 goto efault;
5020             ret = get_errno(sys_getdents(arg1, dirp, count));
5021             if (!is_error(ret)) {
5022                 struct linux_dirent *de;
5023                 int len = ret;
5024                 int reclen;
5025                 de = dirp;
5026                 while (len > 0) {
5027                     reclen = de->d_reclen;
5028                     if (reclen > len)
5029                         break;
5030                     de->d_reclen = tswap16(reclen);
5031                     tswapls(&de->d_ino);
5032                     tswapls(&de->d_off);
5033                     de = (struct linux_dirent *)((char *)de + reclen);
5034                     len -= reclen;
5035                 }
5036             }
5037             unlock_user(dirp, arg2, ret);
5038         }
5039 #endif
5040         break;
5041 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
5042     case TARGET_NR_getdents64:
5043         {
5044             struct linux_dirent64 *dirp;
5045             abi_long count = arg3;
5046             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5047                 goto efault;
5048             ret = get_errno(sys_getdents64(arg1, dirp, count));
5049             if (!is_error(ret)) {
5050                 struct linux_dirent64 *de;
5051                 int len = ret;
5052                 int reclen;
5053                 de = dirp;
5054                 while (len > 0) {
5055                     reclen = de->d_reclen;
5056                     if (reclen > len)
5057                         break;
5058                     de->d_reclen = tswap16(reclen);
5059                     tswap64s((uint64_t *)&de->d_ino);
5060                     tswap64s((uint64_t *)&de->d_off);
5061                     de = (struct linux_dirent64 *)((char *)de + reclen);
5062                     len -= reclen;
5063                 }
5064             }
5065             unlock_user(dirp, arg2, ret);
5066         }
5067         break;
5068 #endif /* TARGET_NR_getdents64 */
5069 #ifdef TARGET_NR__newselect
5070     case TARGET_NR__newselect:
5071         ret = do_select(arg1, arg2, arg3, arg4, arg5);
5072         break;
5073 #endif
5074 #ifdef TARGET_NR_poll
5075     case TARGET_NR_poll:
5076         {
5077             struct target_pollfd *target_pfd;
5078             unsigned int nfds = arg2;
5079             int timeout = arg3;
5080             struct pollfd *pfd;
5081             unsigned int i;
5082
5083             target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
5084             if (!target_pfd)
5085                 goto efault;
5086             pfd = alloca(sizeof(struct pollfd) * nfds);
5087             for(i = 0; i < nfds; i++) {
5088                 pfd[i].fd = tswap32(target_pfd[i].fd);
5089                 pfd[i].events = tswap16(target_pfd[i].events);
5090             }
5091             ret = get_errno(poll(pfd, nfds, timeout));
5092             if (!is_error(ret)) {
5093                 for(i = 0; i < nfds; i++) {
5094                     target_pfd[i].revents = tswap16(pfd[i].revents);
5095                 }
5096                 ret += nfds * (sizeof(struct target_pollfd)
5097                                - sizeof(struct pollfd));
5098             }
5099             unlock_user(target_pfd, arg1, ret);
5100         }
5101         break;
5102 #endif
5103     case TARGET_NR_flock:
5104         /* NOTE: the flock constant seems to be the same for every
5105            Linux platform */
5106         ret = get_errno(flock(arg1, arg2));
5107         break;
5108     case TARGET_NR_readv:
5109         {
5110             int count = arg3;
5111             struct iovec *vec;
5112
5113             vec = alloca(count * sizeof(struct iovec));
5114             if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
5115                 goto efault;
5116             ret = get_errno(readv(arg1, vec, count));
5117             unlock_iovec(vec, arg2, count, 1);
5118         }
5119         break;
5120     case TARGET_NR_writev:
5121         {
5122             int count = arg3;
5123             struct iovec *vec;
5124
5125             vec = alloca(count * sizeof(struct iovec));
5126             if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
5127                 goto efault;
5128             ret = get_errno(writev(arg1, vec, count));
5129             unlock_iovec(vec, arg2, count, 0);
5130         }
5131         break;
5132     case TARGET_NR_getsid:
5133         ret = get_errno(getsid(arg1));
5134         break;
5135 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
5136     case TARGET_NR_fdatasync:
5137         ret = get_errno(fdatasync(arg1));
5138         break;
5139 #endif
5140     case TARGET_NR__sysctl:
5141         /* We don't implement this, but ENOTDIR is always a safe
5142            return value. */
5143         ret = -TARGET_ENOTDIR;
5144         break;
5145     case TARGET_NR_sched_setparam:
5146         {
5147             struct sched_param *target_schp;
5148             struct sched_param schp;
5149
5150             if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
5151                 goto efault;
5152             schp.sched_priority = tswap32(target_schp->sched_priority);
5153             unlock_user_struct(target_schp, arg2, 0);
5154             ret = get_errno(sched_setparam(arg1, &schp));
5155         }
5156         break;
5157     case TARGET_NR_sched_getparam:
5158         {
5159             struct sched_param *target_schp;
5160             struct sched_param schp;
5161             ret = get_errno(sched_getparam(arg1, &schp));
5162             if (!is_error(ret)) {
5163                 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
5164                     goto efault;
5165                 target_schp->sched_priority = tswap32(schp.sched_priority);
5166                 unlock_user_struct(target_schp, arg2, 1);
5167             }
5168         }
5169         break;
5170     case TARGET_NR_sched_setscheduler:
5171         {
5172             struct sched_param *target_schp;
5173             struct sched_param schp;
5174             if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
5175                 goto efault;
5176             schp.sched_priority = tswap32(target_schp->sched_priority);
5177             unlock_user_struct(target_schp, arg3, 0);
5178             ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
5179         }
5180         break;
5181     case TARGET_NR_sched_getscheduler:
5182         ret = get_errno(sched_getscheduler(arg1));
5183         break;
5184     case TARGET_NR_sched_yield:
5185         ret = get_errno(sched_yield());
5186         break;
5187     case TARGET_NR_sched_get_priority_max:
5188         ret = get_errno(sched_get_priority_max(arg1));
5189         break;
5190     case TARGET_NR_sched_get_priority_min:
5191         ret = get_errno(sched_get_priority_min(arg1));
5192         break;
5193     case TARGET_NR_sched_rr_get_interval:
5194         {
5195             struct timespec ts;
5196             ret = get_errno(sched_rr_get_interval(arg1, &ts));
5197             if (!is_error(ret)) {
5198                 host_to_target_timespec(arg2, &ts);
5199             }
5200         }
5201         break;
5202     case TARGET_NR_nanosleep:
5203         {
5204             struct timespec req, rem;
5205             target_to_host_timespec(&req, arg1);
5206             ret = get_errno(nanosleep(&req, &rem));
5207             if (is_error(ret) && arg2) {
5208                 host_to_target_timespec(arg2, &rem);
5209             }
5210         }
5211         break;
5212 #ifdef TARGET_NR_query_module
5213     case TARGET_NR_query_module:
5214         goto unimplemented;
5215 #endif
5216 #ifdef TARGET_NR_nfsservctl
5217     case TARGET_NR_nfsservctl:
5218         goto unimplemented;
5219 #endif
5220     case TARGET_NR_prctl:
5221         switch (arg1)
5222             {
5223             case PR_GET_PDEATHSIG:
5224                 {
5225                     int deathsig;
5226                     ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
5227                     if (!is_error(ret) && arg2
5228                         && put_user_ual(deathsig, arg2))
5229                         goto efault;
5230                 }
5231                 break;
5232             default:
5233                 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
5234                 break;
5235             }
5236         break;
5237 #ifdef TARGET_NR_arch_prctl
5238     case TARGET_NR_arch_prctl:
5239 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5240         ret = do_arch_prctl(cpu_env, arg1, arg2);
5241         break;
5242 #else
5243         goto unimplemented;
5244 #endif
5245 #endif
5246 #ifdef TARGET_NR_pread
5247     case TARGET_NR_pread:
5248 #ifdef TARGET_ARM
5249         if (((CPUARMState *)cpu_env)->eabi)
5250             arg4 = arg5;
5251 #endif
5252         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5253             goto efault;
5254         ret = get_errno(pread(arg1, p, arg3, arg4));
5255         unlock_user(p, arg2, ret);
5256         break;
5257     case TARGET_NR_pwrite:
5258 #ifdef TARGET_ARM
5259         if (((CPUARMState *)cpu_env)->eabi)
5260             arg4 = arg5;
5261 #endif
5262         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5263             goto efault;
5264         ret = get_errno(pwrite(arg1, p, arg3, arg4));
5265         unlock_user(p, arg2, 0);
5266         break;
5267 #endif
5268 #ifdef TARGET_NR_pread64
5269     case TARGET_NR_pread64:
5270         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5271             goto efault;
5272         ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
5273         unlock_user(p, arg2, ret);
5274         break;
5275     case TARGET_NR_pwrite64:
5276         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5277             goto efault;
5278         ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
5279         unlock_user(p, arg2, 0);
5280         break;
5281 #endif
5282     case TARGET_NR_getcwd:
5283         if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
5284             goto efault;
5285         ret = get_errno(sys_getcwd1(p, arg2));
5286         unlock_user(p, arg1, ret);
5287         break;
5288     case TARGET_NR_capget:
5289         goto unimplemented;
5290     case TARGET_NR_capset:
5291         goto unimplemented;
5292     case TARGET_NR_sigaltstack:
5293 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5294     defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
5295         ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
5296         break;
5297 #else
5298         goto unimplemented;
5299 #endif
5300     case TARGET_NR_sendfile:
5301         goto unimplemented;
5302 #ifdef TARGET_NR_getpmsg
5303     case TARGET_NR_getpmsg:
5304         goto unimplemented;
5305 #endif
5306 #ifdef TARGET_NR_putpmsg
5307     case TARGET_NR_putpmsg:
5308         goto unimplemented;
5309 #endif
5310 #ifdef TARGET_NR_vfork
5311     case TARGET_NR_vfork:
5312         ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
5313                         0, 0, 0, 0));
5314         break;
5315 #endif
5316 #ifdef TARGET_NR_ugetrlimit
5317     case TARGET_NR_ugetrlimit:
5318     {
5319         struct rlimit rlim;
5320         ret = get_errno(getrlimit(arg1, &rlim));
5321         if (!is_error(ret)) {
5322             struct target_rlimit *target_rlim;
5323             if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
5324                 goto efault;
5325             target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
5326             target_rlim->rlim_max = tswapl(rlim.rlim_max);
5327             unlock_user_struct(target_rlim, arg2, 1);
5328         }
5329         break;
5330     }
5331 #endif
5332 #ifdef TARGET_NR_truncate64
5333     case TARGET_NR_truncate64:
5334         if (!(p = lock_user_string(arg1)))
5335             goto efault;
5336         ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
5337         unlock_user(p, arg1, 0);
5338         break;
5339 #endif
5340 #ifdef TARGET_NR_ftruncate64
5341     case TARGET_NR_ftruncate64:
5342         ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
5343         break;
5344 #endif
5345 #ifdef TARGET_NR_stat64
5346     case TARGET_NR_stat64:
5347         if (!(p = lock_user_string(arg1)))
5348             goto efault;
5349         ret = get_errno(stat(path(p), &st));
5350         unlock_user(p, arg1, 0);
5351         if (!is_error(ret))
5352             ret = host_to_target_stat64(cpu_env, arg2, &st);
5353         break;
5354 #endif
5355 #ifdef TARGET_NR_lstat64
5356     case TARGET_NR_lstat64:
5357         if (!(p = lock_user_string(arg1)))
5358             goto efault;
5359         ret = get_errno(lstat(path(p), &st));
5360         unlock_user(p, arg1, 0);
5361         if (!is_error(ret))
5362             ret = host_to_target_stat64(cpu_env, arg2, &st);
5363         break;
5364 #endif
5365 #ifdef TARGET_NR_fstat64
5366     case TARGET_NR_fstat64:
5367         ret = get_errno(fstat(arg1, &st));
5368         if (!is_error(ret))
5369             ret = host_to_target_stat64(cpu_env, arg2, &st);
5370         break;
5371 #endif
5372 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
5373     case TARGET_NR_fstatat64:
5374         if (!(p = lock_user_string(arg2)))
5375             goto efault;
5376         ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));
5377         if (!is_error(ret))
5378             ret = host_to_target_stat64(cpu_env, arg3, &st);
5379         break;
5380 #endif
5381 #ifdef USE_UID16
5382     case TARGET_NR_lchown:
5383         if (!(p = lock_user_string(arg1)))
5384             goto efault;
5385         ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
5386         unlock_user(p, arg1, 0);
5387         break;
5388     case TARGET_NR_getuid:
5389         ret = get_errno(high2lowuid(getuid()));
5390         break;
5391     case TARGET_NR_getgid:
5392         ret = get_errno(high2lowgid(getgid()));
5393         break;
5394     case TARGET_NR_geteuid:
5395         ret = get_errno(high2lowuid(geteuid()));
5396         break;
5397     case TARGET_NR_getegid:
5398         ret = get_errno(high2lowgid(getegid()));
5399         break;
5400     case TARGET_NR_setreuid:
5401         ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
5402         break;
5403     case TARGET_NR_setregid:
5404         ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
5405         break;
5406     case TARGET_NR_getgroups:
5407         {
5408             int gidsetsize = arg1;
5409             uint16_t *target_grouplist;
5410             gid_t *grouplist;
5411             int i;
5412
5413             grouplist = alloca(gidsetsize * sizeof(gid_t));
5414             ret = get_errno(getgroups(gidsetsize, grouplist));
5415             if (gidsetsize == 0)
5416                 break;
5417             if (!is_error(ret)) {
5418                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
5419                 if (!target_grouplist)
5420                     goto efault;
5421                 for(i = 0;i < ret; i++)
5422                     target_grouplist[i] = tswap16(grouplist[i]);
5423                 unlock_user(target_grouplist, arg2, gidsetsize * 2);
5424             }
5425         }
5426         break;
5427     case TARGET_NR_setgroups:
5428         {
5429             int gidsetsize = arg1;
5430             uint16_t *target_grouplist;
5431             gid_t *grouplist;
5432             int i;
5433
5434             grouplist = alloca(gidsetsize * sizeof(gid_t));
5435             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
5436             if (!target_grouplist) {
5437                 ret = -TARGET_EFAULT;
5438                 goto fail;
5439             }
5440             for(i = 0;i < gidsetsize; i++)
5441                 grouplist[i] = tswap16(target_grouplist[i]);
5442             unlock_user(target_grouplist, arg2, 0);
5443             ret = get_errno(setgroups(gidsetsize, grouplist));
5444         }
5445         break;
5446     case TARGET_NR_fchown:
5447         ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
5448         break;
5449 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5450     case TARGET_NR_fchownat:
5451         if (!(p = lock_user_string(arg2)))
5452             goto efault;
5453         ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
5454         unlock_user(p, arg2, 0);
5455         break;
5456 #endif
5457 #ifdef TARGET_NR_setresuid
5458     case TARGET_NR_setresuid:
5459         ret = get_errno(setresuid(low2highuid(arg1),
5460                                   low2highuid(arg2),
5461                                   low2highuid(arg3)));
5462         break;
5463 #endif
5464 #ifdef TARGET_NR_getresuid
5465     case TARGET_NR_getresuid:
5466         {
5467             uid_t ruid, euid, suid;
5468             ret = get_errno(getresuid(&ruid, &euid, &suid));
5469             if (!is_error(ret)) {
5470                 if (put_user_u16(high2lowuid(ruid), arg1)
5471                     || put_user_u16(high2lowuid(euid), arg2)
5472                     || put_user_u16(high2lowuid(suid), arg3))
5473                     goto efault;
5474             }
5475         }
5476         break;
5477 #endif
5478 #ifdef TARGET_NR_getresgid
5479     case TARGET_NR_setresgid:
5480         ret = get_errno(setresgid(low2highgid(arg1),
5481                                   low2highgid(arg2),
5482                                   low2highgid(arg3)));
5483         break;
5484 #endif
5485 #ifdef TARGET_NR_getresgid
5486     case TARGET_NR_getresgid:
5487         {
5488             gid_t rgid, egid, sgid;
5489             ret = get_errno(getresgid(&rgid, &egid, &sgid));
5490             if (!is_error(ret)) {
5491                 if (put_user_u16(high2lowgid(rgid), arg1)
5492                     || put_user_u16(high2lowgid(egid), arg2)
5493                     || put_user_u16(high2lowgid(sgid), arg3))
5494                     goto efault;
5495             }
5496         }
5497         break;
5498 #endif
5499     case TARGET_NR_chown:
5500         if (!(p = lock_user_string(arg1)))
5501             goto efault;
5502         ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
5503         unlock_user(p, arg1, 0);
5504         break;
5505     case TARGET_NR_setuid:
5506         ret = get_errno(setuid(low2highuid(arg1)));
5507         break;
5508     case TARGET_NR_setgid:
5509         ret = get_errno(setgid(low2highgid(arg1)));
5510         break;
5511     case TARGET_NR_setfsuid:
5512         ret = get_errno(setfsuid(arg1));
5513         break;
5514     case TARGET_NR_setfsgid:
5515         ret = get_errno(setfsgid(arg1));
5516         break;
5517 #endif /* USE_UID16 */
5518
5519 #ifdef TARGET_NR_lchown32
5520     case TARGET_NR_lchown32:
5521         if (!(p = lock_user_string(arg1)))
5522             goto efault;
5523         ret = get_errno(lchown(p, arg2, arg3));
5524         unlock_user(p, arg1, 0);
5525         break;
5526 #endif
5527 #ifdef TARGET_NR_getuid32
5528     case TARGET_NR_getuid32:
5529         ret = get_errno(getuid());
5530         break;
5531 #endif
5532 #ifdef TARGET_NR_getgid32
5533     case TARGET_NR_getgid32:
5534         ret = get_errno(getgid());
5535         break;
5536 #endif
5537 #ifdef TARGET_NR_geteuid32
5538     case TARGET_NR_geteuid32:
5539         ret = get_errno(geteuid());
5540         break;
5541 #endif
5542 #ifdef TARGET_NR_getegid32
5543     case TARGET_NR_getegid32:
5544         ret = get_errno(getegid());
5545         break;
5546 #endif
5547 #ifdef TARGET_NR_setreuid32
5548     case TARGET_NR_setreuid32:
5549         ret = get_errno(setreuid(arg1, arg2));
5550         break;
5551 #endif
5552 #ifdef TARGET_NR_setregid32
5553     case TARGET_NR_setregid32:
5554         ret = get_errno(setregid(arg1, arg2));
5555         break;
5556 #endif
5557 #ifdef TARGET_NR_getgroups32
5558     case TARGET_NR_getgroups32:
5559         {
5560             int gidsetsize = arg1;
5561             uint32_t *target_grouplist;
5562             gid_t *grouplist;
5563             int i;
5564
5565             grouplist = alloca(gidsetsize * sizeof(gid_t));
5566             ret = get_errno(getgroups(gidsetsize, grouplist));
5567             if (gidsetsize == 0)
5568                 break;
5569             if (!is_error(ret)) {
5570                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
5571                 if (!target_grouplist) {
5572                     ret = -TARGET_EFAULT;
5573                     goto fail;
5574                 }
5575                 for(i = 0;i < ret; i++)
5576                     target_grouplist[i] = tswap32(grouplist[i]);
5577                 unlock_user(target_grouplist, arg2, gidsetsize * 4);
5578             }
5579         }
5580         break;
5581 #endif
5582 #ifdef TARGET_NR_setgroups32
5583     case TARGET_NR_setgroups32:
5584         {
5585             int gidsetsize = arg1;
5586             uint32_t *target_grouplist;
5587             gid_t *grouplist;
5588             int i;
5589
5590             grouplist = alloca(gidsetsize * sizeof(gid_t));
5591             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
5592             if (!target_grouplist) {
5593                 ret = -TARGET_EFAULT;
5594                 goto fail;
5595             }
5596             for(i = 0;i < gidsetsize; i++)
5597                 grouplist[i] = tswap32(target_grouplist[i]);
5598             unlock_user(target_grouplist, arg2, 0);
5599             ret = get_errno(setgroups(gidsetsize, grouplist));
5600         }
5601         break;
5602 #endif
5603 #ifdef TARGET_NR_fchown32
5604     case TARGET_NR_fchown32:
5605         ret = get_errno(fchown(arg1, arg2, arg3));
5606         break;
5607 #endif
5608 #ifdef TARGET_NR_setresuid32
5609     case TARGET_NR_setresuid32:
5610         ret = get_errno(setresuid(arg1, arg2, arg3));
5611         break;
5612 #endif
5613 #ifdef TARGET_NR_getresuid32
5614     case TARGET_NR_getresuid32:
5615         {
5616             uid_t ruid, euid, suid;
5617             ret = get_errno(getresuid(&ruid, &euid, &suid));
5618             if (!is_error(ret)) {
5619                 if (put_user_u32(ruid, arg1)
5620                     || put_user_u32(euid, arg2)
5621                     || put_user_u32(suid, arg3))
5622                     goto efault;
5623             }
5624         }
5625         break;
5626 #endif
5627 #ifdef TARGET_NR_setresgid32
5628     case TARGET_NR_setresgid32:
5629         ret = get_errno(setresgid(arg1, arg2, arg3));
5630         break;
5631 #endif
5632 #ifdef TARGET_NR_getresgid32
5633     case TARGET_NR_getresgid32:
5634         {
5635             gid_t rgid, egid, sgid;
5636             ret = get_errno(getresgid(&rgid, &egid, &sgid));
5637             if (!is_error(ret)) {
5638                 if (put_user_u32(rgid, arg1)
5639                     || put_user_u32(egid, arg2)
5640                     || put_user_u32(sgid, arg3))
5641                     goto efault;
5642             }
5643         }
5644         break;
5645 #endif
5646 #ifdef TARGET_NR_chown32
5647     case TARGET_NR_chown32:
5648         if (!(p = lock_user_string(arg1)))
5649             goto efault;
5650         ret = get_errno(chown(p, arg2, arg3));
5651         unlock_user(p, arg1, 0);
5652         break;
5653 #endif
5654 #ifdef TARGET_NR_setuid32
5655     case TARGET_NR_setuid32:
5656         ret = get_errno(setuid(arg1));
5657         break;
5658 #endif
5659 #ifdef TARGET_NR_setgid32
5660     case TARGET_NR_setgid32:
5661         ret = get_errno(setgid(arg1));
5662         break;
5663 #endif
5664 #ifdef TARGET_NR_setfsuid32
5665     case TARGET_NR_setfsuid32:
5666         ret = get_errno(setfsuid(arg1));
5667         break;
5668 #endif
5669 #ifdef TARGET_NR_setfsgid32
5670     case TARGET_NR_setfsgid32:
5671         ret = get_errno(setfsgid(arg1));
5672         break;
5673 #endif
5674
5675     case TARGET_NR_pivot_root:
5676         goto unimplemented;
5677 #ifdef TARGET_NR_mincore
5678     case TARGET_NR_mincore:
5679         {
5680             void *a;
5681             ret = -TARGET_EFAULT;
5682             if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
5683                 goto efault;
5684             if (!(p = lock_user_string(arg3)))
5685                 goto mincore_fail;
5686             ret = get_errno(mincore(a, arg2, p));
5687             unlock_user(p, arg3, ret);
5688             mincore_fail:
5689             unlock_user(a, arg1, 0);
5690         }
5691         break;
5692 #endif
5693 #ifdef TARGET_NR_arm_fadvise64_64
5694     case TARGET_NR_arm_fadvise64_64:
5695         {
5696                 /*
5697                  * arm_fadvise64_64 looks like fadvise64_64 but
5698                  * with different argument order
5699                  */
5700                 abi_long temp;
5701                 temp = arg3;
5702                 arg3 = arg4;
5703                 arg4 = temp;
5704         }
5705 #endif
5706 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64)
5707 #ifdef TARGET_NR_fadvise64_64
5708     case TARGET_NR_fadvise64_64:
5709 #endif
5710         /* This is a hint, so ignoring and returning success is ok.  */
5711         ret = get_errno(0);
5712         break;
5713 #endif
5714 #ifdef TARGET_NR_madvise
5715     case TARGET_NR_madvise:
5716         /* A straight passthrough may not be safe because qemu sometimes
5717            turns private flie-backed mappings into anonymous mappings.
5718            This will break MADV_DONTNEED.
5719            This is a hint, so ignoring and returning success is ok.  */
5720         ret = get_errno(0);
5721         break;
5722 #endif
5723 #if TARGET_ABI_BITS == 32
5724     case TARGET_NR_fcntl64:
5725     {
5726         int cmd;
5727         struct flock64 fl;
5728         struct target_flock64 *target_fl;
5729 #ifdef TARGET_ARM
5730         struct target_eabi_flock64 *target_efl;
5731 #endif
5732
5733         switch(arg2){
5734         case TARGET_F_GETLK64:
5735             cmd = F_GETLK64;
5736             break;
5737         case TARGET_F_SETLK64:
5738             cmd = F_SETLK64;
5739             break;
5740         case TARGET_F_SETLKW64:
5741             cmd = F_SETLK64;
5742             break;
5743         default:
5744             cmd = arg2;
5745             break;
5746         }
5747
5748         switch(arg2) {
5749         case TARGET_F_GETLK64:
5750 #ifdef TARGET_ARM
5751             if (((CPUARMState *)cpu_env)->eabi) {
5752                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5753                     goto efault;
5754                 fl.l_type = tswap16(target_efl->l_type);
5755                 fl.l_whence = tswap16(target_efl->l_whence);
5756                 fl.l_start = tswap64(target_efl->l_start);
5757                 fl.l_len = tswap64(target_efl->l_len);
5758                 fl.l_pid = tswapl(target_efl->l_pid);
5759                 unlock_user_struct(target_efl, arg3, 0);
5760             } else
5761 #endif
5762             {
5763                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5764                     goto efault;
5765                 fl.l_type = tswap16(target_fl->l_type);
5766                 fl.l_whence = tswap16(target_fl->l_whence);
5767                 fl.l_start = tswap64(target_fl->l_start);
5768                 fl.l_len = tswap64(target_fl->l_len);
5769                 fl.l_pid = tswapl(target_fl->l_pid);
5770                 unlock_user_struct(target_fl, arg3, 0);
5771             }
5772             ret = get_errno(fcntl(arg1, cmd, &fl));
5773             if (ret == 0) {
5774 #ifdef TARGET_ARM
5775                 if (((CPUARMState *)cpu_env)->eabi) {
5776                     if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
5777                         goto efault;
5778                     target_efl->l_type = tswap16(fl.l_type);
5779                     target_efl->l_whence = tswap16(fl.l_whence);
5780                     target_efl->l_start = tswap64(fl.l_start);
5781                     target_efl->l_len = tswap64(fl.l_len);
5782                     target_efl->l_pid = tswapl(fl.l_pid);
5783                     unlock_user_struct(target_efl, arg3, 1);
5784                 } else
5785 #endif
5786                 {
5787                     if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
5788                         goto efault;
5789                     target_fl->l_type = tswap16(fl.l_type);
5790                     target_fl->l_whence = tswap16(fl.l_whence);
5791                     target_fl->l_start = tswap64(fl.l_start);
5792                     target_fl->l_len = tswap64(fl.l_len);
5793                     target_fl->l_pid = tswapl(fl.l_pid);
5794                     unlock_user_struct(target_fl, arg3, 1);
5795                 }
5796             }
5797             break;
5798
5799         case TARGET_F_SETLK64:
5800         case TARGET_F_SETLKW64:
5801 #ifdef TARGET_ARM
5802             if (((CPUARMState *)cpu_env)->eabi) {
5803                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5804                     goto efault;
5805                 fl.l_type = tswap16(target_efl->l_type);
5806                 fl.l_whence = tswap16(target_efl->l_whence);
5807                 fl.l_start = tswap64(target_efl->l_start);
5808                 fl.l_len = tswap64(target_efl->l_len);
5809                 fl.l_pid = tswapl(target_efl->l_pid);
5810                 unlock_user_struct(target_efl, arg3, 0);
5811             } else
5812 #endif
5813             {
5814                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5815                     goto efault;
5816                 fl.l_type = tswap16(target_fl->l_type);
5817                 fl.l_whence = tswap16(target_fl->l_whence);
5818                 fl.l_start = tswap64(target_fl->l_start);
5819                 fl.l_len = tswap64(target_fl->l_len);
5820                 fl.l_pid = tswapl(target_fl->l_pid);
5821                 unlock_user_struct(target_fl, arg3, 0);
5822             }
5823             ret = get_errno(fcntl(arg1, cmd, &fl));
5824             break;
5825         default:
5826             ret = do_fcntl(arg1, cmd, arg3);
5827             break;
5828         }
5829         break;
5830     }
5831 #endif
5832 #ifdef TARGET_NR_cacheflush
5833     case TARGET_NR_cacheflush:
5834         /* self-modifying code is handled automatically, so nothing needed */
5835         ret = 0;
5836         break;
5837 #endif
5838 #ifdef TARGET_NR_security
5839     case TARGET_NR_security:
5840         goto unimplemented;
5841 #endif
5842 #ifdef TARGET_NR_getpagesize
5843     case TARGET_NR_getpagesize:
5844         ret = TARGET_PAGE_SIZE;
5845         break;
5846 #endif
5847     case TARGET_NR_gettid:
5848         ret = get_errno(gettid());
5849         break;
5850 #ifdef TARGET_NR_readahead
5851     case TARGET_NR_readahead:
5852 #if TARGET_ABI_BITS == 32
5853 #ifdef TARGET_ARM
5854         if (((CPUARMState *)cpu_env)->eabi)
5855         {
5856             arg2 = arg3;
5857             arg3 = arg4;
5858             arg4 = arg5;
5859         }
5860 #endif
5861         ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
5862 #else
5863         ret = get_errno(readahead(arg1, arg2, arg3));
5864 #endif
5865         break;
5866 #endif
5867 #ifdef TARGET_NR_setxattr
5868     case TARGET_NR_setxattr:
5869     case TARGET_NR_lsetxattr:
5870     case TARGET_NR_fsetxattr:
5871     case TARGET_NR_getxattr:
5872     case TARGET_NR_lgetxattr:
5873     case TARGET_NR_fgetxattr:
5874     case TARGET_NR_listxattr:
5875     case TARGET_NR_llistxattr:
5876     case TARGET_NR_flistxattr:
5877     case TARGET_NR_removexattr:
5878     case TARGET_NR_lremovexattr:
5879     case TARGET_NR_fremovexattr:
5880         goto unimplemented_nowarn;
5881 #endif
5882 #ifdef TARGET_NR_set_thread_area
5883     case TARGET_NR_set_thread_area:
5884 #if defined(TARGET_MIPS)
5885       ((CPUMIPSState *) cpu_env)->tls_value = arg1;
5886       ret = 0;
5887       break;
5888 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
5889       ret = do_set_thread_area(cpu_env, arg1);
5890       break;
5891 #else
5892       goto unimplemented_nowarn;
5893 #endif
5894 #endif
5895 #ifdef TARGET_NR_get_thread_area
5896     case TARGET_NR_get_thread_area:
5897 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5898         ret = do_get_thread_area(cpu_env, arg1);
5899 #else
5900         goto unimplemented_nowarn;
5901 #endif
5902 #endif
5903 #ifdef TARGET_NR_getdomainname
5904     case TARGET_NR_getdomainname:
5905         goto unimplemented_nowarn;
5906 #endif
5907
5908 #ifdef TARGET_NR_clock_gettime
5909     case TARGET_NR_clock_gettime:
5910     {
5911         struct timespec ts;
5912         ret = get_errno(clock_gettime(arg1, &ts));
5913         if (!is_error(ret)) {
5914             host_to_target_timespec(arg2, &ts);
5915         }
5916         break;
5917     }
5918 #endif
5919 #ifdef TARGET_NR_clock_getres
5920     case TARGET_NR_clock_getres:
5921     {
5922         struct timespec ts;
5923         ret = get_errno(clock_getres(arg1, &ts));
5924         if (!is_error(ret)) {
5925             host_to_target_timespec(arg2, &ts);
5926         }
5927         break;
5928     }
5929 #endif
5930 #ifdef TARGET_NR_clock_nanosleep
5931     case TARGET_NR_clock_nanosleep:
5932     {
5933         struct timespec ts;
5934         target_to_host_timespec(&ts, arg3);
5935         ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
5936         if (arg4)
5937             host_to_target_timespec(arg4, &ts);
5938         break;
5939     }
5940 #endif
5941
5942 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5943     case TARGET_NR_set_tid_address:
5944         ret = get_errno(set_tid_address((int *)g2h(arg1)));
5945         break;
5946 #endif
5947
5948 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
5949     case TARGET_NR_tkill:
5950         ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
5951         break;
5952 #endif
5953
5954 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
5955     case TARGET_NR_tgkill:
5956         ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
5957                         target_to_host_signal(arg3)));
5958         break;
5959 #endif
5960
5961 #ifdef TARGET_NR_set_robust_list
5962     case TARGET_NR_set_robust_list:
5963         goto unimplemented_nowarn;
5964 #endif
5965
5966 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5967     case TARGET_NR_utimensat:
5968         {
5969             struct timespec ts[2];
5970             target_to_host_timespec(ts, arg3);
5971             target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
5972             if (!arg2)
5973                 ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4));
5974             else {
5975                 if (!(p = lock_user_string(arg2))) {
5976                     ret = -TARGET_EFAULT;
5977                     goto fail;
5978                 }
5979                 ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
5980                 unlock_user(p, arg2, 0);
5981             }
5982         }
5983         break;
5984 #endif
5985 #if defined(USE_NPTL)
5986     case TARGET_NR_futex:
5987         ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
5988         break;
5989 #endif
5990 #ifdef TARGET_NR_inotify_init
5991     case TARGET_NR_inotify_init:
5992         ret = get_errno(sys_inotify_init());
5993         break;
5994 #endif
5995 #ifdef TARGET_NR_inotify_add_watch
5996     case TARGET_NR_inotify_add_watch:
5997         p = lock_user_string(arg2);
5998         ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
5999         unlock_user(p, arg2, 0);
6000         break;
6001 #endif
6002 #ifdef TARGET_NR_inotify_rm_watch
6003     case TARGET_NR_inotify_rm_watch:
6004         ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
6005         break;
6006 #endif
6007
6008     default:
6009     unimplemented:
6010         gemu_log("qemu: Unsupported syscall: %d\n", num);
6011 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
6012     unimplemented_nowarn:
6013 #endif
6014         ret = -TARGET_ENOSYS;
6015         break;
6016     }
6017 fail:
6018 #ifdef DEBUG
6019     gemu_log(" = %ld\n", ret);
6020 #endif
6021     if(do_strace)
6022         print_syscall_ret(num, ret);
6023     return ret;
6024 efault:
6025     ret = -TARGET_EFAULT;
6026     goto fail;
6027 }