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