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

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