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