git.maemo.org Git - qemu/blob - linux-user/syscall.c

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