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