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_WAKE_OP:
3985         return get_errno(sys_futex(g2h(uaddr), op, val, NULL, g2h(uaddr2), val3 ));
3986     case FUTEX_FD:
3987         return get_errno(sys_futex(g2h(uaddr), op, val, NULL, NULL, 0));
3988     case FUTEX_REQUEUE:
3989         return get_errno(sys_futex(g2h(uaddr), op, val,
3990                          NULL, g2h(uaddr2), 0));
3991     case FUTEX_CMP_REQUEUE:
3992         return get_errno(sys_futex(g2h(uaddr), op, val,
3993                          NULL, g2h(uaddr2), tswap32(val3)));
3994     default:
3995         return -TARGET_ENOSYS;
3996     }
3997 }
3998 #endif
3999
4000 /* Map host to target signal numbers for the wait family of syscalls.
4001    Assume all other status bits are the same.  */
4002 static int host_to_target_waitstatus(int status)
4003 {
4004     if (WIFSIGNALED(status)) {
4005         return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
4006     }
4007     if (WIFSTOPPED(status)) {
4008         return (host_to_target_signal(WSTOPSIG(status)) << 8)
4009                | (status & 0xff);
4010     }
4011     return status;
4012 }
4013
4014 int get_osversion(void)
4015 {
4016     static int osversion;
4017     struct new_utsname buf;
4018     const char *s;
4019     int i, n, tmp;
4020     if (osversion)
4021         return osversion;
4022     if (qemu_uname_release && *qemu_uname_release) {
4023         s = qemu_uname_release;
4024     } else {
4025         if (sys_uname(&buf))
4026             return 0;
4027         s = buf.release;
4028     }
4029     tmp = 0;
4030     for (i = 0; i < 3; i++) {
4031         n = 0;
4032         while (*s >= '0' && *s <= '9') {
4033             n *= 10;
4034             n += *s - '0';
4035             s++;
4036         }
4037         tmp = (tmp << 8) + n;
4038         if (*s == '.')
4039             s++;
4040     }
4041     osversion = tmp;
4042     return osversion;
4043 }
4044
4045 /* do_syscall() should always have a single exit point at the end so
4046    that actions, such as logging of syscall results, can be performed.
4047    All errnos that do_syscall() returns must be -TARGET_<errcode>. */
4048 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
4049                     abi_long arg2, abi_long arg3, abi_long arg4,
4050                     abi_long arg5, abi_long arg6)
4051 {
4052     abi_long ret;
4053     struct stat st;
4054     struct statfs stfs;
4055     void *p;
4056
4057 #ifdef DEBUG
4058     gemu_log("syscall %d", num);
4059 #endif
4060     if(do_strace)
4061         print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
4062
4063     switch(num) {
4064     case TARGET_NR_exit:
4065 #ifdef USE_NPTL
4066       /* In old applications this may be used to implement _exit(2).
4067          However in threaded applictions it is used for thread termination,
4068          and _exit_group is used for application termination.
4069          Do thread termination if we have more then one thread.  */
4070       /* FIXME: This probably breaks if a signal arrives.  We should probably
4071          be disabling signals.  */
4072       if (first_cpu->next_cpu) {
4073           CPUState **lastp;
4074           CPUState *p;
4075
4076           cpu_list_lock();
4077           lastp = &first_cpu;
4078           p = first_cpu;
4079           while (p && p != (CPUState *)cpu_env) {
4080               lastp = &p->next_cpu;
4081               p = p->next_cpu;
4082           }
4083           /* If we didn't find the CPU for this thread then something is
4084              horribly wrong.  */
4085           if (!p)
4086               abort();
4087           /* Remove the CPU from the list.  */
4088           *lastp = p->next_cpu;
4089           cpu_list_unlock();
4090           TaskState *ts = ((CPUState *)cpu_env)->opaque;
4091           if (ts->child_tidptr) {
4092               put_user_u32(0, ts->child_tidptr);
4093               sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
4094                         NULL, NULL, 0);
4095           }
4096           /* TODO: Free CPU state.  */
4097           pthread_exit(NULL);
4098       }
4099 #endif
4100 #ifdef HAVE_GPROF
4101         _mcleanup();
4102 #endif
4103         gdb_exit(cpu_env, arg1);
4104         _exit(arg1);
4105         ret = 0; /* avoid warning */
4106         break;
4107     case TARGET_NR_read:
4108         if (arg3 == 0)
4109             ret = 0;
4110         else {
4111             if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
4112                 goto efault;
4113             ret = get_errno(read(arg1, p, arg3));
4114             unlock_user(p, arg2, ret);
4115         }
4116         break;
4117     case TARGET_NR_write:
4118         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
4119             goto efault;
4120         ret = get_errno(write(arg1, p, arg3));
4121         unlock_user(p, arg2, 0);
4122         break;
4123     case TARGET_NR_open:
4124         if (!(p = lock_user_string(arg1)))
4125             goto efault;
4126         ret = get_errno(open(path(p),
4127                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
4128                              arg3));
4129         unlock_user(p, arg1, 0);
4130         break;
4131 #if defined(TARGET_NR_openat) && defined(__NR_openat)
4132     case TARGET_NR_openat:
4133         if (!(p = lock_user_string(arg2)))
4134             goto efault;
4135         ret = get_errno(sys_openat(arg1,
4136                                    path(p),
4137                                    target_to_host_bitmask(arg3, fcntl_flags_tbl),
4138                                    arg4));
4139         unlock_user(p, arg2, 0);
4140         break;
4141 #endif
4142     case TARGET_NR_close:
4143         ret = get_errno(close(arg1));
4144         break;
4145     case TARGET_NR_brk:
4146         ret = do_brk(arg1);
4147         break;
4148     case TARGET_NR_fork:
4149         ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
4150         break;
4151 #ifdef TARGET_NR_waitpid
4152     case TARGET_NR_waitpid:
4153         {
4154             int status;
4155             ret = get_errno(waitpid(arg1, &status, arg3));
4156             if (!is_error(ret) && arg2
4157                 && put_user_s32(host_to_target_waitstatus(status), arg2))
4158                 goto efault;
4159         }
4160         break;
4161 #endif
4162 #ifdef TARGET_NR_waitid
4163     case TARGET_NR_waitid:
4164         {
4165             siginfo_t info;
4166             info.si_pid = 0;
4167             ret = get_errno(waitid(arg1, arg2, &info, arg4));
4168             if (!is_error(ret) && arg3 && info.si_pid != 0) {
4169                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
4170                     goto efault;
4171                 host_to_target_siginfo(p, &info);
4172                 unlock_user(p, arg3, sizeof(target_siginfo_t));
4173             }
4174         }
4175         break;
4176 #endif
4177 #ifdef TARGET_NR_creat /* not on alpha */
4178     case TARGET_NR_creat:
4179         if (!(p = lock_user_string(arg1)))
4180             goto efault;
4181         ret = get_errno(creat(p, arg2));
4182         unlock_user(p, arg1, 0);
4183         break;
4184 #endif
4185     case TARGET_NR_link:
4186         {
4187             void * p2;
4188             p = lock_user_string(arg1);
4189             p2 = lock_user_string(arg2);
4190             if (!p || !p2)
4191                 ret = -TARGET_EFAULT;
4192             else
4193                 ret = get_errno(link(p, p2));
4194             unlock_user(p2, arg2, 0);
4195             unlock_user(p, arg1, 0);
4196         }
4197         break;
4198 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
4199     case TARGET_NR_linkat:
4200         {
4201             void * p2 = NULL;
4202             if (!arg2 || !arg4)
4203                 goto efault;
4204             p  = lock_user_string(arg2);
4205             p2 = lock_user_string(arg4);
4206             if (!p || !p2)
4207                 ret = -TARGET_EFAULT;
4208             else
4209                 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
4210             unlock_user(p, arg2, 0);
4211             unlock_user(p2, arg4, 0);
4212         }
4213         break;
4214 #endif
4215     case TARGET_NR_unlink:
4216         if (!(p = lock_user_string(arg1)))
4217             goto efault;
4218         ret = get_errno(unlink(p));
4219         unlock_user(p, arg1, 0);
4220         break;
4221 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
4222     case TARGET_NR_unlinkat:
4223         if (!(p = lock_user_string(arg2)))
4224             goto efault;
4225         ret = get_errno(sys_unlinkat(arg1, p, arg3));
4226         unlock_user(p, arg2, 0);
4227         break;
4228 #endif
4229     case TARGET_NR_execve:
4230         {
4231             char **argp, **envp;
4232             int argc, envc;
4233             abi_ulong gp;
4234             abi_ulong guest_argp;
4235             abi_ulong guest_envp;
4236             abi_ulong addr;
4237             char **q;
4238
4239             argc = 0;
4240             guest_argp = arg2;
4241             for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
4242                 if (get_user_ual(addr, gp))
4243                     goto efault;
4244                 if (!addr)
4245                     break;
4246                 argc++;
4247             }
4248             envc = 0;
4249             guest_envp = arg3;
4250             for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
4251                 if (get_user_ual(addr, gp))
4252                     goto efault;
4253                 if (!addr)
4254                     break;
4255                 envc++;
4256             }
4257
4258             argp = alloca((argc + 1) * sizeof(void *));
4259             envp = alloca((envc + 1) * sizeof(void *));
4260
4261             for (gp = guest_argp, q = argp; gp;
4262                   gp += sizeof(abi_ulong), q++) {
4263                 if (get_user_ual(addr, gp))
4264                     goto execve_efault;
4265                 if (!addr)
4266                     break;
4267                 if (!(*q = lock_user_string(addr)))
4268                     goto execve_efault;
4269             }
4270             *q = NULL;
4271
4272             for (gp = guest_envp, q = envp; gp;
4273                   gp += sizeof(abi_ulong), q++) {
4274                 if (get_user_ual(addr, gp))
4275                     goto execve_efault;
4276                 if (!addr)
4277                     break;
4278                 if (!(*q = lock_user_string(addr)))
4279                     goto execve_efault;
4280             }
4281             *q = NULL;
4282
4283             if (!(p = lock_user_string(arg1)))
4284                 goto execve_efault;
4285             ret = get_errno(execve(p, argp, envp));
4286             unlock_user(p, arg1, 0);
4287
4288             goto execve_end;
4289
4290         execve_efault:
4291             ret = -TARGET_EFAULT;
4292
4293         execve_end:
4294             for (gp = guest_argp, q = argp; *q;
4295                   gp += sizeof(abi_ulong), q++) {
4296                 if (get_user_ual(addr, gp)
4297                     || !addr)
4298                     break;
4299                 unlock_user(*q, addr, 0);
4300             }
4301             for (gp = guest_envp, q = envp; *q;
4302                   gp += sizeof(abi_ulong), q++) {
4303                 if (get_user_ual(addr, gp)
4304                     || !addr)
4305                     break;
4306                 unlock_user(*q, addr, 0);
4307             }
4308         }
4309         break;
4310     case TARGET_NR_chdir:
4311         if (!(p = lock_user_string(arg1)))
4312             goto efault;
4313         ret = get_errno(chdir(p));
4314         unlock_user(p, arg1, 0);
4315         break;
4316 #ifdef TARGET_NR_time
4317     case TARGET_NR_time:
4318         {
4319             time_t host_time;
4320             ret = get_errno(time(&host_time));
4321             if (!is_error(ret)
4322                 && arg1
4323                 && put_user_sal(host_time, arg1))
4324                 goto efault;
4325         }
4326         break;
4327 #endif
4328     case TARGET_NR_mknod:
4329         if (!(p = lock_user_string(arg1)))
4330             goto efault;
4331         ret = get_errno(mknod(p, arg2, arg3));
4332         unlock_user(p, arg1, 0);
4333         break;
4334 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
4335     case TARGET_NR_mknodat:
4336         if (!(p = lock_user_string(arg2)))
4337             goto efault;
4338         ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
4339         unlock_user(p, arg2, 0);
4340         break;
4341 #endif
4342     case TARGET_NR_chmod:
4343         if (!(p = lock_user_string(arg1)))
4344             goto efault;
4345         ret = get_errno(chmod(p, arg2));
4346         unlock_user(p, arg1, 0);
4347         break;
4348 #ifdef TARGET_NR_break
4349     case TARGET_NR_break:
4350         goto unimplemented;
4351 #endif
4352 #ifdef TARGET_NR_oldstat
4353     case TARGET_NR_oldstat:
4354         goto unimplemented;
4355 #endif
4356     case TARGET_NR_lseek:
4357         ret = get_errno(lseek(arg1, arg2, arg3));
4358         break;
4359 #ifdef TARGET_NR_getxpid
4360     case TARGET_NR_getxpid:
4361 #else
4362     case TARGET_NR_getpid:
4363 #endif
4364         ret = get_errno(getpid());
4365         break;
4366     case TARGET_NR_mount:
4367                 {
4368                         /* need to look at the data field */
4369                         void *p2, *p3;
4370                         p = lock_user_string(arg1);
4371                         p2 = lock_user_string(arg2);
4372                         p3 = lock_user_string(arg3);
4373                         if (!p || !p2 || !p3)
4374                             ret = -TARGET_EFAULT;
4375                         else
4376                             /* FIXME - arg5 should be locked, but it isn't clear how to
4377                              * do that since it's not guaranteed to be a NULL-terminated
4378                              * string.
4379                              */
4380                             ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
4381                         unlock_user(p, arg1, 0);
4382                         unlock_user(p2, arg2, 0);
4383                         unlock_user(p3, arg3, 0);
4384                         break;
4385                 }
4386 #ifdef TARGET_NR_umount
4387     case TARGET_NR_umount:
4388         if (!(p = lock_user_string(arg1)))
4389             goto efault;
4390         ret = get_errno(umount(p));
4391         unlock_user(p, arg1, 0);
4392         break;
4393 #endif
4394 #ifdef TARGET_NR_stime /* not on alpha */
4395     case TARGET_NR_stime:
4396         {
4397             time_t host_time;
4398             if (get_user_sal(host_time, arg1))
4399                 goto efault;
4400             ret = get_errno(stime(&host_time));
4401         }
4402         break;
4403 #endif
4404     case TARGET_NR_ptrace:
4405         goto unimplemented;
4406 #ifdef TARGET_NR_alarm /* not on alpha */
4407     case TARGET_NR_alarm:
4408         ret = alarm(arg1);
4409         break;
4410 #endif
4411 #ifdef TARGET_NR_oldfstat
4412     case TARGET_NR_oldfstat:
4413         goto unimplemented;
4414 #endif
4415 #ifdef TARGET_NR_pause /* not on alpha */
4416     case TARGET_NR_pause:
4417         ret = get_errno(pause());
4418         break;
4419 #endif
4420 #ifdef TARGET_NR_utime
4421     case TARGET_NR_utime:
4422         {
4423             struct utimbuf tbuf, *host_tbuf;
4424             struct target_utimbuf *target_tbuf;
4425             if (arg2) {
4426                 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
4427                     goto efault;
4428                 tbuf.actime = tswapl(target_tbuf->actime);
4429                 tbuf.modtime = tswapl(target_tbuf->modtime);
4430                 unlock_user_struct(target_tbuf, arg2, 0);
4431                 host_tbuf = &tbuf;
4432             } else {
4433                 host_tbuf = NULL;
4434             }
4435             if (!(p = lock_user_string(arg1)))
4436                 goto efault;
4437             ret = get_errno(utime(p, host_tbuf));
4438             unlock_user(p, arg1, 0);
4439         }
4440         break;
4441 #endif
4442     case TARGET_NR_utimes:
4443         {
4444             struct timeval *tvp, tv[2];
4445             if (arg2) {
4446                 if (copy_from_user_timeval(&tv[0], arg2)
4447                     || copy_from_user_timeval(&tv[1],
4448                                               arg2 + sizeof(struct target_timeval)))
4449                     goto efault;
4450                 tvp = tv;
4451             } else {
4452                 tvp = NULL;
4453             }
4454             if (!(p = lock_user_string(arg1)))
4455                 goto efault;
4456             ret = get_errno(utimes(p, tvp));
4457             unlock_user(p, arg1, 0);
4458         }
4459         break;
4460 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
4461     case TARGET_NR_futimesat:
4462         {
4463             struct timeval *tvp, tv[2];
4464             if (arg3) {
4465                 if (copy_from_user_timeval(&tv[0], arg3)
4466                     || copy_from_user_timeval(&tv[1],
4467                                               arg3 + sizeof(struct target_timeval)))
4468                     goto efault;
4469                 tvp = tv;
4470             } else {
4471                 tvp = NULL;
4472             }
4473             if (!(p = lock_user_string(arg2)))
4474                 goto efault;
4475             ret = get_errno(sys_futimesat(arg1, path(p), tvp));
4476             unlock_user(p, arg2, 0);
4477         }
4478         break;
4479 #endif
4480 #ifdef TARGET_NR_stty
4481     case TARGET_NR_stty:
4482         goto unimplemented;
4483 #endif
4484 #ifdef TARGET_NR_gtty
4485     case TARGET_NR_gtty:
4486         goto unimplemented;
4487 #endif
4488     case TARGET_NR_access:
4489         if (!(p = lock_user_string(arg1)))
4490             goto efault;
4491         ret = get_errno(access(p, arg2));
4492         unlock_user(p, arg1, 0);
4493         break;
4494 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
4495     case TARGET_NR_faccessat:
4496         if (!(p = lock_user_string(arg2)))
4497             goto efault;
4498         ret = get_errno(sys_faccessat(arg1, p, arg3));
4499         unlock_user(p, arg2, 0);
4500         break;
4501 #endif
4502 #ifdef TARGET_NR_nice /* not on alpha */
4503     case TARGET_NR_nice:
4504         ret = get_errno(nice(arg1));
4505         break;
4506 #endif
4507 #ifdef TARGET_NR_ftime
4508     case TARGET_NR_ftime:
4509         goto unimplemented;
4510 #endif
4511     case TARGET_NR_sync:
4512         sync();
4513         ret = 0;
4514         break;
4515     case TARGET_NR_kill:
4516         ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
4517         break;
4518     case TARGET_NR_rename:
4519         {
4520             void *p2;
4521             p = lock_user_string(arg1);
4522             p2 = lock_user_string(arg2);
4523             if (!p || !p2)
4524                 ret = -TARGET_EFAULT;
4525             else
4526                 ret = get_errno(rename(p, p2));
4527             unlock_user(p2, arg2, 0);
4528             unlock_user(p, arg1, 0);
4529         }
4530         break;
4531 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
4532     case TARGET_NR_renameat:
4533         {
4534             void *p2;
4535             p  = lock_user_string(arg2);
4536             p2 = lock_user_string(arg4);
4537             if (!p || !p2)
4538                 ret = -TARGET_EFAULT;
4539             else
4540                 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
4541             unlock_user(p2, arg4, 0);
4542             unlock_user(p, arg2, 0);
4543         }
4544         break;
4545 #endif
4546     case TARGET_NR_mkdir:
4547         if (!(p = lock_user_string(arg1)))
4548             goto efault;
4549         ret = get_errno(mkdir(p, arg2));
4550         unlock_user(p, arg1, 0);
4551         break;
4552 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
4553     case TARGET_NR_mkdirat:
4554         if (!(p = lock_user_string(arg2)))
4555             goto efault;
4556         ret = get_errno(sys_mkdirat(arg1, p, arg3));
4557         unlock_user(p, arg2, 0);
4558         break;
4559 #endif
4560     case TARGET_NR_rmdir:
4561         if (!(p = lock_user_string(arg1)))
4562             goto efault;
4563         ret = get_errno(rmdir(p));
4564         unlock_user(p, arg1, 0);
4565         break;
4566     case TARGET_NR_dup:
4567         ret = get_errno(dup(arg1));
4568         break;
4569     case TARGET_NR_pipe:
4570         ret = do_pipe(cpu_env, arg1, 0);
4571         break;
4572 #ifdef TARGET_NR_pipe2
4573     case TARGET_NR_pipe2:
4574         ret = do_pipe(cpu_env, arg1, arg2);
4575         break;
4576 #endif
4577     case TARGET_NR_times:
4578         {
4579             struct target_tms *tmsp;
4580             struct tms tms;
4581             ret = get_errno(times(&tms));
4582             if (arg1) {
4583                 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
4584                 if (!tmsp)
4585                     goto efault;
4586                 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
4587                 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
4588                 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
4589                 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
4590             }
4591             if (!is_error(ret))
4592                 ret = host_to_target_clock_t(ret);
4593         }
4594         break;
4595 #ifdef TARGET_NR_prof
4596     case TARGET_NR_prof:
4597         goto unimplemented;
4598 #endif
4599 #ifdef TARGET_NR_signal
4600     case TARGET_NR_signal:
4601         goto unimplemented;
4602 #endif
4603     case TARGET_NR_acct:
4604         if (arg1 == 0) {
4605             ret = get_errno(acct(NULL));
4606         } else {
4607             if (!(p = lock_user_string(arg1)))
4608                 goto efault;
4609             ret = get_errno(acct(path(p)));
4610             unlock_user(p, arg1, 0);
4611         }
4612         break;
4613 #ifdef TARGET_NR_umount2 /* not on alpha */
4614     case TARGET_NR_umount2:
4615         if (!(p = lock_user_string(arg1)))
4616             goto efault;
4617         ret = get_errno(umount2(p, arg2));
4618         unlock_user(p, arg1, 0);
4619         break;
4620 #endif
4621 #ifdef TARGET_NR_lock
4622     case TARGET_NR_lock:
4623         goto unimplemented;
4624 #endif
4625     case TARGET_NR_ioctl:
4626         ret = do_ioctl(arg1, arg2, arg3);
4627         break;
4628     case TARGET_NR_fcntl:
4629         ret = do_fcntl(arg1, arg2, arg3);
4630         break;
4631 #ifdef TARGET_NR_mpx
4632     case TARGET_NR_mpx:
4633         goto unimplemented;
4634 #endif
4635     case TARGET_NR_setpgid:
4636         ret = get_errno(setpgid(arg1, arg2));
4637         break;
4638 #ifdef TARGET_NR_ulimit
4639     case TARGET_NR_ulimit:
4640         goto unimplemented;
4641 #endif
4642 #ifdef TARGET_NR_oldolduname
4643     case TARGET_NR_oldolduname:
4644         goto unimplemented;
4645 #endif
4646     case TARGET_NR_umask:
4647         ret = get_errno(umask(arg1));
4648         break;
4649     case TARGET_NR_chroot:
4650         if (!(p = lock_user_string(arg1)))
4651             goto efault;
4652         ret = get_errno(chroot(p));
4653         unlock_user(p, arg1, 0);
4654         break;
4655     case TARGET_NR_ustat:
4656         goto unimplemented;
4657     case TARGET_NR_dup2:
4658         ret = get_errno(dup2(arg1, arg2));
4659         break;
4660 #ifdef TARGET_NR_getppid /* not on alpha */
4661     case TARGET_NR_getppid:
4662         ret = get_errno(getppid());
4663         break;
4664 #endif
4665     case TARGET_NR_getpgrp:
4666         ret = get_errno(getpgrp());
4667         break;
4668     case TARGET_NR_setsid:
4669         ret = get_errno(setsid());
4670         break;
4671 #ifdef TARGET_NR_sigaction
4672     case TARGET_NR_sigaction:
4673         {
4674 #if !defined(TARGET_MIPS)
4675             struct target_old_sigaction *old_act;
4676             struct target_sigaction act, oact, *pact;
4677             if (arg2) {
4678                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
4679                     goto efault;
4680                 act._sa_handler = old_act->_sa_handler;
4681                 target_siginitset(&act.sa_mask, old_act->sa_mask);
4682                 act.sa_flags = old_act->sa_flags;
4683                 act.sa_restorer = old_act->sa_restorer;
4684                 unlock_user_struct(old_act, arg2, 0);
4685                 pact = &act;
4686             } else {
4687                 pact = NULL;
4688             }
4689             ret = get_errno(do_sigaction(arg1, pact, &oact));
4690             if (!is_error(ret) && arg3) {
4691                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
4692                     goto efault;
4693                 old_act->_sa_handler = oact._sa_handler;
4694                 old_act->sa_mask = oact.sa_mask.sig[0];
4695                 old_act->sa_flags = oact.sa_flags;
4696                 old_act->sa_restorer = oact.sa_restorer;
4697                 unlock_user_struct(old_act, arg3, 1);
4698             }
4699 #else
4700             struct target_sigaction act, oact, *pact, *old_act;
4701
4702             if (arg2) {
4703                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
4704                     goto efault;
4705                 act._sa_handler = old_act->_sa_handler;
4706                 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
4707                 act.sa_flags = old_act->sa_flags;
4708                 unlock_user_struct(old_act, arg2, 0);
4709                 pact = &act;
4710             } else {
4711                 pact = NULL;
4712             }
4713
4714             ret = get_errno(do_sigaction(arg1, pact, &oact));
4715
4716             if (!is_error(ret) && arg3) {
4717                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
4718                     goto efault;
4719                 old_act->_sa_handler = oact._sa_handler;
4720                 old_act->sa_flags = oact.sa_flags;
4721                 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
4722                 old_act->sa_mask.sig[1] = 0;
4723                 old_act->sa_mask.sig[2] = 0;
4724                 old_act->sa_mask.sig[3] = 0;
4725                 unlock_user_struct(old_act, arg3, 1);
4726             }
4727 #endif
4728         }
4729         break;
4730 #endif
4731     case TARGET_NR_rt_sigaction:
4732         {
4733             struct target_sigaction *act;
4734             struct target_sigaction *oact;
4735
4736             if (arg2) {
4737                 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
4738                     goto efault;
4739             } else
4740                 act = NULL;
4741             if (arg3) {
4742                 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
4743                     ret = -TARGET_EFAULT;
4744                     goto rt_sigaction_fail;
4745                 }
4746             } else
4747                 oact = NULL;
4748             ret = get_errno(do_sigaction(arg1, act, oact));
4749         rt_sigaction_fail:
4750             if (act)
4751                 unlock_user_struct(act, arg2, 0);
4752             if (oact)
4753                 unlock_user_struct(oact, arg3, 1);
4754         }
4755         break;
4756 #ifdef TARGET_NR_sgetmask /* not on alpha */
4757     case TARGET_NR_sgetmask:
4758         {
4759             sigset_t cur_set;
4760             abi_ulong target_set;
4761             sigprocmask(0, NULL, &cur_set);
4762             host_to_target_old_sigset(&target_set, &cur_set);
4763             ret = target_set;
4764         }
4765         break;
4766 #endif
4767 #ifdef TARGET_NR_ssetmask /* not on alpha */
4768     case TARGET_NR_ssetmask:
4769         {
4770             sigset_t set, oset, cur_set;
4771             abi_ulong target_set = arg1;
4772             sigprocmask(0, NULL, &cur_set);
4773             target_to_host_old_sigset(&set, &target_set);
4774             sigorset(&set, &set, &cur_set);
4775             sigprocmask(SIG_SETMASK, &set, &oset);
4776             host_to_target_old_sigset(&target_set, &oset);
4777             ret = target_set;
4778         }
4779         break;
4780 #endif
4781 #ifdef TARGET_NR_sigprocmask
4782     case TARGET_NR_sigprocmask:
4783         {
4784             int how = arg1;
4785             sigset_t set, oldset, *set_ptr;
4786
4787             if (arg2) {
4788                 switch(how) {
4789                 case TARGET_SIG_BLOCK:
4790                     how = SIG_BLOCK;
4791                     break;
4792                 case TARGET_SIG_UNBLOCK:
4793                     how = SIG_UNBLOCK;
4794                     break;
4795                 case TARGET_SIG_SETMASK:
4796                     how = SIG_SETMASK;
4797                     break;
4798                 default:
4799                     ret = -TARGET_EINVAL;
4800                     goto fail;
4801                 }
4802                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4803                     goto efault;
4804                 target_to_host_old_sigset(&set, p);
4805                 unlock_user(p, arg2, 0);
4806                 set_ptr = &set;
4807             } else {
4808                 how = 0;
4809                 set_ptr = NULL;
4810             }
4811             ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
4812             if (!is_error(ret) && arg3) {
4813                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4814                     goto efault;
4815                 host_to_target_old_sigset(p, &oldset);
4816                 unlock_user(p, arg3, sizeof(target_sigset_t));
4817             }
4818         }
4819         break;
4820 #endif
4821     case TARGET_NR_rt_sigprocmask:
4822         {
4823             int how = arg1;
4824             sigset_t set, oldset, *set_ptr;
4825
4826             if (arg2) {
4827                 switch(how) {
4828                 case TARGET_SIG_BLOCK:
4829                     how = SIG_BLOCK;
4830                     break;
4831                 case TARGET_SIG_UNBLOCK:
4832                     how = SIG_UNBLOCK;
4833                     break;
4834                 case TARGET_SIG_SETMASK:
4835                     how = SIG_SETMASK;
4836                     break;
4837                 default:
4838                     ret = -TARGET_EINVAL;
4839                     goto fail;
4840                 }
4841                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4842                     goto efault;
4843                 target_to_host_sigset(&set, p);
4844                 unlock_user(p, arg2, 0);
4845                 set_ptr = &set;
4846             } else {
4847                 how = 0;
4848                 set_ptr = NULL;
4849             }
4850             ret = get_errno(sigprocmask(how, set_ptr, &oldset));
4851             if (!is_error(ret) && arg3) {
4852                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4853                     goto efault;
4854                 host_to_target_sigset(p, &oldset);
4855                 unlock_user(p, arg3, sizeof(target_sigset_t));
4856             }
4857         }
4858         break;
4859 #ifdef TARGET_NR_sigpending
4860     case TARGET_NR_sigpending:
4861         {
4862             sigset_t set;
4863             ret = get_errno(sigpending(&set));
4864             if (!is_error(ret)) {
4865                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4866                     goto efault;
4867                 host_to_target_old_sigset(p, &set);
4868                 unlock_user(p, arg1, sizeof(target_sigset_t));
4869             }
4870         }
4871         break;
4872 #endif
4873     case TARGET_NR_rt_sigpending:
4874         {
4875             sigset_t set;
4876             ret = get_errno(sigpending(&set));
4877             if (!is_error(ret)) {
4878                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4879                     goto efault;
4880                 host_to_target_sigset(p, &set);
4881                 unlock_user(p, arg1, sizeof(target_sigset_t));
4882             }
4883         }
4884         break;
4885 #ifdef TARGET_NR_sigsuspend
4886     case TARGET_NR_sigsuspend:
4887         {
4888             sigset_t set;
4889             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4890                 goto efault;
4891             target_to_host_old_sigset(&set, p);
4892             unlock_user(p, arg1, 0);
4893             ret = get_errno(sigsuspend(&set));
4894         }
4895         break;
4896 #endif
4897     case TARGET_NR_rt_sigsuspend:
4898         {
4899             sigset_t set;
4900             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4901                 goto efault;
4902             target_to_host_sigset(&set, p);
4903             unlock_user(p, arg1, 0);
4904             ret = get_errno(sigsuspend(&set));
4905         }
4906         break;
4907     case TARGET_NR_rt_sigtimedwait:
4908         {
4909             sigset_t set;
4910             struct timespec uts, *puts;
4911             siginfo_t uinfo;
4912
4913             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4914                 goto efault;
4915             target_to_host_sigset(&set, p);
4916             unlock_user(p, arg1, 0);
4917             if (arg3) {
4918                 puts = &uts;
4919                 target_to_host_timespec(puts, arg3);
4920             } else {
4921                 puts = NULL;
4922             }
4923             ret = get_errno(sigtimedwait(&set, &uinfo, puts));
4924             if (!is_error(ret) && arg2) {
4925                 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
4926                     goto efault;
4927                 host_to_target_siginfo(p, &uinfo);
4928                 unlock_user(p, arg2, sizeof(target_siginfo_t));
4929             }
4930         }
4931         break;
4932     case TARGET_NR_rt_sigqueueinfo:
4933         {
4934             siginfo_t uinfo;
4935             if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
4936                 goto efault;
4937             target_to_host_siginfo(&uinfo, p);
4938             unlock_user(p, arg1, 0);
4939             ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
4940         }
4941         break;
4942 #ifdef TARGET_NR_sigreturn
4943     case TARGET_NR_sigreturn:
4944         /* NOTE: ret is eax, so not transcoding must be done */
4945         ret = do_sigreturn(cpu_env);
4946         break;
4947 #endif
4948     case TARGET_NR_rt_sigreturn:
4949         /* NOTE: ret is eax, so not transcoding must be done */
4950         ret = do_rt_sigreturn(cpu_env);
4951         break;
4952     case TARGET_NR_sethostname:
4953         if (!(p = lock_user_string(arg1)))
4954             goto efault;
4955         ret = get_errno(sethostname(p, arg2));
4956         unlock_user(p, arg1, 0);
4957         break;
4958     case TARGET_NR_setrlimit:
4959         {
4960             /* XXX: convert resource ? */
4961             int resource = arg1;
4962             struct target_rlimit *target_rlim;
4963             struct rlimit rlim;
4964             if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
4965                 goto efault;
4966             rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4967             rlim.rlim_max = tswapl(target_rlim->rlim_max);
4968             unlock_user_struct(target_rlim, arg2, 0);
4969             ret = get_errno(setrlimit(resource, &rlim));
4970         }
4971         break;
4972     case TARGET_NR_getrlimit:
4973         {
4974             /* XXX: convert resource ? */
4975             int resource = arg1;
4976             struct target_rlimit *target_rlim;
4977             struct rlimit rlim;
4978
4979             ret = get_errno(getrlimit(resource, &rlim));
4980             if (!is_error(ret)) {
4981                 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
4982                     goto efault;
4983                 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4984                 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4985                 unlock_user_struct(target_rlim, arg2, 1);
4986             }
4987         }
4988         break;
4989     case TARGET_NR_getrusage:
4990         {
4991             struct rusage rusage;
4992             ret = get_errno(getrusage(arg1, &rusage));
4993             if (!is_error(ret)) {
4994                 host_to_target_rusage(arg2, &rusage);
4995             }
4996         }
4997         break;
4998     case TARGET_NR_gettimeofday:
4999         {
5000             struct timeval tv;
5001             ret = get_errno(gettimeofday(&tv, NULL));
5002             if (!is_error(ret)) {
5003                 if (copy_to_user_timeval(arg1, &tv))
5004                     goto efault;
5005             }
5006         }
5007         break;
5008     case TARGET_NR_settimeofday:
5009         {
5010             struct timeval tv;
5011             if (copy_from_user_timeval(&tv, arg1))
5012                 goto efault;
5013             ret = get_errno(settimeofday(&tv, NULL));
5014         }
5015         break;
5016 #ifdef TARGET_NR_select
5017     case TARGET_NR_select:
5018         {
5019             struct target_sel_arg_struct *sel;
5020             abi_ulong inp, outp, exp, tvp;
5021             long nsel;
5022
5023             if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
5024                 goto efault;
5025             nsel = tswapl(sel->n);
5026             inp = tswapl(sel->inp);
5027             outp = tswapl(sel->outp);
5028             exp = tswapl(sel->exp);
5029             tvp = tswapl(sel->tvp);
5030             unlock_user_struct(sel, arg1, 0);
5031             ret = do_select(nsel, inp, outp, exp, tvp);
5032         }
5033         break;
5034 #endif
5035     case TARGET_NR_symlink:
5036         {
5037             void *p2;
5038             p = lock_user_string(arg1);
5039             p2 = lock_user_string(arg2);
5040             if (!p || !p2)
5041                 ret = -TARGET_EFAULT;
5042             else
5043                 ret = get_errno(symlink(p, p2));
5044             unlock_user(p2, arg2, 0);
5045             unlock_user(p, arg1, 0);
5046         }
5047         break;
5048 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
5049     case TARGET_NR_symlinkat:
5050         {
5051             void *p2;
5052             p  = lock_user_string(arg1);
5053             p2 = lock_user_string(arg3);
5054             if (!p || !p2)
5055                 ret = -TARGET_EFAULT;
5056             else
5057                 ret = get_errno(sys_symlinkat(p, arg2, p2));
5058             unlock_user(p2, arg3, 0);
5059             unlock_user(p, arg1, 0);
5060         }
5061         break;
5062 #endif
5063 #ifdef TARGET_NR_oldlstat
5064     case TARGET_NR_oldlstat:
5065         goto unimplemented;
5066 #endif
5067     case TARGET_NR_readlink:
5068         {
5069             void *p2, *temp;
5070             p = lock_user_string(arg1);
5071             p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
5072             if (!p || !p2)
5073                 ret = -TARGET_EFAULT;
5074             else {
5075                 if (strncmp((const char *)p, "/proc/self/exe", 14) == 0) {
5076                     char real[PATH_MAX];
5077                     temp = realpath(exec_path,real);
5078                     ret = (temp==NULL) ? get_errno(-1) : strlen(real) ;
5079                     snprintf((char *)p2, arg3, "%s", real);
5080                     }
5081                 else
5082                     ret = get_errno(readlink(path(p), p2, arg3));
5083             }
5084             unlock_user(p2, arg2, ret);
5085             unlock_user(p, arg1, 0);
5086         }
5087         break;
5088 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
5089     case TARGET_NR_readlinkat:
5090         {
5091             void *p2;
5092             p  = lock_user_string(arg2);
5093             p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
5094             if (!p || !p2)
5095                 ret = -TARGET_EFAULT;
5096             else
5097                 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
5098             unlock_user(p2, arg3, ret);
5099             unlock_user(p, arg2, 0);
5100         }
5101         break;
5102 #endif
5103 #ifdef TARGET_NR_uselib
5104     case TARGET_NR_uselib:
5105         goto unimplemented;
5106 #endif
5107 #ifdef TARGET_NR_swapon
5108     case TARGET_NR_swapon:
5109         if (!(p = lock_user_string(arg1)))
5110             goto efault;
5111         ret = get_errno(swapon(p, arg2));
5112         unlock_user(p, arg1, 0);
5113         break;
5114 #endif
5115     case TARGET_NR_reboot:
5116         goto unimplemented;
5117 #ifdef TARGET_NR_readdir
5118     case TARGET_NR_readdir:
5119         goto unimplemented;
5120 #endif
5121 #ifdef TARGET_NR_mmap
5122     case TARGET_NR_mmap:
5123 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
5124         {
5125             abi_ulong *v;
5126             abi_ulong v1, v2, v3, v4, v5, v6;
5127             if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
5128                 goto efault;
5129             v1 = tswapl(v[0]);
5130             v2 = tswapl(v[1]);
5131             v3 = tswapl(v[2]);
5132             v4 = tswapl(v[3]);
5133             v5 = tswapl(v[4]);
5134             v6 = tswapl(v[5]);
5135             unlock_user(v, arg1, 0);
5136             ret = get_errno(target_mmap(v1, v2, v3,
5137                                         target_to_host_bitmask(v4, mmap_flags_tbl),
5138                                         v5, v6));
5139         }
5140 #else
5141         ret = get_errno(target_mmap(arg1, arg2, arg3,
5142                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
5143                                     arg5,
5144                                     arg6));
5145 #endif
5146         break;
5147 #endif
5148 #ifdef TARGET_NR_mmap2
5149     case TARGET_NR_mmap2:
5150 #ifndef MMAP_SHIFT
5151 #define MMAP_SHIFT 12
5152 #endif
5153         ret = get_errno(target_mmap(arg1, arg2, arg3,
5154                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
5155                                     arg5,
5156                                     arg6 << MMAP_SHIFT));
5157         break;
5158 #endif
5159     case TARGET_NR_munmap:
5160         ret = get_errno(target_munmap(arg1, arg2));
5161         break;
5162     case TARGET_NR_mprotect:
5163         ret = get_errno(target_mprotect(arg1, arg2, arg3));
5164         break;
5165 #ifdef TARGET_NR_mremap
5166     case TARGET_NR_mremap:
5167         ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
5168         break;
5169 #endif
5170         /* ??? msync/mlock/munlock are broken for softmmu.  */
5171 #ifdef TARGET_NR_msync
5172     case TARGET_NR_msync:
5173         ret = get_errno(msync(g2h(arg1), arg2, arg3));
5174         break;
5175 #endif
5176 #ifdef TARGET_NR_mlock
5177     case TARGET_NR_mlock:
5178         ret = get_errno(mlock(g2h(arg1), arg2));
5179         break;
5180 #endif
5181 #ifdef TARGET_NR_munlock
5182     case TARGET_NR_munlock:
5183         ret = get_errno(munlock(g2h(arg1), arg2));
5184         break;
5185 #endif
5186 #ifdef TARGET_NR_mlockall
5187     case TARGET_NR_mlockall:
5188         ret = get_errno(mlockall(arg1));
5189         break;
5190 #endif
5191 #ifdef TARGET_NR_munlockall
5192     case TARGET_NR_munlockall:
5193         ret = get_errno(munlockall());
5194         break;
5195 #endif
5196     case TARGET_NR_truncate:
5197         if (!(p = lock_user_string(arg1)))
5198             goto efault;
5199         ret = get_errno(truncate(p, arg2));
5200         unlock_user(p, arg1, 0);
5201         break;
5202     case TARGET_NR_ftruncate:
5203         ret = get_errno(ftruncate(arg1, arg2));
5204         break;
5205     case TARGET_NR_fchmod:
5206         ret = get_errno(fchmod(arg1, arg2));
5207         break;
5208 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
5209     case TARGET_NR_fchmodat:
5210         if (!(p = lock_user_string(arg2)))
5211             goto efault;
5212         ret = get_errno(sys_fchmodat(arg1, p, arg3));
5213         unlock_user(p, arg2, 0);
5214         break;
5215 #endif
5216     case TARGET_NR_getpriority:
5217         /* libc does special remapping of the return value of
5218          * sys_getpriority() so it's just easiest to call
5219          * sys_getpriority() directly rather than through libc. */
5220         ret = sys_getpriority(arg1, arg2);
5221         break;
5222     case TARGET_NR_setpriority:
5223         ret = get_errno(setpriority(arg1, arg2, arg3));
5224         break;
5225 #ifdef TARGET_NR_profil
5226     case TARGET_NR_profil:
5227         goto unimplemented;
5228 #endif
5229     case TARGET_NR_statfs:
5230         if (!(p = lock_user_string(arg1)))
5231             goto efault;
5232         ret = get_errno(statfs(path(p), &stfs));
5233         unlock_user(p, arg1, 0);
5234     convert_statfs:
5235         if (!is_error(ret)) {
5236             struct target_statfs *target_stfs;
5237
5238             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
5239                 goto efault;
5240             __put_user(stfs.f_type, &target_stfs->f_type);
5241             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
5242             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
5243             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
5244             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
5245             __put_user(stfs.f_files, &target_stfs->f_files);
5246             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
5247             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
5248             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
5249             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
5250             unlock_user_struct(target_stfs, arg2, 1);
5251         }
5252         break;
5253     case TARGET_NR_fstatfs:
5254         ret = get_errno(fstatfs(arg1, &stfs));
5255         goto convert_statfs;
5256 #ifdef TARGET_NR_statfs64
5257     case TARGET_NR_statfs64:
5258         if (!(p = lock_user_string(arg1)))
5259             goto efault;
5260         ret = get_errno(statfs(path(p), &stfs));
5261         unlock_user(p, arg1, 0);
5262     convert_statfs64:
5263         if (!is_error(ret)) {
5264             struct target_statfs64 *target_stfs;
5265
5266             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
5267                 goto efault;
5268             __put_user(stfs.f_type, &target_stfs->f_type);
5269             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
5270             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
5271             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
5272             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
5273             __put_user(stfs.f_files, &target_stfs->f_files);
5274             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
5275             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
5276             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
5277             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
5278             unlock_user_struct(target_stfs, arg3, 1);
5279         }
5280         break;
5281     case TARGET_NR_fstatfs64:
5282         ret = get_errno(fstatfs(arg1, &stfs));
5283         goto convert_statfs64;
5284 #endif
5285 #ifdef TARGET_NR_ioperm
5286     case TARGET_NR_ioperm:
5287         goto unimplemented;
5288 #endif
5289 #ifdef TARGET_NR_socketcall
5290     case TARGET_NR_socketcall:
5291         ret = do_socketcall(arg1, arg2);
5292         break;
5293 #endif
5294 #ifdef TARGET_NR_accept
5295     case TARGET_NR_accept:
5296         ret = do_accept(arg1, arg2, arg3);
5297         break;
5298 #endif
5299 #ifdef TARGET_NR_bind
5300     case TARGET_NR_bind:
5301         ret = do_bind(arg1, arg2, arg3);
5302         break;
5303 #endif
5304 #ifdef TARGET_NR_connect
5305     case TARGET_NR_connect:
5306         ret = do_connect(arg1, arg2, arg3);
5307         break;
5308 #endif
5309 #ifdef TARGET_NR_getpeername
5310     case TARGET_NR_getpeername:
5311         ret = do_getpeername(arg1, arg2, arg3);
5312         break;
5313 #endif
5314 #ifdef TARGET_NR_getsockname
5315     case TARGET_NR_getsockname:
5316         ret = do_getsockname(arg1, arg2, arg3);
5317         break;
5318 #endif
5319 #ifdef TARGET_NR_getsockopt
5320     case TARGET_NR_getsockopt:
5321         ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
5322         break;
5323 #endif
5324 #ifdef TARGET_NR_listen
5325     case TARGET_NR_listen:
5326         ret = get_errno(listen(arg1, arg2));
5327         break;
5328 #endif
5329 #ifdef TARGET_NR_recv
5330     case TARGET_NR_recv:
5331         ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
5332         break;
5333 #endif
5334 #ifdef TARGET_NR_recvfrom
5335     case TARGET_NR_recvfrom:
5336         ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
5337         break;
5338 #endif
5339 #ifdef TARGET_NR_recvmsg
5340     case TARGET_NR_recvmsg:
5341         ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
5342         break;
5343 #endif
5344 #ifdef TARGET_NR_send
5345     case TARGET_NR_send:
5346         ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
5347         break;
5348 #endif
5349 #ifdef TARGET_NR_sendmsg
5350     case TARGET_NR_sendmsg:
5351         ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
5352         break;
5353 #endif
5354 #ifdef TARGET_NR_sendto
5355     case TARGET_NR_sendto:
5356         ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
5357         break;
5358 #endif
5359 #ifdef TARGET_NR_shutdown
5360     case TARGET_NR_shutdown:
5361         ret = get_errno(shutdown(arg1, arg2));
5362         break;
5363 #endif
5364 #ifdef TARGET_NR_socket
5365     case TARGET_NR_socket:
5366         ret = do_socket(arg1, arg2, arg3);
5367         break;
5368 #endif
5369 #ifdef TARGET_NR_socketpair
5370     case TARGET_NR_socketpair:
5371         ret = do_socketpair(arg1, arg2, arg3, arg4);
5372         break;
5373 #endif
5374 #ifdef TARGET_NR_setsockopt
5375     case TARGET_NR_setsockopt:
5376         ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
5377         break;
5378 #endif
5379
5380     case TARGET_NR_syslog:
5381         if (!(p = lock_user_string(arg2)))
5382             goto efault;
5383         ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
5384         unlock_user(p, arg2, 0);
5385         break;
5386
5387     case TARGET_NR_setitimer:
5388         {
5389             struct itimerval value, ovalue, *pvalue;
5390
5391             if (arg2) {
5392                 pvalue = &value;
5393                 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
5394                     || copy_from_user_timeval(&pvalue->it_value,
5395                                               arg2 + sizeof(struct target_timeval)))
5396                     goto efault;
5397             } else {
5398                 pvalue = NULL;
5399             }
5400             ret = get_errno(setitimer(arg1, pvalue, &ovalue));
5401             if (!is_error(ret) && arg3) {
5402                 if (copy_to_user_timeval(arg3,
5403                                          &ovalue.it_interval)
5404                     || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
5405                                             &ovalue.it_value))
5406                     goto efault;
5407             }
5408         }
5409         break;
5410     case TARGET_NR_getitimer:
5411         {
5412             struct itimerval value;
5413
5414             ret = get_errno(getitimer(arg1, &value));
5415             if (!is_error(ret) && arg2) {
5416                 if (copy_to_user_timeval(arg2,
5417                                          &value.it_interval)
5418                     || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
5419                                             &value.it_value))
5420                     goto efault;
5421             }
5422         }
5423         break;
5424     case TARGET_NR_stat:
5425         if (!(p = lock_user_string(arg1)))
5426             goto efault;
5427         ret = get_errno(stat(path(p), &st));
5428         unlock_user(p, arg1, 0);
5429         goto do_stat;
5430     case TARGET_NR_lstat:
5431         if (!(p = lock_user_string(arg1)))
5432             goto efault;
5433         ret = get_errno(lstat(path(p), &st));
5434         unlock_user(p, arg1, 0);
5435         goto do_stat;
5436     case TARGET_NR_fstat:
5437         {
5438             ret = get_errno(fstat(arg1, &st));
5439         do_stat:
5440             if (!is_error(ret)) {
5441                 struct target_stat *target_st;
5442
5443                 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
5444                     goto efault;
5445                 __put_user(st.st_dev, &target_st->st_dev);
5446                 __put_user(st.st_ino, &target_st->st_ino);
5447                 __put_user(st.st_mode, &target_st->st_mode);
5448                 __put_user(st.st_uid, &target_st->st_uid);
5449                 __put_user(st.st_gid, &target_st->st_gid);
5450                 __put_user(st.st_nlink, &target_st->st_nlink);
5451                 __put_user(st.st_rdev, &target_st->st_rdev);
5452                 __put_user(st.st_size, &target_st->st_size);
5453                 __put_user(st.st_blksize, &target_st->st_blksize);
5454                 __put_user(st.st_blocks, &target_st->st_blocks);
5455                 __put_user(st.st_atime, &target_st->target_st_atime);
5456                 __put_user(st.st_mtime, &target_st->target_st_mtime);
5457                 __put_user(st.st_ctime, &target_st->target_st_ctime);
5458                 unlock_user_struct(target_st, arg2, 1);
5459             }
5460         }
5461         break;
5462 #ifdef TARGET_NR_olduname
5463     case TARGET_NR_olduname:
5464         goto unimplemented;
5465 #endif
5466 #ifdef TARGET_NR_iopl
5467     case TARGET_NR_iopl:
5468         goto unimplemented;
5469 #endif
5470     case TARGET_NR_vhangup:
5471         ret = get_errno(vhangup());
5472         break;
5473 #ifdef TARGET_NR_idle
5474     case TARGET_NR_idle:
5475         goto unimplemented;
5476 #endif
5477 #ifdef TARGET_NR_syscall
5478     case TARGET_NR_syscall:
5479         ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
5480         break;
5481 #endif
5482     case TARGET_NR_wait4:
5483         {
5484             int status;
5485             abi_long status_ptr = arg2;
5486             struct rusage rusage, *rusage_ptr;
5487             abi_ulong target_rusage = arg4;
5488             if (target_rusage)
5489                 rusage_ptr = &rusage;
5490             else
5491                 rusage_ptr = NULL;
5492             ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
5493             if (!is_error(ret)) {
5494                 if (status_ptr) {
5495                     status = host_to_target_waitstatus(status);
5496                     if (put_user_s32(status, status_ptr))
5497                         goto efault;
5498                 }
5499                 if (target_rusage)
5500                     host_to_target_rusage(target_rusage, &rusage);
5501             }
5502         }
5503         break;
5504 #ifdef TARGET_NR_swapoff
5505     case TARGET_NR_swapoff:
5506         if (!(p = lock_user_string(arg1)))
5507             goto efault;
5508         ret = get_errno(swapoff(p));
5509         unlock_user(p, arg1, 0);
5510         break;
5511 #endif
5512     case TARGET_NR_sysinfo:
5513         {
5514             struct target_sysinfo *target_value;
5515             struct sysinfo value;
5516             ret = get_errno(sysinfo(&value));
5517             if (!is_error(ret) && arg1)
5518             {
5519                 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
5520                     goto efault;
5521                 __put_user(value.uptime, &target_value->uptime);
5522                 __put_user(value.loads[0], &target_value->loads[0]);
5523                 __put_user(value.loads[1], &target_value->loads[1]);
5524                 __put_user(value.loads[2], &target_value->loads[2]);
5525                 __put_user(value.totalram, &target_value->totalram);
5526                 __put_user(value.freeram, &target_value->freeram);
5527                 __put_user(value.sharedram, &target_value->sharedram);
5528                 __put_user(value.bufferram, &target_value->bufferram);
5529                 __put_user(value.totalswap, &target_value->totalswap);
5530                 __put_user(value.freeswap, &target_value->freeswap);
5531                 __put_user(value.procs, &target_value->procs);
5532                 __put_user(value.totalhigh, &target_value->totalhigh);
5533                 __put_user(value.freehigh, &target_value->freehigh);
5534                 __put_user(value.mem_unit, &target_value->mem_unit);
5535                 unlock_user_struct(target_value, arg1, 1);
5536             }
5537         }
5538         break;
5539 #ifdef TARGET_NR_ipc
5540     case TARGET_NR_ipc:
5541         ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
5542         break;
5543 #endif
5544 #ifdef TARGET_NR_semget
5545     case TARGET_NR_semget:
5546         ret = get_errno(semget(arg1, arg2, arg3));
5547         break;
5548 #endif
5549 #ifdef TARGET_NR_semop
5550     case TARGET_NR_semop:
5551         ret = get_errno(do_semop(arg1, arg2, arg3));
5552         break;
5553 #endif
5554 #ifdef TARGET_NR_semctl
5555     case TARGET_NR_semctl:
5556         ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);
5557         break;
5558 #endif
5559 #ifdef TARGET_NR_msgctl
5560     case TARGET_NR_msgctl:
5561         ret = do_msgctl(arg1, arg2, arg3);
5562         break;
5563 #endif
5564 #ifdef TARGET_NR_msgget
5565     case TARGET_NR_msgget:
5566         ret = get_errno(msgget(arg1, arg2));
5567         break;
5568 #endif
5569 #ifdef TARGET_NR_msgrcv
5570     case TARGET_NR_msgrcv:
5571         ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
5572         break;
5573 #endif
5574 #ifdef TARGET_NR_msgsnd
5575     case TARGET_NR_msgsnd:
5576         ret = do_msgsnd(arg1, arg2, arg3, arg4);
5577         break;
5578 #endif
5579 #ifdef TARGET_NR_shmget
5580     case TARGET_NR_shmget:
5581         ret = get_errno(shmget(arg1, arg2, arg3));
5582         break;
5583 #endif
5584 #ifdef TARGET_NR_shmctl
5585     case TARGET_NR_shmctl:
5586         ret = do_shmctl(arg1, arg2, arg3);
5587         break;
5588 #endif
5589 #ifdef TARGET_NR_shmat
5590     case TARGET_NR_shmat:
5591         ret = do_shmat(arg1, arg2, arg3);
5592         break;
5593 #endif
5594 #ifdef TARGET_NR_shmdt
5595     case TARGET_NR_shmdt:
5596         ret = do_shmdt(arg1);
5597         break;
5598 #endif
5599     case TARGET_NR_fsync:
5600         ret = get_errno(fsync(arg1));
5601         break;
5602     case TARGET_NR_clone:
5603 #if defined(TARGET_SH4)
5604         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
5605 #elif defined(TARGET_CRIS)
5606         ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5));
5607 #else
5608         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
5609 #endif
5610         break;
5611 #ifdef __NR_exit_group
5612         /* new thread calls */
5613     case TARGET_NR_exit_group:
5614 #ifdef HAVE_GPROF
5615         _mcleanup();
5616 #endif
5617         gdb_exit(cpu_env, arg1);
5618         ret = get_errno(exit_group(arg1));
5619         break;
5620 #endif
5621     case TARGET_NR_setdomainname:
5622         if (!(p = lock_user_string(arg1)))
5623             goto efault;
5624         ret = get_errno(setdomainname(p, arg2));
5625         unlock_user(p, arg1, 0);
5626         break;
5627     case TARGET_NR_uname:
5628         /* no need to transcode because we use the linux syscall */
5629         {
5630             struct new_utsname * buf;
5631
5632             if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
5633                 goto efault;
5634             ret = get_errno(sys_uname(buf));
5635             if (!is_error(ret)) {
5636                 /* Overrite the native machine name with whatever is being
5637                    emulated. */
5638                 strcpy (buf->machine, UNAME_MACHINE);
5639                 /* Allow the user to override the reported release.  */
5640                 if (qemu_uname_release && *qemu_uname_release)
5641                   strcpy (buf->release, qemu_uname_release);
5642             }
5643             unlock_user_struct(buf, arg1, 1);
5644         }
5645         break;
5646 #ifdef TARGET_I386
5647     case TARGET_NR_modify_ldt:
5648         ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
5649         break;
5650 #if !defined(TARGET_X86_64)
5651     case TARGET_NR_vm86old:
5652         goto unimplemented;
5653     case TARGET_NR_vm86:
5654         ret = do_vm86(cpu_env, arg1, arg2);
5655         break;
5656 #endif
5657 #endif
5658     case TARGET_NR_adjtimex:
5659         goto unimplemented;
5660 #ifdef TARGET_NR_create_module
5661     case TARGET_NR_create_module:
5662 #endif
5663     case TARGET_NR_init_module:
5664     case TARGET_NR_delete_module:
5665 #ifdef TARGET_NR_get_kernel_syms
5666     case TARGET_NR_get_kernel_syms:
5667 #endif
5668         goto unimplemented;
5669     case TARGET_NR_quotactl:
5670         goto unimplemented;
5671     case TARGET_NR_getpgid:
5672         ret = get_errno(getpgid(arg1));
5673         break;
5674     case TARGET_NR_fchdir:
5675         ret = get_errno(fchdir(arg1));
5676         break;
5677 #ifdef TARGET_NR_bdflush /* not on x86_64 */
5678     case TARGET_NR_bdflush:
5679         goto unimplemented;
5680 #endif
5681 #ifdef TARGET_NR_sysfs
5682     case TARGET_NR_sysfs:
5683         goto unimplemented;
5684 #endif
5685     case TARGET_NR_personality:
5686         ret = get_errno(personality(arg1));
5687         break;
5688 #ifdef TARGET_NR_afs_syscall
5689     case TARGET_NR_afs_syscall:
5690         goto unimplemented;
5691 #endif
5692 #ifdef TARGET_NR__llseek /* Not on alpha */
5693     case TARGET_NR__llseek:
5694         {
5695 #if defined (__x86_64__)
5696             ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
5697             if (put_user_s64(ret, arg4))
5698                 goto efault;
5699 #else
5700             int64_t res;
5701             ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
5702             if (put_user_s64(res, arg4))
5703                 goto efault;
5704 #endif
5705         }
5706         break;
5707 #endif
5708     case TARGET_NR_getdents:
5709 #if TARGET_ABI_BITS != 32
5710         goto unimplemented;
5711 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
5712         {
5713             struct target_dirent *target_dirp;
5714             struct linux_dirent *dirp;
5715             abi_long count = arg3;
5716
5717             dirp = malloc(count);
5718             if (!dirp) {
5719                 ret = -TARGET_ENOMEM;
5720                 goto fail;
5721             }
5722
5723             ret = get_errno(sys_getdents(arg1, dirp, count));
5724             if (!is_error(ret)) {
5725                 struct linux_dirent *de;
5726                 struct target_dirent *tde;
5727                 int len = ret;
5728                 int reclen, treclen;
5729                 int count1, tnamelen;
5730
5731                 count1 = 0;
5732                 de = dirp;
5733                 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5734                     goto efault;
5735                 tde = target_dirp;
5736                 while (len > 0) {
5737                     reclen = de->d_reclen;
5738                     treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
5739                     tde->d_reclen = tswap16(treclen);
5740                     tde->d_ino = tswapl(de->d_ino);
5741                     tde->d_off = tswapl(de->d_off);
5742                     tnamelen = treclen - (2 * sizeof(abi_long) + 2);
5743                     if (tnamelen > 256)
5744                         tnamelen = 256;
5745                     /* XXX: may not be correct */
5746                     pstrcpy(tde->d_name, tnamelen, de->d_name);
5747                     de = (struct linux_dirent *)((char *)de + reclen);
5748                     len -= reclen;
5749                     tde = (struct target_dirent *)((char *)tde + treclen);
5750                     count1 += treclen;
5751                 }
5752                 ret = count1;
5753                 unlock_user(target_dirp, arg2, ret);
5754             }
5755             free(dirp);
5756         }
5757 #else
5758         {
5759             struct linux_dirent *dirp;
5760             abi_long count = arg3;
5761
5762             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5763                 goto efault;
5764             ret = get_errno(sys_getdents(arg1, dirp, count));
5765             if (!is_error(ret)) {
5766                 struct linux_dirent *de;
5767                 int len = ret;
5768                 int reclen;
5769                 de = dirp;
5770                 while (len > 0) {
5771                     reclen = de->d_reclen;
5772                     if (reclen > len)
5773                         break;
5774                     de->d_reclen = tswap16(reclen);
5775                     tswapls(&de->d_ino);
5776                     tswapls(&de->d_off);
5777                     de = (struct linux_dirent *)((char *)de + reclen);
5778                     len -= reclen;
5779                 }
5780             }
5781             unlock_user(dirp, arg2, ret);
5782         }
5783 #endif
5784         break;
5785 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
5786     case TARGET_NR_getdents64:
5787         {
5788             struct linux_dirent64 *dirp;
5789             abi_long count = arg3;
5790             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
5791                 goto efault;
5792             ret = get_errno(sys_getdents64(arg1, dirp, count));
5793             if (!is_error(ret)) {
5794                 struct linux_dirent64 *de;
5795                 int len = ret;
5796                 int reclen;
5797                 de = dirp;
5798                 while (len > 0) {
5799                     reclen = de->d_reclen;
5800                     if (reclen > len)
5801                         break;
5802                     de->d_reclen = tswap16(reclen);
5803                     tswap64s((uint64_t *)&de->d_ino);
5804                     tswap64s((uint64_t *)&de->d_off);
5805                     de = (struct linux_dirent64 *)((char *)de + reclen);
5806                     len -= reclen;
5807                 }
5808             }
5809             unlock_user(dirp, arg2, ret);
5810         }
5811         break;
5812 #endif /* TARGET_NR_getdents64 */
5813 #ifdef TARGET_NR__newselect
5814     case TARGET_NR__newselect:
5815         ret = do_select(arg1, arg2, arg3, arg4, arg5);
5816         break;
5817 #endif
5818 #ifdef TARGET_NR_poll
5819     case TARGET_NR_poll:
5820         {
5821             struct target_pollfd *target_pfd;
5822             unsigned int nfds = arg2;
5823             int timeout = arg3;
5824             struct pollfd *pfd;
5825             unsigned int i;
5826
5827             target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
5828             if (!target_pfd)
5829                 goto efault;
5830             pfd = alloca(sizeof(struct pollfd) * nfds);
5831             for(i = 0; i < nfds; i++) {
5832                 pfd[i].fd = tswap32(target_pfd[i].fd);
5833                 pfd[i].events = tswap16(target_pfd[i].events);
5834             }
5835             ret = get_errno(poll(pfd, nfds, timeout));
5836             if (!is_error(ret)) {
5837                 for(i = 0; i < nfds; i++) {
5838                     target_pfd[i].revents = tswap16(pfd[i].revents);
5839                 }
5840                 ret += nfds * (sizeof(struct target_pollfd)
5841                                - sizeof(struct pollfd));
5842             }
5843             unlock_user(target_pfd, arg1, ret);
5844         }
5845         break;
5846 #endif
5847     case TARGET_NR_flock:
5848         /* NOTE: the flock constant seems to be the same for every
5849            Linux platform */
5850         ret = get_errno(flock(arg1, arg2));
5851         break;
5852     case TARGET_NR_readv:
5853         {
5854             int count = arg3;
5855             struct iovec *vec;
5856
5857             vec = alloca(count * sizeof(struct iovec));
5858             if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
5859                 goto efault;
5860             ret = get_errno(readv(arg1, vec, count));
5861             unlock_iovec(vec, arg2, count, 1);
5862         }
5863         break;
5864     case TARGET_NR_writev:
5865         {
5866             int count = arg3;
5867             struct iovec *vec;
5868
5869             vec = alloca(count * sizeof(struct iovec));
5870             if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
5871                 goto efault;
5872             ret = get_errno(writev(arg1, vec, count));
5873             unlock_iovec(vec, arg2, count, 0);
5874         }
5875         break;
5876     case TARGET_NR_getsid:
5877         ret = get_errno(getsid(arg1));
5878         break;
5879 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
5880     case TARGET_NR_fdatasync:
5881         ret = get_errno(fdatasync(arg1));
5882         break;
5883 #endif
5884     case TARGET_NR__sysctl:
5885         /* We don't implement this, but ENOTDIR is always a safe
5886            return value. */
5887         ret = -TARGET_ENOTDIR;
5888         break;
5889     case TARGET_NR_sched_setparam:
5890         {
5891             struct sched_param *target_schp;
5892             struct sched_param schp;
5893
5894             if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
5895                 goto efault;
5896             schp.sched_priority = tswap32(target_schp->sched_priority);
5897             unlock_user_struct(target_schp, arg2, 0);
5898             ret = get_errno(sched_setparam(arg1, &schp));
5899         }
5900         break;
5901     case TARGET_NR_sched_getparam:
5902         {
5903             struct sched_param *target_schp;
5904             struct sched_param schp;
5905             ret = get_errno(sched_getparam(arg1, &schp));
5906             if (!is_error(ret)) {
5907                 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
5908                     goto efault;
5909                 target_schp->sched_priority = tswap32(schp.sched_priority);
5910                 unlock_user_struct(target_schp, arg2, 1);
5911             }
5912         }
5913         break;
5914     case TARGET_NR_sched_setscheduler:
5915         {
5916             struct sched_param *target_schp;
5917             struct sched_param schp;
5918             if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
5919                 goto efault;
5920             schp.sched_priority = tswap32(target_schp->sched_priority);
5921             unlock_user_struct(target_schp, arg3, 0);
5922             ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
5923         }
5924         break;
5925     case TARGET_NR_sched_getscheduler:
5926         ret = get_errno(sched_getscheduler(arg1));
5927         break;
5928     case TARGET_NR_sched_yield:
5929         ret = get_errno(sched_yield());
5930         break;
5931     case TARGET_NR_sched_get_priority_max:
5932         ret = get_errno(sched_get_priority_max(arg1));
5933         break;
5934     case TARGET_NR_sched_get_priority_min:
5935         ret = get_errno(sched_get_priority_min(arg1));
5936         break;
5937     case TARGET_NR_sched_rr_get_interval:
5938         {
5939             struct timespec ts;
5940             ret = get_errno(sched_rr_get_interval(arg1, &ts));
5941             if (!is_error(ret)) {
5942                 host_to_target_timespec(arg2, &ts);
5943             }
5944         }
5945         break;
5946     case TARGET_NR_nanosleep:
5947         {
5948             struct timespec req, rem;
5949             target_to_host_timespec(&req, arg1);
5950             ret = get_errno(nanosleep(&req, &rem));
5951             if (is_error(ret) && arg2) {
5952                 host_to_target_timespec(arg2, &rem);
5953             }
5954         }
5955         break;
5956 #ifdef TARGET_NR_query_module
5957     case TARGET_NR_query_module:
5958         goto unimplemented;
5959 #endif
5960 #ifdef TARGET_NR_nfsservctl
5961     case TARGET_NR_nfsservctl:
5962         goto unimplemented;
5963 #endif
5964     case TARGET_NR_prctl:
5965         switch (arg1)
5966             {
5967             case PR_GET_PDEATHSIG:
5968                 {
5969                     int deathsig;
5970                     ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
5971                     if (!is_error(ret) && arg2
5972                         && put_user_ual(deathsig, arg2))
5973                         goto efault;
5974                 }
5975                 break;
5976             default:
5977                 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
5978                 break;
5979             }
5980         break;
5981 #ifdef TARGET_NR_arch_prctl
5982     case TARGET_NR_arch_prctl:
5983 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5984         ret = do_arch_prctl(cpu_env, arg1, arg2);
5985         break;
5986 #else
5987         goto unimplemented;
5988 #endif
5989 #endif
5990 #ifdef TARGET_NR_pread
5991     case TARGET_NR_pread:
5992 #ifdef TARGET_ARM
5993         if (((CPUARMState *)cpu_env)->eabi)
5994             arg4 = arg5;
5995 #endif
5996         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5997             goto efault;
5998         ret = get_errno(pread(arg1, p, arg3, arg4));
5999         unlock_user(p, arg2, ret);
6000         break;
6001     case TARGET_NR_pwrite:
6002 #ifdef TARGET_ARM
6003         if (((CPUARMState *)cpu_env)->eabi)
6004             arg4 = arg5;
6005 #endif
6006         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
6007             goto efault;
6008         ret = get_errno(pwrite(arg1, p, arg3, arg4));
6009         unlock_user(p, arg2, 0);
6010         break;
6011 #endif
6012 #ifdef TARGET_NR_pread64
6013     case TARGET_NR_pread64:
6014         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
6015             goto efault;
6016         ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
6017         unlock_user(p, arg2, ret);
6018         break;
6019     case TARGET_NR_pwrite64:
6020         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
6021             goto efault;
6022         ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
6023         unlock_user(p, arg2, 0);
6024         break;
6025 #endif
6026     case TARGET_NR_getcwd:
6027         if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
6028             goto efault;
6029         ret = get_errno(sys_getcwd1(p, arg2));
6030         unlock_user(p, arg1, ret);
6031         break;
6032     case TARGET_NR_capget:
6033         goto unimplemented;
6034     case TARGET_NR_capset:
6035         goto unimplemented;
6036     case TARGET_NR_sigaltstack:
6037 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
6038     defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
6039         ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
6040         break;
6041 #else
6042         goto unimplemented;
6043 #endif
6044     case TARGET_NR_sendfile:
6045         goto unimplemented;
6046 #ifdef TARGET_NR_getpmsg
6047     case TARGET_NR_getpmsg:
6048         goto unimplemented;
6049 #endif
6050 #ifdef TARGET_NR_putpmsg
6051     case TARGET_NR_putpmsg:
6052         goto unimplemented;
6053 #endif
6054 #ifdef TARGET_NR_vfork
6055     case TARGET_NR_vfork:
6056         ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
6057                         0, 0, 0, 0));
6058         break;
6059 #endif
6060 #ifdef TARGET_NR_ugetrlimit
6061     case TARGET_NR_ugetrlimit:
6062     {
6063         struct rlimit rlim;
6064         ret = get_errno(getrlimit(arg1, &rlim));
6065         if (!is_error(ret)) {
6066             struct target_rlimit *target_rlim;
6067             if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
6068                 goto efault;
6069             target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
6070             target_rlim->rlim_max = tswapl(rlim.rlim_max);
6071             unlock_user_struct(target_rlim, arg2, 1);
6072         }
6073         break;
6074     }
6075 #endif
6076 #ifdef TARGET_NR_truncate64
6077     case TARGET_NR_truncate64:
6078         if (!(p = lock_user_string(arg1)))
6079             goto efault;
6080         ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
6081         unlock_user(p, arg1, 0);
6082         break;
6083 #endif
6084 #ifdef TARGET_NR_ftruncate64
6085     case TARGET_NR_ftruncate64:
6086         ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
6087         break;
6088 #endif
6089 #ifdef TARGET_NR_stat64
6090     case TARGET_NR_stat64:
6091         if (!(p = lock_user_string(arg1)))
6092             goto efault;
6093         ret = get_errno(stat(path(p), &st));
6094         unlock_user(p, arg1, 0);
6095         if (!is_error(ret))
6096             ret = host_to_target_stat64(cpu_env, arg2, &st);
6097         break;
6098 #endif
6099 #ifdef TARGET_NR_lstat64
6100     case TARGET_NR_lstat64:
6101         if (!(p = lock_user_string(arg1)))
6102             goto efault;
6103         ret = get_errno(lstat(path(p), &st));
6104         unlock_user(p, arg1, 0);
6105         if (!is_error(ret))
6106             ret = host_to_target_stat64(cpu_env, arg2, &st);
6107         break;
6108 #endif
6109 #ifdef TARGET_NR_fstat64
6110     case TARGET_NR_fstat64:
6111         ret = get_errno(fstat(arg1, &st));
6112         if (!is_error(ret))
6113             ret = host_to_target_stat64(cpu_env, arg2, &st);
6114         break;
6115 #endif
6116 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \
6117         (defined(__NR_fstatat64) || defined(__NR_newfstatat))
6118 #ifdef TARGET_NR_fstatat64
6119     case TARGET_NR_fstatat64:
6120 #endif
6121 #ifdef TARGET_NR_newfstatat
6122     case TARGET_NR_newfstatat:
6123 #endif
6124         if (!(p = lock_user_string(arg2)))
6125             goto efault;
6126 #ifdef __NR_fstatat64
6127         ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));
6128 #else
6129         ret = get_errno(sys_newfstatat(arg1, path(p), &st, arg4));
6130 #endif
6131         if (!is_error(ret))
6132             ret = host_to_target_stat64(cpu_env, arg3, &st);
6133         break;
6134 #endif
6135 #ifdef USE_UID16
6136     case TARGET_NR_lchown:
6137         if (!(p = lock_user_string(arg1)))
6138             goto efault;
6139         ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
6140         unlock_user(p, arg1, 0);
6141         break;
6142     case TARGET_NR_getuid:
6143         ret = get_errno(high2lowuid(getuid()));
6144         break;
6145     case TARGET_NR_getgid:
6146         ret = get_errno(high2lowgid(getgid()));
6147         break;
6148     case TARGET_NR_geteuid:
6149         ret = get_errno(high2lowuid(geteuid()));
6150         break;
6151     case TARGET_NR_getegid:
6152         ret = get_errno(high2lowgid(getegid()));
6153         break;
6154     case TARGET_NR_setreuid:
6155         ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
6156         break;
6157     case TARGET_NR_setregid:
6158         ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
6159         break;
6160     case TARGET_NR_getgroups:
6161         {
6162             int gidsetsize = arg1;
6163             uint16_t *target_grouplist;
6164             gid_t *grouplist;
6165             int i;
6166
6167             grouplist = alloca(gidsetsize * sizeof(gid_t));
6168             ret = get_errno(getgroups(gidsetsize, grouplist));
6169             if (gidsetsize == 0)
6170                 break;
6171             if (!is_error(ret)) {
6172                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
6173                 if (!target_grouplist)
6174                     goto efault;
6175                 for(i = 0;i < ret; i++)
6176                     target_grouplist[i] = tswap16(grouplist[i]);
6177                 unlock_user(target_grouplist, arg2, gidsetsize * 2);
6178             }
6179         }
6180         break;
6181     case TARGET_NR_setgroups:
6182         {
6183             int gidsetsize = arg1;
6184             uint16_t *target_grouplist;
6185             gid_t *grouplist;
6186             int i;
6187
6188             grouplist = alloca(gidsetsize * sizeof(gid_t));
6189             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
6190             if (!target_grouplist) {
6191                 ret = -TARGET_EFAULT;
6192                 goto fail;
6193             }
6194             for(i = 0;i < gidsetsize; i++)
6195                 grouplist[i] = tswap16(target_grouplist[i]);
6196             unlock_user(target_grouplist, arg2, 0);
6197             ret = get_errno(setgroups(gidsetsize, grouplist));
6198         }
6199         break;
6200     case TARGET_NR_fchown:
6201         ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
6202         break;
6203 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
6204     case TARGET_NR_fchownat:
6205         if (!(p = lock_user_string(arg2)))
6206             goto efault;
6207         ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
6208         unlock_user(p, arg2, 0);
6209         break;
6210 #endif
6211 #ifdef TARGET_NR_setresuid
6212     case TARGET_NR_setresuid:
6213         ret = get_errno(setresuid(low2highuid(arg1),
6214                                   low2highuid(arg2),
6215                                   low2highuid(arg3)));
6216         break;
6217 #endif
6218 #ifdef TARGET_NR_getresuid
6219     case TARGET_NR_getresuid:
6220         {
6221             uid_t ruid, euid, suid;
6222             ret = get_errno(getresuid(&ruid, &euid, &suid));
6223             if (!is_error(ret)) {
6224                 if (put_user_u16(high2lowuid(ruid), arg1)
6225                     || put_user_u16(high2lowuid(euid), arg2)
6226                     || put_user_u16(high2lowuid(suid), arg3))
6227                     goto efault;
6228             }
6229         }
6230         break;
6231 #endif
6232 #ifdef TARGET_NR_getresgid
6233     case TARGET_NR_setresgid:
6234         ret = get_errno(setresgid(low2highgid(arg1),
6235                                   low2highgid(arg2),
6236                                   low2highgid(arg3)));
6237         break;
6238 #endif
6239 #ifdef TARGET_NR_getresgid
6240     case TARGET_NR_getresgid:
6241         {
6242             gid_t rgid, egid, sgid;
6243             ret = get_errno(getresgid(&rgid, &egid, &sgid));
6244             if (!is_error(ret)) {
6245                 if (put_user_u16(high2lowgid(rgid), arg1)
6246                     || put_user_u16(high2lowgid(egid), arg2)
6247                     || put_user_u16(high2lowgid(sgid), arg3))
6248                     goto efault;
6249             }
6250         }
6251         break;
6252 #endif
6253     case TARGET_NR_chown:
6254         if (!(p = lock_user_string(arg1)))
6255             goto efault;
6256         ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
6257         unlock_user(p, arg1, 0);
6258         break;
6259     case TARGET_NR_setuid:
6260         ret = get_errno(setuid(low2highuid(arg1)));
6261         break;
6262     case TARGET_NR_setgid:
6263         ret = get_errno(setgid(low2highgid(arg1)));
6264         break;
6265     case TARGET_NR_setfsuid:
6266         ret = get_errno(setfsuid(arg1));
6267         break;
6268     case TARGET_NR_setfsgid:
6269         ret = get_errno(setfsgid(arg1));
6270         break;
6271 #endif /* USE_UID16 */
6272
6273 #ifdef TARGET_NR_lchown32
6274     case TARGET_NR_lchown32:
6275         if (!(p = lock_user_string(arg1)))
6276             goto efault;
6277         ret = get_errno(lchown(p, arg2, arg3));
6278         unlock_user(p, arg1, 0);
6279         break;
6280 #endif
6281 #ifdef TARGET_NR_getuid32
6282     case TARGET_NR_getuid32:
6283         ret = get_errno(getuid());
6284         break;
6285 #endif
6286
6287 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
6288    /* Alpha specific */
6289     case TARGET_NR_getxuid:
6290          {
6291             uid_t euid;
6292             euid=geteuid();
6293             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
6294          }
6295         ret = get_errno(getuid());
6296         break;
6297 #endif
6298 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
6299    /* Alpha specific */
6300     case TARGET_NR_getxgid:
6301          {
6302             uid_t egid;
6303             egid=getegid();
6304             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
6305          }
6306         ret = get_errno(getgid());
6307         break;
6308 #endif
6309
6310 #ifdef TARGET_NR_getgid32
6311     case TARGET_NR_getgid32:
6312         ret = get_errno(getgid());
6313         break;
6314 #endif
6315 #ifdef TARGET_NR_geteuid32
6316     case TARGET_NR_geteuid32:
6317         ret = get_errno(geteuid());
6318         break;
6319 #endif
6320 #ifdef TARGET_NR_getegid32
6321     case TARGET_NR_getegid32:
6322         ret = get_errno(getegid());
6323         break;
6324 #endif
6325 #ifdef TARGET_NR_setreuid32
6326     case TARGET_NR_setreuid32:
6327         ret = get_errno(setreuid(arg1, arg2));
6328         break;
6329 #endif
6330 #ifdef TARGET_NR_setregid32
6331     case TARGET_NR_setregid32:
6332         ret = get_errno(setregid(arg1, arg2));
6333         break;
6334 #endif
6335 #ifdef TARGET_NR_getgroups32
6336     case TARGET_NR_getgroups32:
6337         {
6338             int gidsetsize = arg1;
6339             uint32_t *target_grouplist;
6340             gid_t *grouplist;
6341             int i;
6342
6343             grouplist = alloca(gidsetsize * sizeof(gid_t));
6344             ret = get_errno(getgroups(gidsetsize, grouplist));
6345             if (gidsetsize == 0)
6346                 break;
6347             if (!is_error(ret)) {
6348                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
6349                 if (!target_grouplist) {
6350                     ret = -TARGET_EFAULT;
6351                     goto fail;
6352                 }
6353                 for(i = 0;i < ret; i++)
6354                     target_grouplist[i] = tswap32(grouplist[i]);
6355                 unlock_user(target_grouplist, arg2, gidsetsize * 4);
6356             }
6357         }
6358         break;
6359 #endif
6360 #ifdef TARGET_NR_setgroups32
6361     case TARGET_NR_setgroups32:
6362         {
6363             int gidsetsize = arg1;
6364             uint32_t *target_grouplist;
6365             gid_t *grouplist;
6366             int i;
6367
6368             grouplist = alloca(gidsetsize * sizeof(gid_t));
6369             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
6370             if (!target_grouplist) {
6371                 ret = -TARGET_EFAULT;
6372                 goto fail;
6373             }
6374             for(i = 0;i < gidsetsize; i++)
6375                 grouplist[i] = tswap32(target_grouplist[i]);
6376             unlock_user(target_grouplist, arg2, 0);
6377             ret = get_errno(setgroups(gidsetsize, grouplist));
6378         }
6379         break;
6380 #endif
6381 #ifdef TARGET_NR_fchown32
6382     case TARGET_NR_fchown32:
6383         ret = get_errno(fchown(arg1, arg2, arg3));
6384         break;
6385 #endif
6386 #ifdef TARGET_NR_setresuid32
6387     case TARGET_NR_setresuid32:
6388         ret = get_errno(setresuid(arg1, arg2, arg3));
6389         break;
6390 #endif
6391 #ifdef TARGET_NR_getresuid32
6392     case TARGET_NR_getresuid32:
6393         {
6394             uid_t ruid, euid, suid;
6395             ret = get_errno(getresuid(&ruid, &euid, &suid));
6396             if (!is_error(ret)) {
6397                 if (put_user_u32(ruid, arg1)
6398                     || put_user_u32(euid, arg2)
6399                     || put_user_u32(suid, arg3))
6400                     goto efault;
6401             }
6402         }
6403         break;
6404 #endif
6405 #ifdef TARGET_NR_setresgid32
6406     case TARGET_NR_setresgid32:
6407         ret = get_errno(setresgid(arg1, arg2, arg3));
6408         break;
6409 #endif
6410 #ifdef TARGET_NR_getresgid32
6411     case TARGET_NR_getresgid32:
6412         {
6413             gid_t rgid, egid, sgid;
6414             ret = get_errno(getresgid(&rgid, &egid, &sgid));
6415             if (!is_error(ret)) {
6416                 if (put_user_u32(rgid, arg1)
6417                     || put_user_u32(egid, arg2)
6418                     || put_user_u32(sgid, arg3))
6419                     goto efault;
6420             }
6421         }
6422         break;
6423 #endif
6424 #ifdef TARGET_NR_chown32
6425     case TARGET_NR_chown32:
6426         if (!(p = lock_user_string(arg1)))
6427             goto efault;
6428         ret = get_errno(chown(p, arg2, arg3));
6429         unlock_user(p, arg1, 0);
6430         break;
6431 #endif
6432 #ifdef TARGET_NR_setuid32
6433     case TARGET_NR_setuid32:
6434         ret = get_errno(setuid(arg1));
6435         break;
6436 #endif
6437 #ifdef TARGET_NR_setgid32
6438     case TARGET_NR_setgid32:
6439         ret = get_errno(setgid(arg1));
6440         break;
6441 #endif
6442 #ifdef TARGET_NR_setfsuid32
6443     case TARGET_NR_setfsuid32:
6444         ret = get_errno(setfsuid(arg1));
6445         break;
6446 #endif
6447 #ifdef TARGET_NR_setfsgid32
6448     case TARGET_NR_setfsgid32:
6449         ret = get_errno(setfsgid(arg1));
6450         break;
6451 #endif
6452
6453     case TARGET_NR_pivot_root:
6454         goto unimplemented;
6455 #ifdef TARGET_NR_mincore
6456     case TARGET_NR_mincore:
6457         {
6458             void *a;
6459             ret = -TARGET_EFAULT;
6460             if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
6461                 goto efault;
6462             if (!(p = lock_user_string(arg3)))
6463                 goto mincore_fail;
6464             ret = get_errno(mincore(a, arg2, p));
6465             unlock_user(p, arg3, ret);
6466             mincore_fail:
6467             unlock_user(a, arg1, 0);
6468         }
6469         break;
6470 #endif
6471 #ifdef TARGET_NR_arm_fadvise64_64
6472     case TARGET_NR_arm_fadvise64_64:
6473         {
6474                 /*
6475                  * arm_fadvise64_64 looks like fadvise64_64 but
6476                  * with different argument order
6477                  */
6478                 abi_long temp;
6479                 temp = arg3;
6480                 arg3 = arg4;
6481                 arg4 = temp;
6482         }
6483 #endif
6484 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64)
6485 #ifdef TARGET_NR_fadvise64_64
6486     case TARGET_NR_fadvise64_64:
6487 #endif
6488         /* This is a hint, so ignoring and returning success is ok.  */
6489         ret = get_errno(0);
6490         break;
6491 #endif
6492 #ifdef TARGET_NR_madvise
6493     case TARGET_NR_madvise:
6494         /* A straight passthrough may not be safe because qemu sometimes
6495            turns private flie-backed mappings into anonymous mappings.
6496            This will break MADV_DONTNEED.
6497            This is a hint, so ignoring and returning success is ok.  */
6498         ret = get_errno(0);
6499         break;
6500 #endif
6501 #if TARGET_ABI_BITS == 32
6502     case TARGET_NR_fcntl64:
6503     {
6504         int cmd;
6505         struct flock64 fl;
6506         struct target_flock64 *target_fl;
6507 #ifdef TARGET_ARM
6508         struct target_eabi_flock64 *target_efl;
6509 #endif
6510
6511         switch(arg2){
6512         case TARGET_F_GETLK64:
6513             cmd = F_GETLK64;
6514             break;
6515         case TARGET_F_SETLK64:
6516             cmd = F_SETLK64;
6517             break;
6518         case TARGET_F_SETLKW64:
6519             cmd = F_SETLK64;
6520             break;
6521         default:
6522             cmd = arg2;
6523             break;
6524         }
6525
6526         switch(arg2) {
6527         case TARGET_F_GETLK64:
6528 #ifdef TARGET_ARM
6529             if (((CPUARMState *)cpu_env)->eabi) {
6530                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
6531                     goto efault;
6532                 fl.l_type = tswap16(target_efl->l_type);
6533                 fl.l_whence = tswap16(target_efl->l_whence);
6534                 fl.l_start = tswap64(target_efl->l_start);
6535                 fl.l_len = tswap64(target_efl->l_len);
6536                 fl.l_pid = tswapl(target_efl->l_pid);
6537                 unlock_user_struct(target_efl, arg3, 0);
6538             } else
6539 #endif
6540             {
6541                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
6542                     goto efault;
6543                 fl.l_type = tswap16(target_fl->l_type);
6544                 fl.l_whence = tswap16(target_fl->l_whence);
6545                 fl.l_start = tswap64(target_fl->l_start);
6546                 fl.l_len = tswap64(target_fl->l_len);
6547                 fl.l_pid = tswapl(target_fl->l_pid);
6548                 unlock_user_struct(target_fl, arg3, 0);
6549             }
6550             ret = get_errno(fcntl(arg1, cmd, &fl));
6551             if (ret == 0) {
6552 #ifdef TARGET_ARM
6553                 if (((CPUARMState *)cpu_env)->eabi) {
6554                     if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
6555                         goto efault;
6556                     target_efl->l_type = tswap16(fl.l_type);
6557                     target_efl->l_whence = tswap16(fl.l_whence);
6558                     target_efl->l_start = tswap64(fl.l_start);
6559                     target_efl->l_len = tswap64(fl.l_len);
6560                     target_efl->l_pid = tswapl(fl.l_pid);
6561                     unlock_user_struct(target_efl, arg3, 1);
6562                 } else
6563 #endif
6564                 {
6565                     if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
6566                         goto efault;
6567                     target_fl->l_type = tswap16(fl.l_type);
6568                     target_fl->l_whence = tswap16(fl.l_whence);
6569                     target_fl->l_start = tswap64(fl.l_start);
6570                     target_fl->l_len = tswap64(fl.l_len);
6571                     target_fl->l_pid = tswapl(fl.l_pid);
6572                     unlock_user_struct(target_fl, arg3, 1);
6573                 }
6574             }
6575             break;
6576
6577         case TARGET_F_SETLK64:
6578         case TARGET_F_SETLKW64:
6579 #ifdef TARGET_ARM
6580             if (((CPUARMState *)cpu_env)->eabi) {
6581                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
6582                     goto efault;
6583                 fl.l_type = tswap16(target_efl->l_type);
6584                 fl.l_whence = tswap16(target_efl->l_whence);
6585                 fl.l_start = tswap64(target_efl->l_start);
6586                 fl.l_len = tswap64(target_efl->l_len);
6587                 fl.l_pid = tswapl(target_efl->l_pid);
6588                 unlock_user_struct(target_efl, arg3, 0);
6589             } else
6590 #endif
6591             {
6592                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
6593                     goto efault;
6594                 fl.l_type = tswap16(target_fl->l_type);
6595                 fl.l_whence = tswap16(target_fl->l_whence);
6596                 fl.l_start = tswap64(target_fl->l_start);
6597                 fl.l_len = tswap64(target_fl->l_len);
6598                 fl.l_pid = tswapl(target_fl->l_pid);
6599                 unlock_user_struct(target_fl, arg3, 0);
6600             }
6601             ret = get_errno(fcntl(arg1, cmd, &fl));
6602             break;
6603         default:
6604             ret = do_fcntl(arg1, arg2, arg3);
6605             break;
6606         }
6607         break;
6608     }
6609 #endif
6610 #ifdef TARGET_NR_cacheflush
6611     case TARGET_NR_cacheflush:
6612         /* self-modifying code is handled automatically, so nothing needed */
6613         ret = 0;
6614         break;
6615 #endif
6616 #ifdef TARGET_NR_security
6617     case TARGET_NR_security:
6618         goto unimplemented;
6619 #endif
6620 #ifdef TARGET_NR_getpagesize
6621     case TARGET_NR_getpagesize:
6622         ret = TARGET_PAGE_SIZE;
6623         break;
6624 #endif
6625     case TARGET_NR_gettid:
6626         ret = get_errno(gettid());
6627         break;
6628 #ifdef TARGET_NR_readahead
6629     case TARGET_NR_readahead:
6630 #if TARGET_ABI_BITS == 32
6631 #ifdef TARGET_ARM
6632         if (((CPUARMState *)cpu_env)->eabi)
6633         {
6634             arg2 = arg3;
6635             arg3 = arg4;
6636             arg4 = arg5;
6637         }
6638 #endif
6639         ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
6640 #else
6641         ret = get_errno(readahead(arg1, arg2, arg3));
6642 #endif
6643         break;
6644 #endif
6645 #ifdef TARGET_NR_setxattr
6646     case TARGET_NR_setxattr:
6647     case TARGET_NR_lsetxattr:
6648     case TARGET_NR_fsetxattr:
6649     case TARGET_NR_getxattr:
6650     case TARGET_NR_lgetxattr:
6651     case TARGET_NR_fgetxattr:
6652     case TARGET_NR_listxattr:
6653     case TARGET_NR_llistxattr:
6654     case TARGET_NR_flistxattr:
6655     case TARGET_NR_removexattr:
6656     case TARGET_NR_lremovexattr:
6657     case TARGET_NR_fremovexattr:
6658         ret = -TARGET_EOPNOTSUPP;
6659         break;
6660 #endif
6661 #ifdef TARGET_NR_set_thread_area
6662     case TARGET_NR_set_thread_area:
6663 #if defined(TARGET_MIPS)
6664       ((CPUMIPSState *) cpu_env)->tls_value = arg1;
6665       ret = 0;
6666       break;
6667 #elif defined(TARGET_CRIS)
6668       if (arg1 & 0xff)
6669           ret = -TARGET_EINVAL;
6670       else {
6671           ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
6672           ret = 0;
6673       }
6674       break;
6675 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
6676       ret = do_set_thread_area(cpu_env, arg1);
6677       break;
6678 #else
6679       goto unimplemented_nowarn;
6680 #endif
6681 #endif
6682 #ifdef TARGET_NR_get_thread_area
6683     case TARGET_NR_get_thread_area:
6684 #if defined(TARGET_I386) && defined(TARGET_ABI32)
6685         ret = do_get_thread_area(cpu_env, arg1);
6686 #else
6687         goto unimplemented_nowarn;
6688 #endif
6689 #endif
6690 #ifdef TARGET_NR_getdomainname
6691     case TARGET_NR_getdomainname:
6692         goto unimplemented_nowarn;
6693 #endif
6694
6695 #ifdef TARGET_NR_clock_gettime
6696     case TARGET_NR_clock_gettime:
6697     {
6698         struct timespec ts;
6699         ret = get_errno(clock_gettime(arg1, &ts));
6700         if (!is_error(ret)) {
6701             host_to_target_timespec(arg2, &ts);
6702         }
6703         break;
6704     }
6705 #endif
6706 #ifdef TARGET_NR_clock_getres
6707     case TARGET_NR_clock_getres:
6708     {
6709         struct timespec ts;
6710         ret = get_errno(clock_getres(arg1, &ts));
6711         if (!is_error(ret)) {
6712             host_to_target_timespec(arg2, &ts);
6713         }
6714         break;
6715     }
6716 #endif
6717 #ifdef TARGET_NR_clock_nanosleep
6718     case TARGET_NR_clock_nanosleep:
6719     {
6720         struct timespec ts;
6721         target_to_host_timespec(&ts, arg3);
6722         ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
6723         if (arg4)
6724             host_to_target_timespec(arg4, &ts);
6725         break;
6726     }
6727 #endif
6728
6729 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
6730     case TARGET_NR_set_tid_address:
6731         ret = get_errno(set_tid_address((int *)g2h(arg1)));
6732         break;
6733 #endif
6734
6735 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
6736     case TARGET_NR_tkill:
6737         ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
6738         break;
6739 #endif
6740
6741 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
6742     case TARGET_NR_tgkill:
6743         ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
6744                         target_to_host_signal(arg3)));
6745         break;
6746 #endif
6747
6748 #ifdef TARGET_NR_set_robust_list
6749     case TARGET_NR_set_robust_list:
6750         goto unimplemented_nowarn;
6751 #endif
6752
6753 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
6754     case TARGET_NR_utimensat:
6755         {
6756             struct timespec *tsp, ts[2];
6757             if (!arg3) {
6758                 tsp = NULL;
6759             } else {
6760                 target_to_host_timespec(ts, arg3);
6761                 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
6762                 tsp = ts;
6763             }
6764             if (!arg2)
6765                 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
6766             else {
6767                 if (!(p = lock_user_string(arg2))) {
6768                     ret = -TARGET_EFAULT;
6769                     goto fail;
6770                 }
6771                 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
6772                 unlock_user(p, arg2, 0);
6773             }
6774         }
6775         break;
6776 #endif
6777 #if defined(USE_NPTL)
6778     case TARGET_NR_futex:
6779         ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
6780         break;
6781 #endif
6782 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
6783     case TARGET_NR_inotify_init:
6784         ret = get_errno(sys_inotify_init());
6785         break;
6786 #endif
6787 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
6788     case TARGET_NR_inotify_add_watch:
6789         p = lock_user_string(arg2);
6790         ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
6791         unlock_user(p, arg2, 0);
6792         break;
6793 #endif
6794 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
6795     case TARGET_NR_inotify_rm_watch:
6796         ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
6797         break;
6798 #endif
6799
6800 #ifdef TARGET_NR_mq_open
6801     case TARGET_NR_mq_open:
6802         {
6803             struct mq_attr posix_mq_attr;
6804
6805             p = lock_user_string(arg1 - 1);
6806             if (arg4 != 0)
6807                 copy_from_user_mq_attr (&posix_mq_attr, arg4);
6808             ret = get_errno(mq_open(p, arg2, arg3, &posix_mq_attr));
6809             unlock_user (p, arg1, 0);
6810         }
6811         break;
6812
6813     case TARGET_NR_mq_unlink:
6814         p = lock_user_string(arg1 - 1);
6815         ret = get_errno(mq_unlink(p));
6816         unlock_user (p, arg1, 0);
6817         break;
6818
6819     case TARGET_NR_mq_timedsend:
6820         {
6821             struct timespec ts;
6822
6823             p = lock_user (VERIFY_READ, arg2, arg3, 1);
6824             if (arg5 != 0) {
6825                 target_to_host_timespec(&ts, arg5);
6826                 ret = get_errno(mq_timedsend(arg1, p, arg3, arg4, &ts));
6827                 host_to_target_timespec(arg5, &ts);
6828             }
6829             else
6830                 ret = get_errno(mq_send(arg1, p, arg3, arg4));
6831             unlock_user (p, arg2, arg3);
6832         }
6833         break;
6834
6835     case TARGET_NR_mq_timedreceive:
6836         {
6837             struct timespec ts;
6838             unsigned int prio;
6839
6840             p = lock_user (VERIFY_READ, arg2, arg3, 1);
6841             if (arg5 != 0) {
6842                 target_to_host_timespec(&ts, arg5);
6843                 ret = get_errno(mq_timedreceive(arg1, p, arg3, &prio, &ts));
6844                 host_to_target_timespec(arg5, &ts);
6845             }
6846             else
6847                 ret = get_errno(mq_receive(arg1, p, arg3, &prio));
6848             unlock_user (p, arg2, arg3);
6849             if (arg4 != 0)
6850                 put_user_u32(prio, arg4);
6851         }
6852         break;
6853
6854     /* Not implemented for now... */
6855 /*     case TARGET_NR_mq_notify: */
6856 /*         break; */
6857
6858     case TARGET_NR_mq_getsetattr:
6859         {
6860             struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
6861             ret = 0;
6862             if (arg3 != 0) {
6863                 ret = mq_getattr(arg1, &posix_mq_attr_out);
6864                 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
6865             }
6866             if (arg2 != 0) {
6867                 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
6868                 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
6869             }
6870
6871         }
6872         break;
6873 #endif
6874
6875     default:
6876     unimplemented:
6877         gemu_log("qemu: Unsupported syscall: %d\n", num);
6878 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
6879     unimplemented_nowarn:
6880 #endif
6881         ret = -TARGET_ENOSYS;
6882         break;
6883     }
6884 fail:
6885 #ifdef DEBUG
6886     gemu_log(" = %ld\n", ret);
6887 #endif
6888     if(do_strace)
6889         print_syscall_ret(num, ret);
6890     return ret;
6891 efault:
6892     ret = -TARGET_EFAULT;
6893     goto fail;
6894 }