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 <grp.h>
  32 #include <sys/types.h>
  33 #include <sys/ipc.h>
  34 #include <sys/msg.h>
  35 #include <sys/wait.h>
  36 #include <sys/time.h>
  37 #include <sys/stat.h>
  38 #include <sys/mount.h>
  39 #include <sys/file.h>
  40 #include <sys/fsuid.h>
  41 #include <sys/personality.h>
  42 #include <sys/prctl.h>
  43 #include <sys/resource.h>
  44 #include <sys/mman.h>
  45 #include <sys/swap.h>
  46 #include <signal.h>
  47 #include <sched.h>
  48 #ifdef __ia64__
  49 int __clone2(int (*fn)(void *), void *child_stack_base,
  50              size_t stack_size, int flags, void *arg, ...);
  51 #endif
  52 #include <sys/socket.h>
  53 #include <sys/un.h>
  54 #include <sys/uio.h>
  55 #include <sys/poll.h>
  56 #include <sys/times.h>
  57 #include <sys/shm.h>
  58 #include <sys/sem.h>
  59 #include <sys/statfs.h>
  60 #include <utime.h>
  61 #include <sys/sysinfo.h>
  62 #include <sys/utsname.h>
  63 //#include <sys/user.h>
  64 #include <netinet/ip.h>
  65 #include <netinet/tcp.h>
  66 #include <linux/wireless.h>
  67 #include <linux/icmp.h>
  68 #include "qemu-common.h"
  69 #ifdef TARGET_GPROF
  70 #include <sys/gmon.h>
  71 #endif
  72 #ifdef CONFIG_EVENTFD
  73 #include <sys/eventfd.h>
  74 #endif
  75 #ifdef CONFIG_EPOLL
  76 #include <sys/epoll.h>
  77 #endif
  78 #ifdef CONFIG_ATTR
  79 #include "qemu/xattr.h"
  80 #endif
  81 #ifdef CONFIG_SENDFILE
  82 #include <sys/sendfile.h>
  83 #endif
  84
  85 #define termios host_termios
  86 #define winsize host_winsize
  87 #define termio host_termio
  88 #define sgttyb host_sgttyb /* same as target */
  89 #define tchars host_tchars /* same as target */
  90 #define ltchars host_ltchars /* same as target */
  91
  92 #include <linux/termios.h>
  93 #include <linux/unistd.h>
  94 #include <linux/utsname.h>
  95 #include <linux/cdrom.h>
  96 #include <linux/hdreg.h>
  97 #include <linux/soundcard.h>
  98 #include <linux/kd.h>
  99 #include <linux/mtio.h>
 100 #include <linux/fs.h>
 101 #if defined(CONFIG_FIEMAP)
 102 #include <linux/fiemap.h>
 103 #endif
 104 #include <linux/fb.h>
 105 #include <linux/vt.h>
 106 #include <linux/dm-ioctl.h>
 107 #include <linux/reboot.h>
 108 #include <linux/route.h>
 109 #include <linux/filter.h>
 110 #include "linux_loop.h"
 111 #include "cpu-uname.h"
 112
 113 #include "qemu.h"
 114
 115 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
 116     CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
 117
 118 //#define DEBUG
 119
 120 //#include <linux/msdos_fs.h>
 121 #define VFAT_IOCTL_READDIR_BOTH         _IOR('r', 1, struct linux_dirent [2])
 122 #define VFAT_IOCTL_READDIR_SHORT        _IOR('r', 2, struct linux_dirent [2])
 123
 124
 125 #undef _syscall0
 126 #undef _syscall1
 127 #undef _syscall2
 128 #undef _syscall3
 129 #undef _syscall4
 130 #undef _syscall5
 131 #undef _syscall6
 132
 133 #define _syscall0(type,name)            \
 134 static type name (void)                 \
 135 {                                       \
 136         return syscall(__NR_##name);    \
 137 }
 138
 139 #define _syscall1(type,name,type1,arg1)         \
 140 static type name (type1 arg1)                   \
 141 {                                               \
 142         return syscall(__NR_##name, arg1);      \
 143 }
 144
 145 #define _syscall2(type,name,type1,arg1,type2,arg2)      \
 146 static type name (type1 arg1,type2 arg2)                \
 147 {                                                       \
 148         return syscall(__NR_##name, arg1, arg2);        \
 149 }
 150
 151 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)   \
 152 static type name (type1 arg1,type2 arg2,type3 arg3)             \
 153 {                                                               \
 154         return syscall(__NR_##name, arg1, arg2, arg3);          \
 155 }
 156
 157 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)        \
 158 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4)                  \
 159 {                                                                               \
 160         return syscall(__NR_##name, arg1, arg2, arg3, arg4);                    \
 161 }
 162
 163 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 164                   type5,arg5)                                                   \
 165 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5)       \
 166 {                                                                               \
 167         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5);              \
 168 }
 169
 170
 171 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 172                   type5,arg5,type6,arg6)                                        \
 173 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,       \
 174                   type6 arg6)                                                   \
 175 {                                                                               \
 176         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6);        \
 177 }
 178
 179
 180 #define __NR_sys_uname __NR_uname
 181 #define __NR_sys_getcwd1 __NR_getcwd
 182 #define __NR_sys_getdents __NR_getdents
 183 #define __NR_sys_getdents64 __NR_getdents64
 184 #define __NR_sys_getpriority __NR_getpriority
 185 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
 186 #define __NR_sys_syslog __NR_syslog
 187 #define __NR_sys_tgkill __NR_tgkill
 188 #define __NR_sys_tkill __NR_tkill
 189 #define __NR_sys_futex __NR_futex
 190 #define __NR_sys_inotify_init __NR_inotify_init
 191 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
 192 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
 193
 194 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__) || \
 195     defined(__s390x__)
 196 #define __NR__llseek __NR_lseek
 197 #endif
 198
 199 #ifdef __NR_gettid
 200 _syscall0(int, gettid)
 201 #else
 202 /* This is a replacement for the host gettid() and must return a host
 203    errno. */
 204 static int gettid(void) {
 205     return -ENOSYS;
 206 }
 207 #endif
 208 #ifdef __NR_getdents
 209 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
 210 #endif
 211 #if !defined(__NR_getdents) || \
 212     (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
 213 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
 214 #endif
 215 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
 216 _syscall5(int, _llseek,  uint,  fd, ulong, hi, ulong, lo,
 217           loff_t *, res, uint, wh);
 218 #endif
 219 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
 220 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
 221 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
 222 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
 223 #endif
 224 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
 225 _syscall2(int,sys_tkill,int,tid,int,sig)
 226 #endif
 227 #ifdef __NR_exit_group
 228 _syscall1(int,exit_group,int,error_code)
 229 #endif
 230 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
 231 _syscall1(int,set_tid_address,int *,tidptr)
 232 #endif
 233 #if defined(TARGET_NR_futex) && defined(__NR_futex)
 234 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
 235           const struct timespec *,timeout,int *,uaddr2,int,val3)
 236 #endif
 237 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
 238 _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len,
 239           unsigned long *, user_mask_ptr);
 240 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
 241 _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len,
 242           unsigned long *, user_mask_ptr);
 243 _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd,
 244           void *, arg);
 245
 246 static bitmask_transtbl fcntl_flags_tbl[] = {
 247   { TARGET_O_ACCMODE,   TARGET_O_WRONLY,    O_ACCMODE,   O_WRONLY,    },
 248   { TARGET_O_ACCMODE,   TARGET_O_RDWR,      O_ACCMODE,   O_RDWR,      },
 249   { TARGET_O_CREAT,     TARGET_O_CREAT,     O_CREAT,     O_CREAT,     },
 250   { TARGET_O_EXCL,      TARGET_O_EXCL,      O_EXCL,      O_EXCL,      },
 251   { TARGET_O_NOCTTY,    TARGET_O_NOCTTY,    O_NOCTTY,    O_NOCTTY,    },
 252   { TARGET_O_TRUNC,     TARGET_O_TRUNC,     O_TRUNC,     O_TRUNC,     },
 253   { TARGET_O_APPEND,    TARGET_O_APPEND,    O_APPEND,    O_APPEND,    },
 254   { TARGET_O_NONBLOCK,  TARGET_O_NONBLOCK,  O_NONBLOCK,  O_NONBLOCK,  },
 255   { TARGET_O_SYNC,      TARGET_O_DSYNC,     O_SYNC,      O_DSYNC,     },
 256   { TARGET_O_SYNC,      TARGET_O_SYNC,      O_SYNC,      O_SYNC,      },
 257   { TARGET_FASYNC,      TARGET_FASYNC,      FASYNC,      FASYNC,      },
 258   { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
 259   { TARGET_O_NOFOLLOW,  TARGET_O_NOFOLLOW,  O_NOFOLLOW,  O_NOFOLLOW,  },
 260 #if defined(O_DIRECT)
 261   { TARGET_O_DIRECT,    TARGET_O_DIRECT,    O_DIRECT,    O_DIRECT,    },
 262 #endif
 263 #if defined(O_NOATIME)
 264   { TARGET_O_NOATIME,   TARGET_O_NOATIME,   O_NOATIME,   O_NOATIME    },
 265 #endif
 266 #if defined(O_CLOEXEC)
 267   { TARGET_O_CLOEXEC,   TARGET_O_CLOEXEC,   O_CLOEXEC,   O_CLOEXEC    },
 268 #endif
 269 #if defined(O_PATH)
 270   { TARGET_O_PATH,      TARGET_O_PATH,      O_PATH,      O_PATH       },
 271 #endif
 272   /* Don't terminate the list prematurely on 64-bit host+guest.  */
 273 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
 274   { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
 275 #endif
 276   { 0, 0, 0, 0 }
 277 };
 278
 279 #define COPY_UTSNAME_FIELD(dest, src) \
 280   do { \
 281       /* __NEW_UTS_LEN doesn't include terminating null */ \
 282       (void) strncpy((dest), (src), __NEW_UTS_LEN); \
 283       (dest)[__NEW_UTS_LEN] = '\0'; \
 284   } while (0)
 285
 286 static int sys_uname(struct new_utsname *buf)
 287 {
 288   struct utsname uts_buf;
 289
 290   if (uname(&uts_buf) < 0)
 291       return (-1);
 292
 293   /*
 294    * Just in case these have some differences, we
 295    * translate utsname to new_utsname (which is the
 296    * struct linux kernel uses).
 297    */
 298
 299   memset(buf, 0, sizeof(*buf));
 300   COPY_UTSNAME_FIELD(buf->sysname, uts_buf.sysname);
 301   COPY_UTSNAME_FIELD(buf->nodename, uts_buf.nodename);
 302   COPY_UTSNAME_FIELD(buf->release, uts_buf.release);
 303   COPY_UTSNAME_FIELD(buf->version, uts_buf.version);
 304   COPY_UTSNAME_FIELD(buf->machine, uts_buf.machine);
 305 #ifdef _GNU_SOURCE
 306   COPY_UTSNAME_FIELD(buf->domainname, uts_buf.domainname);
 307 #endif
 308   return (0);
 309
 310 #undef COPY_UTSNAME_FIELD
 311 }
 312
 313 static int sys_getcwd1(char *buf, size_t size)
 314 {
 315   if (getcwd(buf, size) == NULL) {
 316       /* getcwd() sets errno */
 317       return (-1);
 318   }
 319   return strlen(buf)+1;
 320 }
 321
 322 #ifdef TARGET_NR_openat
 323 static int sys_openat(int dirfd, const char *pathname, int flags, mode_t mode)
 324 {
 325   /*
 326    * open(2) has extra parameter 'mode' when called with
 327    * flag O_CREAT.
 328    */
 329   if ((flags & O_CREAT) != 0) {
 330       return (openat(dirfd, pathname, flags, mode));
 331   }
 332   return (openat(dirfd, pathname, flags));
 333 }
 334 #endif
 335
 336 #ifdef TARGET_NR_utimensat
 337 #ifdef CONFIG_UTIMENSAT
 338 static int sys_utimensat(int dirfd, const char *pathname,
 339     const struct timespec times[2], int flags)
 340 {
 341     if (pathname == NULL)
 342         return futimens(dirfd, times);
 343     else
 344         return utimensat(dirfd, pathname, times, flags);
 345 }
 346 #elif defined(__NR_utimensat)
 347 #define __NR_sys_utimensat __NR_utimensat
 348 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
 349           const struct timespec *,tsp,int,flags)
 350 #else
 351 static int sys_utimensat(int dirfd, const char *pathname,
 352                          const struct timespec times[2], int flags)
 353 {
 354     errno = ENOSYS;
 355     return -1;
 356 }
 357 #endif
 358 #endif /* TARGET_NR_utimensat */
 359
 360 #ifdef CONFIG_INOTIFY
 361 #include <sys/inotify.h>
 362
 363 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
 364 static int sys_inotify_init(void)
 365 {
 366   return (inotify_init());
 367 }
 368 #endif
 369 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
 370 static int sys_inotify_add_watch(int fd,const char *pathname, int32_t mask)
 371 {
 372   return (inotify_add_watch(fd, pathname, mask));
 373 }
 374 #endif
 375 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
 376 static int sys_inotify_rm_watch(int fd, int32_t wd)
 377 {
 378   return (inotify_rm_watch(fd, wd));
 379 }
 380 #endif
 381 #ifdef CONFIG_INOTIFY1
 382 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
 383 static int sys_inotify_init1(int flags)
 384 {
 385   return (inotify_init1(flags));
 386 }
 387 #endif
 388 #endif
 389 #else
 390 /* Userspace can usually survive runtime without inotify */
 391 #undef TARGET_NR_inotify_init
 392 #undef TARGET_NR_inotify_init1
 393 #undef TARGET_NR_inotify_add_watch
 394 #undef TARGET_NR_inotify_rm_watch
 395 #endif /* CONFIG_INOTIFY  */
 396
 397 #if defined(TARGET_NR_ppoll)
 398 #ifndef __NR_ppoll
 399 # define __NR_ppoll -1
 400 #endif
 401 #define __NR_sys_ppoll __NR_ppoll
 402 _syscall5(int, sys_ppoll, struct pollfd *, fds, nfds_t, nfds,
 403           struct timespec *, timeout, const __sigset_t *, sigmask,
 404           size_t, sigsetsize)
 405 #endif
 406
 407 #if defined(TARGET_NR_pselect6)
 408 #ifndef __NR_pselect6
 409 # define __NR_pselect6 -1
 410 #endif
 411 #define __NR_sys_pselect6 __NR_pselect6
 412 _syscall6(int, sys_pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds,
 413           fd_set *, exceptfds, struct timespec *, timeout, void *, sig);
 414 #endif
 415
 416 #if defined(TARGET_NR_prlimit64)
 417 #ifndef __NR_prlimit64
 418 # define __NR_prlimit64 -1
 419 #endif
 420 #define __NR_sys_prlimit64 __NR_prlimit64
 421 /* The glibc rlimit structure may not be that used by the underlying syscall */
 422 struct host_rlimit64 {
 423     uint64_t rlim_cur;
 424     uint64_t rlim_max;
 425 };
 426 _syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
 427           const struct host_rlimit64 *, new_limit,
 428           struct host_rlimit64 *, old_limit)
 429 #endif
 430
 431
 432 #if defined(TARGET_NR_timer_create)
 433 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
 434 static timer_t g_posix_timers[32] = { 0, } ;
 435
 436 static inline int next_free_host_timer(void)
 437 {
 438     int k ;
 439     /* FIXME: Does finding the next free slot require a lock? */
 440     for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) {
 441         if (g_posix_timers[k] == 0) {
 442             g_posix_timers[k] = (timer_t) 1;
 443             return k;
 444         }
 445     }
 446     return -1;
 447 }
 448 #endif
 449
 450 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
 451 #ifdef TARGET_ARM
 452 static inline int regpairs_aligned(void *cpu_env) {
 453     return ((((CPUARMState *)cpu_env)->eabi) == 1) ;
 454 }
 455 #elif defined(TARGET_MIPS)
 456 static inline int regpairs_aligned(void *cpu_env) { return 1; }
 457 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
 458 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
 459  * of registers which translates to the same as ARM/MIPS, because we start with
 460  * r3 as arg1 */
 461 static inline int regpairs_aligned(void *cpu_env) { return 1; }
 462 #else
 463 static inline int regpairs_aligned(void *cpu_env) { return 0; }
 464 #endif
 465
 466 #define ERRNO_TABLE_SIZE 1200
 467
 468 /* target_to_host_errno_table[] is initialized from
 469  * host_to_target_errno_table[] in syscall_init(). */
 470 static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
 471 };
 472
 473 /*
 474  * This list is the union of errno values overridden in asm-<arch>/errno.h
 475  * minus the errnos that are not actually generic to all archs.
 476  */
 477 static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
 478     [EIDRM]             = TARGET_EIDRM,
 479     [ECHRNG]            = TARGET_ECHRNG,
 480     [EL2NSYNC]          = TARGET_EL2NSYNC,
 481     [EL3HLT]            = TARGET_EL3HLT,
 482     [EL3RST]            = TARGET_EL3RST,
 483     [ELNRNG]            = TARGET_ELNRNG,
 484     [EUNATCH]           = TARGET_EUNATCH,
 485     [ENOCSI]            = TARGET_ENOCSI,
 486     [EL2HLT]            = TARGET_EL2HLT,
 487     [EDEADLK]           = TARGET_EDEADLK,
 488     [ENOLCK]            = TARGET_ENOLCK,
 489     [EBADE]             = TARGET_EBADE,
 490     [EBADR]             = TARGET_EBADR,
 491     [EXFULL]            = TARGET_EXFULL,
 492     [ENOANO]            = TARGET_ENOANO,
 493     [EBADRQC]           = TARGET_EBADRQC,
 494     [EBADSLT]           = TARGET_EBADSLT,
 495     [EBFONT]            = TARGET_EBFONT,
 496     [ENOSTR]            = TARGET_ENOSTR,
 497     [ENODATA]           = TARGET_ENODATA,
 498     [ETIME]             = TARGET_ETIME,
 499     [ENOSR]             = TARGET_ENOSR,
 500     [ENONET]            = TARGET_ENONET,
 501     [ENOPKG]            = TARGET_ENOPKG,
 502     [EREMOTE]           = TARGET_EREMOTE,
 503     [ENOLINK]           = TARGET_ENOLINK,
 504     [EADV]              = TARGET_EADV,
 505     [ESRMNT]            = TARGET_ESRMNT,
 506     [ECOMM]             = TARGET_ECOMM,
 507     [EPROTO]            = TARGET_EPROTO,
 508     [EDOTDOT]           = TARGET_EDOTDOT,
 509     [EMULTIHOP]         = TARGET_EMULTIHOP,
 510     [EBADMSG]           = TARGET_EBADMSG,
 511     [ENAMETOOLONG]      = TARGET_ENAMETOOLONG,
 512     [EOVERFLOW]         = TARGET_EOVERFLOW,
 513     [ENOTUNIQ]          = TARGET_ENOTUNIQ,
 514     [EBADFD]            = TARGET_EBADFD,
 515     [EREMCHG]           = TARGET_EREMCHG,
 516     [ELIBACC]           = TARGET_ELIBACC,
 517     [ELIBBAD]           = TARGET_ELIBBAD,
 518     [ELIBSCN]           = TARGET_ELIBSCN,
 519     [ELIBMAX]           = TARGET_ELIBMAX,
 520     [ELIBEXEC]          = TARGET_ELIBEXEC,
 521     [EILSEQ]            = TARGET_EILSEQ,
 522     [ENOSYS]            = TARGET_ENOSYS,
 523     [ELOOP]             = TARGET_ELOOP,
 524     [ERESTART]          = TARGET_ERESTART,
 525     [ESTRPIPE]          = TARGET_ESTRPIPE,
 526     [ENOTEMPTY]         = TARGET_ENOTEMPTY,
 527     [EUSERS]            = TARGET_EUSERS,
 528     [ENOTSOCK]          = TARGET_ENOTSOCK,
 529     [EDESTADDRREQ]      = TARGET_EDESTADDRREQ,
 530     [EMSGSIZE]          = TARGET_EMSGSIZE,
 531     [EPROTOTYPE]        = TARGET_EPROTOTYPE,
 532     [ENOPROTOOPT]       = TARGET_ENOPROTOOPT,
 533     [EPROTONOSUPPORT]   = TARGET_EPROTONOSUPPORT,
 534     [ESOCKTNOSUPPORT]   = TARGET_ESOCKTNOSUPPORT,
 535     [EOPNOTSUPP]        = TARGET_EOPNOTSUPP,
 536     [EPFNOSUPPORT]      = TARGET_EPFNOSUPPORT,
 537     [EAFNOSUPPORT]      = TARGET_EAFNOSUPPORT,
 538     [EADDRINUSE]        = TARGET_EADDRINUSE,
 539     [EADDRNOTAVAIL]     = TARGET_EADDRNOTAVAIL,
 540     [ENETDOWN]          = TARGET_ENETDOWN,
 541     [ENETUNREACH]       = TARGET_ENETUNREACH,
 542     [ENETRESET]         = TARGET_ENETRESET,
 543     [ECONNABORTED]      = TARGET_ECONNABORTED,
 544     [ECONNRESET]        = TARGET_ECONNRESET,
 545     [ENOBUFS]           = TARGET_ENOBUFS,
 546     [EISCONN]           = TARGET_EISCONN,
 547     [ENOTCONN]          = TARGET_ENOTCONN,
 548     [EUCLEAN]           = TARGET_EUCLEAN,
 549     [ENOTNAM]           = TARGET_ENOTNAM,
 550     [ENAVAIL]           = TARGET_ENAVAIL,
 551     [EISNAM]            = TARGET_EISNAM,
 552     [EREMOTEIO]         = TARGET_EREMOTEIO,
 553     [ESHUTDOWN]         = TARGET_ESHUTDOWN,
 554     [ETOOMANYREFS]      = TARGET_ETOOMANYREFS,
 555     [ETIMEDOUT]         = TARGET_ETIMEDOUT,
 556     [ECONNREFUSED]      = TARGET_ECONNREFUSED,
 557     [EHOSTDOWN]         = TARGET_EHOSTDOWN,
 558     [EHOSTUNREACH]      = TARGET_EHOSTUNREACH,
 559     [EALREADY]          = TARGET_EALREADY,
 560     [EINPROGRESS]       = TARGET_EINPROGRESS,
 561     [ESTALE]            = TARGET_ESTALE,
 562     [ECANCELED]         = TARGET_ECANCELED,
 563     [ENOMEDIUM]         = TARGET_ENOMEDIUM,
 564     [EMEDIUMTYPE]       = TARGET_EMEDIUMTYPE,
 565 #ifdef ENOKEY
 566     [ENOKEY]            = TARGET_ENOKEY,
 567 #endif
 568 #ifdef EKEYEXPIRED
 569     [EKEYEXPIRED]       = TARGET_EKEYEXPIRED,
 570 #endif
 571 #ifdef EKEYREVOKED
 572     [EKEYREVOKED]       = TARGET_EKEYREVOKED,
 573 #endif
 574 #ifdef EKEYREJECTED
 575     [EKEYREJECTED]      = TARGET_EKEYREJECTED,
 576 #endif
 577 #ifdef EOWNERDEAD
 578     [EOWNERDEAD]        = TARGET_EOWNERDEAD,
 579 #endif
 580 #ifdef ENOTRECOVERABLE
 581     [ENOTRECOVERABLE]   = TARGET_ENOTRECOVERABLE,
 582 #endif
 583 };
 584
 585 static inline int host_to_target_errno(int err)
 586 {
 587     if(host_to_target_errno_table[err])
 588         return host_to_target_errno_table[err];
 589     return err;
 590 }
 591
 592 static inline int target_to_host_errno(int err)
 593 {
 594     if (target_to_host_errno_table[err])
 595         return target_to_host_errno_table[err];
 596     return err;
 597 }
 598
 599 static inline abi_long get_errno(abi_long ret)
 600 {
 601     if (ret == -1)
 602         return -host_to_target_errno(errno);
 603     else
 604         return ret;
 605 }
 606
 607 static inline int is_error(abi_long ret)
 608 {
 609     return (abi_ulong)ret >= (abi_ulong)(-4096);
 610 }
 611
 612 char *target_strerror(int err)
 613 {
 614     if ((err >= ERRNO_TABLE_SIZE) || (err < 0)) {
 615         return NULL;
 616     }
 617     return strerror(target_to_host_errno(err));
 618 }
 619
 620 static abi_ulong target_brk;
 621 static abi_ulong target_original_brk;
 622 static abi_ulong brk_page;
 623
 624 void target_set_brk(abi_ulong new_brk)
 625 {
 626     target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
 627     brk_page = HOST_PAGE_ALIGN(target_brk);
 628 }
 629
 630 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
 631 #define DEBUGF_BRK(message, args...)
 632
 633 /* do_brk() must return target values and target errnos. */
 634 abi_long do_brk(abi_ulong new_brk)
 635 {
 636     abi_long mapped_addr;
 637     int new_alloc_size;
 638
 639     DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk);
 640
 641     if (!new_brk) {
 642         DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk);
 643         return target_brk;
 644     }
 645     if (new_brk < target_original_brk) {
 646         DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n",
 647                    target_brk);
 648         return target_brk;
 649     }
 650
 651     /* If the new brk is less than the highest page reserved to the
 652      * target heap allocation, set it and we're almost done...  */
 653     if (new_brk <= brk_page) {
 654         /* Heap contents are initialized to zero, as for anonymous
 655          * mapped pages.  */
 656         if (new_brk > target_brk) {
 657             memset(g2h(target_brk), 0, new_brk - target_brk);
 658         }
 659         target_brk = new_brk;
 660         DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk);
 661         return target_brk;
 662     }
 663
 664     /* We need to allocate more memory after the brk... Note that
 665      * we don't use MAP_FIXED because that will map over the top of
 666      * any existing mapping (like the one with the host libc or qemu
 667      * itself); instead we treat "mapped but at wrong address" as
 668      * a failure and unmap again.
 669      */
 670     new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page);
 671     mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
 672                                         PROT_READ|PROT_WRITE,
 673                                         MAP_ANON|MAP_PRIVATE, 0, 0));
 674
 675     if (mapped_addr == brk_page) {
 676         /* Heap contents are initialized to zero, as for anonymous
 677          * mapped pages.  Technically the new pages are already
 678          * initialized to zero since they *are* anonymous mapped
 679          * pages, however we have to take care with the contents that
 680          * come from the remaining part of the previous page: it may
 681          * contains garbage data due to a previous heap usage (grown
 682          * then shrunken).  */
 683         memset(g2h(target_brk), 0, brk_page - target_brk);
 684
 685         target_brk = new_brk;
 686         brk_page = HOST_PAGE_ALIGN(target_brk);
 687         DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n",
 688             target_brk);
 689         return target_brk;
 690     } else if (mapped_addr != -1) {
 691         /* Mapped but at wrong address, meaning there wasn't actually
 692          * enough space for this brk.
 693          */
 694         target_munmap(mapped_addr, new_alloc_size);
 695         mapped_addr = -1;
 696         DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk);
 697     }
 698     else {
 699         DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk);
 700     }
 701
 702 #if defined(TARGET_ALPHA)
 703     /* We (partially) emulate OSF/1 on Alpha, which requires we
 704        return a proper errno, not an unchanged brk value.  */
 705     return -TARGET_ENOMEM;
 706 #endif
 707     /* For everything else, return the previous break. */
 708     return target_brk;
 709 }
 710
 711 static inline abi_long copy_from_user_fdset(fd_set *fds,
 712                                             abi_ulong target_fds_addr,
 713                                             int n)
 714 {
 715     int i, nw, j, k;
 716     abi_ulong b, *target_fds;
 717
 718     nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
 719     if (!(target_fds = lock_user(VERIFY_READ,
 720                                  target_fds_addr,
 721                                  sizeof(abi_ulong) * nw,
 722                                  1)))
 723         return -TARGET_EFAULT;
 724
 725     FD_ZERO(fds);
 726     k = 0;
 727     for (i = 0; i < nw; i++) {
 728         /* grab the abi_ulong */
 729         __get_user(b, &target_fds[i]);
 730         for (j = 0; j < TARGET_ABI_BITS; j++) {
 731             /* check the bit inside the abi_ulong */
 732             if ((b >> j) & 1)
 733                 FD_SET(k, fds);
 734             k++;
 735         }
 736     }
 737
 738     unlock_user(target_fds, target_fds_addr, 0);
 739
 740     return 0;
 741 }
 742
 743 static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr,
 744                                                  abi_ulong target_fds_addr,
 745                                                  int n)
 746 {
 747     if (target_fds_addr) {
 748         if (copy_from_user_fdset(fds, target_fds_addr, n))
 749             return -TARGET_EFAULT;
 750         *fds_ptr = fds;
 751     } else {
 752         *fds_ptr = NULL;
 753     }
 754     return 0;
 755 }
 756
 757 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
 758                                           const fd_set *fds,
 759                                           int n)
 760 {
 761     int i, nw, j, k;
 762     abi_long v;
 763     abi_ulong *target_fds;
 764
 765     nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
 766     if (!(target_fds = lock_user(VERIFY_WRITE,
 767                                  target_fds_addr,
 768                                  sizeof(abi_ulong) * nw,
 769                                  0)))
 770         return -TARGET_EFAULT;
 771
 772     k = 0;
 773     for (i = 0; i < nw; i++) {
 774         v = 0;
 775         for (j = 0; j < TARGET_ABI_BITS; j++) {
 776             v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j);
 777             k++;
 778         }
 779         __put_user(v, &target_fds[i]);
 780     }
 781
 782     unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
 783
 784     return 0;
 785 }
 786
 787 #if defined(__alpha__)
 788 #define HOST_HZ 1024
 789 #else
 790 #define HOST_HZ 100
 791 #endif
 792
 793 static inline abi_long host_to_target_clock_t(long ticks)
 794 {
 795 #if HOST_HZ == TARGET_HZ
 796     return ticks;
 797 #else
 798     return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
 799 #endif
 800 }
 801
 802 static inline abi_long host_to_target_rusage(abi_ulong target_addr,
 803                                              const struct rusage *rusage)
 804 {
 805     struct target_rusage *target_rusage;
 806
 807     if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
 808         return -TARGET_EFAULT;
 809     target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec);
 810     target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec);
 811     target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec);
 812     target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec);
 813     target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss);
 814     target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss);
 815     target_rusage->ru_idrss = tswapal(rusage->ru_idrss);
 816     target_rusage->ru_isrss = tswapal(rusage->ru_isrss);
 817     target_rusage->ru_minflt = tswapal(rusage->ru_minflt);
 818     target_rusage->ru_majflt = tswapal(rusage->ru_majflt);
 819     target_rusage->ru_nswap = tswapal(rusage->ru_nswap);
 820     target_rusage->ru_inblock = tswapal(rusage->ru_inblock);
 821     target_rusage->ru_oublock = tswapal(rusage->ru_oublock);
 822     target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd);
 823     target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv);
 824     target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals);
 825     target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw);
 826     target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw);
 827     unlock_user_struct(target_rusage, target_addr, 1);
 828
 829     return 0;
 830 }
 831
 832 static inline rlim_t target_to_host_rlim(abi_ulong target_rlim)
 833 {
 834     abi_ulong target_rlim_swap;
 835     rlim_t result;
 836
 837     target_rlim_swap = tswapal(target_rlim);
 838     if (target_rlim_swap == TARGET_RLIM_INFINITY)
 839         return RLIM_INFINITY;
 840
 841     result = target_rlim_swap;
 842     if (target_rlim_swap != (rlim_t)result)
 843         return RLIM_INFINITY;
 844
 845     return result;
 846 }
 847
 848 static inline abi_ulong host_to_target_rlim(rlim_t rlim)
 849 {
 850     abi_ulong target_rlim_swap;
 851     abi_ulong result;
 852
 853     if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim)
 854         target_rlim_swap = TARGET_RLIM_INFINITY;
 855     else
 856         target_rlim_swap = rlim;
 857     result = tswapal(target_rlim_swap);
 858
 859     return result;
 860 }
 861
 862 static inline int target_to_host_resource(int code)
 863 {
 864     switch (code) {
 865     case TARGET_RLIMIT_AS:
 866         return RLIMIT_AS;
 867     case TARGET_RLIMIT_CORE:
 868         return RLIMIT_CORE;
 869     case TARGET_RLIMIT_CPU:
 870         return RLIMIT_CPU;
 871     case TARGET_RLIMIT_DATA:
 872         return RLIMIT_DATA;
 873     case TARGET_RLIMIT_FSIZE:
 874         return RLIMIT_FSIZE;
 875     case TARGET_RLIMIT_LOCKS:
 876         return RLIMIT_LOCKS;
 877     case TARGET_RLIMIT_MEMLOCK:
 878         return RLIMIT_MEMLOCK;
 879     case TARGET_RLIMIT_MSGQUEUE:
 880         return RLIMIT_MSGQUEUE;
 881     case TARGET_RLIMIT_NICE:
 882         return RLIMIT_NICE;
 883     case TARGET_RLIMIT_NOFILE:
 884         return RLIMIT_NOFILE;
 885     case TARGET_RLIMIT_NPROC:
 886         return RLIMIT_NPROC;
 887     case TARGET_RLIMIT_RSS:
 888         return RLIMIT_RSS;
 889     case TARGET_RLIMIT_RTPRIO:
 890         return RLIMIT_RTPRIO;
 891     case TARGET_RLIMIT_SIGPENDING:
 892         return RLIMIT_SIGPENDING;
 893     case TARGET_RLIMIT_STACK:
 894         return RLIMIT_STACK;
 895     default:
 896         return code;
 897     }
 898 }
 899
 900 static inline abi_long copy_from_user_timeval(struct timeval *tv,
 901                                               abi_ulong target_tv_addr)
 902 {
 903     struct target_timeval *target_tv;
 904
 905     if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
 906         return -TARGET_EFAULT;
 907
 908     __get_user(tv->tv_sec, &target_tv->tv_sec);
 909     __get_user(tv->tv_usec, &target_tv->tv_usec);
 910
 911     unlock_user_struct(target_tv, target_tv_addr, 0);
 912
 913     return 0;
 914 }
 915
 916 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
 917                                             const struct timeval *tv)
 918 {
 919     struct target_timeval *target_tv;
 920
 921     if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
 922         return -TARGET_EFAULT;
 923
 924     __put_user(tv->tv_sec, &target_tv->tv_sec);
 925     __put_user(tv->tv_usec, &target_tv->tv_usec);
 926
 927     unlock_user_struct(target_tv, target_tv_addr, 1);
 928
 929     return 0;
 930 }
 931
 932 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
 933 #include <mqueue.h>
 934
 935 static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr,
 936                                               abi_ulong target_mq_attr_addr)
 937 {
 938     struct target_mq_attr *target_mq_attr;
 939
 940     if (!lock_user_struct(VERIFY_READ, target_mq_attr,
 941                           target_mq_attr_addr, 1))
 942         return -TARGET_EFAULT;
 943
 944     __get_user(attr->mq_flags, &target_mq_attr->mq_flags);
 945     __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
 946     __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
 947     __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
 948
 949     unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0);
 950
 951     return 0;
 952 }
 953
 954 static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr,
 955                                             const struct mq_attr *attr)
 956 {
 957     struct target_mq_attr *target_mq_attr;
 958
 959     if (!lock_user_struct(VERIFY_WRITE, target_mq_attr,
 960                           target_mq_attr_addr, 0))
 961         return -TARGET_EFAULT;
 962
 963     __put_user(attr->mq_flags, &target_mq_attr->mq_flags);
 964     __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
 965     __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
 966     __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
 967
 968     unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1);
 969
 970     return 0;
 971 }
 972 #endif
 973
 974 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
 975 /* do_select() must return target values and target errnos. */
 976 static abi_long do_select(int n,
 977                           abi_ulong rfd_addr, abi_ulong wfd_addr,
 978                           abi_ulong efd_addr, abi_ulong target_tv_addr)
 979 {
 980     fd_set rfds, wfds, efds;
 981     fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
 982     struct timeval tv, *tv_ptr;
 983     abi_long ret;
 984
 985     ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
 986     if (ret) {
 987         return ret;
 988     }
 989     ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
 990     if (ret) {
 991         return ret;
 992     }
 993     ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
 994     if (ret) {
 995         return ret;
 996     }
 997
 998     if (target_tv_addr) {
 999         if (copy_from_user_timeval(&tv, target_tv_addr))
1000             return -TARGET_EFAULT;
1001         tv_ptr = &tv;
1002     } else {
1003         tv_ptr = NULL;
1004     }
1005
1006     ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
1007
1008     if (!is_error(ret)) {
1009         if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
1010             return -TARGET_EFAULT;
1011         if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
1012             return -TARGET_EFAULT;
1013         if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
1014             return -TARGET_EFAULT;
1015
1016         if (target_tv_addr && copy_to_user_timeval(target_tv_addr, &tv))
1017             return -TARGET_EFAULT;
1018     }
1019
1020     return ret;
1021 }
1022 #endif
1023
1024 static abi_long do_pipe2(int host_pipe[], int flags)
1025 {
1026 #ifdef CONFIG_PIPE2
1027     return pipe2(host_pipe, flags);
1028 #else
1029     return -ENOSYS;
1030 #endif
1031 }
1032
1033 static abi_long do_pipe(void *cpu_env, abi_ulong pipedes,
1034                         int flags, int is_pipe2)
1035 {
1036     int host_pipe[2];
1037     abi_long ret;
1038     ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe);
1039
1040     if (is_error(ret))
1041         return get_errno(ret);
1042
1043     /* Several targets have special calling conventions for the original
1044        pipe syscall, but didn't replicate this into the pipe2 syscall.  */
1045     if (!is_pipe2) {
1046 #if defined(TARGET_ALPHA)
1047         ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1];
1048         return host_pipe[0];
1049 #elif defined(TARGET_MIPS)
1050         ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1];
1051         return host_pipe[0];
1052 #elif defined(TARGET_SH4)
1053         ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
1054         return host_pipe[0];
1055 #elif defined(TARGET_SPARC)
1056         ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1];
1057         return host_pipe[0];
1058 #endif
1059     }
1060
1061     if (put_user_s32(host_pipe[0], pipedes)
1062         || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0])))
1063         return -TARGET_EFAULT;
1064     return get_errno(ret);
1065 }
1066
1067 static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn,
1068                                               abi_ulong target_addr,
1069                                               socklen_t len)
1070 {
1071     struct target_ip_mreqn *target_smreqn;
1072
1073     target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1);
1074     if (!target_smreqn)
1075         return -TARGET_EFAULT;
1076     mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr;
1077     mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr;
1078     if (len == sizeof(struct target_ip_mreqn))
1079         mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex);
1080     unlock_user(target_smreqn, target_addr, 0);
1081
1082     return 0;
1083 }
1084
1085 static inline abi_long target_to_host_sockaddr(struct sockaddr *addr,
1086                                                abi_ulong target_addr,
1087                                                socklen_t len)
1088 {
1089     const socklen_t unix_maxlen = sizeof (struct sockaddr_un);
1090     sa_family_t sa_family;
1091     struct target_sockaddr *target_saddr;
1092
1093     target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1094     if (!target_saddr)
1095         return -TARGET_EFAULT;
1096
1097     sa_family = tswap16(target_saddr->sa_family);
1098
1099     /* Oops. The caller might send a incomplete sun_path; sun_path
1100      * must be terminated by \0 (see the manual page), but
1101      * unfortunately it is quite common to specify sockaddr_un
1102      * length as "strlen(x->sun_path)" while it should be
1103      * "strlen(...) + 1". We'll fix that here if needed.
1104      * Linux kernel has a similar feature.
1105      */
1106
1107     if (sa_family == AF_UNIX) {
1108         if (len < unix_maxlen && len > 0) {
1109             char *cp = (char*)target_saddr;
1110
1111             if ( cp[len-1] && !cp[len] )
1112                 len++;
1113         }
1114         if (len > unix_maxlen)
1115             len = unix_maxlen;
1116     }
1117
1118     memcpy(addr, target_saddr, len);
1119     addr->sa_family = sa_family;
1120     unlock_user(target_saddr, target_addr, 0);
1121
1122     return 0;
1123 }
1124
1125 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
1126                                                struct sockaddr *addr,
1127                                                socklen_t len)
1128 {
1129     struct target_sockaddr *target_saddr;
1130
1131     target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
1132     if (!target_saddr)
1133         return -TARGET_EFAULT;
1134     memcpy(target_saddr, addr, len);
1135     target_saddr->sa_family = tswap16(addr->sa_family);
1136     unlock_user(target_saddr, target_addr, len);
1137
1138     return 0;
1139 }
1140
1141 static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
1142                                            struct target_msghdr *target_msgh)
1143 {
1144     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1145     abi_long msg_controllen;
1146     abi_ulong target_cmsg_addr;
1147     struct target_cmsghdr *target_cmsg;
1148     socklen_t space = 0;
1149
1150     msg_controllen = tswapal(target_msgh->msg_controllen);
1151     if (msg_controllen < sizeof (struct target_cmsghdr))
1152         goto the_end;
1153     target_cmsg_addr = tswapal(target_msgh->msg_control);
1154     target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
1155     if (!target_cmsg)
1156         return -TARGET_EFAULT;
1157
1158     while (cmsg && target_cmsg) {
1159         void *data = CMSG_DATA(cmsg);
1160         void *target_data = TARGET_CMSG_DATA(target_cmsg);
1161
1162         int len = tswapal(target_cmsg->cmsg_len)
1163                   - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
1164
1165         space += CMSG_SPACE(len);
1166         if (space > msgh->msg_controllen) {
1167             space -= CMSG_SPACE(len);
1168             gemu_log("Host cmsg overflow\n");
1169             break;
1170         }
1171
1172         if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) {
1173             cmsg->cmsg_level = SOL_SOCKET;
1174         } else {
1175             cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
1176         }
1177         cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
1178         cmsg->cmsg_len = CMSG_LEN(len);
1179
1180         if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
1181             gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
1182             memcpy(data, target_data, len);
1183         } else {
1184             int *fd = (int *)data;
1185             int *target_fd = (int *)target_data;
1186             int i, numfds = len / sizeof(int);
1187
1188             for (i = 0; i < numfds; i++)
1189                 fd[i] = tswap32(target_fd[i]);
1190         }
1191
1192         cmsg = CMSG_NXTHDR(msgh, cmsg);
1193         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
1194     }
1195     unlock_user(target_cmsg, target_cmsg_addr, 0);
1196  the_end:
1197     msgh->msg_controllen = space;
1198     return 0;
1199 }
1200
1201 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
1202                                            struct msghdr *msgh)
1203 {
1204     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1205     abi_long msg_controllen;
1206     abi_ulong target_cmsg_addr;
1207     struct target_cmsghdr *target_cmsg;
1208     socklen_t space = 0;
1209
1210     msg_controllen = tswapal(target_msgh->msg_controllen);
1211     if (msg_controllen < sizeof (struct target_cmsghdr))
1212         goto the_end;
1213     target_cmsg_addr = tswapal(target_msgh->msg_control);
1214     target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
1215     if (!target_cmsg)
1216         return -TARGET_EFAULT;
1217
1218     while (cmsg && target_cmsg) {
1219         void *data = CMSG_DATA(cmsg);
1220         void *target_data = TARGET_CMSG_DATA(target_cmsg);
1221
1222         int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
1223
1224         space += TARGET_CMSG_SPACE(len);
1225         if (space > msg_controllen) {
1226             space -= TARGET_CMSG_SPACE(len);
1227             gemu_log("Target cmsg overflow\n");
1228             break;
1229         }
1230
1231         if (cmsg->cmsg_level == SOL_SOCKET) {
1232             target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET);
1233         } else {
1234             target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
1235         }
1236         target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
1237         target_cmsg->cmsg_len = tswapal(TARGET_CMSG_LEN(len));
1238
1239         if ((cmsg->cmsg_level == SOL_SOCKET) &&
1240                                 (cmsg->cmsg_type == SCM_RIGHTS)) {
1241             int *fd = (int *)data;
1242             int *target_fd = (int *)target_data;
1243             int i, numfds = len / sizeof(int);
1244
1245             for (i = 0; i < numfds; i++)
1246                 target_fd[i] = tswap32(fd[i]);
1247         } else if ((cmsg->cmsg_level == SOL_SOCKET) &&
1248                                 (cmsg->cmsg_type == SO_TIMESTAMP) &&
1249                                 (len == sizeof(struct timeval))) {
1250             /* copy struct timeval to target */
1251             struct timeval *tv = (struct timeval *)data;
1252             struct target_timeval *target_tv =
1253                                         (struct target_timeval *)target_data;
1254
1255             target_tv->tv_sec = tswapal(tv->tv_sec);
1256             target_tv->tv_usec = tswapal(tv->tv_usec);
1257         } else {
1258             gemu_log("Unsupported ancillary data: %d/%d\n",
1259                                         cmsg->cmsg_level, cmsg->cmsg_type);
1260             memcpy(target_data, data, len);
1261         }
1262
1263         cmsg = CMSG_NXTHDR(msgh, cmsg);
1264         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
1265     }
1266     unlock_user(target_cmsg, target_cmsg_addr, space);
1267  the_end:
1268     target_msgh->msg_controllen = tswapal(space);
1269     return 0;
1270 }
1271
1272 /* do_setsockopt() Must return target values and target errnos. */
1273 static abi_long do_setsockopt(int sockfd, int level, int optname,
1274                               abi_ulong optval_addr, socklen_t optlen)
1275 {
1276     abi_long ret;
1277     int val;
1278     struct ip_mreqn *ip_mreq;
1279     struct ip_mreq_source *ip_mreq_source;
1280
1281     switch(level) {
1282     case SOL_TCP:
1283         /* TCP options all take an 'int' value.  */
1284         if (optlen < sizeof(uint32_t))
1285             return -TARGET_EINVAL;
1286
1287         if (get_user_u32(val, optval_addr))
1288             return -TARGET_EFAULT;
1289         ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
1290         break;
1291     case SOL_IP:
1292         switch(optname) {
1293         case IP_TOS:
1294         case IP_TTL:
1295         case IP_HDRINCL:
1296         case IP_ROUTER_ALERT:
1297         case IP_RECVOPTS:
1298         case IP_RETOPTS:
1299         case IP_PKTINFO:
1300         case IP_MTU_DISCOVER:
1301         case IP_RECVERR:
1302         case IP_RECVTOS:
1303 #ifdef IP_FREEBIND
1304         case IP_FREEBIND:
1305 #endif
1306         case IP_MULTICAST_TTL:
1307         case IP_MULTICAST_LOOP:
1308             val = 0;
1309             if (optlen >= sizeof(uint32_t)) {
1310                 if (get_user_u32(val, optval_addr))
1311                     return -TARGET_EFAULT;
1312             } else if (optlen >= 1) {
1313                 if (get_user_u8(val, optval_addr))
1314                     return -TARGET_EFAULT;
1315             }
1316             ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
1317             break;
1318         case IP_ADD_MEMBERSHIP:
1319         case IP_DROP_MEMBERSHIP:
1320             if (optlen < sizeof (struct target_ip_mreq) ||
1321                 optlen > sizeof (struct target_ip_mreqn))
1322                 return -TARGET_EINVAL;
1323
1324             ip_mreq = (struct ip_mreqn *) alloca(optlen);
1325             target_to_host_ip_mreq(ip_mreq, optval_addr, optlen);
1326             ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen));
1327             break;
1328
1329         case IP_BLOCK_SOURCE:
1330         case IP_UNBLOCK_SOURCE:
1331         case IP_ADD_SOURCE_MEMBERSHIP:
1332         case IP_DROP_SOURCE_MEMBERSHIP:
1333             if (optlen != sizeof (struct target_ip_mreq_source))
1334                 return -TARGET_EINVAL;
1335
1336             ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1);
1337             ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen));
1338             unlock_user (ip_mreq_source, optval_addr, 0);
1339             break;
1340
1341         default:
1342             goto unimplemented;
1343         }
1344         break;
1345     case SOL_IPV6:
1346         switch (optname) {
1347         case IPV6_MTU_DISCOVER:
1348         case IPV6_MTU:
1349         case IPV6_V6ONLY:
1350         case IPV6_RECVPKTINFO:
1351             val = 0;
1352             if (optlen < sizeof(uint32_t)) {
1353                 return -TARGET_EINVAL;
1354             }
1355             if (get_user_u32(val, optval_addr)) {
1356                 return -TARGET_EFAULT;
1357             }
1358             ret = get_errno(setsockopt(sockfd, level, optname,
1359                                        &val, sizeof(val)));
1360             break;
1361         default:
1362             goto unimplemented;
1363         }
1364         break;
1365     case SOL_RAW:
1366         switch (optname) {
1367         case ICMP_FILTER:
1368             /* struct icmp_filter takes an u32 value */
1369             if (optlen < sizeof(uint32_t)) {
1370                 return -TARGET_EINVAL;
1371             }
1372
1373             if (get_user_u32(val, optval_addr)) {
1374                 return -TARGET_EFAULT;
1375             }
1376             ret = get_errno(setsockopt(sockfd, level, optname,
1377                                        &val, sizeof(val)));
1378             break;
1379
1380         default:
1381             goto unimplemented;
1382         }
1383         break;
1384     case TARGET_SOL_SOCKET:
1385         switch (optname) {
1386         case TARGET_SO_RCVTIMEO:
1387         {
1388                 struct timeval tv;
1389
1390                 optname = SO_RCVTIMEO;
1391
1392 set_timeout:
1393                 if (optlen != sizeof(struct target_timeval)) {
1394                     return -TARGET_EINVAL;
1395                 }
1396
1397                 if (copy_from_user_timeval(&tv, optval_addr)) {
1398                     return -TARGET_EFAULT;
1399                 }
1400
1401                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
1402                                 &tv, sizeof(tv)));
1403                 return ret;
1404         }
1405         case TARGET_SO_SNDTIMEO:
1406                 optname = SO_SNDTIMEO;
1407                 goto set_timeout;
1408         case TARGET_SO_ATTACH_FILTER:
1409         {
1410                 struct target_sock_fprog *tfprog;
1411                 struct target_sock_filter *tfilter;
1412                 struct sock_fprog fprog;
1413                 struct sock_filter *filter;
1414                 int i;
1415
1416                 if (optlen != sizeof(*tfprog)) {
1417                     return -TARGET_EINVAL;
1418                 }
1419                 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) {
1420                     return -TARGET_EFAULT;
1421                 }
1422                 if (!lock_user_struct(VERIFY_READ, tfilter,
1423                                       tswapal(tfprog->filter), 0)) {
1424                     unlock_user_struct(tfprog, optval_addr, 1);
1425                     return -TARGET_EFAULT;
1426                 }
1427
1428                 fprog.len = tswap16(tfprog->len);
1429                 filter = malloc(fprog.len * sizeof(*filter));
1430                 if (filter == NULL) {
1431                     unlock_user_struct(tfilter, tfprog->filter, 1);
1432                     unlock_user_struct(tfprog, optval_addr, 1);
1433                     return -TARGET_ENOMEM;
1434                 }
1435                 for (i = 0; i < fprog.len; i++) {
1436                     filter[i].code = tswap16(tfilter[i].code);
1437                     filter[i].jt = tfilter[i].jt;
1438                     filter[i].jf = tfilter[i].jf;
1439                     filter[i].k = tswap32(tfilter[i].k);
1440                 }
1441                 fprog.filter = filter;
1442
1443                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET,
1444                                 SO_ATTACH_FILTER, &fprog, sizeof(fprog)));
1445                 free(filter);
1446
1447                 unlock_user_struct(tfilter, tfprog->filter, 1);
1448                 unlock_user_struct(tfprog, optval_addr, 1);
1449                 return ret;
1450         }
1451             /* Options with 'int' argument.  */
1452         case TARGET_SO_DEBUG:
1453                 optname = SO_DEBUG;
1454                 break;
1455         case TARGET_SO_REUSEADDR:
1456                 optname = SO_REUSEADDR;
1457                 break;
1458         case TARGET_SO_TYPE:
1459                 optname = SO_TYPE;
1460                 break;
1461         case TARGET_SO_ERROR:
1462                 optname = SO_ERROR;
1463                 break;
1464         case TARGET_SO_DONTROUTE:
1465                 optname = SO_DONTROUTE;
1466                 break;
1467         case TARGET_SO_BROADCAST:
1468                 optname = SO_BROADCAST;
1469                 break;
1470         case TARGET_SO_SNDBUF:
1471                 optname = SO_SNDBUF;
1472                 break;
1473         case TARGET_SO_RCVBUF:
1474                 optname = SO_RCVBUF;
1475                 break;
1476         case TARGET_SO_KEEPALIVE:
1477                 optname = SO_KEEPALIVE;
1478                 break;
1479         case TARGET_SO_OOBINLINE:
1480                 optname = SO_OOBINLINE;
1481                 break;
1482         case TARGET_SO_NO_CHECK:
1483                 optname = SO_NO_CHECK;
1484                 break;
1485         case TARGET_SO_PRIORITY:
1486                 optname = SO_PRIORITY;
1487                 break;
1488 #ifdef SO_BSDCOMPAT
1489         case TARGET_SO_BSDCOMPAT:
1490                 optname = SO_BSDCOMPAT;
1491                 break;
1492 #endif
1493         case TARGET_SO_PASSCRED:
1494                 optname = SO_PASSCRED;
1495                 break;
1496         case TARGET_SO_TIMESTAMP:
1497                 optname = SO_TIMESTAMP;
1498                 break;
1499         case TARGET_SO_RCVLOWAT:
1500                 optname = SO_RCVLOWAT;
1501                 break;
1502             break;
1503         default:
1504             goto unimplemented;
1505         }
1506         if (optlen < sizeof(uint32_t))
1507             return -TARGET_EINVAL;
1508
1509         if (get_user_u32(val, optval_addr))
1510             return -TARGET_EFAULT;
1511         ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
1512         break;
1513     default:
1514     unimplemented:
1515         gemu_log("Unsupported setsockopt level=%d optname=%d\n", level, optname);
1516         ret = -TARGET_ENOPROTOOPT;
1517     }
1518     return ret;
1519 }
1520
1521 /* do_getsockopt() Must return target values and target errnos. */
1522 static abi_long do_getsockopt(int sockfd, int level, int optname,
1523                               abi_ulong optval_addr, abi_ulong optlen)
1524 {
1525     abi_long ret;
1526     int len, val;
1527     socklen_t lv;
1528
1529     switch(level) {
1530     case TARGET_SOL_SOCKET:
1531         level = SOL_SOCKET;
1532         switch (optname) {
1533         /* These don't just return a single integer */
1534         case TARGET_SO_LINGER:
1535         case TARGET_SO_RCVTIMEO:
1536         case TARGET_SO_SNDTIMEO:
1537         case TARGET_SO_PEERNAME:
1538             goto unimplemented;
1539         case TARGET_SO_PEERCRED: {
1540             struct ucred cr;
1541             socklen_t crlen;
1542             struct target_ucred *tcr;
1543
1544             if (get_user_u32(len, optlen)) {
1545                 return -TARGET_EFAULT;
1546             }
1547             if (len < 0) {
1548                 return -TARGET_EINVAL;
1549             }
1550
1551             crlen = sizeof(cr);
1552             ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED,
1553                                        &cr, &crlen));
1554             if (ret < 0) {
1555                 return ret;
1556             }
1557             if (len > crlen) {
1558                 len = crlen;
1559             }
1560             if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) {
1561                 return -TARGET_EFAULT;
1562             }
1563             __put_user(cr.pid, &tcr->pid);
1564             __put_user(cr.uid, &tcr->uid);
1565             __put_user(cr.gid, &tcr->gid);
1566             unlock_user_struct(tcr, optval_addr, 1);
1567             if (put_user_u32(len, optlen)) {
1568                 return -TARGET_EFAULT;
1569             }
1570             break;
1571         }
1572         /* Options with 'int' argument.  */
1573         case TARGET_SO_DEBUG:
1574             optname = SO_DEBUG;
1575             goto int_case;
1576         case TARGET_SO_REUSEADDR:
1577             optname = SO_REUSEADDR;
1578             goto int_case;
1579         case TARGET_SO_TYPE:
1580             optname = SO_TYPE;
1581             goto int_case;
1582         case TARGET_SO_ERROR:
1583             optname = SO_ERROR;
1584             goto int_case;
1585         case TARGET_SO_DONTROUTE:
1586             optname = SO_DONTROUTE;
1587             goto int_case;
1588         case TARGET_SO_BROADCAST:
1589             optname = SO_BROADCAST;
1590             goto int_case;
1591         case TARGET_SO_SNDBUF:
1592             optname = SO_SNDBUF;
1593             goto int_case;
1594         case TARGET_SO_RCVBUF:
1595             optname = SO_RCVBUF;
1596             goto int_case;
1597         case TARGET_SO_KEEPALIVE:
1598             optname = SO_KEEPALIVE;
1599             goto int_case;
1600         case TARGET_SO_OOBINLINE:
1601             optname = SO_OOBINLINE;
1602             goto int_case;
1603         case TARGET_SO_NO_CHECK:
1604             optname = SO_NO_CHECK;
1605             goto int_case;
1606         case TARGET_SO_PRIORITY:
1607             optname = SO_PRIORITY;
1608             goto int_case;
1609 #ifdef SO_BSDCOMPAT
1610         case TARGET_SO_BSDCOMPAT:
1611             optname = SO_BSDCOMPAT;
1612             goto int_case;
1613 #endif
1614         case TARGET_SO_PASSCRED:
1615             optname = SO_PASSCRED;
1616             goto int_case;
1617         case TARGET_SO_TIMESTAMP:
1618             optname = SO_TIMESTAMP;
1619             goto int_case;
1620         case TARGET_SO_RCVLOWAT:
1621             optname = SO_RCVLOWAT;
1622             goto int_case;
1623         default:
1624             goto int_case;
1625         }
1626         break;
1627     case SOL_TCP:
1628         /* TCP options all take an 'int' value.  */
1629     int_case:
1630         if (get_user_u32(len, optlen))
1631             return -TARGET_EFAULT;
1632         if (len < 0)
1633             return -TARGET_EINVAL;
1634         lv = sizeof(lv);
1635         ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
1636         if (ret < 0)
1637             return ret;
1638         if (len > lv)
1639             len = lv;
1640         if (len == 4) {
1641             if (put_user_u32(val, optval_addr))
1642                 return -TARGET_EFAULT;
1643         } else {
1644             if (put_user_u8(val, optval_addr))
1645                 return -TARGET_EFAULT;
1646         }
1647         if (put_user_u32(len, optlen))
1648             return -TARGET_EFAULT;
1649         break;
1650     case SOL_IP:
1651         switch(optname) {
1652         case IP_TOS:
1653         case IP_TTL:
1654         case IP_HDRINCL:
1655         case IP_ROUTER_ALERT:
1656         case IP_RECVOPTS:
1657         case IP_RETOPTS:
1658         case IP_PKTINFO:
1659         case IP_MTU_DISCOVER:
1660         case IP_RECVERR:
1661         case IP_RECVTOS:
1662 #ifdef IP_FREEBIND
1663         case IP_FREEBIND:
1664 #endif
1665         case IP_MULTICAST_TTL:
1666         case IP_MULTICAST_LOOP:
1667             if (get_user_u32(len, optlen))
1668                 return -TARGET_EFAULT;
1669             if (len < 0)
1670                 return -TARGET_EINVAL;
1671             lv = sizeof(lv);
1672             ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
1673             if (ret < 0)
1674                 return ret;
1675             if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
1676                 len = 1;
1677                 if (put_user_u32(len, optlen)
1678                     || put_user_u8(val, optval_addr))
1679                     return -TARGET_EFAULT;
1680             } else {
1681                 if (len > sizeof(int))
1682                     len = sizeof(int);
1683                 if (put_user_u32(len, optlen)
1684                     || put_user_u32(val, optval_addr))
1685                     return -TARGET_EFAULT;
1686             }
1687             break;
1688         default:
1689             ret = -TARGET_ENOPROTOOPT;
1690             break;
1691         }
1692         break;
1693     default:
1694     unimplemented:
1695         gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1696                  level, optname);
1697         ret = -TARGET_EOPNOTSUPP;
1698         break;
1699     }
1700     return ret;
1701 }
1702
1703 static struct iovec *lock_iovec(int type, abi_ulong target_addr,
1704                                 int count, int copy)
1705 {
1706     struct target_iovec *target_vec;
1707     struct iovec *vec;
1708     abi_ulong total_len, max_len;
1709     int i;
1710
1711     if (count == 0) {
1712         errno = 0;
1713         return NULL;
1714     }
1715     if (count < 0 || count > IOV_MAX) {
1716         errno = EINVAL;
1717         return NULL;
1718     }
1719
1720     vec = calloc(count, sizeof(struct iovec));
1721     if (vec == NULL) {
1722         errno = ENOMEM;
1723         return NULL;
1724     }
1725
1726     target_vec = lock_user(VERIFY_READ, target_addr,
1727                            count * sizeof(struct target_iovec), 1);
1728     if (target_vec == NULL) {
1729         errno = EFAULT;
1730         goto fail2;
1731     }
1732
1733     /* ??? If host page size > target page size, this will result in a
1734        value larger than what we can actually support.  */
1735     max_len = 0x7fffffff & TARGET_PAGE_MASK;
1736     total_len = 0;
1737
1738     for (i = 0; i < count; i++) {
1739         abi_ulong base = tswapal(target_vec[i].iov_base);
1740         abi_long len = tswapal(target_vec[i].iov_len);
1741
1742         if (len < 0) {
1743             errno = EINVAL;
1744             goto fail;
1745         } else if (len == 0) {
1746             /* Zero length pointer is ignored.  */
1747             vec[i].iov_base = 0;
1748         } else {
1749             vec[i].iov_base = lock_user(type, base, len, copy);
1750             if (!vec[i].iov_base) {
1751                 errno = EFAULT;
1752                 goto fail;
1753             }
1754             if (len > max_len - total_len) {
1755                 len = max_len - total_len;
1756             }
1757         }
1758         vec[i].iov_len = len;
1759         total_len += len;
1760     }
1761
1762     unlock_user(target_vec, target_addr, 0);
1763     return vec;
1764
1765  fail:
1766     free(vec);
1767  fail2:
1768     unlock_user(target_vec, target_addr, 0);
1769     return NULL;
1770 }
1771
1772 static void unlock_iovec(struct iovec *vec, abi_ulong target_addr,
1773                          int count, int copy)
1774 {
1775     struct target_iovec *target_vec;
1776     int i;
1777
1778     target_vec = lock_user(VERIFY_READ, target_addr,
1779                            count * sizeof(struct target_iovec), 1);
1780     if (target_vec) {
1781         for (i = 0; i < count; i++) {
1782             abi_ulong base = tswapal(target_vec[i].iov_base);
1783             abi_long len = tswapal(target_vec[i].iov_base);
1784             if (len < 0) {
1785                 break;
1786             }
1787             unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
1788         }
1789         unlock_user(target_vec, target_addr, 0);
1790     }
1791
1792     free(vec);
1793 }
1794
1795 static inline int target_to_host_sock_type(int *type)
1796 {
1797     int host_type = 0;
1798     int target_type = *type;
1799
1800     switch (target_type & TARGET_SOCK_TYPE_MASK) {
1801     case TARGET_SOCK_DGRAM:
1802         host_type = SOCK_DGRAM;
1803         break;
1804     case TARGET_SOCK_STREAM:
1805         host_type = SOCK_STREAM;
1806         break;
1807     default:
1808         host_type = target_type & TARGET_SOCK_TYPE_MASK;
1809         break;
1810     }
1811     if (target_type & TARGET_SOCK_CLOEXEC) {
1812 #if defined(SOCK_CLOEXEC)
1813         host_type |= SOCK_CLOEXEC;
1814 #else
1815         return -TARGET_EINVAL;
1816 #endif
1817     }
1818     if (target_type & TARGET_SOCK_NONBLOCK) {
1819 #if defined(SOCK_NONBLOCK)
1820         host_type |= SOCK_NONBLOCK;
1821 #elif !defined(O_NONBLOCK)
1822         return -TARGET_EINVAL;
1823 #endif
1824     }
1825     *type = host_type;
1826     return 0;
1827 }
1828
1829 /* Try to emulate socket type flags after socket creation.  */
1830 static int sock_flags_fixup(int fd, int target_type)
1831 {
1832 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
1833     if (target_type & TARGET_SOCK_NONBLOCK) {
1834         int flags = fcntl(fd, F_GETFL);
1835         if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) {
1836             close(fd);
1837             return -TARGET_EINVAL;
1838         }
1839     }
1840 #endif
1841     return fd;
1842 }
1843
1844 /* do_socket() Must return target values and target errnos. */
1845 static abi_long do_socket(int domain, int type, int protocol)
1846 {
1847     int target_type = type;
1848     int ret;
1849
1850     ret = target_to_host_sock_type(&type);
1851     if (ret) {
1852         return ret;
1853     }
1854
1855     if (domain == PF_NETLINK)
1856         return -EAFNOSUPPORT; /* do not NETLINK socket connections possible */
1857     ret = get_errno(socket(domain, type, protocol));
1858     if (ret >= 0) {
1859         ret = sock_flags_fixup(ret, target_type);
1860     }
1861     return ret;
1862 }
1863
1864 /* do_bind() Must return target values and target errnos. */
1865 static abi_long do_bind(int sockfd, abi_ulong target_addr,
1866                         socklen_t addrlen)
1867 {
1868     void *addr;
1869     abi_long ret;
1870
1871     if ((int)addrlen < 0) {
1872         return -TARGET_EINVAL;
1873     }
1874
1875     addr = alloca(addrlen+1);
1876
1877     ret = target_to_host_sockaddr(addr, target_addr, addrlen);
1878     if (ret)
1879         return ret;
1880
1881     return get_errno(bind(sockfd, addr, addrlen));
1882 }
1883
1884 /* do_connect() Must return target values and target errnos. */
1885 static abi_long do_connect(int sockfd, abi_ulong target_addr,
1886                            socklen_t addrlen)
1887 {
1888     void *addr;
1889     abi_long ret;
1890
1891     if ((int)addrlen < 0) {
1892         return -TARGET_EINVAL;
1893     }
1894
1895     addr = alloca(addrlen);
1896
1897     ret = target_to_host_sockaddr(addr, target_addr, addrlen);
1898     if (ret)
1899         return ret;
1900
1901     return get_errno(connect(sockfd, addr, addrlen));
1902 }
1903
1904 /* do_sendrecvmsg() Must return target values and target errnos. */
1905 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
1906                                int flags, int send)
1907 {
1908     abi_long ret, len;
1909     struct target_msghdr *msgp;
1910     struct msghdr msg;
1911     int count;
1912     struct iovec *vec;
1913     abi_ulong target_vec;
1914
1915     /* FIXME */
1916     if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
1917                           msgp,
1918                           target_msg,
1919                           send ? 1 : 0))
1920         return -TARGET_EFAULT;
1921     if (msgp->msg_name) {
1922         msg.msg_namelen = tswap32(msgp->msg_namelen);
1923         msg.msg_name = alloca(msg.msg_namelen);
1924         ret = target_to_host_sockaddr(msg.msg_name, tswapal(msgp->msg_name),
1925                                 msg.msg_namelen);
1926         if (ret) {
1927             goto out2;
1928         }
1929     } else {
1930         msg.msg_name = NULL;
1931         msg.msg_namelen = 0;
1932     }
1933     msg.msg_controllen = 2 * tswapal(msgp->msg_controllen);
1934     msg.msg_control = alloca(msg.msg_controllen);
1935     msg.msg_flags = tswap32(msgp->msg_flags);
1936
1937     count = tswapal(msgp->msg_iovlen);
1938     target_vec = tswapal(msgp->msg_iov);
1939     vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,
1940                      target_vec, count, send);
1941     if (vec == NULL) {
1942         ret = -host_to_target_errno(errno);
1943         goto out2;
1944     }
1945     msg.msg_iovlen = count;
1946     msg.msg_iov = vec;
1947
1948     if (send) {
1949         ret = target_to_host_cmsg(&msg, msgp);
1950         if (ret == 0)
1951             ret = get_errno(sendmsg(fd, &msg, flags));
1952     } else {
1953         ret = get_errno(recvmsg(fd, &msg, flags));
1954         if (!is_error(ret)) {
1955             len = ret;
1956             ret = host_to_target_cmsg(msgp, &msg);
1957             if (!is_error(ret)) {
1958                 msgp->msg_namelen = tswap32(msg.msg_namelen);
1959                 if (msg.msg_name != NULL) {
1960                     ret = host_to_target_sockaddr(tswapal(msgp->msg_name),
1961                                     msg.msg_name, msg.msg_namelen);
1962                     if (ret) {
1963                         goto out;
1964                     }
1965                 }
1966
1967                 ret = len;
1968             }
1969         }
1970     }
1971
1972 out:
1973     unlock_iovec(vec, target_vec, count, !send);
1974 out2:
1975     unlock_user_struct(msgp, target_msg, send ? 0 : 1);
1976     return ret;
1977 }
1978
1979 /* If we don't have a system accept4() then just call accept.
1980  * The callsites to do_accept4() will ensure that they don't
1981  * pass a non-zero flags argument in this config.
1982  */
1983 #ifndef CONFIG_ACCEPT4
1984 static inline int accept4(int sockfd, struct sockaddr *addr,
1985                           socklen_t *addrlen, int flags)
1986 {
1987     assert(flags == 0);
1988     return accept(sockfd, addr, addrlen);
1989 }
1990 #endif
1991
1992 /* do_accept4() Must return target values and target errnos. */
1993 static abi_long do_accept4(int fd, abi_ulong target_addr,
1994                            abi_ulong target_addrlen_addr, int flags)
1995 {
1996     socklen_t addrlen;
1997     void *addr;
1998     abi_long ret;
1999
2000     if (target_addr == 0) {
2001         return get_errno(accept4(fd, NULL, NULL, flags));
2002     }
2003
2004     /* linux returns EINVAL if addrlen pointer is invalid */
2005     if (get_user_u32(addrlen, target_addrlen_addr))
2006         return -TARGET_EINVAL;
2007
2008     if ((int)addrlen < 0) {
2009         return -TARGET_EINVAL;
2010     }
2011
2012     if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
2013         return -TARGET_EINVAL;
2014
2015     addr = alloca(addrlen);
2016
2017     ret = get_errno(accept4(fd, addr, &addrlen, flags));
2018     if (!is_error(ret)) {
2019         host_to_target_sockaddr(target_addr, addr, addrlen);
2020         if (put_user_u32(addrlen, target_addrlen_addr))
2021             ret = -TARGET_EFAULT;
2022     }
2023     return ret;
2024 }
2025
2026 /* do_getpeername() Must return target values and target errnos. */
2027 static abi_long do_getpeername(int fd, abi_ulong target_addr,
2028                                abi_ulong target_addrlen_addr)
2029 {
2030     socklen_t addrlen;
2031     void *addr;
2032     abi_long ret;
2033
2034     if (get_user_u32(addrlen, target_addrlen_addr))
2035         return -TARGET_EFAULT;
2036
2037     if ((int)addrlen < 0) {
2038         return -TARGET_EINVAL;
2039     }
2040
2041     if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
2042         return -TARGET_EFAULT;
2043
2044     addr = alloca(addrlen);
2045
2046     ret = get_errno(getpeername(fd, addr, &addrlen));
2047     if (!is_error(ret)) {
2048         host_to_target_sockaddr(target_addr, addr, addrlen);
2049         if (put_user_u32(addrlen, target_addrlen_addr))
2050             ret = -TARGET_EFAULT;
2051     }
2052     return ret;
2053 }
2054
2055 /* do_getsockname() Must return target values and target errnos. */
2056 static abi_long do_getsockname(int fd, abi_ulong target_addr,
2057                                abi_ulong target_addrlen_addr)
2058 {
2059     socklen_t addrlen;
2060     void *addr;
2061     abi_long ret;
2062
2063     if (get_user_u32(addrlen, target_addrlen_addr))
2064         return -TARGET_EFAULT;
2065
2066     if ((int)addrlen < 0) {
2067         return -TARGET_EINVAL;
2068     }
2069
2070     if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
2071         return -TARGET_EFAULT;
2072
2073     addr = alloca(addrlen);
2074
2075     ret = get_errno(getsockname(fd, addr, &addrlen));
2076     if (!is_error(ret)) {
2077         host_to_target_sockaddr(target_addr, addr, addrlen);
2078         if (put_user_u32(addrlen, target_addrlen_addr))
2079             ret = -TARGET_EFAULT;
2080     }
2081     return ret;
2082 }
2083
2084 /* do_socketpair() Must return target values and target errnos. */
2085 static abi_long do_socketpair(int domain, int type, int protocol,
2086                               abi_ulong target_tab_addr)
2087 {
2088     int tab[2];
2089     abi_long ret;
2090
2091     target_to_host_sock_type(&type);
2092
2093     ret = get_errno(socketpair(domain, type, protocol, tab));
2094     if (!is_error(ret)) {
2095         if (put_user_s32(tab[0], target_tab_addr)
2096             || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
2097             ret = -TARGET_EFAULT;
2098     }
2099     return ret;
2100 }
2101
2102 /* do_sendto() Must return target values and target errnos. */
2103 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
2104                           abi_ulong target_addr, socklen_t addrlen)
2105 {
2106     void *addr;
2107     void *host_msg;
2108     abi_long ret;
2109
2110     if ((int)addrlen < 0) {
2111         return -TARGET_EINVAL;
2112     }
2113
2114     host_msg = lock_user(VERIFY_READ, msg, len, 1);
2115     if (!host_msg)
2116         return -TARGET_EFAULT;
2117     if (target_addr) {
2118         addr = alloca(addrlen);
2119         ret = target_to_host_sockaddr(addr, target_addr, addrlen);
2120         if (ret) {
2121             unlock_user(host_msg, msg, 0);
2122             return ret;
2123         }
2124         ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen));
2125     } else {
2126         ret = get_errno(send(fd, host_msg, len, flags));
2127     }
2128     unlock_user(host_msg, msg, 0);
2129     return ret;
2130 }
2131
2132 /* do_recvfrom() Must return target values and target errnos. */
2133 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
2134                             abi_ulong target_addr,
2135                             abi_ulong target_addrlen)
2136 {
2137     socklen_t addrlen;
2138     void *addr;
2139     void *host_msg;
2140     abi_long ret;
2141
2142     host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
2143     if (!host_msg)
2144         return -TARGET_EFAULT;
2145     if (target_addr) {
2146         if (get_user_u32(addrlen, target_addrlen)) {
2147             ret = -TARGET_EFAULT;
2148             goto fail;
2149         }
2150         if ((int)addrlen < 0) {
2151             ret = -TARGET_EINVAL;
2152             goto fail;
2153         }
2154         addr = alloca(addrlen);
2155         ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen));
2156     } else {
2157         addr = NULL; /* To keep compiler quiet.  */
2158         ret = get_errno(qemu_recv(fd, host_msg, len, flags));
2159     }
2160     if (!is_error(ret)) {
2161         if (target_addr) {
2162             host_to_target_sockaddr(target_addr, addr, addrlen);
2163             if (put_user_u32(addrlen, target_addrlen)) {
2164                 ret = -TARGET_EFAULT;
2165                 goto fail;
2166             }
2167         }
2168         unlock_user(host_msg, msg, len);
2169     } else {
2170 fail:
2171         unlock_user(host_msg, msg, 0);
2172     }
2173     return ret;
2174 }
2175
2176 #ifdef TARGET_NR_socketcall
2177 /* do_socketcall() Must return target values and target errnos. */
2178 static abi_long do_socketcall(int num, abi_ulong vptr)
2179 {
2180     static const unsigned ac[] = { /* number of arguments per call */
2181         [SOCKOP_socket] = 3,      /* domain, type, protocol */
2182         [SOCKOP_bind] = 3,        /* sockfd, addr, addrlen */
2183         [SOCKOP_connect] = 3,     /* sockfd, addr, addrlen */
2184         [SOCKOP_listen] = 2,      /* sockfd, backlog */
2185         [SOCKOP_accept] = 3,      /* sockfd, addr, addrlen */
2186         [SOCKOP_accept4] = 4,     /* sockfd, addr, addrlen, flags */
2187         [SOCKOP_getsockname] = 3, /* sockfd, addr, addrlen */
2188         [SOCKOP_getpeername] = 3, /* sockfd, addr, addrlen */
2189         [SOCKOP_socketpair] = 4,  /* domain, type, protocol, tab */
2190         [SOCKOP_send] = 4,        /* sockfd, msg, len, flags */
2191         [SOCKOP_recv] = 4,        /* sockfd, msg, len, flags */
2192         [SOCKOP_sendto] = 6,      /* sockfd, msg, len, flags, addr, addrlen */
2193         [SOCKOP_recvfrom] = 6,    /* sockfd, msg, len, flags, addr, addrlen */
2194         [SOCKOP_shutdown] = 2,    /* sockfd, how */
2195         [SOCKOP_sendmsg] = 3,     /* sockfd, msg, flags */
2196         [SOCKOP_recvmsg] = 3,     /* sockfd, msg, flags */
2197         [SOCKOP_setsockopt] = 5,  /* sockfd, level, optname, optval, optlen */
2198         [SOCKOP_getsockopt] = 5,  /* sockfd, level, optname, optval, optlen */
2199     };
2200     abi_long a[6]; /* max 6 args */
2201
2202     /* first, collect the arguments in a[] according to ac[] */
2203     if (num >= 0 && num < ARRAY_SIZE(ac)) {
2204         unsigned i;
2205         assert(ARRAY_SIZE(a) >= ac[num]); /* ensure we have space for args */
2206         for (i = 0; i < ac[num]; ++i) {
2207             if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
2208                 return -TARGET_EFAULT;
2209             }
2210         }
2211     }
2212
2213     /* now when we have the args, actually handle the call */
2214     switch (num) {
2215     case SOCKOP_socket: /* domain, type, protocol */
2216         return do_socket(a[0], a[1], a[2]);
2217     case SOCKOP_bind: /* sockfd, addr, addrlen */
2218         return do_bind(a[0], a[1], a[2]);
2219     case SOCKOP_connect: /* sockfd, addr, addrlen */
2220         return do_connect(a[0], a[1], a[2]);
2221     case SOCKOP_listen: /* sockfd, backlog */
2222         return get_errno(listen(a[0], a[1]));
2223     case SOCKOP_accept: /* sockfd, addr, addrlen */
2224         return do_accept4(a[0], a[1], a[2], 0);
2225     case SOCKOP_accept4: /* sockfd, addr, addrlen, flags */
2226         return do_accept4(a[0], a[1], a[2], a[3]);
2227     case SOCKOP_getsockname: /* sockfd, addr, addrlen */
2228         return do_getsockname(a[0], a[1], a[2]);
2229     case SOCKOP_getpeername: /* sockfd, addr, addrlen */
2230         return do_getpeername(a[0], a[1], a[2]);
2231     case SOCKOP_socketpair: /* domain, type, protocol, tab */
2232         return do_socketpair(a[0], a[1], a[2], a[3]);
2233     case SOCKOP_send: /* sockfd, msg, len, flags */
2234         return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
2235     case SOCKOP_recv: /* sockfd, msg, len, flags */
2236         return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
2237     case SOCKOP_sendto: /* sockfd, msg, len, flags, addr, addrlen */
2238         return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
2239     case SOCKOP_recvfrom: /* sockfd, msg, len, flags, addr, addrlen */
2240         return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
2241     case SOCKOP_shutdown: /* sockfd, how */
2242         return get_errno(shutdown(a[0], a[1]));
2243     case SOCKOP_sendmsg: /* sockfd, msg, flags */
2244         return do_sendrecvmsg(a[0], a[1], a[2], 1);
2245     case SOCKOP_recvmsg: /* sockfd, msg, flags */
2246         return do_sendrecvmsg(a[0], a[1], a[2], 0);
2247     case SOCKOP_setsockopt: /* sockfd, level, optname, optval, optlen */
2248         return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
2249     case SOCKOP_getsockopt: /* sockfd, level, optname, optval, optlen */
2250         return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
2251     default:
2252         gemu_log("Unsupported socketcall: %d\n", num);
2253         return -TARGET_ENOSYS;
2254     }
2255 }
2256 #endif
2257
2258 #define N_SHM_REGIONS   32
2259
2260 static struct shm_region {
2261     abi_ulong   start;
2262     abi_ulong   size;
2263 } shm_regions[N_SHM_REGIONS];
2264
2265 struct target_semid_ds
2266 {
2267   struct target_ipc_perm sem_perm;
2268   abi_ulong sem_otime;
2269   abi_ulong __unused1;
2270   abi_ulong sem_ctime;
2271   abi_ulong __unused2;
2272   abi_ulong sem_nsems;
2273   abi_ulong __unused3;
2274   abi_ulong __unused4;
2275 };
2276
2277 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
2278                                                abi_ulong target_addr)
2279 {
2280     struct target_ipc_perm *target_ip;
2281     struct target_semid_ds *target_sd;
2282
2283     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
2284         return -TARGET_EFAULT;
2285     target_ip = &(target_sd->sem_perm);
2286     host_ip->__key = tswap32(target_ip->__key);
2287     host_ip->uid = tswap32(target_ip->uid);
2288     host_ip->gid = tswap32(target_ip->gid);
2289     host_ip->cuid = tswap32(target_ip->cuid);
2290     host_ip->cgid = tswap32(target_ip->cgid);
2291 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
2292     host_ip->mode = tswap32(target_ip->mode);
2293 #else
2294     host_ip->mode = tswap16(target_ip->mode);
2295 #endif
2296 #if defined(TARGET_PPC)
2297     host_ip->__seq = tswap32(target_ip->__seq);
2298 #else
2299     host_ip->__seq = tswap16(target_ip->__seq);
2300 #endif
2301     unlock_user_struct(target_sd, target_addr, 0);
2302     return 0;
2303 }
2304
2305 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
2306                                                struct ipc_perm *host_ip)
2307 {
2308     struct target_ipc_perm *target_ip;
2309     struct target_semid_ds *target_sd;
2310
2311     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
2312         return -TARGET_EFAULT;
2313     target_ip = &(target_sd->sem_perm);
2314     target_ip->__key = tswap32(host_ip->__key);
2315     target_ip->uid = tswap32(host_ip->uid);
2316     target_ip->gid = tswap32(host_ip->gid);
2317     target_ip->cuid = tswap32(host_ip->cuid);
2318     target_ip->cgid = tswap32(host_ip->cgid);
2319 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
2320     target_ip->mode = tswap32(host_ip->mode);
2321 #else
2322     target_ip->mode = tswap16(host_ip->mode);
2323 #endif
2324 #if defined(TARGET_PPC)
2325     target_ip->__seq = tswap32(host_ip->__seq);
2326 #else
2327     target_ip->__seq = tswap16(host_ip->__seq);
2328 #endif
2329     unlock_user_struct(target_sd, target_addr, 1);
2330     return 0;
2331 }
2332
2333 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
2334                                                abi_ulong target_addr)
2335 {
2336     struct target_semid_ds *target_sd;
2337
2338     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
2339         return -TARGET_EFAULT;
2340     if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr))
2341         return -TARGET_EFAULT;
2342     host_sd->sem_nsems = tswapal(target_sd->sem_nsems);
2343     host_sd->sem_otime = tswapal(target_sd->sem_otime);
2344     host_sd->sem_ctime = tswapal(target_sd->sem_ctime);
2345     unlock_user_struct(target_sd, target_addr, 0);
2346     return 0;
2347 }
2348
2349 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
2350                                                struct semid_ds *host_sd)
2351 {
2352     struct target_semid_ds *target_sd;
2353
2354     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
2355         return -TARGET_EFAULT;
2356     if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)))
2357         return -TARGET_EFAULT;
2358     target_sd->sem_nsems = tswapal(host_sd->sem_nsems);
2359     target_sd->sem_otime = tswapal(host_sd->sem_otime);
2360     target_sd->sem_ctime = tswapal(host_sd->sem_ctime);
2361     unlock_user_struct(target_sd, target_addr, 1);
2362     return 0;
2363 }
2364
2365 struct target_seminfo {
2366     int semmap;
2367     int semmni;
2368     int semmns;
2369     int semmnu;
2370     int semmsl;
2371     int semopm;
2372     int semume;
2373     int semusz;
2374     int semvmx;
2375     int semaem;
2376 };
2377
2378 static inline abi_long host_to_target_seminfo(abi_ulong target_addr,
2379                                               struct seminfo *host_seminfo)
2380 {
2381     struct target_seminfo *target_seminfo;
2382     if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0))
2383         return -TARGET_EFAULT;
2384     __put_user(host_seminfo->semmap, &target_seminfo->semmap);
2385     __put_user(host_seminfo->semmni, &target_seminfo->semmni);
2386     __put_user(host_seminfo->semmns, &target_seminfo->semmns);
2387     __put_user(host_seminfo->semmnu, &target_seminfo->semmnu);
2388     __put_user(host_seminfo->semmsl, &target_seminfo->semmsl);
2389     __put_user(host_seminfo->semopm, &target_seminfo->semopm);
2390     __put_user(host_seminfo->semume, &target_seminfo->semume);
2391     __put_user(host_seminfo->semusz, &target_seminfo->semusz);
2392     __put_user(host_seminfo->semvmx, &target_seminfo->semvmx);
2393     __put_user(host_seminfo->semaem, &target_seminfo->semaem);
2394     unlock_user_struct(target_seminfo, target_addr, 1);
2395     return 0;
2396 }
2397
2398 union semun {
2399         int val;
2400         struct semid_ds *buf;
2401         unsigned short *array;
2402         struct seminfo *__buf;
2403 };
2404
2405 union target_semun {
2406         int val;
2407         abi_ulong buf;
2408         abi_ulong array;
2409         abi_ulong __buf;
2410 };
2411
2412 static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array,
2413                                                abi_ulong target_addr)
2414 {
2415     int nsems;
2416     unsigned short *array;
2417     union semun semun;
2418     struct semid_ds semid_ds;
2419     int i, ret;
2420
2421     semun.buf = &semid_ds;
2422
2423     ret = semctl(semid, 0, IPC_STAT, semun);
2424     if (ret == -1)
2425         return get_errno(ret);
2426
2427     nsems = semid_ds.sem_nsems;
2428
2429     *host_array = malloc(nsems*sizeof(unsigned short));
2430     array = lock_user(VERIFY_READ, target_addr,
2431                       nsems*sizeof(unsigned short), 1);
2432     if (!array)
2433         return -TARGET_EFAULT;
2434
2435     for(i=0; i<nsems; i++) {
2436         __get_user((*host_array)[i], &array[i]);
2437     }
2438     unlock_user(array, target_addr, 0);
2439
2440     return 0;
2441 }
2442
2443 static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr,
2444                                                unsigned short **host_array)
2445 {
2446     int nsems;
2447     unsigned short *array;
2448     union semun semun;
2449     struct semid_ds semid_ds;
2450     int i, ret;
2451
2452     semun.buf = &semid_ds;
2453
2454     ret = semctl(semid, 0, IPC_STAT, semun);
2455     if (ret == -1)
2456         return get_errno(ret);
2457
2458     nsems = semid_ds.sem_nsems;
2459
2460     array = lock_user(VERIFY_WRITE, target_addr,
2461                       nsems*sizeof(unsigned short), 0);
2462     if (!array)
2463         return -TARGET_EFAULT;
2464
2465     for(i=0; i<nsems; i++) {
2466         __put_user((*host_array)[i], &array[i]);
2467     }
2468     free(*host_array);
2469     unlock_user(array, target_addr, 1);
2470
2471     return 0;
2472 }
2473
2474 static inline abi_long do_semctl(int semid, int semnum, int cmd,
2475                                  union target_semun target_su)
2476 {
2477     union semun arg;
2478     struct semid_ds dsarg;
2479     unsigned short *array = NULL;
2480     struct seminfo seminfo;
2481     abi_long ret = -TARGET_EINVAL;
2482     abi_long err;
2483     cmd &= 0xff;
2484
2485     switch( cmd ) {
2486         case GETVAL:
2487         case SETVAL:
2488             arg.val = tswap32(target_su.val);
2489             ret = get_errno(semctl(semid, semnum, cmd, arg));
2490             target_su.val = tswap32(arg.val);
2491             break;
2492         case GETALL:
2493         case SETALL:
2494             err = target_to_host_semarray(semid, &array, target_su.array);
2495             if (err)
2496                 return err;
2497             arg.array = array;
2498             ret = get_errno(semctl(semid, semnum, cmd, arg));
2499             err = host_to_target_semarray(semid, target_su.array, &array);
2500             if (err)
2501                 return err;
2502             break;
2503         case IPC_STAT:
2504         case IPC_SET:
2505         case SEM_STAT:
2506             err = target_to_host_semid_ds(&dsarg, target_su.buf);
2507             if (err)
2508                 return err;
2509             arg.buf = &dsarg;
2510             ret = get_errno(semctl(semid, semnum, cmd, arg));
2511             err = host_to_target_semid_ds(target_su.buf, &dsarg);
2512             if (err)
2513                 return err;
2514             break;
2515         case IPC_INFO:
2516         case SEM_INFO:
2517             arg.__buf = &seminfo;
2518             ret = get_errno(semctl(semid, semnum, cmd, arg));
2519             err = host_to_target_seminfo(target_su.__buf, &seminfo);
2520             if (err)
2521                 return err;
2522             break;
2523         case IPC_RMID:
2524         case GETPID:
2525         case GETNCNT:
2526         case GETZCNT:
2527             ret = get_errno(semctl(semid, semnum, cmd, NULL));
2528             break;
2529     }
2530
2531     return ret;
2532 }
2533
2534 struct target_sembuf {
2535     unsigned short sem_num;
2536     short sem_op;
2537     short sem_flg;
2538 };
2539
2540 static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
2541                                              abi_ulong target_addr,
2542                                              unsigned nsops)
2543 {
2544     struct target_sembuf *target_sembuf;
2545     int i;
2546
2547     target_sembuf = lock_user(VERIFY_READ, target_addr,
2548                               nsops*sizeof(struct target_sembuf), 1);
2549     if (!target_sembuf)
2550         return -TARGET_EFAULT;
2551
2552     for(i=0; i<nsops; i++) {
2553         __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num);
2554         __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op);
2555         __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg);
2556     }
2557
2558     unlock_user(target_sembuf, target_addr, 0);
2559
2560     return 0;
2561 }
2562
2563 static inline abi_long do_semop(int semid, abi_long ptr, unsigned nsops)
2564 {
2565     struct sembuf sops[nsops];
2566
2567     if (target_to_host_sembuf(sops, ptr, nsops))
2568         return -TARGET_EFAULT;
2569
2570     return get_errno(semop(semid, sops, nsops));
2571 }
2572
2573 struct target_msqid_ds
2574 {
2575     struct target_ipc_perm msg_perm;
2576     abi_ulong msg_stime;
2577 #if TARGET_ABI_BITS == 32
2578     abi_ulong __unused1;
2579 #endif
2580     abi_ulong msg_rtime;
2581 #if TARGET_ABI_BITS == 32
2582     abi_ulong __unused2;
2583 #endif
2584     abi_ulong msg_ctime;
2585 #if TARGET_ABI_BITS == 32
2586     abi_ulong __unused3;
2587 #endif
2588     abi_ulong __msg_cbytes;
2589     abi_ulong msg_qnum;
2590     abi_ulong msg_qbytes;
2591     abi_ulong msg_lspid;
2592     abi_ulong msg_lrpid;
2593     abi_ulong __unused4;
2594     abi_ulong __unused5;
2595 };
2596
2597 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
2598                                                abi_ulong target_addr)
2599 {
2600     struct target_msqid_ds *target_md;
2601
2602     if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
2603         return -TARGET_EFAULT;
2604     if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
2605         return -TARGET_EFAULT;
2606     host_md->msg_stime = tswapal(target_md->msg_stime);
2607     host_md->msg_rtime = tswapal(target_md->msg_rtime);
2608     host_md->msg_ctime = tswapal(target_md->msg_ctime);
2609     host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes);
2610     host_md->msg_qnum = tswapal(target_md->msg_qnum);
2611     host_md->msg_qbytes = tswapal(target_md->msg_qbytes);
2612     host_md->msg_lspid = tswapal(target_md->msg_lspid);
2613     host_md->msg_lrpid = tswapal(target_md->msg_lrpid);
2614     unlock_user_struct(target_md, target_addr, 0);
2615     return 0;
2616 }
2617
2618 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
2619                                                struct msqid_ds *host_md)
2620 {
2621     struct target_msqid_ds *target_md;
2622
2623     if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
2624         return -TARGET_EFAULT;
2625     if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
2626         return -TARGET_EFAULT;
2627     target_md->msg_stime = tswapal(host_md->msg_stime);
2628     target_md->msg_rtime = tswapal(host_md->msg_rtime);
2629     target_md->msg_ctime = tswapal(host_md->msg_ctime);
2630     target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes);
2631     target_md->msg_qnum = tswapal(host_md->msg_qnum);
2632     target_md->msg_qbytes = tswapal(host_md->msg_qbytes);
2633     target_md->msg_lspid = tswapal(host_md->msg_lspid);
2634     target_md->msg_lrpid = tswapal(host_md->msg_lrpid);
2635     unlock_user_struct(target_md, target_addr, 1);
2636     return 0;
2637 }
2638
2639 struct target_msginfo {
2640     int msgpool;
2641     int msgmap;
2642     int msgmax;
2643     int msgmnb;
2644     int msgmni;
2645     int msgssz;
2646     int msgtql;
2647     unsigned short int msgseg;
2648 };
2649
2650 static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
2651                                               struct msginfo *host_msginfo)
2652 {
2653     struct target_msginfo *target_msginfo;
2654     if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
2655         return -TARGET_EFAULT;
2656     __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
2657     __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
2658     __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
2659     __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
2660     __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
2661     __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
2662     __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
2663     __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
2664     unlock_user_struct(target_msginfo, target_addr, 1);
2665     return 0;
2666 }
2667
2668 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
2669 {
2670     struct msqid_ds dsarg;
2671     struct msginfo msginfo;
2672     abi_long ret = -TARGET_EINVAL;
2673
2674     cmd &= 0xff;
2675
2676     switch (cmd) {
2677     case IPC_STAT:
2678     case IPC_SET:
2679     case MSG_STAT:
2680         if (target_to_host_msqid_ds(&dsarg,ptr))
2681             return -TARGET_EFAULT;
2682         ret = get_errno(msgctl(msgid, cmd, &dsarg));
2683         if (host_to_target_msqid_ds(ptr,&dsarg))
2684             return -TARGET_EFAULT;
2685         break;
2686     case IPC_RMID:
2687         ret = get_errno(msgctl(msgid, cmd, NULL));
2688         break;
2689     case IPC_INFO:
2690     case MSG_INFO:
2691         ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
2692         if (host_to_target_msginfo(ptr, &msginfo))
2693             return -TARGET_EFAULT;
2694         break;
2695     }
2696
2697     return ret;
2698 }
2699
2700 struct target_msgbuf {
2701     abi_long mtype;
2702     char        mtext[1];
2703 };
2704
2705 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
2706                                  unsigned int msgsz, int msgflg)
2707 {
2708     struct target_msgbuf *target_mb;
2709     struct msgbuf *host_mb;
2710     abi_long ret = 0;
2711
2712     if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
2713         return -TARGET_EFAULT;
2714     host_mb = malloc(msgsz+sizeof(long));
2715     host_mb->mtype = (abi_long) tswapal(target_mb->mtype);
2716     memcpy(host_mb->mtext, target_mb->mtext, msgsz);
2717     ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
2718     free(host_mb);
2719     unlock_user_struct(target_mb, msgp, 0);
2720
2721     return ret;
2722 }
2723
2724 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
2725                                  unsigned int msgsz, abi_long msgtyp,
2726                                  int msgflg)
2727 {
2728     struct target_msgbuf *target_mb;
2729     char *target_mtext;
2730     struct msgbuf *host_mb;
2731     abi_long ret = 0;
2732
2733     if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
2734         return -TARGET_EFAULT;
2735
2736     host_mb = g_malloc(msgsz+sizeof(long));
2737     ret = get_errno(msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg));
2738
2739     if (ret > 0) {
2740         abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
2741         target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
2742         if (!target_mtext) {
2743             ret = -TARGET_EFAULT;
2744             goto end;
2745         }
2746         memcpy(target_mb->mtext, host_mb->mtext, ret);
2747         unlock_user(target_mtext, target_mtext_addr, ret);
2748     }
2749
2750     target_mb->mtype = tswapal(host_mb->mtype);
2751
2752 end:
2753     if (target_mb)
2754         unlock_user_struct(target_mb, msgp, 1);
2755     g_free(host_mb);
2756     return ret;
2757 }
2758
2759 static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
2760                                                abi_ulong target_addr)
2761 {
2762     struct target_shmid_ds *target_sd;
2763
2764     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
2765         return -TARGET_EFAULT;
2766     if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr))
2767         return -TARGET_EFAULT;
2768     __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
2769     __get_user(host_sd->shm_atime, &target_sd->shm_atime);
2770     __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
2771     __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
2772     __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
2773     __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
2774     __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
2775     unlock_user_struct(target_sd, target_addr, 0);
2776     return 0;
2777 }
2778
2779 static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr,
2780                                                struct shmid_ds *host_sd)
2781 {
2782     struct target_shmid_ds *target_sd;
2783
2784     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
2785         return -TARGET_EFAULT;
2786     if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm)))
2787         return -TARGET_EFAULT;
2788     __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
2789     __put_user(host_sd->shm_atime, &target_sd->shm_atime);
2790     __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
2791     __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
2792     __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
2793     __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
2794     __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
2795     unlock_user_struct(target_sd, target_addr, 1);
2796     return 0;
2797 }
2798
2799 struct  target_shminfo {
2800     abi_ulong shmmax;
2801     abi_ulong shmmin;
2802     abi_ulong shmmni;
2803     abi_ulong shmseg;
2804     abi_ulong shmall;
2805 };
2806
2807 static inline abi_long host_to_target_shminfo(abi_ulong target_addr,
2808                                               struct shminfo *host_shminfo)
2809 {
2810     struct target_shminfo *target_shminfo;
2811     if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0))
2812         return -TARGET_EFAULT;
2813     __put_user(host_shminfo->shmmax, &target_shminfo->shmmax);
2814     __put_user(host_shminfo->shmmin, &target_shminfo->shmmin);
2815     __put_user(host_shminfo->shmmni, &target_shminfo->shmmni);
2816     __put_user(host_shminfo->shmseg, &target_shminfo->shmseg);
2817     __put_user(host_shminfo->shmall, &target_shminfo->shmall);
2818     unlock_user_struct(target_shminfo, target_addr, 1);
2819     return 0;
2820 }
2821
2822 struct target_shm_info {
2823     int used_ids;
2824     abi_ulong shm_tot;
2825     abi_ulong shm_rss;
2826     abi_ulong shm_swp;
2827     abi_ulong swap_attempts;
2828     abi_ulong swap_successes;
2829 };
2830
2831 static inline abi_long host_to_target_shm_info(abi_ulong target_addr,
2832                                                struct shm_info *host_shm_info)
2833 {
2834     struct target_shm_info *target_shm_info;
2835     if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0))
2836         return -TARGET_EFAULT;
2837     __put_user(host_shm_info->used_ids, &target_shm_info->used_ids);
2838     __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot);
2839     __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss);
2840     __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp);
2841     __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts);
2842     __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes);
2843     unlock_user_struct(target_shm_info, target_addr, 1);
2844     return 0;
2845 }
2846
2847 static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf)
2848 {
2849     struct shmid_ds dsarg;
2850     struct shminfo shminfo;
2851     struct shm_info shm_info;
2852     abi_long ret = -TARGET_EINVAL;
2853
2854     cmd &= 0xff;
2855
2856     switch(cmd) {
2857     case IPC_STAT:
2858     case IPC_SET:
2859     case SHM_STAT:
2860         if (target_to_host_shmid_ds(&dsarg, buf))
2861             return -TARGET_EFAULT;
2862         ret = get_errno(shmctl(shmid, cmd, &dsarg));
2863         if (host_to_target_shmid_ds(buf, &dsarg))
2864             return -TARGET_EFAULT;
2865         break;
2866     case IPC_INFO:
2867         ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo));
2868         if (host_to_target_shminfo(buf, &shminfo))
2869             return -TARGET_EFAULT;
2870         break;
2871     case SHM_INFO:
2872         ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info));
2873         if (host_to_target_shm_info(buf, &shm_info))
2874             return -TARGET_EFAULT;
2875         break;
2876     case IPC_RMID:
2877     case SHM_LOCK:
2878     case SHM_UNLOCK:
2879         ret = get_errno(shmctl(shmid, cmd, NULL));
2880         break;
2881     }
2882
2883     return ret;
2884 }
2885
2886 static inline abi_ulong do_shmat(int shmid, abi_ulong shmaddr, int shmflg)
2887 {
2888     abi_long raddr;
2889     void *host_raddr;
2890     struct shmid_ds shm_info;
2891     int i,ret;
2892
2893     /* find out the length of the shared memory segment */
2894     ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
2895     if (is_error(ret)) {
2896         /* can't get length, bail out */
2897         return ret;
2898     }
2899
2900     mmap_lock();
2901
2902     if (shmaddr)
2903         host_raddr = shmat(shmid, (void *)g2h(shmaddr), shmflg);
2904     else {
2905         abi_ulong mmap_start;
2906
2907         mmap_start = mmap_find_vma(0, shm_info.shm_segsz);
2908
2909         if (mmap_start == -1) {
2910             errno = ENOMEM;
2911             host_raddr = (void *)-1;
2912         } else
2913             host_raddr = shmat(shmid, g2h(mmap_start), shmflg | SHM_REMAP);
2914     }
2915
2916     if (host_raddr == (void *)-1) {
2917         mmap_unlock();
2918         return get_errno((long)host_raddr);
2919     }
2920     raddr=h2g((unsigned long)host_raddr);
2921
2922     page_set_flags(raddr, raddr + shm_info.shm_segsz,
2923                    PAGE_VALID | PAGE_READ |
2924                    ((shmflg & SHM_RDONLY)? 0 : PAGE_WRITE));
2925
2926     for (i = 0; i < N_SHM_REGIONS; i++) {
2927         if (shm_regions[i].start == 0) {
2928             shm_regions[i].start = raddr;
2929             shm_regions[i].size = shm_info.shm_segsz;
2930             break;
2931         }
2932     }
2933
2934     mmap_unlock();
2935     return raddr;
2936
2937 }
2938
2939 static inline abi_long do_shmdt(abi_ulong shmaddr)
2940 {
2941     int i;
2942
2943     for (i = 0; i < N_SHM_REGIONS; ++i) {
2944         if (shm_regions[i].start == shmaddr) {
2945             shm_regions[i].start = 0;
2946             page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0);
2947             break;
2948         }
2949     }
2950
2951     return get_errno(shmdt(g2h(shmaddr)));
2952 }
2953
2954 #ifdef TARGET_NR_ipc
2955 /* ??? This only works with linear mappings.  */
2956 /* do_ipc() must return target values and target errnos. */
2957 static abi_long do_ipc(unsigned int call, int first,
2958                        int second, int third,
2959                        abi_long ptr, abi_long fifth)
2960 {
2961     int version;
2962     abi_long ret = 0;
2963
2964     version = call >> 16;
2965     call &= 0xffff;
2966
2967     switch (call) {
2968     case IPCOP_semop:
2969         ret = do_semop(first, ptr, second);
2970         break;
2971
2972     case IPCOP_semget:
2973         ret = get_errno(semget(first, second, third));
2974         break;
2975
2976     case IPCOP_semctl:
2977         ret = do_semctl(first, second, third, (union target_semun)(abi_ulong) ptr);
2978         break;
2979
2980     case IPCOP_msgget:
2981         ret = get_errno(msgget(first, second));
2982         break;
2983
2984     case IPCOP_msgsnd:
2985         ret = do_msgsnd(first, ptr, second, third);
2986         break;
2987
2988     case IPCOP_msgctl:
2989         ret = do_msgctl(first, second, ptr);
2990         break;
2991
2992     case IPCOP_msgrcv:
2993         switch (version) {
2994         case 0:
2995             {
2996                 struct target_ipc_kludge {
2997                     abi_long msgp;
2998                     abi_long msgtyp;
2999                 } *tmp;
3000
3001                 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
3002                     ret = -TARGET_EFAULT;
3003                     break;
3004                 }
3005
3006                 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third);
3007
3008                 unlock_user_struct(tmp, ptr, 0);
3009                 break;
3010             }
3011         default:
3012             ret = do_msgrcv(first, ptr, second, fifth, third);
3013         }
3014         break;
3015
3016     case IPCOP_shmat:
3017         switch (version) {
3018         default:
3019         {
3020             abi_ulong raddr;
3021             raddr = do_shmat(first, ptr, second);
3022             if (is_error(raddr))
3023                 return get_errno(raddr);
3024             if (put_user_ual(raddr, third))
3025                 return -TARGET_EFAULT;
3026             break;
3027         }
3028         case 1:
3029             ret = -TARGET_EINVAL;
3030             break;
3031         }
3032         break;
3033     case IPCOP_shmdt:
3034         ret = do_shmdt(ptr);
3035         break;
3036
3037     case IPCOP_shmget:
3038         /* IPC_* flag values are the same on all linux platforms */
3039         ret = get_errno(shmget(first, second, third));
3040         break;
3041
3042         /* IPC_* and SHM_* command values are the same on all linux platforms */
3043     case IPCOP_shmctl:
3044         ret = do_shmctl(first, second, ptr);
3045         break;
3046     default:
3047         gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
3048         ret = -TARGET_ENOSYS;
3049         break;
3050     }
3051     return ret;
3052 }
3053 #endif
3054
3055 /* kernel structure types definitions */
3056
3057 #define STRUCT(name, ...) STRUCT_ ## name,
3058 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
3059 enum {
3060 #include "syscall_types.h"
3061 };
3062 #undef STRUCT
3063 #undef STRUCT_SPECIAL
3064
3065 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = {  __VA_ARGS__, TYPE_NULL };
3066 #define STRUCT_SPECIAL(name)
3067 #include "syscall_types.h"
3068 #undef STRUCT
3069 #undef STRUCT_SPECIAL
3070
3071 typedef struct IOCTLEntry IOCTLEntry;
3072
3073 typedef abi_long do_ioctl_fn(const IOCTLEntry *ie, uint8_t *buf_temp,
3074                              int fd, abi_long cmd, abi_long arg);
3075
3076 struct IOCTLEntry {
3077     unsigned int target_cmd;
3078     unsigned int host_cmd;
3079     const char *name;
3080     int access;
3081     do_ioctl_fn *do_ioctl;
3082     const argtype arg_type[5];
3083 };
3084
3085 #define IOC_R 0x0001
3086 #define IOC_W 0x0002
3087 #define IOC_RW (IOC_R | IOC_W)
3088
3089 #define MAX_STRUCT_SIZE 4096
3090
3091 #ifdef CONFIG_FIEMAP
3092 /* So fiemap access checks don't overflow on 32 bit systems.
3093  * This is very slightly smaller than the limit imposed by
3094  * the underlying kernel.
3095  */
3096 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap))  \
3097                             / sizeof(struct fiemap_extent))
3098
3099 static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
3100                                        int fd, abi_long cmd, abi_long arg)
3101 {
3102     /* The parameter for this ioctl is a struct fiemap followed
3103      * by an array of struct fiemap_extent whose size is set
3104      * in fiemap->fm_extent_count. The array is filled in by the
3105      * ioctl.
3106      */
3107     int target_size_in, target_size_out;
3108     struct fiemap *fm;
3109     const argtype *arg_type = ie->arg_type;
3110     const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) };
3111     void *argptr, *p;
3112     abi_long ret;
3113     int i, extent_size = thunk_type_size(extent_arg_type, 0);
3114     uint32_t outbufsz;
3115     int free_fm = 0;
3116
3117     assert(arg_type[0] == TYPE_PTR);
3118     assert(ie->access == IOC_RW);
3119     arg_type++;
3120     target_size_in = thunk_type_size(arg_type, 0);
3121     argptr = lock_user(VERIFY_READ, arg, target_size_in, 1);
3122     if (!argptr) {
3123         return -TARGET_EFAULT;
3124     }
3125     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
3126     unlock_user(argptr, arg, 0);
3127     fm = (struct fiemap *)buf_temp;
3128     if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) {
3129         return -TARGET_EINVAL;
3130     }
3131
3132     outbufsz = sizeof (*fm) +
3133         (sizeof(struct fiemap_extent) * fm->fm_extent_count);
3134
3135     if (outbufsz > MAX_STRUCT_SIZE) {
3136         /* We can't fit all the extents into the fixed size buffer.
3137          * Allocate one that is large enough and use it instead.
3138          */
3139         fm = malloc(outbufsz);
3140         if (!fm) {
3141             return -TARGET_ENOMEM;
3142         }
3143         memcpy(fm, buf_temp, sizeof(struct fiemap));
3144         free_fm = 1;
3145     }
3146     ret = get_errno(ioctl(fd, ie->host_cmd, fm));
3147     if (!is_error(ret)) {
3148         target_size_out = target_size_in;
3149         /* An extent_count of 0 means we were only counting the extents
3150          * so there are no structs to copy
3151          */
3152         if (fm->fm_extent_count != 0) {
3153             target_size_out += fm->fm_mapped_extents * extent_size;
3154         }
3155         argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0);
3156         if (!argptr) {
3157             ret = -TARGET_EFAULT;
3158         } else {
3159             /* Convert the struct fiemap */
3160             thunk_convert(argptr, fm, arg_type, THUNK_TARGET);
3161             if (fm->fm_extent_count != 0) {
3162                 p = argptr + target_size_in;
3163                 /* ...and then all the struct fiemap_extents */
3164                 for (i = 0; i < fm->fm_mapped_extents; i++) {
3165                     thunk_convert(p, &fm->fm_extents[i], extent_arg_type,
3166                                   THUNK_TARGET);
3167                     p += extent_size;
3168                 }
3169             }
3170             unlock_user(argptr, arg, target_size_out);
3171         }
3172     }
3173     if (free_fm) {
3174         free(fm);
3175     }
3176     return ret;
3177 }
3178 #endif
3179
3180 static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp,
3181                                 int fd, abi_long cmd, abi_long arg)
3182 {
3183     const argtype *arg_type = ie->arg_type;
3184     int target_size;
3185     void *argptr;
3186     int ret;
3187     struct ifconf *host_ifconf;
3188     uint32_t outbufsz;
3189     const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) };
3190     int target_ifreq_size;
3191     int nb_ifreq;
3192     int free_buf = 0;
3193     int i;
3194     int target_ifc_len;
3195     abi_long target_ifc_buf;
3196     int host_ifc_len;
3197     char *host_ifc_buf;
3198
3199     assert(arg_type[0] == TYPE_PTR);
3200     assert(ie->access == IOC_RW);
3201
3202     arg_type++;
3203     target_size = thunk_type_size(arg_type, 0);
3204
3205     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
3206     if (!argptr)
3207         return -TARGET_EFAULT;
3208     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
3209     unlock_user(argptr, arg, 0);
3210
3211     host_ifconf = (struct ifconf *)(unsigned long)buf_temp;
3212     target_ifc_len = host_ifconf->ifc_len;
3213     target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf;
3214
3215     target_ifreq_size = thunk_type_size(ifreq_arg_type, 0);
3216     nb_ifreq = target_ifc_len / target_ifreq_size;
3217     host_ifc_len = nb_ifreq * sizeof(struct ifreq);
3218
3219     outbufsz = sizeof(*host_ifconf) + host_ifc_len;
3220     if (outbufsz > MAX_STRUCT_SIZE) {
3221         /* We can't fit all the extents into the fixed size buffer.
3222          * Allocate one that is large enough and use it instead.
3223          */
3224         host_ifconf = malloc(outbufsz);
3225         if (!host_ifconf) {
3226             return -TARGET_ENOMEM;
3227         }
3228         memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf));
3229         free_buf = 1;
3230     }
3231     host_ifc_buf = (char*)host_ifconf + sizeof(*host_ifconf);
3232
3233     host_ifconf->ifc_len = host_ifc_len;
3234     host_ifconf->ifc_buf = host_ifc_buf;
3235
3236     ret = get_errno(ioctl(fd, ie->host_cmd, host_ifconf));
3237     if (!is_error(ret)) {
3238         /* convert host ifc_len to target ifc_len */
3239
3240         nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq);
3241         target_ifc_len = nb_ifreq * target_ifreq_size;
3242         host_ifconf->ifc_len = target_ifc_len;
3243
3244         /* restore target ifc_buf */
3245
3246         host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf;
3247
3248         /* copy struct ifconf to target user */
3249
3250         argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
3251         if (!argptr)
3252             return -TARGET_EFAULT;
3253         thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET);
3254         unlock_user(argptr, arg, target_size);
3255
3256         /* copy ifreq[] to target user */
3257
3258         argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0);
3259         for (i = 0; i < nb_ifreq ; i++) {
3260             thunk_convert(argptr + i * target_ifreq_size,
3261                           host_ifc_buf + i * sizeof(struct ifreq),
3262                           ifreq_arg_type, THUNK_TARGET);
3263         }
3264         unlock_user(argptr, target_ifc_buf, target_ifc_len);
3265     }
3266
3267     if (free_buf) {
3268         free(host_ifconf);
3269     }
3270
3271     return ret;
3272 }
3273
3274 static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
3275                             abi_long cmd, abi_long arg)
3276 {
3277     void *argptr;
3278     struct dm_ioctl *host_dm;
3279     abi_long guest_data;
3280     uint32_t guest_data_size;
3281     int target_size;
3282     const argtype *arg_type = ie->arg_type;
3283     abi_long ret;
3284     void *big_buf = NULL;
3285     char *host_data;
3286
3287     arg_type++;
3288     target_size = thunk_type_size(arg_type, 0);
3289     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
3290     if (!argptr) {
3291         ret = -TARGET_EFAULT;
3292         goto out;
3293     }
3294     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
3295     unlock_user(argptr, arg, 0);
3296
3297     /* buf_temp is too small, so fetch things into a bigger buffer */
3298     big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2);
3299     memcpy(big_buf, buf_temp, target_size);
3300     buf_temp = big_buf;
3301     host_dm = big_buf;
3302
3303     guest_data = arg + host_dm->data_start;
3304     if ((guest_data - arg) < 0) {
3305         ret = -EINVAL;
3306         goto out;
3307     }
3308     guest_data_size = host_dm->data_size - host_dm->data_start;
3309     host_data = (char*)host_dm + host_dm->data_start;
3310
3311     argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1);
3312     switch (ie->host_cmd) {
3313     case DM_REMOVE_ALL:
3314     case DM_LIST_DEVICES:
3315     case DM_DEV_CREATE:
3316     case DM_DEV_REMOVE:
3317     case DM_DEV_SUSPEND:
3318     case DM_DEV_STATUS:
3319     case DM_DEV_WAIT:
3320     case DM_TABLE_STATUS:
3321     case DM_TABLE_CLEAR:
3322     case DM_TABLE_DEPS:
3323     case DM_LIST_VERSIONS:
3324         /* no input data */
3325         break;
3326     case DM_DEV_RENAME:
3327     case DM_DEV_SET_GEOMETRY:
3328         /* data contains only strings */
3329         memcpy(host_data, argptr, guest_data_size);
3330         break;
3331     case DM_TARGET_MSG:
3332         memcpy(host_data, argptr, guest_data_size);
3333         *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr);
3334         break;
3335     case DM_TABLE_LOAD:
3336     {
3337         void *gspec = argptr;
3338         void *cur_data = host_data;
3339         const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
3340         int spec_size = thunk_type_size(arg_type, 0);
3341         int i;
3342
3343         for (i = 0; i < host_dm->target_count; i++) {
3344             struct dm_target_spec *spec = cur_data;
3345             uint32_t next;
3346             int slen;
3347
3348             thunk_convert(spec, gspec, arg_type, THUNK_HOST);
3349             slen = strlen((char*)gspec + spec_size) + 1;
3350             next = spec->next;
3351             spec->next = sizeof(*spec) + slen;
3352             strcpy((char*)&spec[1], gspec + spec_size);
3353             gspec += next;
3354             cur_data += spec->next;
3355         }
3356         break;
3357     }
3358     default:
3359         ret = -TARGET_EINVAL;
3360         goto out;
3361     }
3362     unlock_user(argptr, guest_data, 0);
3363
3364     ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
3365     if (!is_error(ret)) {
3366         guest_data = arg + host_dm->data_start;
3367         guest_data_size = host_dm->data_size - host_dm->data_start;
3368         argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0);
3369         switch (ie->host_cmd) {
3370         case DM_REMOVE_ALL:
3371         case DM_DEV_CREATE:
3372         case DM_DEV_REMOVE:
3373         case DM_DEV_RENAME:
3374         case DM_DEV_SUSPEND:
3375         case DM_DEV_STATUS:
3376         case DM_TABLE_LOAD:
3377         case DM_TABLE_CLEAR:
3378         case DM_TARGET_MSG:
3379         case DM_DEV_SET_GEOMETRY:
3380             /* no return data */
3381             break;
3382         case DM_LIST_DEVICES:
3383         {
3384             struct dm_name_list *nl = (void*)host_dm + host_dm->data_start;
3385             uint32_t remaining_data = guest_data_size;
3386             void *cur_data = argptr;
3387             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) };
3388             int nl_size = 12; /* can't use thunk_size due to alignment */
3389
3390             while (1) {
3391                 uint32_t next = nl->next;
3392                 if (next) {
3393                     nl->next = nl_size + (strlen(nl->name) + 1);
3394                 }
3395                 if (remaining_data < nl->next) {
3396                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
3397                     break;
3398                 }
3399                 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET);
3400                 strcpy(cur_data + nl_size, nl->name);
3401                 cur_data += nl->next;
3402                 remaining_data -= nl->next;
3403                 if (!next) {
3404                     break;
3405                 }
3406                 nl = (void*)nl + next;
3407             }
3408             break;
3409         }
3410         case DM_DEV_WAIT:
3411         case DM_TABLE_STATUS:
3412         {
3413             struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start;
3414             void *cur_data = argptr;
3415             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
3416             int spec_size = thunk_type_size(arg_type, 0);
3417             int i;
3418
3419             for (i = 0; i < host_dm->target_count; i++) {
3420                 uint32_t next = spec->next;
3421                 int slen = strlen((char*)&spec[1]) + 1;
3422                 spec->next = (cur_data - argptr) + spec_size + slen;
3423                 if (guest_data_size < spec->next) {
3424                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
3425                     break;
3426                 }
3427                 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET);
3428                 strcpy(cur_data + spec_size, (char*)&spec[1]);
3429                 cur_data = argptr + spec->next;
3430                 spec = (void*)host_dm + host_dm->data_start + next;
3431             }
3432             break;
3433         }
3434         case DM_TABLE_DEPS:
3435         {
3436             void *hdata = (void*)host_dm + host_dm->data_start;
3437             int count = *(uint32_t*)hdata;
3438             uint64_t *hdev = hdata + 8;
3439             uint64_t *gdev = argptr + 8;
3440             int i;
3441
3442             *(uint32_t*)argptr = tswap32(count);
3443             for (i = 0; i < count; i++) {
3444                 *gdev = tswap64(*hdev);
3445                 gdev++;
3446                 hdev++;
3447             }
3448             break;
3449         }
3450         case DM_LIST_VERSIONS:
3451         {
3452             struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start;
3453             uint32_t remaining_data = guest_data_size;
3454             void *cur_data = argptr;
3455             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) };
3456             int vers_size = thunk_type_size(arg_type, 0);
3457
3458             while (1) {
3459                 uint32_t next = vers->next;
3460                 if (next) {
3461                     vers->next = vers_size + (strlen(vers->name) + 1);
3462                 }
3463                 if (remaining_data < vers->next) {
3464                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
3465                     break;
3466                 }
3467                 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET);
3468                 strcpy(cur_data + vers_size, vers->name);
3469                 cur_data += vers->next;
3470                 remaining_data -= vers->next;
3471                 if (!next) {
3472                     break;
3473                 }
3474                 vers = (void*)vers + next;
3475             }
3476             break;
3477         }
3478         default:
3479             ret = -TARGET_EINVAL;
3480             goto out;
3481         }
3482         unlock_user(argptr, guest_data, guest_data_size);
3483
3484         argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
3485         if (!argptr) {
3486             ret = -TARGET_EFAULT;
3487             goto out;
3488         }
3489         thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
3490         unlock_user(argptr, arg, target_size);
3491     }
3492 out:
3493     g_free(big_buf);
3494     return ret;
3495 }
3496
3497 static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
3498                                 int fd, abi_long cmd, abi_long arg)
3499 {
3500     const argtype *arg_type = ie->arg_type;
3501     const StructEntry *se;
3502     const argtype *field_types;
3503     const int *dst_offsets, *src_offsets;
3504     int target_size;
3505     void *argptr;
3506     abi_ulong *target_rt_dev_ptr;
3507     unsigned long *host_rt_dev_ptr;
3508     abi_long ret;
3509     int i;
3510
3511     assert(ie->access == IOC_W);
3512     assert(*arg_type == TYPE_PTR);
3513     arg_type++;
3514     assert(*arg_type == TYPE_STRUCT);
3515     target_size = thunk_type_size(arg_type, 0);
3516     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
3517     if (!argptr) {
3518         return -TARGET_EFAULT;
3519     }
3520     arg_type++;
3521     assert(*arg_type == (int)STRUCT_rtentry);
3522     se = struct_entries + *arg_type++;
3523     assert(se->convert[0] == NULL);
3524     /* convert struct here to be able to catch rt_dev string */
3525     field_types = se->field_types;
3526     dst_offsets = se->field_offsets[THUNK_HOST];
3527     src_offsets = se->field_offsets[THUNK_TARGET];
3528     for (i = 0; i < se->nb_fields; i++) {
3529         if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) {
3530             assert(*field_types == TYPE_PTRVOID);
3531             target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]);
3532             host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]);
3533             if (*target_rt_dev_ptr != 0) {
3534                 *host_rt_dev_ptr = (unsigned long)lock_user_string(
3535                                                   tswapal(*target_rt_dev_ptr));
3536                 if (!*host_rt_dev_ptr) {
3537                     unlock_user(argptr, arg, 0);
3538                     return -TARGET_EFAULT;
3539                 }
3540             } else {
3541                 *host_rt_dev_ptr = 0;
3542             }
3543             field_types++;
3544             continue;
3545         }
3546         field_types = thunk_convert(buf_temp + dst_offsets[i],
3547                                     argptr + src_offsets[i],
3548                                     field_types, THUNK_HOST);
3549     }
3550     unlock_user(argptr, arg, 0);
3551
3552     ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
3553     if (*host_rt_dev_ptr != 0) {
3554         unlock_user((void *)*host_rt_dev_ptr,
3555                     *target_rt_dev_ptr, 0);
3556     }
3557     return ret;
3558 }
3559
3560 static IOCTLEntry ioctl_entries[] = {
3561 #define IOCTL(cmd, access, ...) \
3562     { TARGET_ ## cmd, cmd, #cmd, access, 0, {  __VA_ARGS__ } },
3563 #define IOCTL_SPECIAL(cmd, access, dofn, ...)                      \
3564     { TARGET_ ## cmd, cmd, #cmd, access, dofn, {  __VA_ARGS__ } },
3565 #include "ioctls.h"
3566     { 0, 0, },
3567 };
3568
3569 /* ??? Implement proper locking for ioctls.  */
3570 /* do_ioctl() Must return target values and target errnos. */
3571 static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
3572 {
3573     const IOCTLEntry *ie;
3574     const argtype *arg_type;
3575     abi_long ret;
3576     uint8_t buf_temp[MAX_STRUCT_SIZE];
3577     int target_size;
3578     void *argptr;
3579
3580     ie = ioctl_entries;
3581     for(;;) {
3582         if (ie->target_cmd == 0) {
3583             gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
3584             return -TARGET_ENOSYS;
3585         }
3586         if (ie->target_cmd == cmd)
3587             break;
3588         ie++;
3589     }
3590     arg_type = ie->arg_type;
3591 #if defined(DEBUG)
3592     gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
3593 #endif
3594     if (ie->do_ioctl) {
3595         return ie->do_ioctl(ie, buf_temp, fd, cmd, arg);
3596     }
3597
3598     switch(arg_type[0]) {
3599     case TYPE_NULL:
3600         /* no argument */
3601         ret = get_errno(ioctl(fd, ie->host_cmd));
3602         break;
3603     case TYPE_PTRVOID:
3604     case TYPE_INT:
3605         /* int argment */
3606         ret = get_errno(ioctl(fd, ie->host_cmd, arg));
3607         break;
3608     case TYPE_PTR:
3609         arg_type++;
3610         target_size = thunk_type_size(arg_type, 0);
3611         switch(ie->access) {
3612         case IOC_R:
3613             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
3614             if (!is_error(ret)) {
3615                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
3616                 if (!argptr)
3617                     return -TARGET_EFAULT;
3618                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
3619                 unlock_user(argptr, arg, target_size);
3620             }
3621             break;
3622         case IOC_W:
3623             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
3624             if (!argptr)
3625                 return -TARGET_EFAULT;
3626             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
3627             unlock_user(argptr, arg, 0);
3628             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
3629             break;
3630         default:
3631         case IOC_RW:
3632             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
3633             if (!argptr)
3634                 return -TARGET_EFAULT;
3635             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
3636             unlock_user(argptr, arg, 0);
3637             ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
3638             if (!is_error(ret)) {
3639                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
3640                 if (!argptr)
3641                     return -TARGET_EFAULT;
3642                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
3643                 unlock_user(argptr, arg, target_size);
3644             }
3645             break;
3646         }
3647         break;
3648     default:
3649         gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
3650                  (long)cmd, arg_type[0]);
3651         ret = -TARGET_ENOSYS;
3652         break;
3653     }
3654     return ret;
3655 }
3656
3657 static const bitmask_transtbl iflag_tbl[] = {
3658         { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
3659         { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
3660         { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
3661         { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
3662         { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
3663         { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
3664         { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
3665         { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
3666         { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
3667         { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
3668         { TARGET_IXON, TARGET_IXON, IXON, IXON },
3669         { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
3670         { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
3671         { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
3672         { 0, 0, 0, 0 }
3673 };
3674
3675 static const bitmask_transtbl oflag_tbl[] = {
3676         { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
3677         { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
3678         { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
3679         { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
3680         { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
3681         { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
3682         { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
3683         { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
3684         { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
3685         { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
3686         { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
3687         { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
3688         { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
3689         { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
3690         { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
3691         { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
3692         { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
3693         { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
3694         { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
3695         { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
3696         { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
3697         { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
3698         { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
3699         { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
3700         { 0, 0, 0, 0 }
3701 };
3702
3703 static const bitmask_transtbl cflag_tbl[] = {
3704         { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
3705         { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
3706         { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
3707         { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
3708         { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
3709         { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
3710         { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
3711         { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
3712         { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
3713         { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
3714         { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
3715         { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
3716         { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
3717         { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
3718         { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
3719         { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
3720         { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
3721         { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
3722         { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
3723         { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
3724         { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
3725         { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
3726         { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
3727         { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
3728         { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
3729         { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
3730         { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
3731         { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
3732         { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
3733         { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
3734         { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
3735         { 0, 0, 0, 0 }
3736 };
3737
3738 static const bitmask_transtbl lflag_tbl[] = {
3739         { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
3740         { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
3741         { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
3742         { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
3743         { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
3744         { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
3745         { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
3746         { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
3747         { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
3748         { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
3749         { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
3750         { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
3751         { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
3752         { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
3753         { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
3754         { 0, 0, 0, 0 }
3755 };
3756
3757 static void target_to_host_termios (void *dst, const void *src)
3758 {
3759     struct host_termios *host = dst;
3760     const struct target_termios *target = src;
3761
3762     host->c_iflag =
3763         target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
3764     host->c_oflag =
3765         target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
3766     host->c_cflag =
3767         target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
3768     host->c_lflag =
3769         target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
3770     host->c_line = target->c_line;
3771
3772     memset(host->c_cc, 0, sizeof(host->c_cc));
3773     host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
3774     host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
3775     host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
3776     host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
3777     host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
3778     host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
3779     host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
3780     host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
3781     host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
3782     host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
3783     host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
3784     host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
3785     host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
3786     host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
3787     host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
3788     host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
3789     host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
3790 }
3791
3792 static void host_to_target_termios (void *dst, const void *src)
3793 {
3794     struct target_termios *target = dst;
3795     const struct host_termios *host = src;
3796
3797     target->c_iflag =
3798         tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
3799     target->c_oflag =
3800         tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
3801     target->c_cflag =
3802         tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
3803     target->c_lflag =
3804         tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
3805     target->c_line = host->c_line;
3806
3807     memset(target->c_cc, 0, sizeof(target->c_cc));
3808     target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
3809     target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
3810     target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
3811     target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
3812     target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
3813     target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
3814     target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
3815     target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
3816     target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
3817     target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
3818     target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
3819     target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
3820     target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
3821     target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
3822     target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
3823     target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
3824     target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
3825 }
3826
3827 static const StructEntry struct_termios_def = {
3828     .convert = { host_to_target_termios, target_to_host_termios },
3829     .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
3830     .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
3831 };
3832
3833 static bitmask_transtbl mmap_flags_tbl[] = {
3834         { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
3835         { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
3836         { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
3837         { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
3838         { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
3839         { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
3840         { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
3841         { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
3842         { 0, 0, 0, 0 }
3843 };
3844
3845 #if defined(TARGET_I386)
3846
3847 /* NOTE: there is really one LDT for all the threads */
3848 static uint8_t *ldt_table;
3849
3850 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
3851 {
3852     int size;
3853     void *p;
3854
3855     if (!ldt_table)
3856         return 0;
3857     size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
3858     if (size > bytecount)
3859         size = bytecount;
3860     p = lock_user(VERIFY_WRITE, ptr, size, 0);
3861     if (!p)
3862         return -TARGET_EFAULT;
3863     /* ??? Should this by byteswapped?  */
3864     memcpy(p, ldt_table, size);
3865     unlock_user(p, ptr, size);
3866     return size;
3867 }
3868
3869 /* XXX: add locking support */
3870 static abi_long write_ldt(CPUX86State *env,
3871                           abi_ulong ptr, unsigned long bytecount, int oldmode)
3872 {
3873     struct target_modify_ldt_ldt_s ldt_info;
3874     struct target_modify_ldt_ldt_s *target_ldt_info;
3875     int seg_32bit, contents, read_exec_only, limit_in_pages;
3876     int seg_not_present, useable, lm;
3877     uint32_t *lp, entry_1, entry_2;
3878
3879     if (bytecount != sizeof(ldt_info))
3880         return -TARGET_EINVAL;
3881     if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
3882         return -TARGET_EFAULT;
3883     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
3884     ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
3885     ldt_info.limit = tswap32(target_ldt_info->limit);
3886     ldt_info.flags = tswap32(target_ldt_info->flags);
3887     unlock_user_struct(target_ldt_info, ptr, 0);
3888
3889     if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
3890         return -TARGET_EINVAL;
3891     seg_32bit = ldt_info.flags & 1;
3892     contents = (ldt_info.flags >> 1) & 3;
3893     read_exec_only = (ldt_info.flags >> 3) & 1;
3894     limit_in_pages = (ldt_info.flags >> 4) & 1;
3895     seg_not_present = (ldt_info.flags >> 5) & 1;
3896     useable = (ldt_info.flags >> 6) & 1;
3897 #ifdef TARGET_ABI32
3898     lm = 0;
3899 #else
3900     lm = (ldt_info.flags >> 7) & 1;
3901 #endif
3902     if (contents == 3) {
3903         if (oldmode)
3904             return -TARGET_EINVAL;
3905         if (seg_not_present == 0)
3906             return -TARGET_EINVAL;
3907     }
3908     /* allocate the LDT */
3909     if (!ldt_table) {
3910         env->ldt.base = target_mmap(0,
3911                                     TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
3912                                     PROT_READ|PROT_WRITE,
3913                                     MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
3914         if (env->ldt.base == -1)
3915             return -TARGET_ENOMEM;
3916         memset(g2h(env->ldt.base), 0,
3917                TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
3918         env->ldt.limit = 0xffff;
3919         ldt_table = g2h(env->ldt.base);
3920     }
3921
3922     /* NOTE: same code as Linux kernel */
3923     /* Allow LDTs to be cleared by the user. */
3924     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
3925         if (oldmode ||
3926             (contents == 0              &&
3927              read_exec_only == 1        &&
3928              seg_32bit == 0             &&
3929              limit_in_pages == 0        &&
3930              seg_not_present == 1       &&
3931              useable == 0 )) {
3932             entry_1 = 0;
3933             entry_2 = 0;
3934             goto install;
3935         }
3936     }
3937
3938     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
3939         (ldt_info.limit & 0x0ffff);
3940     entry_2 = (ldt_info.base_addr & 0xff000000) |
3941         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
3942         (ldt_info.limit & 0xf0000) |
3943         ((read_exec_only ^ 1) << 9) |
3944         (contents << 10) |
3945         ((seg_not_present ^ 1) << 15) |
3946         (seg_32bit << 22) |
3947         (limit_in_pages << 23) |
3948         (lm << 21) |
3949         0x7000;
3950     if (!oldmode)
3951         entry_2 |= (useable << 20);
3952
3953     /* Install the new entry ...  */
3954 install:
3955     lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
3956     lp[0] = tswap32(entry_1);
3957     lp[1] = tswap32(entry_2);
3958     return 0;
3959 }
3960
3961 /* specific and weird i386 syscalls */
3962 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
3963                               unsigned long bytecount)
3964 {
3965     abi_long ret;
3966
3967     switch (func) {
3968     case 0:
3969         ret = read_ldt(ptr, bytecount);
3970         break;
3971     case 1:
3972         ret = write_ldt(env, ptr, bytecount, 1);
3973         break;
3974     case 0x11:
3975         ret = write_ldt(env, ptr, bytecount, 0);
3976         break;
3977     default:
3978         ret = -TARGET_ENOSYS;
3979         break;
3980     }
3981     return ret;
3982 }
3983
3984 #if defined(TARGET_I386) && defined(TARGET_ABI32)
3985 abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
3986 {
3987     uint64_t *gdt_table = g2h(env->gdt.base);
3988     struct target_modify_ldt_ldt_s ldt_info;
3989     struct target_modify_ldt_ldt_s *target_ldt_info;
3990     int seg_32bit, contents, read_exec_only, limit_in_pages;
3991     int seg_not_present, useable, lm;
3992     uint32_t *lp, entry_1, entry_2;
3993     int i;
3994
3995     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
3996     if (!target_ldt_info)
3997         return -TARGET_EFAULT;
3998     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
3999     ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
4000     ldt_info.limit = tswap32(target_ldt_info->limit);
4001     ldt_info.flags = tswap32(target_ldt_info->flags);
4002     if (ldt_info.entry_number == -1) {
4003         for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
4004             if (gdt_table[i] == 0) {
4005                 ldt_info.entry_number = i;
4006                 target_ldt_info->entry_number = tswap32(i);
4007                 break;
4008             }
4009         }
4010     }
4011     unlock_user_struct(target_ldt_info, ptr, 1);
4012
4013     if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
4014         ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
4015            return -TARGET_EINVAL;
4016     seg_32bit = ldt_info.flags & 1;
4017     contents = (ldt_info.flags >> 1) & 3;
4018     read_exec_only = (ldt_info.flags >> 3) & 1;
4019     limit_in_pages = (ldt_info.flags >> 4) & 1;
4020     seg_not_present = (ldt_info.flags >> 5) & 1;
4021     useable = (ldt_info.flags >> 6) & 1;
4022 #ifdef TARGET_ABI32
4023     lm = 0;
4024 #else
4025     lm = (ldt_info.flags >> 7) & 1;
4026 #endif
4027
4028     if (contents == 3) {
4029         if (seg_not_present == 0)
4030             return -TARGET_EINVAL;
4031     }
4032
4033     /* NOTE: same code as Linux kernel */
4034     /* Allow LDTs to be cleared by the user. */
4035     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
4036         if ((contents == 0             &&
4037              read_exec_only == 1       &&
4038              seg_32bit == 0            &&
4039              limit_in_pages == 0       &&
4040              seg_not_present == 1      &&
4041              useable == 0 )) {
4042             entry_1 = 0;
4043             entry_2 = 0;
4044             goto install;
4045         }
4046     }
4047
4048     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
4049         (ldt_info.limit & 0x0ffff);
4050     entry_2 = (ldt_info.base_addr & 0xff000000) |
4051         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
4052         (ldt_info.limit & 0xf0000) |
4053         ((read_exec_only ^ 1) << 9) |
4054         (contents << 10) |
4055         ((seg_not_present ^ 1) << 15) |
4056         (seg_32bit << 22) |
4057         (limit_in_pages << 23) |
4058         (useable << 20) |
4059         (lm << 21) |
4060         0x7000;
4061
4062     /* Install the new entry ...  */
4063 install:
4064     lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
4065     lp[0] = tswap32(entry_1);
4066     lp[1] = tswap32(entry_2);
4067     return 0;
4068 }
4069
4070 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
4071 {
4072     struct target_modify_ldt_ldt_s *target_ldt_info;
4073     uint64_t *gdt_table = g2h(env->gdt.base);
4074     uint32_t base_addr, limit, flags;
4075     int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
4076     int seg_not_present, useable, lm;
4077     uint32_t *lp, entry_1, entry_2;
4078
4079     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
4080     if (!target_ldt_info)
4081         return -TARGET_EFAULT;
4082     idx = tswap32(target_ldt_info->entry_number);
4083     if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
4084         idx > TARGET_GDT_ENTRY_TLS_MAX) {
4085         unlock_user_struct(target_ldt_info, ptr, 1);
4086         return -TARGET_EINVAL;
4087     }
4088     lp = (uint32_t *)(gdt_table + idx);
4089     entry_1 = tswap32(lp[0]);
4090     entry_2 = tswap32(lp[1]);
4091
4092     read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
4093     contents = (entry_2 >> 10) & 3;
4094     seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
4095     seg_32bit = (entry_2 >> 22) & 1;
4096     limit_in_pages = (entry_2 >> 23) & 1;
4097     useable = (entry_2 >> 20) & 1;
4098 #ifdef TARGET_ABI32
4099     lm = 0;
4100 #else
4101     lm = (entry_2 >> 21) & 1;
4102 #endif
4103     flags = (seg_32bit << 0) | (contents << 1) |
4104         (read_exec_only << 3) | (limit_in_pages << 4) |
4105         (seg_not_present << 5) | (useable << 6) | (lm << 7);
4106     limit = (entry_1 & 0xffff) | (entry_2  & 0xf0000);
4107     base_addr = (entry_1 >> 16) |
4108         (entry_2 & 0xff000000) |
4109         ((entry_2 & 0xff) << 16);
4110     target_ldt_info->base_addr = tswapal(base_addr);
4111     target_ldt_info->limit = tswap32(limit);
4112     target_ldt_info->flags = tswap32(flags);
4113     unlock_user_struct(target_ldt_info, ptr, 1);
4114     return 0;
4115 }
4116 #endif /* TARGET_I386 && TARGET_ABI32 */
4117
4118 #ifndef TARGET_ABI32
4119 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
4120 {
4121     abi_long ret = 0;
4122     abi_ulong val;
4123     int idx;
4124
4125     switch(code) {
4126     case TARGET_ARCH_SET_GS:
4127     case TARGET_ARCH_SET_FS:
4128         if (code == TARGET_ARCH_SET_GS)
4129             idx = R_GS;
4130         else
4131             idx = R_FS;
4132         cpu_x86_load_seg(env, idx, 0);
4133         env->segs[idx].base = addr;
4134         break;
4135     case TARGET_ARCH_GET_GS:
4136     case TARGET_ARCH_GET_FS:
4137         if (code == TARGET_ARCH_GET_GS)
4138             idx = R_GS;
4139         else
4140             idx = R_FS;
4141         val = env->segs[idx].base;
4142         if (put_user(val, addr, abi_ulong))
4143             ret = -TARGET_EFAULT;
4144         break;
4145     default:
4146         ret = -TARGET_EINVAL;
4147         break;
4148     }
4149     return ret;
4150 }
4151 #endif
4152
4153 #endif /* defined(TARGET_I386) */
4154
4155 #define NEW_STACK_SIZE 0x40000
4156
4157
4158 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
4159 typedef struct {
4160     CPUArchState *env;
4161     pthread_mutex_t mutex;
4162     pthread_cond_t cond;
4163     pthread_t thread;
4164     uint32_t tid;
4165     abi_ulong child_tidptr;
4166     abi_ulong parent_tidptr;
4167     sigset_t sigmask;
4168 } new_thread_info;
4169
4170 static void *clone_func(void *arg)
4171 {
4172     new_thread_info *info = arg;
4173     CPUArchState *env;
4174     CPUState *cpu;
4175     TaskState *ts;
4176
4177     env = info->env;
4178     cpu = ENV_GET_CPU(env);
4179     thread_cpu = cpu;
4180     ts = (TaskState *)env->opaque;
4181     info->tid = gettid();
4182     cpu->host_tid = info->tid;
4183     task_settid(ts);
4184     if (info->child_tidptr)
4185         put_user_u32(info->tid, info->child_tidptr);
4186     if (info->parent_tidptr)
4187         put_user_u32(info->tid, info->parent_tidptr);
4188     /* Enable signals.  */
4189     sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
4190     /* Signal to the parent that we're ready.  */
4191     pthread_mutex_lock(&info->mutex);
4192     pthread_cond_broadcast(&info->cond);
4193     pthread_mutex_unlock(&info->mutex);
4194     /* Wait until the parent has finshed initializing the tls state.  */
4195     pthread_mutex_lock(&clone_lock);
4196     pthread_mutex_unlock(&clone_lock);
4197     cpu_loop(env);
4198     /* never exits */
4199     return NULL;
4200 }
4201
4202 /* do_fork() Must return host values and target errnos (unlike most
4203    do_*() functions). */
4204 static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
4205                    abi_ulong parent_tidptr, target_ulong newtls,
4206                    abi_ulong child_tidptr)
4207 {
4208     int ret;
4209     TaskState *ts;
4210     CPUArchState *new_env;
4211     unsigned int nptl_flags;
4212     sigset_t sigmask;
4213
4214     /* Emulate vfork() with fork() */
4215     if (flags & CLONE_VFORK)
4216         flags &= ~(CLONE_VFORK | CLONE_VM);
4217
4218     if (flags & CLONE_VM) {
4219         TaskState *parent_ts = (TaskState *)env->opaque;
4220         new_thread_info info;
4221         pthread_attr_t attr;
4222
4223         ts = g_malloc0(sizeof(TaskState));
4224         init_task_state(ts);
4225         /* we create a new CPU instance. */
4226         new_env = cpu_copy(env);
4227         /* Init regs that differ from the parent.  */
4228         cpu_clone_regs(new_env, newsp);
4229         new_env->opaque = ts;
4230         ts->bprm = parent_ts->bprm;
4231         ts->info = parent_ts->info;
4232         nptl_flags = flags;
4233         flags &= ~CLONE_NPTL_FLAGS2;
4234
4235         if (nptl_flags & CLONE_CHILD_CLEARTID) {
4236             ts->child_tidptr = child_tidptr;
4237         }
4238
4239         if (nptl_flags & CLONE_SETTLS)
4240             cpu_set_tls (new_env, newtls);
4241
4242         /* Grab a mutex so that thread setup appears atomic.  */
4243         pthread_mutex_lock(&clone_lock);
4244
4245         memset(&info, 0, sizeof(info));
4246         pthread_mutex_init(&info.mutex, NULL);
4247         pthread_mutex_lock(&info.mutex);
4248         pthread_cond_init(&info.cond, NULL);
4249         info.env = new_env;
4250         if (nptl_flags & CLONE_CHILD_SETTID)
4251             info.child_tidptr = child_tidptr;
4252         if (nptl_flags & CLONE_PARENT_SETTID)
4253             info.parent_tidptr = parent_tidptr;
4254
4255         ret = pthread_attr_init(&attr);
4256         ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE);
4257         ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
4258         /* It is not safe to deliver signals until the child has finished
4259            initializing, so temporarily block all signals.  */
4260         sigfillset(&sigmask);
4261         sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
4262
4263         ret = pthread_create(&info.thread, &attr, clone_func, &info);
4264         /* TODO: Free new CPU state if thread creation failed.  */
4265
4266         sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
4267         pthread_attr_destroy(&attr);
4268         if (ret == 0) {
4269             /* Wait for the child to initialize.  */
4270             pthread_cond_wait(&info.cond, &info.mutex);
4271             ret = info.tid;
4272             if (flags & CLONE_PARENT_SETTID)
4273                 put_user_u32(ret, parent_tidptr);
4274         } else {
4275             ret = -1;
4276         }
4277         pthread_mutex_unlock(&info.mutex);
4278         pthread_cond_destroy(&info.cond);
4279         pthread_mutex_destroy(&info.mutex);
4280         pthread_mutex_unlock(&clone_lock);
4281     } else {
4282         /* if no CLONE_VM, we consider it is a fork */
4283         if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
4284             return -EINVAL;
4285         fork_start();
4286         ret = fork();
4287         if (ret == 0) {
4288             /* Child Process.  */
4289             cpu_clone_regs(env, newsp);
4290             fork_end(1);
4291             /* There is a race condition here.  The parent process could
4292                theoretically read the TID in the child process before the child
4293                tid is set.  This would require using either ptrace
4294                (not implemented) or having *_tidptr to point at a shared memory
4295                mapping.  We can't repeat the spinlock hack used above because
4296                the child process gets its own copy of the lock.  */
4297             if (flags & CLONE_CHILD_SETTID)
4298                 put_user_u32(gettid(), child_tidptr);
4299             if (flags & CLONE_PARENT_SETTID)
4300                 put_user_u32(gettid(), parent_tidptr);
4301             ts = (TaskState *)env->opaque;
4302             if (flags & CLONE_SETTLS)
4303                 cpu_set_tls (env, newtls);
4304             if (flags & CLONE_CHILD_CLEARTID)
4305                 ts->child_tidptr = child_tidptr;
4306         } else {
4307             fork_end(0);
4308         }
4309     }
4310     return ret;
4311 }
4312
4313 /* warning : doesn't handle linux specific flags... */
4314 static int target_to_host_fcntl_cmd(int cmd)
4315 {
4316     switch(cmd) {
4317         case TARGET_F_DUPFD:
4318         case TARGET_F_GETFD:
4319         case TARGET_F_SETFD:
4320         case TARGET_F_GETFL:
4321         case TARGET_F_SETFL:
4322             return cmd;
4323         case TARGET_F_GETLK:
4324             return F_GETLK;
4325         case TARGET_F_SETLK:
4326             return F_SETLK;
4327         case TARGET_F_SETLKW:
4328             return F_SETLKW;
4329         case TARGET_F_GETOWN:
4330             return F_GETOWN;
4331         case TARGET_F_SETOWN:
4332             return F_SETOWN;
4333         case TARGET_F_GETSIG:
4334             return F_GETSIG;
4335         case TARGET_F_SETSIG:
4336             return F_SETSIG;
4337 #if TARGET_ABI_BITS == 32
4338         case TARGET_F_GETLK64:
4339             return F_GETLK64;
4340         case TARGET_F_SETLK64:
4341             return F_SETLK64;
4342         case TARGET_F_SETLKW64:
4343             return F_SETLKW64;
4344 #endif
4345         case TARGET_F_SETLEASE:
4346             return F_SETLEASE;
4347         case TARGET_F_GETLEASE:
4348             return F_GETLEASE;
4349 #ifdef F_DUPFD_CLOEXEC
4350         case TARGET_F_DUPFD_CLOEXEC:
4351             return F_DUPFD_CLOEXEC;
4352 #endif
4353         case TARGET_F_NOTIFY:
4354             return F_NOTIFY;
4355         default:
4356             return -TARGET_EINVAL;
4357     }
4358     return -TARGET_EINVAL;
4359 }
4360
4361 #define TRANSTBL_CONVERT(a) { -1, TARGET_##a, -1, a }
4362 static const bitmask_transtbl flock_tbl[] = {
4363     TRANSTBL_CONVERT(F_RDLCK),
4364     TRANSTBL_CONVERT(F_WRLCK),
4365     TRANSTBL_CONVERT(F_UNLCK),
4366     TRANSTBL_CONVERT(F_EXLCK),
4367     TRANSTBL_CONVERT(F_SHLCK),
4368     { 0, 0, 0, 0 }
4369 };
4370
4371 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
4372 {
4373     struct flock fl;
4374     struct target_flock *target_fl;
4375     struct flock64 fl64;
4376     struct target_flock64 *target_fl64;
4377     abi_long ret;
4378     int host_cmd = target_to_host_fcntl_cmd(cmd);
4379
4380     if (host_cmd == -TARGET_EINVAL)
4381             return host_cmd;
4382
4383     switch(cmd) {
4384     case TARGET_F_GETLK:
4385         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
4386             return -TARGET_EFAULT;
4387         fl.l_type =
4388                   target_to_host_bitmask(tswap16(target_fl->l_type), flock_tbl);
4389         fl.l_whence = tswap16(target_fl->l_whence);
4390         fl.l_start = tswapal(target_fl->l_start);
4391         fl.l_len = tswapal(target_fl->l_len);
4392         fl.l_pid = tswap32(target_fl->l_pid);
4393         unlock_user_struct(target_fl, arg, 0);
4394         ret = get_errno(fcntl(fd, host_cmd, &fl));
4395         if (ret == 0) {
4396             if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0))
4397                 return -TARGET_EFAULT;
4398             target_fl->l_type =
4399                           host_to_target_bitmask(tswap16(fl.l_type), flock_tbl);
4400             target_fl->l_whence = tswap16(fl.l_whence);
4401             target_fl->l_start = tswapal(fl.l_start);
4402             target_fl->l_len = tswapal(fl.l_len);
4403             target_fl->l_pid = tswap32(fl.l_pid);
4404             unlock_user_struct(target_fl, arg, 1);
4405         }
4406         break;
4407
4408     case TARGET_F_SETLK:
4409     case TARGET_F_SETLKW:
4410         if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
4411             return -TARGET_EFAULT;
4412         fl.l_type =
4413                   target_to_host_bitmask(tswap16(target_fl->l_type), flock_tbl);
4414         fl.l_whence = tswap16(target_fl->l_whence);
4415         fl.l_start = tswapal(target_fl->l_start);
4416         fl.l_len = tswapal(target_fl->l_len);
4417         fl.l_pid = tswap32(target_fl->l_pid);
4418         unlock_user_struct(target_fl, arg, 0);
4419         ret = get_errno(fcntl(fd, host_cmd, &fl));
4420         break;
4421
4422     case TARGET_F_GETLK64:
4423         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
4424             return -TARGET_EFAULT;
4425         fl64.l_type =
4426            target_to_host_bitmask(tswap16(target_fl64->l_type), flock_tbl) >> 1;
4427         fl64.l_whence = tswap16(target_fl64->l_whence);
4428         fl64.l_start = tswap64(target_fl64->l_start);
4429         fl64.l_len = tswap64(target_fl64->l_len);
4430         fl64.l_pid = tswap32(target_fl64->l_pid);
4431         unlock_user_struct(target_fl64, arg, 0);
4432         ret = get_errno(fcntl(fd, host_cmd, &fl64));
4433         if (ret == 0) {
4434             if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0))
4435                 return -TARGET_EFAULT;
4436             target_fl64->l_type =
4437                    host_to_target_bitmask(tswap16(fl64.l_type), flock_tbl) >> 1;
4438             target_fl64->l_whence = tswap16(fl64.l_whence);
4439             target_fl64->l_start = tswap64(fl64.l_start);
4440             target_fl64->l_len = tswap64(fl64.l_len);
4441             target_fl64->l_pid = tswap32(fl64.l_pid);
4442             unlock_user_struct(target_fl64, arg, 1);
4443         }
4444         break;
4445     case TARGET_F_SETLK64:
4446     case TARGET_F_SETLKW64:
4447         if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
4448             return -TARGET_EFAULT;
4449         fl64.l_type =
4450            target_to_host_bitmask(tswap16(target_fl64->l_type), flock_tbl) >> 1;
4451         fl64.l_whence = tswap16(target_fl64->l_whence);
4452         fl64.l_start = tswap64(target_fl64->l_start);
4453         fl64.l_len = tswap64(target_fl64->l_len);
4454         fl64.l_pid = tswap32(target_fl64->l_pid);
4455         unlock_user_struct(target_fl64, arg, 0);
4456         ret = get_errno(fcntl(fd, host_cmd, &fl64));
4457         break;
4458
4459     case TARGET_F_GETFL:
4460         ret = get_errno(fcntl(fd, host_cmd, arg));
4461         if (ret >= 0) {
4462             ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
4463         }
4464         break;
4465
4466     case TARGET_F_SETFL:
4467         ret = get_errno(fcntl(fd, host_cmd, target_to_host_bitmask(arg, fcntl_flags_tbl)));
4468         break;
4469
4470     case TARGET_F_SETOWN:
4471     case TARGET_F_GETOWN:
4472     case TARGET_F_SETSIG:
4473     case TARGET_F_GETSIG:
4474     case TARGET_F_SETLEASE:
4475     case TARGET_F_GETLEASE:
4476         ret = get_errno(fcntl(fd, host_cmd, arg));
4477         break;
4478
4479     default:
4480         ret = get_errno(fcntl(fd, cmd, arg));
4481         break;
4482     }
4483     return ret;
4484 }
4485
4486 #ifdef USE_UID16
4487
4488 static inline int high2lowuid(int uid)
4489 {
4490     if (uid > 65535)
4491         return 65534;
4492     else
4493         return uid;
4494 }
4495
4496 static inline int high2lowgid(int gid)
4497 {
4498     if (gid > 65535)
4499         return 65534;
4500     else
4501         return gid;
4502 }
4503
4504 static inline int low2highuid(int uid)
4505 {
4506     if ((int16_t)uid == -1)
4507         return -1;
4508     else
4509         return uid;
4510 }
4511
4512 static inline int low2highgid(int gid)
4513 {
4514     if ((int16_t)gid == -1)
4515         return -1;
4516     else
4517         return gid;
4518 }
4519 static inline int tswapid(int id)
4520 {
4521     return tswap16(id);
4522 }
4523 #else /* !USE_UID16 */
4524 static inline int high2lowuid(int uid)
4525 {
4526     return uid;
4527 }
4528 static inline int high2lowgid(int gid)
4529 {
4530     return gid;
4531 }
4532 static inline int low2highuid(int uid)
4533 {
4534     return uid;
4535 }
4536 static inline int low2highgid(int gid)
4537 {
4538     return gid;
4539 }
4540 static inline int tswapid(int id)
4541 {
4542     return tswap32(id);
4543 }
4544 #endif /* USE_UID16 */
4545
4546 void syscall_init(void)
4547 {
4548     IOCTLEntry *ie;
4549     const argtype *arg_type;
4550     int size;
4551     int i;
4552
4553 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
4554 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
4555 #include "syscall_types.h"
4556 #undef STRUCT
4557 #undef STRUCT_SPECIAL
4558
4559     /* Build target_to_host_errno_table[] table from
4560      * host_to_target_errno_table[]. */
4561     for (i = 0; i < ERRNO_TABLE_SIZE; i++) {
4562         target_to_host_errno_table[host_to_target_errno_table[i]] = i;
4563     }
4564
4565     /* we patch the ioctl size if necessary. We rely on the fact that
4566        no ioctl has all the bits at '1' in the size field */
4567     ie = ioctl_entries;
4568     while (ie->target_cmd != 0) {
4569         if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
4570             TARGET_IOC_SIZEMASK) {
4571             arg_type = ie->arg_type;
4572             if (arg_type[0] != TYPE_PTR) {
4573                 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
4574                         ie->target_cmd);
4575                 exit(1);
4576             }
4577             arg_type++;
4578             size = thunk_type_size(arg_type, 0);
4579             ie->target_cmd = (ie->target_cmd &
4580                               ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
4581                 (size << TARGET_IOC_SIZESHIFT);
4582         }
4583
4584         /* automatic consistency check if same arch */
4585 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
4586     (defined(__x86_64__) && defined(TARGET_X86_64))
4587         if (unlikely(ie->target_cmd != ie->host_cmd)) {
4588             fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
4589                     ie->name, ie->target_cmd, ie->host_cmd);
4590         }
4591 #endif
4592         ie++;
4593     }
4594 }
4595
4596 #if TARGET_ABI_BITS == 32
4597 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
4598 {
4599 #ifdef TARGET_WORDS_BIGENDIAN
4600     return ((uint64_t)word0 << 32) | word1;
4601 #else
4602     return ((uint64_t)word1 << 32) | word0;
4603 #endif
4604 }
4605 #else /* TARGET_ABI_BITS == 32 */
4606 static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
4607 {
4608     return word0;
4609 }
4610 #endif /* TARGET_ABI_BITS != 32 */
4611
4612 #ifdef TARGET_NR_truncate64
4613 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
4614                                          abi_long arg2,
4615                                          abi_long arg3,
4616                                          abi_long arg4)
4617 {
4618     if (regpairs_aligned(cpu_env)) {
4619         arg2 = arg3;
4620         arg3 = arg4;
4621     }
4622     return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
4623 }
4624 #endif
4625
4626 #ifdef TARGET_NR_ftruncate64
4627 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
4628                                           abi_long arg2,
4629                                           abi_long arg3,
4630                                           abi_long arg4)
4631 {
4632     if (regpairs_aligned(cpu_env)) {
4633         arg2 = arg3;
4634         arg3 = arg4;
4635     }
4636     return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
4637 }
4638 #endif
4639
4640 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
4641                                                abi_ulong target_addr)
4642 {
4643     struct target_timespec *target_ts;
4644
4645     if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
4646         return -TARGET_EFAULT;
4647     host_ts->tv_sec = tswapal(target_ts->tv_sec);
4648     host_ts->tv_nsec = tswapal(target_ts->tv_nsec);
4649     unlock_user_struct(target_ts, target_addr, 0);
4650     return 0;
4651 }
4652
4653 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
4654                                                struct timespec *host_ts)
4655 {
4656     struct target_timespec *target_ts;
4657
4658     if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
4659         return -TARGET_EFAULT;
4660     target_ts->tv_sec = tswapal(host_ts->tv_sec);
4661     target_ts->tv_nsec = tswapal(host_ts->tv_nsec);
4662     unlock_user_struct(target_ts, target_addr, 1);
4663     return 0;
4664 }
4665
4666 static inline abi_long target_to_host_itimerspec(struct itimerspec *host_itspec,
4667                                                  abi_ulong target_addr)
4668 {
4669     struct target_itimerspec *target_itspec;
4670
4671     if (!lock_user_struct(VERIFY_READ, target_itspec, target_addr, 1)) {
4672         return -TARGET_EFAULT;
4673     }
4674
4675     host_itspec->it_interval.tv_sec =
4676                             tswapal(target_itspec->it_interval.tv_sec);
4677     host_itspec->it_interval.tv_nsec =
4678                             tswapal(target_itspec->it_interval.tv_nsec);
4679     host_itspec->it_value.tv_sec = tswapal(target_itspec->it_value.tv_sec);
4680     host_itspec->it_value.tv_nsec = tswapal(target_itspec->it_value.tv_nsec);
4681
4682     unlock_user_struct(target_itspec, target_addr, 1);
4683     return 0;
4684 }
4685
4686 static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
4687                                                struct itimerspec *host_its)
4688 {
4689     struct target_itimerspec *target_itspec;
4690
4691     if (!lock_user_struct(VERIFY_WRITE, target_itspec, target_addr, 0)) {
4692         return -TARGET_EFAULT;
4693     }
4694
4695     target_itspec->it_interval.tv_sec = tswapal(host_its->it_interval.tv_sec);
4696     target_itspec->it_interval.tv_nsec = tswapal(host_its->it_interval.tv_nsec);
4697
4698     target_itspec->it_value.tv_sec = tswapal(host_its->it_value.tv_sec);
4699     target_itspec->it_value.tv_nsec = tswapal(host_its->it_value.tv_nsec);
4700
4701     unlock_user_struct(target_itspec, target_addr, 0);
4702     return 0;
4703 }
4704
4705 #if defined(TARGET_NR_stat64) || defined(TARGET_NR_newfstatat)
4706 static inline abi_long host_to_target_stat64(void *cpu_env,
4707                                              abi_ulong target_addr,
4708                                              struct stat *host_st)
4709 {
4710 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
4711     if (((CPUARMState *)cpu_env)->eabi) {
4712         struct target_eabi_stat64 *target_st;
4713
4714         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
4715             return -TARGET_EFAULT;
4716         memset(target_st, 0, sizeof(struct target_eabi_stat64));
4717         __put_user(host_st->st_dev, &target_st->st_dev);
4718         __put_user(host_st->st_ino, &target_st->st_ino);
4719 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
4720         __put_user(host_st->st_ino, &target_st->__st_ino);
4721 #endif
4722         __put_user(host_st->st_mode, &target_st->st_mode);
4723         __put_user(host_st->st_nlink, &target_st->st_nlink);
4724         __put_user(host_st->st_uid, &target_st->st_uid);
4725         __put_user(host_st->st_gid, &target_st->st_gid);
4726         __put_user(host_st->st_rdev, &target_st->st_rdev);
4727         __put_user(host_st->st_size, &target_st->st_size);
4728         __put_user(host_st->st_blksize, &target_st->st_blksize);
4729         __put_user(host_st->st_blocks, &target_st->st_blocks);
4730         __put_user(host_st->st_atime, &target_st->target_st_atime);
4731         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
4732         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
4733         unlock_user_struct(target_st, target_addr, 1);
4734     } else
4735 #endif
4736     {
4737 #if defined(TARGET_HAS_STRUCT_STAT64)
4738         struct target_stat64 *target_st;
4739 #else
4740         struct target_stat *target_st;
4741 #endif
4742
4743         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
4744             return -TARGET_EFAULT;
4745         memset(target_st, 0, sizeof(*target_st));
4746         __put_user(host_st->st_dev, &target_st->st_dev);
4747         __put_user(host_st->st_ino, &target_st->st_ino);
4748 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
4749         __put_user(host_st->st_ino, &target_st->__st_ino);
4750 #endif
4751         __put_user(host_st->st_mode, &target_st->st_mode);
4752         __put_user(host_st->st_nlink, &target_st->st_nlink);
4753         __put_user(host_st->st_uid, &target_st->st_uid);
4754         __put_user(host_st->st_gid, &target_st->st_gid);
4755         __put_user(host_st->st_rdev, &target_st->st_rdev);
4756         /* XXX: better use of kernel struct */
4757         __put_user(host_st->st_size, &target_st->st_size);
4758         __put_user(host_st->st_blksize, &target_st->st_blksize);
4759         __put_user(host_st->st_blocks, &target_st->st_blocks);
4760         __put_user(host_st->st_atime, &target_st->target_st_atime);
4761         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
4762         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
4763         unlock_user_struct(target_st, target_addr, 1);
4764     }
4765
4766     return 0;
4767 }
4768 #endif
4769
4770 /* ??? Using host futex calls even when target atomic operations
4771    are not really atomic probably breaks things.  However implementing
4772    futexes locally would make futexes shared between multiple processes
4773    tricky.  However they're probably useless because guest atomic
4774    operations won't work either.  */
4775 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
4776                     target_ulong uaddr2, int val3)
4777 {
4778     struct timespec ts, *pts;
4779     int base_op;
4780
4781     /* ??? We assume FUTEX_* constants are the same on both host
4782        and target.  */
4783 #ifdef FUTEX_CMD_MASK
4784     base_op = op & FUTEX_CMD_MASK;
4785 #else
4786     base_op = op;
4787 #endif
4788     switch (base_op) {
4789     case FUTEX_WAIT:
4790     case FUTEX_WAIT_BITSET:
4791         if (timeout) {
4792             pts = &ts;
4793             target_to_host_timespec(pts, timeout);
4794         } else {
4795             pts = NULL;
4796         }
4797         return get_errno(sys_futex(g2h(uaddr), op, tswap32(val),
4798                          pts, NULL, val3));
4799     case FUTEX_WAKE:
4800         return get_errno(sys_futex(g2h(uaddr), op, val, NULL, NULL, 0));
4801     case FUTEX_FD:
4802         return get_errno(sys_futex(g2h(uaddr), op, val, NULL, NULL, 0));
4803     case FUTEX_REQUEUE:
4804     case FUTEX_CMP_REQUEUE:
4805     case FUTEX_WAKE_OP:
4806         /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
4807            TIMEOUT parameter is interpreted as a uint32_t by the kernel.
4808            But the prototype takes a `struct timespec *'; insert casts
4809            to satisfy the compiler.  We do not need to tswap TIMEOUT
4810            since it's not compared to guest memory.  */
4811         pts = (struct timespec *)(uintptr_t) timeout;
4812         return get_errno(sys_futex(g2h(uaddr), op, val, pts,
4813                                    g2h(uaddr2),
4814                                    (base_op == FUTEX_CMP_REQUEUE
4815                                     ? tswap32(val3)
4816                                     : val3)));
4817     default:
4818         return -TARGET_ENOSYS;
4819     }
4820 }
4821
4822 /* Map host to target signal numbers for the wait family of syscalls.
4823    Assume all other status bits are the same.  */
4824 int host_to_target_waitstatus(int status)
4825 {
4826     if (WIFSIGNALED(status)) {
4827         return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
4828     }
4829     if (WIFSTOPPED(status)) {
4830         return (host_to_target_signal(WSTOPSIG(status)) << 8)
4831                | (status & 0xff);
4832     }
4833     return status;
4834 }
4835
4836 static int relstr_to_int(const char *s)
4837 {
4838     /* Convert a uname release string like "2.6.18" to an integer
4839      * of the form 0x020612. (Beware that 0x020612 is *not* 2.6.12.)
4840      */
4841     int i, n, tmp;
4842
4843     tmp = 0;
4844     for (i = 0; i < 3; i++) {
4845         n = 0;
4846         while (*s >= '0' && *s <= '9') {
4847             n *= 10;
4848             n += *s - '0';
4849             s++;
4850         }
4851         tmp = (tmp << 8) + n;
4852         if (*s == '.') {
4853             s++;
4854         }
4855     }
4856     return tmp;
4857 }
4858
4859 int get_osversion(void)
4860 {
4861     static int osversion;
4862     struct new_utsname buf;
4863     const char *s;
4864
4865     if (osversion)
4866         return osversion;
4867     if (qemu_uname_release && *qemu_uname_release) {
4868         s = qemu_uname_release;
4869     } else {
4870         if (sys_uname(&buf))
4871             return 0;
4872         s = buf.release;
4873     }
4874     osversion = relstr_to_int(s);
4875     return osversion;
4876 }
4877
4878 void init_qemu_uname_release(void)
4879 {
4880     /* Initialize qemu_uname_release for later use.
4881      * If the host kernel is too old and the user hasn't asked for
4882      * a specific fake version number, we might want to fake a minimum
4883      * target kernel version.
4884      */
4885 #ifdef UNAME_MINIMUM_RELEASE
4886     struct new_utsname buf;
4887
4888     if (qemu_uname_release && *qemu_uname_release) {
4889         return;
4890     }
4891
4892     if (sys_uname(&buf)) {
4893         return;
4894     }
4895
4896     if (relstr_to_int(buf.release) < relstr_to_int(UNAME_MINIMUM_RELEASE)) {
4897         qemu_uname_release = UNAME_MINIMUM_RELEASE;
4898     }
4899 #endif
4900 }
4901
4902 static int open_self_maps(void *cpu_env, int fd)
4903 {
4904 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
4905     TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
4906 #endif
4907     FILE *fp;
4908     char *line = NULL;
4909     size_t len = 0;
4910     ssize_t read;
4911
4912     fp = fopen("/proc/self/maps", "r");
4913     if (fp == NULL) {
4914         return -EACCES;
4915     }
4916
4917     while ((read = getline(&line, &len, fp)) != -1) {
4918         int fields, dev_maj, dev_min, inode;
4919         uint64_t min, max, offset;
4920         char flag_r, flag_w, flag_x, flag_p;
4921         char path[512] = "";
4922         fields = sscanf(line, "%"PRIx64"-%"PRIx64" %c%c%c%c %"PRIx64" %x:%x %d"
4923                         " %512s", &min, &max, &flag_r, &flag_w, &flag_x,
4924                         &flag_p, &offset, &dev_maj, &dev_min, &inode, path);
4925
4926         if ((fields < 10) || (fields > 11)) {
4927             continue;
4928         }
4929         if (!strncmp(path, "[stack]", 7)) {
4930             continue;
4931         }
4932         if (h2g_valid(min) && h2g_valid(max)) {
4933             dprintf(fd, TARGET_ABI_FMT_lx "-" TARGET_ABI_FMT_lx
4934                     " %c%c%c%c %08" PRIx64 " %02x:%02x %d %s%s\n",
4935                     h2g(min), h2g(max), flag_r, flag_w,
4936                     flag_x, flag_p, offset, dev_maj, dev_min, inode,
4937                     path[0] ? "         " : "", path);
4938         }
4939     }
4940
4941     free(line);
4942     fclose(fp);
4943
4944 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
4945     dprintf(fd, "%08llx-%08llx rw-p %08llx 00:00 0          [stack]\n",
4946                 (unsigned long long)ts->info->stack_limit,
4947                 (unsigned long long)(ts->info->start_stack +
4948                                      (TARGET_PAGE_SIZE - 1)) & TARGET_PAGE_MASK,
4949                 (unsigned long long)0);
4950 #endif
4951
4952     return 0;
4953 }
4954
4955 static int open_self_stat(void *cpu_env, int fd)
4956 {
4957     TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
4958     abi_ulong start_stack = ts->info->start_stack;
4959     int i;
4960
4961     for (i = 0; i < 44; i++) {
4962       char buf[128];
4963       int len;
4964       uint64_t val = 0;
4965
4966       if (i == 0) {
4967         /* pid */
4968         val = getpid();
4969         snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
4970       } else if (i == 1) {
4971         /* app name */
4972         snprintf(buf, sizeof(buf), "(%s) ", ts->bprm->argv[0]);
4973       } else if (i == 27) {
4974         /* stack bottom */
4975         val = start_stack;
4976         snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
4977       } else {
4978         /* for the rest, there is MasterCard */
4979         snprintf(buf, sizeof(buf), "0%c", i == 43 ? '\n' : ' ');
4980       }
4981
4982       len = strlen(buf);
4983       if (write(fd, buf, len) != len) {
4984           return -1;
4985       }
4986     }
4987
4988     return 0;
4989 }
4990
4991 static int open_self_auxv(void *cpu_env, int fd)
4992 {
4993     TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
4994     abi_ulong auxv = ts->info->saved_auxv;
4995     abi_ulong len = ts->info->auxv_len;
4996     char *ptr;
4997
4998     /*
4999      * Auxiliary vector is stored in target process stack.
5000      * read in whole auxv vector and copy it to file
5001      */
5002     ptr = lock_user(VERIFY_READ, auxv, len, 0);
5003     if (ptr != NULL) {
5004         while (len > 0) {
5005             ssize_t r;
5006             r = write(fd, ptr, len);
5007             if (r <= 0) {
5008                 break;
5009             }
5010             len -= r;
5011             ptr += r;
5012         }
5013         lseek(fd, 0, SEEK_SET);
5014         unlock_user(ptr, auxv, len);
5015     }
5016
5017     return 0;
5018 }
5019
5020 static int is_proc_myself(const char *filename, const char *entry)
5021 {
5022     if (!strncmp(filename, "/proc/", strlen("/proc/"))) {
5023         filename += strlen("/proc/");
5024         if (!strncmp(filename, "self/", strlen("self/"))) {
5025             filename += strlen("self/");
5026         } else if (*filename >= '1' && *filename <= '9') {
5027             char myself[80];
5028             snprintf(myself, sizeof(myself), "%d/", getpid());
5029             if (!strncmp(filename, myself, strlen(myself))) {
5030                 filename += strlen(myself);
5031             } else {
5032                 return 0;
5033             }
5034         } else {
5035             return 0;
5036         }
5037         if (!strcmp(filename, entry)) {
5038             return 1;
5039         }
5040     }
5041     return 0;
5042 }
5043
5044 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
5045 static int is_proc(const char *filename, const char *entry)
5046 {
5047     return strcmp(filename, entry) == 0;
5048 }
5049
5050 static int open_net_route(void *cpu_env, int fd)
5051 {
5052     FILE *fp;
5053     char *line = NULL;
5054     size_t len = 0;
5055     ssize_t read;
5056
5057     fp = fopen("/proc/net/route", "r");
5058     if (fp == NULL) {
5059         return -EACCES;
5060     }
5061
5062     /* read header */
5063
5064     read = getline(&line, &len, fp);
5065     dprintf(fd, "%s", line);
5066
5067     /* read routes */
5068
5069     while ((read = getline(&line, &len, fp)) != -1) {
5070         char iface[16];
5071         uint32_t dest, gw, mask;
5072         unsigned int flags, refcnt, use, metric, mtu, window, irtt;
5073         sscanf(line, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
5074                      iface, &dest, &gw, &flags, &refcnt, &use, &metric,
5075                      &mask, &mtu, &window, &irtt);
5076         dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
5077                 iface, tswap32(dest), tswap32(gw), flags, refcnt, use,
5078                 metric, tswap32(mask), mtu, window, irtt);
5079     }
5080
5081     free(line);
5082     fclose(fp);
5083
5084     return 0;
5085 }
5086 #endif
5087
5088 static int do_open(void *cpu_env, const char *pathname, int flags, mode_t mode)
5089 {
5090     struct fake_open {
5091         const char *filename;
5092         int (*fill)(void *cpu_env, int fd);
5093         int (*cmp)(const char *s1, const char *s2);
5094     };
5095     const struct fake_open *fake_open;
5096     static const struct fake_open fakes[] = {
5097         { "maps", open_self_maps, is_proc_myself },
5098         { "stat", open_self_stat, is_proc_myself },
5099         { "auxv", open_self_auxv, is_proc_myself },
5100 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
5101         { "/proc/net/route", open_net_route, is_proc },
5102 #endif
5103         { NULL, NULL, NULL }
5104     };
5105
5106     for (fake_open = fakes; fake_open->filename; fake_open++) {
5107         if (fake_open->cmp(pathname, fake_open->filename)) {
5108             break;
5109         }
5110     }
5111
5112     if (fake_open->filename) {
5113         const char *tmpdir;
5114         char filename[PATH_MAX];
5115         int fd, r;
5116
5117         /* create temporary file to map stat to */
5118         tmpdir = getenv("TMPDIR");
5119         if (!tmpdir)
5120             tmpdir = "/tmp";
5121         snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir);
5122         fd = mkstemp(filename);
5123         if (fd < 0) {
5124             return fd;
5125         }
5126         unlink(filename);
5127
5128         if ((r = fake_open->fill(cpu_env, fd))) {
5129             close(fd);
5130             return r;
5131         }
5132         lseek(fd, 0, SEEK_SET);
5133
5134         return fd;
5135     }
5136
5137     return get_errno(open(path(pathname), flags, mode));
5138 }
5139
5140 /* do_syscall() should always have a single exit point at the end so
5141    that actions, such as logging of syscall results, can be performed.
5142    All errnos that do_syscall() returns must be -TARGET_<errcode>. */
5143 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
5144                     abi_long arg2, abi_long arg3, abi_long arg4,
5145                     abi_long arg5, abi_long arg6, abi_long arg7,
5146                     abi_long arg8)
5147 {
5148     CPUState *cpu = ENV_GET_CPU(cpu_env);
5149     abi_long ret;
5150     struct stat st;
5151     struct statfs stfs;
5152     void *p;
5153
5154 #ifdef DEBUG
5155     gemu_log("syscall %d", num);
5156 #endif
5157     if(do_strace)
5158         print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
5159
5160     switch(num) {
5161     case TARGET_NR_exit:
5162         /* In old applications this may be used to implement _exit(2).
5163            However in threaded applictions it is used for thread termination,
5164            and _exit_group is used for application termination.
5165            Do thread termination if we have more then one thread.  */
5166         /* FIXME: This probably breaks if a signal arrives.  We should probably
5167            be disabling signals.  */
5168         if (CPU_NEXT(first_cpu)) {
5169             TaskState *ts;
5170
5171             cpu_list_lock();
5172             /* Remove the CPU from the list.  */
5173             QTAILQ_REMOVE(&cpus, cpu, node);
5174             cpu_list_unlock();
5175             ts = ((CPUArchState *)cpu_env)->opaque;
5176             if (ts->child_tidptr) {
5177                 put_user_u32(0, ts->child_tidptr);
5178                 sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
5179                           NULL, NULL, 0);
5180             }
5181             thread_cpu = NULL;
5182             object_unref(OBJECT(ENV_GET_CPU(cpu_env)));
5183             g_free(ts);
5184             pthread_exit(NULL);
5185         }
5186 #ifdef TARGET_GPROF
5187         _mcleanup();
5188 #endif
5189         gdb_exit(cpu_env, arg1);
5190         _exit(arg1);
5191         ret = 0; /* avoid warning */
5192         break;
5193     case TARGET_NR_read:
5194         if (arg3 == 0)
5195             ret = 0;
5196         else {
5197             if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5198                 goto efault;
5199             ret = get_errno(read(arg1, p, arg3));
5200             unlock_user(p, arg2, ret);
5201         }
5202         break;
5203     case TARGET_NR_write:
5204         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5205             goto efault;
5206         ret = get_errno(write(arg1, p, arg3));
5207         unlock_user(p, arg2, 0);
5208         break;
5209     case TARGET_NR_open:
5210         if (!(p = lock_user_string(arg1)))
5211             goto efault;
5212         ret = get_errno(do_open(cpu_env, p,
5213                                 target_to_host_bitmask(arg2, fcntl_flags_tbl),
5214                                 arg3));
5215         unlock_user(p, arg1, 0);
5216         break;
5217 #if defined(TARGET_NR_openat) && defined(__NR_openat)
5218     case TARGET_NR_openat:
5219         if (!(p = lock_user_string(arg2)))
5220             goto efault;
5221         ret = get_errno(sys_openat(arg1,
5222                                    path(p),
5223                                    target_to_host_bitmask(arg3, fcntl_flags_tbl),
5224                                    arg4));
5225         unlock_user(p, arg2, 0);
5226         break;
5227 #endif
5228     case TARGET_NR_close:
5229         ret = get_errno(close(arg1));
5230         break;
5231     case TARGET_NR_brk:
5232         ret = do_brk(arg1);
5233         break;
5234     case TARGET_NR_fork:
5235         ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
5236         break;
5237 #ifdef TARGET_NR_waitpid
5238     case TARGET_NR_waitpid:
5239         {
5240             int status;
5241             ret = get_errno(waitpid(arg1, &status, arg3));
5242             if (!is_error(ret) && arg2 && ret
5243                 && put_user_s32(host_to_target_waitstatus(status), arg2))
5244                 goto efault;
5245         }
5246         break;
5247 #endif
5248 #ifdef TARGET_NR_waitid
5249     case TARGET_NR_waitid:
5250         {
5251             siginfo_t info;
5252             info.si_pid = 0;
5253             ret = get_errno(waitid(arg1, arg2, &info, arg4));
5254             if (!is_error(ret) && arg3 && info.si_pid != 0) {
5255                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
5256                     goto efault;
5257                 host_to_target_siginfo(p, &info);
5258                 unlock_user(p, arg3, sizeof(target_siginfo_t));
5259             }
5260         }
5261         break;
5262 #endif
5263 #ifdef TARGET_NR_creat /* not on alpha */
5264     case TARGET_NR_creat:
5265         if (!(p = lock_user_string(arg1)))
5266             goto efault;
5267         ret = get_errno(creat(p, arg2));
5268         unlock_user(p, arg1, 0);
5269         break;
5270 #endif
5271     case TARGET_NR_link:
5272         {
5273             void * p2;
5274             p = lock_user_string(arg1);
5275             p2 = lock_user_string(arg2);
5276             if (!p || !p2)
5277                 ret = -TARGET_EFAULT;
5278             else
5279                 ret = get_errno(link(p, p2));
5280             unlock_user(p2, arg2, 0);
5281             unlock_user(p, arg1, 0);
5282         }
5283         break;
5284 #if defined(TARGET_NR_linkat)
5285     case TARGET_NR_linkat:
5286         {
5287             void * p2 = NULL;
5288             if (!arg2 || !arg4)
5289                 goto efault;
5290             p  = lock_user_string(arg2);
5291             p2 = lock_user_string(arg4);
5292             if (!p || !p2)
5293                 ret = -TARGET_EFAULT;
5294             else
5295                 ret = get_errno(linkat(arg1, p, arg3, p2, arg5));
5296             unlock_user(p, arg2, 0);
5297             unlock_user(p2, arg4, 0);
5298         }
5299         break;
5300 #endif
5301     case TARGET_NR_unlink:
5302         if (!(p = lock_user_string(arg1)))
5303             goto efault;
5304         ret = get_errno(unlink(p));
5305         unlock_user(p, arg1, 0);
5306         break;
5307 #if defined(TARGET_NR_unlinkat)
5308     case TARGET_NR_unlinkat:
5309         if (!(p = lock_user_string(arg2)))
5310             goto efault;
5311         ret = get_errno(unlinkat(arg1, p, arg3));
5312         unlock_user(p, arg2, 0);
5313         break;
5314 #endif
5315     case TARGET_NR_execve:
5316         {
5317             char **argp, **envp;
5318             int argc, envc;
5319             abi_ulong gp;
5320             abi_ulong guest_argp;
5321             abi_ulong guest_envp;
5322             abi_ulong addr;
5323             char **q;
5324             int total_size = 0;
5325
5326             argc = 0;
5327             guest_argp = arg2;
5328             for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
5329                 if (get_user_ual(addr, gp))
5330                     goto efault;
5331                 if (!addr)
5332                     break;
5333                 argc++;
5334             }
5335             envc = 0;
5336             guest_envp = arg3;
5337             for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
5338                 if (get_user_ual(addr, gp))
5339                     goto efault;
5340                 if (!addr)
5341                     break;
5342                 envc++;
5343             }
5344
5345             argp = alloca((argc + 1) * sizeof(void *));
5346             envp = alloca((envc + 1) * sizeof(void *));
5347
5348             for (gp = guest_argp, q = argp; gp;
5349                   gp += sizeof(abi_ulong), q++) {
5350                 if (get_user_ual(addr, gp))
5351                     goto execve_efault;
5352                 if (!addr)
5353                     break;
5354                 if (!(*q = lock_user_string(addr)))
5355                     goto execve_efault;
5356                 total_size += strlen(*q) + 1;
5357             }
5358             *q = NULL;
5359
5360             for (gp = guest_envp, q = envp; gp;
5361                   gp += sizeof(abi_ulong), q++) {
5362                 if (get_user_ual(addr, gp))
5363                     goto execve_efault;
5364                 if (!addr)
5365                     break;
5366                 if (!(*q = lock_user_string(addr)))
5367                     goto execve_efault;
5368                 total_size += strlen(*q) + 1;
5369             }
5370             *q = NULL;
5371
5372             /* This case will not be caught by the host's execve() if its
5373                page size is bigger than the target's. */
5374             if (total_size > MAX_ARG_PAGES * TARGET_PAGE_SIZE) {
5375                 ret = -TARGET_E2BIG;
5376                 goto execve_end;
5377             }
5378             if (!(p = lock_user_string(arg1)))
5379                 goto execve_efault;
5380             ret = get_errno(execve(p, argp, envp));
5381             unlock_user(p, arg1, 0);
5382
5383             goto execve_end;
5384
5385         execve_efault:
5386             ret = -TARGET_EFAULT;
5387
5388         execve_end:
5389             for (gp = guest_argp, q = argp; *q;
5390                   gp += sizeof(abi_ulong), q++) {
5391                 if (get_user_ual(addr, gp)
5392                     || !addr)
5393                     break;
5394                 unlock_user(*q, addr, 0);
5395             }
5396             for (gp = guest_envp, q = envp; *q;
5397                   gp += sizeof(abi_ulong), q++) {
5398                 if (get_user_ual(addr, gp)
5399                     || !addr)
5400                     break;
5401                 unlock_user(*q, addr, 0);
5402             }
5403         }
5404         break;
5405     case TARGET_NR_chdir:
5406         if (!(p = lock_user_string(arg1)))
5407             goto efault;
5408         ret = get_errno(chdir(p));
5409         unlock_user(p, arg1, 0);
5410         break;
5411 #ifdef TARGET_NR_time
5412     case TARGET_NR_time:
5413         {
5414             time_t host_time;
5415             ret = get_errno(time(&host_time));
5416             if (!is_error(ret)
5417                 && arg1
5418                 && put_user_sal(host_time, arg1))
5419                 goto efault;
5420         }
5421         break;
5422 #endif
5423     case TARGET_NR_mknod:
5424         if (!(p = lock_user_string(arg1)))
5425             goto efault;
5426         ret = get_errno(mknod(p, arg2, arg3));
5427         unlock_user(p, arg1, 0);
5428         break;
5429 #if defined(TARGET_NR_mknodat)
5430     case TARGET_NR_mknodat:
5431         if (!(p = lock_user_string(arg2)))
5432             goto efault;
5433         ret = get_errno(mknodat(arg1, p, arg3, arg4));
5434         unlock_user(p, arg2, 0);
5435         break;
5436 #endif
5437     case TARGET_NR_chmod:
5438         if (!(p = lock_user_string(arg1)))
5439             goto efault;
5440         ret = get_errno(chmod(p, arg2));
5441         unlock_user(p, arg1, 0);
5442         break;
5443 #ifdef TARGET_NR_break
5444     case TARGET_NR_break:
5445         goto unimplemented;
5446 #endif
5447 #ifdef TARGET_NR_oldstat
5448     case TARGET_NR_oldstat:
5449         goto unimplemented;
5450 #endif
5451     case TARGET_NR_lseek:
5452         ret = get_errno(lseek(arg1, arg2, arg3));
5453         break;
5454 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
5455     /* Alpha specific */
5456     case TARGET_NR_getxpid:
5457         ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
5458         ret = get_errno(getpid());
5459         break;
5460 #endif
5461 #ifdef TARGET_NR_getpid
5462     case TARGET_NR_getpid:
5463         ret = get_errno(getpid());
5464         break;
5465 #endif
5466     case TARGET_NR_mount:
5467                 {
5468                         /* need to look at the data field */
5469                         void *p2, *p3;
5470                         p = lock_user_string(arg1);
5471                         p2 = lock_user_string(arg2);
5472                         p3 = lock_user_string(arg3);
5473                         if (!p || !p2 || !p3)
5474                             ret = -TARGET_EFAULT;
5475                         else {
5476                             /* FIXME - arg5 should be locked, but it isn't clear how to
5477                              * do that since it's not guaranteed to be a NULL-terminated
5478                              * string.
5479                              */
5480                             if ( ! arg5 )
5481                                 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, NULL));
5482                             else
5483                                 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
5484                         }
5485                         unlock_user(p, arg1, 0);
5486                         unlock_user(p2, arg2, 0);
5487                         unlock_user(p3, arg3, 0);
5488                         break;
5489                 }
5490 #ifdef TARGET_NR_umount
5491     case TARGET_NR_umount:
5492         if (!(p = lock_user_string(arg1)))
5493             goto efault;
5494         ret = get_errno(umount(p));
5495         unlock_user(p, arg1, 0);
5496         break;
5497 #endif
5498 #ifdef TARGET_NR_stime /* not on alpha */
5499     case TARGET_NR_stime:
5500         {
5501             time_t host_time;
5502             if (get_user_sal(host_time, arg1))
5503                 goto efault;
5504             ret = get_errno(stime(&host_time));
5505         }
5506         break;
5507 #endif
5508     case TARGET_NR_ptrace:
5509         goto unimplemented;
5510 #ifdef TARGET_NR_alarm /* not on alpha */
5511     case TARGET_NR_alarm:
5512         ret = alarm(arg1);
5513         break;
5514 #endif
5515 #ifdef TARGET_NR_oldfstat
5516     case TARGET_NR_oldfstat:
5517         goto unimplemented;
5518 #endif
5519 #ifdef TARGET_NR_pause /* not on alpha */
5520     case TARGET_NR_pause:
5521         ret = get_errno(pause());
5522         break;
5523 #endif
5524 #ifdef TARGET_NR_utime
5525     case TARGET_NR_utime:
5526         {
5527             struct utimbuf tbuf, *host_tbuf;
5528             struct target_utimbuf *target_tbuf;
5529             if (arg2) {
5530                 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
5531                     goto efault;
5532                 tbuf.actime = tswapal(target_tbuf->actime);
5533                 tbuf.modtime = tswapal(target_tbuf->modtime);
5534                 unlock_user_struct(target_tbuf, arg2, 0);
5535                 host_tbuf = &tbuf;
5536             } else {
5537                 host_tbuf = NULL;
5538             }
5539             if (!(p = lock_user_string(arg1)))
5540                 goto efault;
5541             ret = get_errno(utime(p, host_tbuf));
5542             unlock_user(p, arg1, 0);
5543         }
5544         break;
5545 #endif
5546     case TARGET_NR_utimes:
5547         {
5548             struct timeval *tvp, tv[2];
5549             if (arg2) {
5550                 if (copy_from_user_timeval(&tv[0], arg2)
5551                     || copy_from_user_timeval(&tv[1],
5552                                               arg2 + sizeof(struct target_timeval)))
5553                     goto efault;
5554                 tvp = tv;
5555             } else {
5556                 tvp = NULL;
5557             }
5558             if (!(p = lock_user_string(arg1)))
5559                 goto efault;
5560             ret = get_errno(utimes(p, tvp));
5561             unlock_user(p, arg1, 0);
5562         }
5563         break;
5564 #if defined(TARGET_NR_futimesat)
5565     case TARGET_NR_futimesat:
5566         {
5567             struct timeval *tvp, tv[2];
5568             if (arg3) {
5569                 if (copy_from_user_timeval(&tv[0], arg3)
5570                     || copy_from_user_timeval(&tv[1],
5571                                               arg3 + sizeof(struct target_timeval)))
5572                     goto efault;
5573                 tvp = tv;
5574             } else {
5575                 tvp = NULL;
5576             }
5577             if (!(p = lock_user_string(arg2)))
5578                 goto efault;
5579             ret = get_errno(futimesat(arg1, path(p), tvp));
5580             unlock_user(p, arg2, 0);
5581         }
5582         break;
5583 #endif
5584 #ifdef TARGET_NR_stty
5585     case TARGET_NR_stty:
5586         goto unimplemented;
5587 #endif
5588 #ifdef TARGET_NR_gtty
5589     case TARGET_NR_gtty:
5590         goto unimplemented;
5591 #endif
5592     case TARGET_NR_access:
5593         if (!(p = lock_user_string(arg1)))
5594             goto efault;
5595         ret = get_errno(access(path(p), arg2));
5596         unlock_user(p, arg1, 0);
5597         break;
5598 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
5599     case TARGET_NR_faccessat:
5600         if (!(p = lock_user_string(arg2)))
5601             goto efault;
5602         ret = get_errno(faccessat(arg1, p, arg3, 0));
5603         unlock_user(p, arg2, 0);
5604         break;
5605 #endif
5606 #ifdef TARGET_NR_nice /* not on alpha */
5607     case TARGET_NR_nice:
5608         ret = get_errno(nice(arg1));
5609         break;
5610 #endif
5611 #ifdef TARGET_NR_ftime
5612     case TARGET_NR_ftime:
5613         goto unimplemented;
5614 #endif
5615     case TARGET_NR_sync:
5616         sync();
5617         ret = 0;
5618         break;
5619     case TARGET_NR_kill:
5620         ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
5621         break;
5622     case TARGET_NR_rename:
5623         {
5624             void *p2;
5625             p = lock_user_string(arg1);
5626             p2 = lock_user_string(arg2);
5627             if (!p || !p2)
5628                 ret = -TARGET_EFAULT;
5629             else
5630                 ret = get_errno(rename(p, p2));
5631             unlock_user(p2, arg2, 0);
5632             unlock_user(p, arg1, 0);
5633         }
5634         break;
5635 #if defined(TARGET_NR_renameat)
5636     case TARGET_NR_renameat:
5637         {
5638             void *p2;
5639             p  = lock_user_string(arg2);
5640             p2 = lock_user_string(arg4);
5641             if (!p || !p2)
5642                 ret = -TARGET_EFAULT;
5643             else
5644                 ret = get_errno(renameat(arg1, p, arg3, p2));
5645             unlock_user(p2, arg4, 0);
5646             unlock_user(p, arg2, 0);
5647         }
5648         break;
5649 #endif
5650     case TARGET_NR_mkdir:
5651         if (!(p = lock_user_string(arg1)))
5652             goto efault;
5653         ret = get_errno(mkdir(p, arg2));
5654         unlock_user(p, arg1, 0);
5655         break;
5656 #if defined(TARGET_NR_mkdirat)
5657     case TARGET_NR_mkdirat:
5658         if (!(p = lock_user_string(arg2)))
5659             goto efault;
5660         ret = get_errno(mkdirat(arg1, p, arg3));
5661         unlock_user(p, arg2, 0);
5662         break;
5663 #endif
5664     case TARGET_NR_rmdir:
5665         if (!(p = lock_user_string(arg1)))
5666             goto efault;
5667         ret = get_errno(rmdir(p));
5668         unlock_user(p, arg1, 0);
5669         break;
5670     case TARGET_NR_dup:
5671         ret = get_errno(dup(arg1));
5672         break;
5673     case TARGET_NR_pipe:
5674         ret = do_pipe(cpu_env, arg1, 0, 0);
5675         break;
5676 #ifdef TARGET_NR_pipe2
5677     case TARGET_NR_pipe2:
5678         ret = do_pipe(cpu_env, arg1,
5679                       target_to_host_bitmask(arg2, fcntl_flags_tbl), 1);
5680         break;
5681 #endif
5682     case TARGET_NR_times:
5683         {
5684             struct target_tms *tmsp;
5685             struct tms tms;
5686             ret = get_errno(times(&tms));
5687             if (arg1) {
5688                 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
5689                 if (!tmsp)
5690                     goto efault;
5691                 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime));
5692                 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime));
5693                 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime));
5694                 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime));
5695             }
5696             if (!is_error(ret))
5697                 ret = host_to_target_clock_t(ret);
5698         }
5699         break;
5700 #ifdef TARGET_NR_prof
5701     case TARGET_NR_prof:
5702         goto unimplemented;
5703 #endif
5704 #ifdef TARGET_NR_signal
5705     case TARGET_NR_signal:
5706         goto unimplemented;
5707 #endif
5708     case TARGET_NR_acct:
5709         if (arg1 == 0) {
5710             ret = get_errno(acct(NULL));
5711         } else {
5712             if (!(p = lock_user_string(arg1)))
5713                 goto efault;
5714             ret = get_errno(acct(path(p)));
5715             unlock_user(p, arg1, 0);
5716         }
5717         break;
5718 #ifdef TARGET_NR_umount2
5719     case TARGET_NR_umount2:
5720         if (!(p = lock_user_string(arg1)))
5721             goto efault;
5722         ret = get_errno(umount2(p, arg2));
5723         unlock_user(p, arg1, 0);
5724         break;
5725 #endif
5726 #ifdef TARGET_NR_lock
5727     case TARGET_NR_lock:
5728         goto unimplemented;
5729 #endif
5730     case TARGET_NR_ioctl:
5731         ret = do_ioctl(arg1, arg2, arg3);
5732         break;
5733     case TARGET_NR_fcntl:
5734         ret = do_fcntl(arg1, arg2, arg3);
5735         break;
5736 #ifdef TARGET_NR_mpx
5737     case TARGET_NR_mpx:
5738         goto unimplemented;
5739 #endif
5740     case TARGET_NR_setpgid:
5741         ret = get_errno(setpgid(arg1, arg2));
5742         break;
5743 #ifdef TARGET_NR_ulimit
5744     case TARGET_NR_ulimit:
5745         goto unimplemented;
5746 #endif
5747 #ifdef TARGET_NR_oldolduname
5748     case TARGET_NR_oldolduname:
5749         goto unimplemented;
5750 #endif
5751     case TARGET_NR_umask:
5752         ret = get_errno(umask(arg1));
5753         break;
5754     case TARGET_NR_chroot:
5755         if (!(p = lock_user_string(arg1)))
5756             goto efault;
5757         ret = get_errno(chroot(p));
5758         unlock_user(p, arg1, 0);
5759         break;
5760     case TARGET_NR_ustat:
5761         goto unimplemented;
5762     case TARGET_NR_dup2:
5763         ret = get_errno(dup2(arg1, arg2));
5764         break;
5765 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
5766     case TARGET_NR_dup3:
5767         ret = get_errno(dup3(arg1, arg2, arg3));
5768         break;
5769 #endif
5770 #ifdef TARGET_NR_getppid /* not on alpha */
5771     case TARGET_NR_getppid:
5772         ret = get_errno(getppid());
5773         break;
5774 #endif
5775     case TARGET_NR_getpgrp:
5776         ret = get_errno(getpgrp());
5777         break;
5778     case TARGET_NR_setsid:
5779         ret = get_errno(setsid());
5780         break;
5781 #ifdef TARGET_NR_sigaction
5782     case TARGET_NR_sigaction:
5783         {
5784 #if defined(TARGET_ALPHA)
5785             struct target_sigaction act, oact, *pact = 0;
5786             struct target_old_sigaction *old_act;
5787             if (arg2) {
5788                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5789                     goto efault;
5790                 act._sa_handler = old_act->_sa_handler;
5791                 target_siginitset(&act.sa_mask, old_act->sa_mask);
5792                 act.sa_flags = old_act->sa_flags;
5793                 act.sa_restorer = 0;
5794                 unlock_user_struct(old_act, arg2, 0);
5795                 pact = &act;
5796             }
5797             ret = get_errno(do_sigaction(arg1, pact, &oact));
5798             if (!is_error(ret) && arg3) {
5799                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5800                     goto efault;
5801                 old_act->_sa_handler = oact._sa_handler;
5802                 old_act->sa_mask = oact.sa_mask.sig[0];
5803                 old_act->sa_flags = oact.sa_flags;
5804                 unlock_user_struct(old_act, arg3, 1);
5805             }
5806 #elif defined(TARGET_MIPS)
5807             struct target_sigaction act, oact, *pact, *old_act;
5808
5809             if (arg2) {
5810                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5811                     goto efault;
5812                 act._sa_handler = old_act->_sa_handler;
5813                 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
5814                 act.sa_flags = old_act->sa_flags;
5815                 unlock_user_struct(old_act, arg2, 0);
5816                 pact = &act;
5817             } else {
5818                 pact = NULL;
5819             }
5820
5821             ret = get_errno(do_sigaction(arg1, pact, &oact));
5822
5823             if (!is_error(ret) && arg3) {
5824                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5825                     goto efault;
5826                 old_act->_sa_handler = oact._sa_handler;
5827                 old_act->sa_flags = oact.sa_flags;
5828                 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
5829                 old_act->sa_mask.sig[1] = 0;
5830                 old_act->sa_mask.sig[2] = 0;
5831                 old_act->sa_mask.sig[3] = 0;
5832                 unlock_user_struct(old_act, arg3, 1);
5833             }
5834 #else
5835             struct target_old_sigaction *old_act;
5836             struct target_sigaction act, oact, *pact;
5837             if (arg2) {
5838                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5839                     goto efault;
5840                 act._sa_handler = old_act->_sa_handler;
5841                 target_siginitset(&act.sa_mask, old_act->sa_mask);
5842                 act.sa_flags = old_act->sa_flags;
5843                 act.sa_restorer = old_act->sa_restorer;
5844                 unlock_user_struct(old_act, arg2, 0);
5845                 pact = &act;
5846             } else {
5847                 pact = NULL;
5848             }
5849             ret = get_errno(do_sigaction(arg1, pact, &oact));
5850             if (!is_error(ret) && arg3) {
5851                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5852                     goto efault;
5853                 old_act->_sa_handler = oact._sa_handler;
5854                 old_act->sa_mask = oact.sa_mask.sig[0];
5855                 old_act->sa_flags = oact.sa_flags;
5856                 old_act->sa_restorer = oact.sa_restorer;
5857                 unlock_user_struct(old_act, arg3, 1);
5858             }
5859 #endif
5860         }
5861         break;
5862 #endif
5863     case TARGET_NR_rt_sigaction:
5864         {
5865 #if defined(TARGET_ALPHA)
5866             struct target_sigaction act, oact, *pact = 0;
5867             struct target_rt_sigaction *rt_act;
5868             /* ??? arg4 == sizeof(sigset_t).  */
5869             if (arg2) {
5870                 if (!lock_user_struct(VERIFY_READ, rt_act, arg2, 1))
5871                     goto efault;
5872                 act._sa_handler = rt_act->_sa_handler;
5873                 act.sa_mask = rt_act->sa_mask;
5874                 act.sa_flags = rt_act->sa_flags;
5875                 act.sa_restorer = arg5;
5876                 unlock_user_struct(rt_act, arg2, 0);
5877                 pact = &act;
5878             }
5879             ret = get_errno(do_sigaction(arg1, pact, &oact));
5880             if (!is_error(ret) && arg3) {
5881                 if (!lock_user_struct(VERIFY_WRITE, rt_act, arg3, 0))
5882                     goto efault;
5883                 rt_act->_sa_handler = oact._sa_handler;
5884                 rt_act->sa_mask = oact.sa_mask;
5885                 rt_act->sa_flags = oact.sa_flags;
5886                 unlock_user_struct(rt_act, arg3, 1);
5887             }
5888 #else
5889             struct target_sigaction *act;
5890             struct target_sigaction *oact;
5891
5892             if (arg2) {
5893                 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
5894                     goto efault;
5895             } else
5896                 act = NULL;
5897             if (arg3) {
5898                 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
5899                     ret = -TARGET_EFAULT;
5900                     goto rt_sigaction_fail;
5901                 }
5902             } else
5903                 oact = NULL;
5904             ret = get_errno(do_sigaction(arg1, act, oact));
5905         rt_sigaction_fail:
5906             if (act)
5907                 unlock_user_struct(act, arg2, 0);
5908             if (oact)
5909                 unlock_user_struct(oact, arg3, 1);
5910 #endif
5911         }
5912         break;
5913 #ifdef TARGET_NR_sgetmask /* not on alpha */
5914     case TARGET_NR_sgetmask:
5915         {
5916             sigset_t cur_set;
5917             abi_ulong target_set;
5918             sigprocmask(0, NULL, &cur_set);
5919             host_to_target_old_sigset(&target_set, &cur_set);
5920             ret = target_set;
5921         }
5922         break;
5923 #endif
5924 #ifdef TARGET_NR_ssetmask /* not on alpha */
5925     case TARGET_NR_ssetmask:
5926         {
5927             sigset_t set, oset, cur_set;
5928             abi_ulong target_set = arg1;
5929             sigprocmask(0, NULL, &cur_set);
5930             target_to_host_old_sigset(&set, &target_set);
5931             sigorset(&set, &set, &cur_set);
5932             sigprocmask(SIG_SETMASK, &set, &oset);
5933             host_to_target_old_sigset(&target_set, &oset);
5934             ret = target_set;
5935         }
5936         break;
5937 #endif
5938 #ifdef TARGET_NR_sigprocmask
5939     case TARGET_NR_sigprocmask:
5940         {
5941 #if defined(TARGET_ALPHA)
5942             sigset_t set, oldset;
5943             abi_ulong mask;
5944             int how;
5945
5946             switch (arg1) {
5947             case TARGET_SIG_BLOCK:
5948                 how = SIG_BLOCK;
5949                 break;
5950             case TARGET_SIG_UNBLOCK:
5951                 how = SIG_UNBLOCK;
5952                 break;
5953             case TARGET_SIG_SETMASK:
5954                 how = SIG_SETMASK;
5955                 break;
5956             default:
5957                 ret = -TARGET_EINVAL;
5958                 goto fail;
5959             }
5960             mask = arg2;
5961             target_to_host_old_sigset(&set, &mask);
5962
5963             ret = get_errno(sigprocmask(how, &set, &oldset));
5964             if (!is_error(ret)) {
5965                 host_to_target_old_sigset(&mask, &oldset);
5966                 ret = mask;
5967                 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */
5968             }
5969 #else
5970             sigset_t set, oldset, *set_ptr;
5971             int how;
5972
5973             if (arg2) {
5974                 switch (arg1) {
5975                 case TARGET_SIG_BLOCK:
5976                     how = SIG_BLOCK;
5977                     break;
5978                 case TARGET_SIG_UNBLOCK:
5979                     how = SIG_UNBLOCK;
5980                     break;
5981                 case TARGET_SIG_SETMASK:
5982                     how = SIG_SETMASK;
5983                     break;
5984                 default:
5985                     ret = -TARGET_EINVAL;
5986                     goto fail;
5987                 }
5988                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
5989                     goto efault;
5990                 target_to_host_old_sigset(&set, p);
5991                 unlock_user(p, arg2, 0);
5992                 set_ptr = &set;
5993             } else {
5994                 how = 0;
5995                 set_ptr = NULL;
5996             }
5997             ret = get_errno(sigprocmask(how, set_ptr, &oldset));
5998             if (!is_error(ret) && arg3) {
5999                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
6000                     goto efault;
6001                 host_to_target_old_sigset(p, &oldset);
6002                 unlock_user(p, arg3, sizeof(target_sigset_t));
6003             }
6004 #endif
6005         }
6006         break;
6007 #endif
6008     case TARGET_NR_rt_sigprocmask:
6009         {
6010             int how = arg1;
6011             sigset_t set, oldset, *set_ptr;
6012
6013             if (arg2) {
6014                 switch(how) {
6015                 case TARGET_SIG_BLOCK:
6016                     how = SIG_BLOCK;
6017                     break;
6018                 case TARGET_SIG_UNBLOCK:
6019                     how = SIG_UNBLOCK;
6020                     break;
6021                 case TARGET_SIG_SETMASK:
6022                     how = SIG_SETMASK;
6023                     break;
6024                 default:
6025                     ret = -TARGET_EINVAL;
6026                     goto fail;
6027                 }
6028                 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
6029                     goto efault;
6030                 target_to_host_sigset(&set, p);
6031                 unlock_user(p, arg2, 0);
6032                 set_ptr = &set;
6033             } else {
6034                 how = 0;
6035                 set_ptr = NULL;
6036             }
6037             ret = get_errno(sigprocmask(how, set_ptr, &oldset));
6038             if (!is_error(ret) && arg3) {
6039                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
6040                     goto efault;
6041                 host_to_target_sigset(p, &oldset);
6042                 unlock_user(p, arg3, sizeof(target_sigset_t));
6043             }
6044         }
6045         break;
6046 #ifdef TARGET_NR_sigpending
6047     case TARGET_NR_sigpending:
6048         {
6049             sigset_t set;
6050             ret = get_errno(sigpending(&set));
6051             if (!is_error(ret)) {
6052                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
6053                     goto efault;
6054                 host_to_target_old_sigset(p, &set);
6055                 unlock_user(p, arg1, sizeof(target_sigset_t));
6056             }
6057         }
6058         break;
6059 #endif
6060     case TARGET_NR_rt_sigpending:
6061         {
6062             sigset_t set;
6063             ret = get_errno(sigpending(&set));
6064             if (!is_error(ret)) {
6065                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
6066                     goto efault;
6067                 host_to_target_sigset(p, &set);
6068                 unlock_user(p, arg1, sizeof(target_sigset_t));
6069             }
6070         }
6071         break;
6072 #ifdef TARGET_NR_sigsuspend
6073     case TARGET_NR_sigsuspend:
6074         {
6075             sigset_t set;
6076 #if defined(TARGET_ALPHA)
6077             abi_ulong mask = arg1;
6078             target_to_host_old_sigset(&set, &mask);
6079 #else
6080             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
6081                 goto efault;
6082             target_to_host_old_sigset(&set, p);
6083             unlock_user(p, arg1, 0);
6084 #endif
6085             ret = get_errno(sigsuspend(&set));
6086         }
6087         break;
6088 #endif
6089     case TARGET_NR_rt_sigsuspend:
6090         {
6091             sigset_t set;
6092             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
6093                 goto efault;
6094             target_to_host_sigset(&set, p);
6095             unlock_user(p, arg1, 0);
6096             ret = get_errno(sigsuspend(&set));
6097         }
6098         break;
6099     case TARGET_NR_rt_sigtimedwait:
6100         {
6101             sigset_t set;
6102             struct timespec uts, *puts;
6103             siginfo_t uinfo;
6104
6105             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
6106                 goto efault;
6107             target_to_host_sigset(&set, p);
6108             unlock_user(p, arg1, 0);
6109             if (arg3) {
6110                 puts = &uts;
6111                 target_to_host_timespec(puts, arg3);
6112             } else {
6113                 puts = NULL;
6114             }
6115             ret = get_errno(sigtimedwait(&set, &uinfo, puts));
6116             if (!is_error(ret) && arg2) {
6117                 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
6118                     goto efault;
6119                 host_to_target_siginfo(p, &uinfo);
6120                 unlock_user(p, arg2, sizeof(target_siginfo_t));
6121             }
6122         }
6123         break;
6124     case TARGET_NR_rt_sigqueueinfo:
6125         {
6126             siginfo_t uinfo;
6127             if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
6128                 goto efault;
6129             target_to_host_siginfo(&uinfo, p);
6130             unlock_user(p, arg1, 0);
6131             ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
6132         }
6133         break;
6134 #ifdef TARGET_NR_sigreturn
6135     case TARGET_NR_sigreturn:
6136         /* NOTE: ret is eax, so not transcoding must be done */
6137         ret = do_sigreturn(cpu_env);
6138         break;
6139 #endif
6140     case TARGET_NR_rt_sigreturn:
6141         /* NOTE: ret is eax, so not transcoding must be done */
6142         ret = do_rt_sigreturn(cpu_env);
6143         break;
6144     case TARGET_NR_sethostname:
6145         if (!(p = lock_user_string(arg1)))
6146             goto efault;
6147         ret = get_errno(sethostname(p, arg2));
6148         unlock_user(p, arg1, 0);
6149         break;
6150     case TARGET_NR_setrlimit:
6151         {
6152             int resource = target_to_host_resource(arg1);
6153             struct target_rlimit *target_rlim;
6154             struct rlimit rlim;
6155             if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
6156                 goto efault;
6157             rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
6158             rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
6159             unlock_user_struct(target_rlim, arg2, 0);
6160             ret = get_errno(setrlimit(resource, &rlim));
6161         }
6162         break;
6163     case TARGET_NR_getrlimit:
6164         {
6165             int resource = target_to_host_resource(arg1);
6166             struct target_rlimit *target_rlim;
6167             struct rlimit rlim;
6168
6169             ret = get_errno(getrlimit(resource, &rlim));
6170             if (!is_error(ret)) {
6171                 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
6172                     goto efault;
6173                 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
6174                 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
6175                 unlock_user_struct(target_rlim, arg2, 1);
6176             }
6177         }
6178         break;
6179     case TARGET_NR_getrusage:
6180         {
6181             struct rusage rusage;
6182             ret = get_errno(getrusage(arg1, &rusage));
6183             if (!is_error(ret)) {
6184                 host_to_target_rusage(arg2, &rusage);
6185             }
6186         }
6187         break;
6188     case TARGET_NR_gettimeofday:
6189         {
6190             struct timeval tv;
6191             ret = get_errno(gettimeofday(&tv, NULL));
6192             if (!is_error(ret)) {
6193                 if (copy_to_user_timeval(arg1, &tv))
6194                     goto efault;
6195             }
6196         }
6197         break;
6198     case TARGET_NR_settimeofday:
6199         {
6200             struct timeval tv;
6201             if (copy_from_user_timeval(&tv, arg1))
6202                 goto efault;
6203             ret = get_errno(settimeofday(&tv, NULL));
6204         }
6205         break;
6206 #if defined(TARGET_NR_select)
6207     case TARGET_NR_select:
6208 #if defined(TARGET_S390X) || defined(TARGET_ALPHA)
6209         ret = do_select(arg1, arg2, arg3, arg4, arg5);
6210 #else
6211         {
6212             struct target_sel_arg_struct *sel;
6213             abi_ulong inp, outp, exp, tvp;
6214             long nsel;
6215
6216             if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
6217                 goto efault;
6218             nsel = tswapal(sel->n);
6219             inp = tswapal(sel->inp);
6220             outp = tswapal(sel->outp);
6221             exp = tswapal(sel->exp);
6222             tvp = tswapal(sel->tvp);
6223             unlock_user_struct(sel, arg1, 0);
6224             ret = do_select(nsel, inp, outp, exp, tvp);
6225         }
6226 #endif
6227         break;
6228 #endif
6229 #ifdef TARGET_NR_pselect6
6230     case TARGET_NR_pselect6:
6231         {
6232             abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
6233             fd_set rfds, wfds, efds;
6234             fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
6235             struct timespec ts, *ts_ptr;
6236
6237             /*
6238              * The 6th arg is actually two args smashed together,
6239              * so we cannot use the C library.
6240              */
6241             sigset_t set;
6242             struct {
6243                 sigset_t *set;
6244                 size_t size;
6245             } sig, *sig_ptr;
6246
6247             abi_ulong arg_sigset, arg_sigsize, *arg7;
6248             target_sigset_t *target_sigset;
6249
6250             n = arg1;
6251             rfd_addr = arg2;
6252             wfd_addr = arg3;
6253             efd_addr = arg4;
6254             ts_addr = arg5;
6255
6256             ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
6257             if (ret) {
6258                 goto fail;
6259             }
6260             ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
6261             if (ret) {
6262                 goto fail;
6263             }
6264             ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
6265             if (ret) {
6266                 goto fail;
6267             }
6268
6269             /*
6270              * This takes a timespec, and not a timeval, so we cannot
6271              * use the do_select() helper ...
6272              */
6273             if (ts_addr) {
6274                 if (target_to_host_timespec(&ts, ts_addr)) {
6275                     goto efault;
6276                 }
6277                 ts_ptr = &ts;
6278             } else {
6279                 ts_ptr = NULL;
6280             }
6281
6282             /* Extract the two packed args for the sigset */
6283             if (arg6) {
6284                 sig_ptr = &sig;
6285                 sig.size = _NSIG / 8;
6286
6287                 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
6288                 if (!arg7) {
6289                     goto efault;
6290                 }
6291                 arg_sigset = tswapal(arg7[0]);
6292                 arg_sigsize = tswapal(arg7[1]);
6293                 unlock_user(arg7, arg6, 0);
6294
6295                 if (arg_sigset) {
6296                     sig.set = &set;
6297                     if (arg_sigsize != sizeof(*target_sigset)) {
6298                         /* Like the kernel, we enforce correct size sigsets */
6299                         ret = -TARGET_EINVAL;
6300                         goto fail;
6301                     }
6302                     target_sigset = lock_user(VERIFY_READ, arg_sigset,
6303                                               sizeof(*target_sigset), 1);
6304                     if (!target_sigset) {
6305                         goto efault;
6306                     }
6307                     target_to_host_sigset(&set, target_sigset);
6308                     unlock_user(target_sigset, arg_sigset, 0);
6309                 } else {
6310                     sig.set = NULL;
6311                 }
6312             } else {
6313                 sig_ptr = NULL;
6314             }
6315
6316             ret = get_errno(sys_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
6317                                          ts_ptr, sig_ptr));
6318
6319             if (!is_error(ret)) {
6320                 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
6321                     goto efault;
6322                 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
6323                     goto efault;
6324                 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
6325                     goto efault;
6326
6327                 if (ts_addr && host_to_target_timespec(ts_addr, &ts))
6328                     goto efault;
6329             }
6330         }
6331         break;
6332 #endif
6333     case TARGET_NR_symlink:
6334         {
6335             void *p2;
6336             p = lock_user_string(arg1);
6337             p2 = lock_user_string(arg2);
6338             if (!p || !p2)
6339                 ret = -TARGET_EFAULT;
6340             else
6341                 ret = get_errno(symlink(p, p2));
6342             unlock_user(p2, arg2, 0);
6343             unlock_user(p, arg1, 0);
6344         }
6345         break;
6346 #if defined(TARGET_NR_symlinkat)
6347     case TARGET_NR_symlinkat:
6348         {
6349             void *p2;
6350             p  = lock_user_string(arg1);
6351             p2 = lock_user_string(arg3);
6352             if (!p || !p2)
6353                 ret = -TARGET_EFAULT;
6354             else
6355                 ret = get_errno(symlinkat(p, arg2, p2));
6356             unlock_user(p2, arg3, 0);
6357             unlock_user(p, arg1, 0);
6358         }
6359         break;
6360 #endif
6361 #ifdef TARGET_NR_oldlstat
6362     case TARGET_NR_oldlstat:
6363         goto unimplemented;
6364 #endif
6365     case TARGET_NR_readlink:
6366         {
6367             void *p2;
6368             p = lock_user_string(arg1);
6369             p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
6370             if (!p || !p2) {
6371                 ret = -TARGET_EFAULT;
6372             } else if (is_proc_myself((const char *)p, "exe")) {
6373                 char real[PATH_MAX], *temp;
6374                 temp = realpath(exec_path, real);
6375                 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
6376                 snprintf((char *)p2, arg3, "%s", real);
6377             } else {
6378                 ret = get_errno(readlink(path(p), p2, arg3));
6379             }
6380             unlock_user(p2, arg2, ret);
6381             unlock_user(p, arg1, 0);
6382         }
6383         break;
6384 #if defined(TARGET_NR_readlinkat)
6385     case TARGET_NR_readlinkat:
6386         {
6387             void *p2;
6388             p  = lock_user_string(arg2);
6389             p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
6390             if (!p || !p2) {
6391                 ret = -TARGET_EFAULT;
6392             } else if (is_proc_myself((const char *)p, "exe")) {
6393                 char real[PATH_MAX], *temp;
6394                 temp = realpath(exec_path, real);
6395                 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
6396                 snprintf((char *)p2, arg4, "%s", real);
6397             } else {
6398                 ret = get_errno(readlinkat(arg1, path(p), p2, arg4));
6399             }
6400             unlock_user(p2, arg3, ret);
6401             unlock_user(p, arg2, 0);
6402         }
6403         break;
6404 #endif
6405 #ifdef TARGET_NR_uselib
6406     case TARGET_NR_uselib:
6407         goto unimplemented;
6408 #endif
6409 #ifdef TARGET_NR_swapon
6410     case TARGET_NR_swapon:
6411         if (!(p = lock_user_string(arg1)))
6412             goto efault;
6413         ret = get_errno(swapon(p, arg2));
6414         unlock_user(p, arg1, 0);
6415         break;
6416 #endif
6417     case TARGET_NR_reboot:
6418         if (arg3 == LINUX_REBOOT_CMD_RESTART2) {
6419            /* arg4 must be ignored in all other cases */
6420            p = lock_user_string(arg4);
6421            if (!p) {
6422               goto efault;
6423            }
6424            ret = get_errno(reboot(arg1, arg2, arg3, p));
6425            unlock_user(p, arg4, 0);
6426         } else {
6427            ret = get_errno(reboot(arg1, arg2, arg3, NULL));
6428         }
6429         break;
6430 #ifdef TARGET_NR_readdir
6431     case TARGET_NR_readdir:
6432         goto unimplemented;
6433 #endif
6434 #ifdef TARGET_NR_mmap
6435     case TARGET_NR_mmap:
6436 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6437     (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
6438     defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
6439     || defined(TARGET_S390X)
6440         {
6441             abi_ulong *v;
6442             abi_ulong v1, v2, v3, v4, v5, v6;
6443             if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
6444                 goto efault;
6445             v1 = tswapal(v[0]);
6446             v2 = tswapal(v[1]);
6447             v3 = tswapal(v[2]);
6448             v4 = tswapal(v[3]);
6449             v5 = tswapal(v[4]);
6450             v6 = tswapal(v[5]);
6451             unlock_user(v, arg1, 0);
6452             ret = get_errno(target_mmap(v1, v2, v3,
6453                                         target_to_host_bitmask(v4, mmap_flags_tbl),
6454                                         v5, v6));
6455         }
6456 #else
6457         ret = get_errno(target_mmap(arg1, arg2, arg3,
6458                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
6459                                     arg5,
6460                                     arg6));
6461 #endif
6462         break;
6463 #endif
6464 #ifdef TARGET_NR_mmap2
6465     case TARGET_NR_mmap2:
6466 #ifndef MMAP_SHIFT
6467 #define MMAP_SHIFT 12
6468 #endif
6469         ret = get_errno(target_mmap(arg1, arg2, arg3,
6470                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
6471                                     arg5,
6472                                     arg6 << MMAP_SHIFT));
6473         break;
6474 #endif
6475     case TARGET_NR_munmap:
6476         ret = get_errno(target_munmap(arg1, arg2));
6477         break;
6478     case TARGET_NR_mprotect:
6479         {
6480             TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
6481             /* Special hack to detect libc making the stack executable.  */
6482             if ((arg3 & PROT_GROWSDOWN)
6483                 && arg1 >= ts->info->stack_limit
6484                 && arg1 <= ts->info->start_stack) {
6485                 arg3 &= ~PROT_GROWSDOWN;
6486                 arg2 = arg2 + arg1 - ts->info->stack_limit;
6487                 arg1 = ts->info->stack_limit;
6488             }
6489         }
6490         ret = get_errno(target_mprotect(arg1, arg2, arg3));
6491         break;
6492 #ifdef TARGET_NR_mremap
6493     case TARGET_NR_mremap:
6494         ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
6495         break;
6496 #endif
6497         /* ??? msync/mlock/munlock are broken for softmmu.  */
6498 #ifdef TARGET_NR_msync
6499     case TARGET_NR_msync:
6500         ret = get_errno(msync(g2h(arg1), arg2, arg3));
6501         break;
6502 #endif
6503 #ifdef TARGET_NR_mlock
6504     case TARGET_NR_mlock:
6505         ret = get_errno(mlock(g2h(arg1), arg2));
6506         break;
6507 #endif
6508 #ifdef TARGET_NR_munlock
6509     case TARGET_NR_munlock:
6510         ret = get_errno(munlock(g2h(arg1), arg2));
6511         break;
6512 #endif
6513 #ifdef TARGET_NR_mlockall
6514     case TARGET_NR_mlockall:
6515         ret = get_errno(mlockall(arg1));
6516         break;
6517 #endif
6518 #ifdef TARGET_NR_munlockall
6519     case TARGET_NR_munlockall:
6520         ret = get_errno(munlockall());
6521         break;
6522 #endif
6523     case TARGET_NR_truncate:
6524         if (!(p = lock_user_string(arg1)))
6525             goto efault;
6526         ret = get_errno(truncate(p, arg2));
6527         unlock_user(p, arg1, 0);
6528         break;
6529     case TARGET_NR_ftruncate:
6530         ret = get_errno(ftruncate(arg1, arg2));
6531         break;
6532     case TARGET_NR_fchmod:
6533         ret = get_errno(fchmod(arg1, arg2));
6534         break;
6535 #if defined(TARGET_NR_fchmodat)
6536     case TARGET_NR_fchmodat:
6537         if (!(p = lock_user_string(arg2)))
6538             goto efault;
6539         ret = get_errno(fchmodat(arg1, p, arg3, 0));
6540         unlock_user(p, arg2, 0);
6541         break;
6542 #endif
6543     case TARGET_NR_getpriority:
6544         /* Note that negative values are valid for getpriority, so we must
6545            differentiate based on errno settings.  */
6546         errno = 0;
6547         ret = getpriority(arg1, arg2);
6548         if (ret == -1 && errno != 0) {
6549             ret = -host_to_target_errno(errno);
6550             break;
6551         }
6552 #ifdef TARGET_ALPHA
6553         /* Return value is the unbiased priority.  Signal no error.  */
6554         ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0;
6555 #else
6556         /* Return value is a biased priority to avoid negative numbers.  */
6557         ret = 20 - ret;
6558 #endif
6559         break;
6560     case TARGET_NR_setpriority:
6561         ret = get_errno(setpriority(arg1, arg2, arg3));
6562         break;
6563 #ifdef TARGET_NR_profil
6564     case TARGET_NR_profil:
6565         goto unimplemented;
6566 #endif
6567     case TARGET_NR_statfs:
6568         if (!(p = lock_user_string(arg1)))
6569             goto efault;
6570         ret = get_errno(statfs(path(p), &stfs));
6571         unlock_user(p, arg1, 0);
6572     convert_statfs:
6573         if (!is_error(ret)) {
6574             struct target_statfs *target_stfs;
6575
6576             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
6577                 goto efault;
6578             __put_user(stfs.f_type, &target_stfs->f_type);
6579             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
6580             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
6581             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
6582             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
6583             __put_user(stfs.f_files, &target_stfs->f_files);
6584             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
6585             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
6586             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
6587             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
6588             __put_user(stfs.f_frsize, &target_stfs->f_frsize);
6589             memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
6590             unlock_user_struct(target_stfs, arg2, 1);
6591         }
6592         break;
6593     case TARGET_NR_fstatfs:
6594         ret = get_errno(fstatfs(arg1, &stfs));
6595         goto convert_statfs;
6596 #ifdef TARGET_NR_statfs64
6597     case TARGET_NR_statfs64:
6598         if (!(p = lock_user_string(arg1)))
6599             goto efault;
6600         ret = get_errno(statfs(path(p), &stfs));
6601         unlock_user(p, arg1, 0);
6602     convert_statfs64:
6603         if (!is_error(ret)) {
6604             struct target_statfs64 *target_stfs;
6605
6606             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
6607                 goto efault;
6608             __put_user(stfs.f_type, &target_stfs->f_type);
6609             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
6610             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
6611             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
6612             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
6613             __put_user(stfs.f_files, &target_stfs->f_files);
6614             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
6615             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
6616             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
6617             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
6618             __put_user(stfs.f_frsize, &target_stfs->f_frsize);
6619             memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
6620             unlock_user_struct(target_stfs, arg3, 1);
6621         }
6622         break;
6623     case TARGET_NR_fstatfs64:
6624         ret = get_errno(fstatfs(arg1, &stfs));
6625         goto convert_statfs64;
6626 #endif
6627 #ifdef TARGET_NR_ioperm
6628     case TARGET_NR_ioperm:
6629         goto unimplemented;
6630 #endif
6631 #ifdef TARGET_NR_socketcall
6632     case TARGET_NR_socketcall:
6633         ret = do_socketcall(arg1, arg2);
6634         break;
6635 #endif
6636 #ifdef TARGET_NR_accept
6637     case TARGET_NR_accept:
6638         ret = do_accept4(arg1, arg2, arg3, 0);
6639         break;
6640 #endif
6641 #ifdef TARGET_NR_accept4
6642     case TARGET_NR_accept4:
6643 #ifdef CONFIG_ACCEPT4
6644         ret = do_accept4(arg1, arg2, arg3, arg4);
6645 #else
6646         goto unimplemented;
6647 #endif
6648         break;
6649 #endif
6650 #ifdef TARGET_NR_bind
6651     case TARGET_NR_bind:
6652         ret = do_bind(arg1, arg2, arg3);
6653         break;
6654 #endif
6655 #ifdef TARGET_NR_connect
6656     case TARGET_NR_connect:
6657         ret = do_connect(arg1, arg2, arg3);
6658         break;
6659 #endif
6660 #ifdef TARGET_NR_getpeername
6661     case TARGET_NR_getpeername:
6662         ret = do_getpeername(arg1, arg2, arg3);
6663         break;
6664 #endif
6665 #ifdef TARGET_NR_getsockname
6666     case TARGET_NR_getsockname:
6667         ret = do_getsockname(arg1, arg2, arg3);
6668         break;
6669 #endif
6670 #ifdef TARGET_NR_getsockopt
6671     case TARGET_NR_getsockopt:
6672         ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
6673         break;
6674 #endif
6675 #ifdef TARGET_NR_listen
6676     case TARGET_NR_listen:
6677         ret = get_errno(listen(arg1, arg2));
6678         break;
6679 #endif
6680 #ifdef TARGET_NR_recv
6681     case TARGET_NR_recv:
6682         ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
6683         break;
6684 #endif
6685 #ifdef TARGET_NR_recvfrom
6686     case TARGET_NR_recvfrom:
6687         ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
6688         break;
6689 #endif
6690 #ifdef TARGET_NR_recvmsg
6691     case TARGET_NR_recvmsg:
6692         ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
6693         break;
6694 #endif
6695 #ifdef TARGET_NR_send
6696     case TARGET_NR_send:
6697         ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
6698         break;
6699 #endif
6700 #ifdef TARGET_NR_sendmsg
6701     case TARGET_NR_sendmsg:
6702         ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
6703         break;
6704 #endif
6705 #ifdef TARGET_NR_sendto
6706     case TARGET_NR_sendto:
6707         ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
6708         break;
6709 #endif
6710 #ifdef TARGET_NR_shutdown
6711     case TARGET_NR_shutdown:
6712         ret = get_errno(shutdown(arg1, arg2));
6713         break;
6714 #endif
6715 #ifdef TARGET_NR_socket
6716     case TARGET_NR_socket:
6717         ret = do_socket(arg1, arg2, arg3);
6718         break;
6719 #endif
6720 #ifdef TARGET_NR_socketpair
6721     case TARGET_NR_socketpair:
6722         ret = do_socketpair(arg1, arg2, arg3, arg4);
6723         break;
6724 #endif
6725 #ifdef TARGET_NR_setsockopt
6726     case TARGET_NR_setsockopt:
6727         ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
6728         break;
6729 #endif
6730
6731     case TARGET_NR_syslog:
6732         if (!(p = lock_user_string(arg2)))
6733             goto efault;
6734         ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
6735         unlock_user(p, arg2, 0);
6736         break;
6737
6738     case TARGET_NR_setitimer:
6739         {
6740             struct itimerval value, ovalue, *pvalue;
6741
6742             if (arg2) {
6743                 pvalue = &value;
6744                 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
6745                     || copy_from_user_timeval(&pvalue->it_value,
6746                                               arg2 + sizeof(struct target_timeval)))
6747                     goto efault;
6748             } else {
6749                 pvalue = NULL;
6750             }
6751             ret = get_errno(setitimer(arg1, pvalue, &ovalue));
6752             if (!is_error(ret) && arg3) {
6753                 if (copy_to_user_timeval(arg3,
6754                                          &ovalue.it_interval)
6755                     || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
6756                                             &ovalue.it_value))
6757                     goto efault;
6758             }
6759         }
6760         break;
6761     case TARGET_NR_getitimer:
6762         {
6763             struct itimerval value;
6764
6765             ret = get_errno(getitimer(arg1, &value));
6766             if (!is_error(ret) && arg2) {
6767                 if (copy_to_user_timeval(arg2,
6768                                          &value.it_interval)
6769                     || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
6770                                             &value.it_value))
6771                     goto efault;
6772             }
6773         }
6774         break;
6775     case TARGET_NR_stat:
6776         if (!(p = lock_user_string(arg1)))
6777             goto efault;
6778         ret = get_errno(stat(path(p), &st));
6779         unlock_user(p, arg1, 0);
6780         goto do_stat;
6781     case TARGET_NR_lstat:
6782         if (!(p = lock_user_string(arg1)))
6783             goto efault;
6784         ret = get_errno(lstat(path(p), &st));
6785         unlock_user(p, arg1, 0);
6786         goto do_stat;
6787     case TARGET_NR_fstat:
6788         {
6789             ret = get_errno(fstat(arg1, &st));
6790         do_stat:
6791             if (!is_error(ret)) {
6792                 struct target_stat *target_st;
6793
6794                 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
6795                     goto efault;
6796                 memset(target_st, 0, sizeof(*target_st));
6797                 __put_user(st.st_dev, &target_st->st_dev);
6798                 __put_user(st.st_ino, &target_st->st_ino);
6799                 __put_user(st.st_mode, &target_st->st_mode);
6800                 __put_user(st.st_uid, &target_st->st_uid);
6801                 __put_user(st.st_gid, &target_st->st_gid);
6802                 __put_user(st.st_nlink, &target_st->st_nlink);
6803                 __put_user(st.st_rdev, &target_st->st_rdev);
6804                 __put_user(st.st_size, &target_st->st_size);
6805                 __put_user(st.st_blksize, &target_st->st_blksize);
6806                 __put_user(st.st_blocks, &target_st->st_blocks);
6807                 __put_user(st.st_atime, &target_st->target_st_atime);
6808                 __put_user(st.st_mtime, &target_st->target_st_mtime);
6809                 __put_user(st.st_ctime, &target_st->target_st_ctime);
6810                 unlock_user_struct(target_st, arg2, 1);
6811             }
6812         }
6813         break;
6814 #ifdef TARGET_NR_olduname
6815     case TARGET_NR_olduname:
6816         goto unimplemented;
6817 #endif
6818 #ifdef TARGET_NR_iopl
6819     case TARGET_NR_iopl:
6820         goto unimplemented;
6821 #endif
6822     case TARGET_NR_vhangup:
6823         ret = get_errno(vhangup());
6824         break;
6825 #ifdef TARGET_NR_idle
6826     case TARGET_NR_idle:
6827         goto unimplemented;
6828 #endif
6829 #ifdef TARGET_NR_syscall
6830     case TARGET_NR_syscall:
6831         ret = do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5,
6832                          arg6, arg7, arg8, 0);
6833         break;
6834 #endif
6835     case TARGET_NR_wait4:
6836         {
6837             int status;
6838             abi_long status_ptr = arg2;
6839             struct rusage rusage, *rusage_ptr;
6840             abi_ulong target_rusage = arg4;
6841             if (target_rusage)
6842                 rusage_ptr = &rusage;
6843             else
6844                 rusage_ptr = NULL;
6845             ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
6846             if (!is_error(ret)) {
6847                 if (status_ptr && ret) {
6848                     status = host_to_target_waitstatus(status);
6849                     if (put_user_s32(status, status_ptr))
6850                         goto efault;
6851                 }
6852                 if (target_rusage)
6853                     host_to_target_rusage(target_rusage, &rusage);
6854             }
6855         }
6856         break;
6857 #ifdef TARGET_NR_swapoff
6858     case TARGET_NR_swapoff:
6859         if (!(p = lock_user_string(arg1)))
6860             goto efault;
6861         ret = get_errno(swapoff(p));
6862         unlock_user(p, arg1, 0);
6863         break;
6864 #endif
6865     case TARGET_NR_sysinfo:
6866         {
6867             struct target_sysinfo *target_value;
6868             struct sysinfo value;
6869             ret = get_errno(sysinfo(&value));
6870             if (!is_error(ret) && arg1)
6871             {
6872                 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
6873                     goto efault;
6874                 __put_user(value.uptime, &target_value->uptime);
6875                 __put_user(value.loads[0], &target_value->loads[0]);
6876                 __put_user(value.loads[1], &target_value->loads[1]);
6877                 __put_user(value.loads[2], &target_value->loads[2]);
6878                 __put_user(value.totalram, &target_value->totalram);
6879                 __put_user(value.freeram, &target_value->freeram);
6880                 __put_user(value.sharedram, &target_value->sharedram);
6881                 __put_user(value.bufferram, &target_value->bufferram);
6882                 __put_user(value.totalswap, &target_value->totalswap);
6883                 __put_user(value.freeswap, &target_value->freeswap);
6884                 __put_user(value.procs, &target_value->procs);
6885                 __put_user(value.totalhigh, &target_value->totalhigh);
6886                 __put_user(value.freehigh, &target_value->freehigh);
6887                 __put_user(value.mem_unit, &target_value->mem_unit);
6888                 unlock_user_struct(target_value, arg1, 1);
6889             }
6890         }
6891         break;
6892 #ifdef TARGET_NR_ipc
6893     case TARGET_NR_ipc:
6894         ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
6895         break;
6896 #endif
6897 #ifdef TARGET_NR_semget
6898     case TARGET_NR_semget:
6899         ret = get_errno(semget(arg1, arg2, arg3));
6900         break;
6901 #endif
6902 #ifdef TARGET_NR_semop
6903     case TARGET_NR_semop:
6904         ret = do_semop(arg1, arg2, arg3);
6905         break;
6906 #endif
6907 #ifdef TARGET_NR_semctl
6908     case TARGET_NR_semctl:
6909         ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);
6910         break;
6911 #endif
6912 #ifdef TARGET_NR_msgctl
6913     case TARGET_NR_msgctl:
6914         ret = do_msgctl(arg1, arg2, arg3);
6915         break;
6916 #endif
6917 #ifdef TARGET_NR_msgget
6918     case TARGET_NR_msgget:
6919         ret = get_errno(msgget(arg1, arg2));
6920         break;
6921 #endif
6922 #ifdef TARGET_NR_msgrcv
6923     case TARGET_NR_msgrcv:
6924         ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
6925         break;
6926 #endif
6927 #ifdef TARGET_NR_msgsnd
6928     case TARGET_NR_msgsnd:
6929         ret = do_msgsnd(arg1, arg2, arg3, arg4);
6930         break;
6931 #endif
6932 #ifdef TARGET_NR_shmget
6933     case TARGET_NR_shmget:
6934         ret = get_errno(shmget(arg1, arg2, arg3));
6935         break;
6936 #endif
6937 #ifdef TARGET_NR_shmctl
6938     case TARGET_NR_shmctl:
6939         ret = do_shmctl(arg1, arg2, arg3);
6940         break;
6941 #endif
6942 #ifdef TARGET_NR_shmat
6943     case TARGET_NR_shmat:
6944         ret = do_shmat(arg1, arg2, arg3);
6945         break;
6946 #endif
6947 #ifdef TARGET_NR_shmdt
6948     case TARGET_NR_shmdt:
6949         ret = do_shmdt(arg1);
6950         break;
6951 #endif
6952     case TARGET_NR_fsync:
6953         ret = get_errno(fsync(arg1));
6954         break;
6955     case TARGET_NR_clone:
6956         /* Linux manages to have three different orderings for its
6957          * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
6958          * match the kernel's CONFIG_CLONE_* settings.
6959          * Microblaze is further special in that it uses a sixth
6960          * implicit argument to clone for the TLS pointer.
6961          */
6962 #if defined(TARGET_MICROBLAZE)
6963         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5));
6964 #elif defined(TARGET_CLONE_BACKWARDS)
6965         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
6966 #elif defined(TARGET_CLONE_BACKWARDS2)
6967         ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
6968 #else
6969         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
6970 #endif
6971         break;
6972 #ifdef __NR_exit_group
6973         /* new thread calls */
6974     case TARGET_NR_exit_group:
6975 #ifdef TARGET_GPROF
6976         _mcleanup();
6977 #endif
6978         gdb_exit(cpu_env, arg1);
6979         ret = get_errno(exit_group(arg1));
6980         break;
6981 #endif
6982     case TARGET_NR_setdomainname:
6983         if (!(p = lock_user_string(arg1)))
6984             goto efault;
6985         ret = get_errno(setdomainname(p, arg2));
6986         unlock_user(p, arg1, 0);
6987         break;
6988     case TARGET_NR_uname:
6989         /* no need to transcode because we use the linux syscall */
6990         {
6991             struct new_utsname * buf;
6992
6993             if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
6994                 goto efault;
6995             ret = get_errno(sys_uname(buf));
6996             if (!is_error(ret)) {
6997                 /* Overrite the native machine name with whatever is being
6998                    emulated. */
6999                 strcpy (buf->machine, cpu_to_uname_machine(cpu_env));
7000                 /* Allow the user to override the reported release.  */
7001                 if (qemu_uname_release && *qemu_uname_release)
7002                   strcpy (buf->release, qemu_uname_release);
7003             }
7004             unlock_user_struct(buf, arg1, 1);
7005         }
7006         break;
7007 #ifdef TARGET_I386
7008     case TARGET_NR_modify_ldt:
7009         ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
7010         break;
7011 #if !defined(TARGET_X86_64)
7012     case TARGET_NR_vm86old:
7013         goto unimplemented;
7014     case TARGET_NR_vm86:
7015         ret = do_vm86(cpu_env, arg1, arg2);
7016         break;
7017 #endif
7018 #endif
7019     case TARGET_NR_adjtimex:
7020         goto unimplemented;
7021 #ifdef TARGET_NR_create_module
7022     case TARGET_NR_create_module:
7023 #endif
7024     case TARGET_NR_init_module:
7025     case TARGET_NR_delete_module:
7026 #ifdef TARGET_NR_get_kernel_syms
7027     case TARGET_NR_get_kernel_syms:
7028 #endif
7029         goto unimplemented;
7030     case TARGET_NR_quotactl:
7031         goto unimplemented;
7032     case TARGET_NR_getpgid:
7033         ret = get_errno(getpgid(arg1));
7034         break;
7035     case TARGET_NR_fchdir:
7036         ret = get_errno(fchdir(arg1));
7037         break;
7038 #ifdef TARGET_NR_bdflush /* not on x86_64 */
7039     case TARGET_NR_bdflush:
7040         goto unimplemented;
7041 #endif
7042 #ifdef TARGET_NR_sysfs
7043     case TARGET_NR_sysfs:
7044         goto unimplemented;
7045 #endif
7046     case TARGET_NR_personality:
7047         ret = get_errno(personality(arg1));
7048         break;
7049 #ifdef TARGET_NR_afs_syscall
7050     case TARGET_NR_afs_syscall:
7051         goto unimplemented;
7052 #endif
7053 #ifdef TARGET_NR__llseek /* Not on alpha */
7054     case TARGET_NR__llseek:
7055         {
7056             int64_t res;
7057 #if !defined(__NR_llseek)
7058             res = lseek(arg1, ((uint64_t)arg2 << 32) | arg3, arg5);
7059             if (res == -1) {
7060                 ret = get_errno(res);
7061             } else {
7062                 ret = 0;
7063             }
7064 #else
7065             ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
7066 #endif
7067             if ((ret == 0) && put_user_s64(res, arg4)) {
7068                 goto efault;
7069             }
7070         }
7071         break;
7072 #endif
7073     case TARGET_NR_getdents:
7074 #ifdef __NR_getdents
7075 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
7076         {
7077             struct target_dirent *target_dirp;
7078             struct linux_dirent *dirp;
7079             abi_long count = arg3;
7080
7081             dirp = malloc(count);
7082             if (!dirp) {
7083                 ret = -TARGET_ENOMEM;
7084                 goto fail;
7085             }
7086
7087             ret = get_errno(sys_getdents(arg1, dirp, count));
7088             if (!is_error(ret)) {
7089                 struct linux_dirent *de;
7090                 struct target_dirent *tde;
7091                 int len = ret;
7092                 int reclen, treclen;
7093                 int count1, tnamelen;
7094
7095                 count1 = 0;
7096                 de = dirp;
7097                 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
7098                     goto efault;
7099                 tde = target_dirp;
7100                 while (len > 0) {
7101                     reclen = de->d_reclen;
7102                     tnamelen = reclen - offsetof(struct linux_dirent, d_name);
7103                     assert(tnamelen >= 0);
7104                     treclen = tnamelen + offsetof(struct target_dirent, d_name);
7105                     assert(count1 + treclen <= count);
7106                     tde->d_reclen = tswap16(treclen);
7107                     tde->d_ino = tswapal(de->d_ino);
7108                     tde->d_off = tswapal(de->d_off);
7109                     memcpy(tde->d_name, de->d_name, tnamelen);
7110                     de = (struct linux_dirent *)((char *)de + reclen);
7111                     len -= reclen;
7112                     tde = (struct target_dirent *)((char *)tde + treclen);
7113                     count1 += treclen;
7114                 }
7115                 ret = count1;
7116                 unlock_user(target_dirp, arg2, ret);
7117             }
7118             free(dirp);
7119         }
7120 #else
7121         {
7122             struct linux_dirent *dirp;
7123             abi_long count = arg3;
7124
7125             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
7126                 goto efault;
7127             ret = get_errno(sys_getdents(arg1, dirp, count));
7128             if (!is_error(ret)) {
7129                 struct linux_dirent *de;
7130                 int len = ret;
7131                 int reclen;
7132                 de = dirp;
7133                 while (len > 0) {
7134                     reclen = de->d_reclen;
7135                     if (reclen > len)
7136                         break;
7137                     de->d_reclen = tswap16(reclen);
7138                     tswapls(&de->d_ino);
7139                     tswapls(&de->d_off);
7140                     de = (struct linux_dirent *)((char *)de + reclen);
7141                     len -= reclen;
7142                 }
7143             }
7144             unlock_user(dirp, arg2, ret);
7145         }
7146 #endif
7147 #else
7148         /* Implement getdents in terms of getdents64 */
7149         {
7150             struct linux_dirent64 *dirp;
7151             abi_long count = arg3;
7152
7153             dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
7154             if (!dirp) {
7155                 goto efault;
7156             }
7157             ret = get_errno(sys_getdents64(arg1, dirp, count));
7158             if (!is_error(ret)) {
7159                 /* Convert the dirent64 structs to target dirent.  We do this
7160                  * in-place, since we can guarantee that a target_dirent is no
7161                  * larger than a dirent64; however this means we have to be
7162                  * careful to read everything before writing in the new format.
7163                  */
7164                 struct linux_dirent64 *de;
7165                 struct target_dirent *tde;
7166                 int len = ret;
7167                 int tlen = 0;
7168
7169                 de = dirp;
7170                 tde = (struct target_dirent *)dirp;
7171                 while (len > 0) {
7172                     int namelen, treclen;
7173                     int reclen = de->d_reclen;
7174                     uint64_t ino = de->d_ino;
7175                     int64_t off = de->d_off;
7176                     uint8_t type = de->d_type;
7177
7178                     namelen = strlen(de->d_name);
7179                     treclen = offsetof(struct target_dirent, d_name)
7180                         + namelen + 2;
7181                     treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
7182
7183                     memmove(tde->d_name, de->d_name, namelen + 1);
7184                     tde->d_ino = tswapal(ino);
7185                     tde->d_off = tswapal(off);
7186                     tde->d_reclen = tswap16(treclen);
7187                     /* The target_dirent type is in what was formerly a padding
7188                      * byte at the end of the structure:
7189                      */
7190                     *(((char *)tde) + treclen - 1) = type;
7191
7192                     de = (struct linux_dirent64 *)((char *)de + reclen);
7193                     tde = (struct target_dirent *)((char *)tde + treclen);
7194                     len -= reclen;
7195                     tlen += treclen;
7196                 }
7197                 ret = tlen;
7198             }
7199             unlock_user(dirp, arg2, ret);
7200         }
7201 #endif
7202         break;
7203 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
7204     case TARGET_NR_getdents64:
7205         {
7206             struct linux_dirent64 *dirp;
7207             abi_long count = arg3;
7208             if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
7209                 goto efault;
7210             ret = get_errno(sys_getdents64(arg1, dirp, count));
7211             if (!is_error(ret)) {
7212                 struct linux_dirent64 *de;
7213                 int len = ret;
7214                 int reclen;
7215                 de = dirp;
7216                 while (len > 0) {
7217                     reclen = de->d_reclen;
7218                     if (reclen > len)
7219                         break;
7220                     de->d_reclen = tswap16(reclen);
7221                     tswap64s((uint64_t *)&de->d_ino);
7222                     tswap64s((uint64_t *)&de->d_off);
7223                     de = (struct linux_dirent64 *)((char *)de + reclen);
7224                     len -= reclen;
7225                 }
7226             }
7227             unlock_user(dirp, arg2, ret);
7228         }
7229         break;
7230 #endif /* TARGET_NR_getdents64 */
7231 #if defined(TARGET_NR__newselect)
7232     case TARGET_NR__newselect:
7233         ret = do_select(arg1, arg2, arg3, arg4, arg5);
7234         break;
7235 #endif
7236 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
7237 # ifdef TARGET_NR_poll
7238     case TARGET_NR_poll:
7239 # endif
7240 # ifdef TARGET_NR_ppoll
7241     case TARGET_NR_ppoll:
7242 # endif
7243         {
7244             struct target_pollfd *target_pfd;
7245             unsigned int nfds = arg2;
7246             int timeout = arg3;
7247             struct pollfd *pfd;
7248             unsigned int i;
7249
7250             target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
7251             if (!target_pfd)
7252                 goto efault;
7253
7254             pfd = alloca(sizeof(struct pollfd) * nfds);
7255             for(i = 0; i < nfds; i++) {
7256                 pfd[i].fd = tswap32(target_pfd[i].fd);
7257                 pfd[i].events = tswap16(target_pfd[i].events);
7258             }
7259
7260 # ifdef TARGET_NR_ppoll
7261             if (num == TARGET_NR_ppoll) {
7262                 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
7263                 target_sigset_t *target_set;
7264                 sigset_t _set, *set = &_set;
7265
7266                 if (arg3) {
7267                     if (target_to_host_timespec(timeout_ts, arg3)) {
7268                         unlock_user(target_pfd, arg1, 0);
7269                         goto efault;
7270                     }
7271                 } else {
7272                     timeout_ts = NULL;
7273                 }
7274
7275                 if (arg4) {
7276                     target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
7277                     if (!target_set) {
7278                         unlock_user(target_pfd, arg1, 0);
7279                         goto efault;
7280                     }
7281                     target_to_host_sigset(set, target_set);
7282                 } else {
7283                     set = NULL;
7284                 }
7285
7286                 ret = get_errno(sys_ppoll(pfd, nfds, timeout_ts, set, _NSIG/8));
7287
7288                 if (!is_error(ret) && arg3) {
7289                     host_to_target_timespec(arg3, timeout_ts);
7290                 }
7291                 if (arg4) {
7292                     unlock_user(target_set, arg4, 0);
7293                 }
7294             } else
7295 # endif
7296                 ret = get_errno(poll(pfd, nfds, timeout));
7297
7298             if (!is_error(ret)) {
7299                 for(i = 0; i < nfds; i++) {
7300                     target_pfd[i].revents = tswap16(pfd[i].revents);
7301                 }
7302             }
7303             unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
7304         }
7305         break;
7306 #endif
7307     case TARGET_NR_flock:
7308         /* NOTE: the flock constant seems to be the same for every
7309            Linux platform */
7310         ret = get_errno(flock(arg1, arg2));
7311         break;
7312     case TARGET_NR_readv:
7313         {
7314             struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
7315             if (vec != NULL) {
7316                 ret = get_errno(readv(arg1, vec, arg3));
7317                 unlock_iovec(vec, arg2, arg3, 1);
7318             } else {
7319                 ret = -host_to_target_errno(errno);
7320             }
7321         }
7322         break;
7323     case TARGET_NR_writev:
7324         {
7325             struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
7326             if (vec != NULL) {
7327                 ret = get_errno(writev(arg1, vec, arg3));
7328                 unlock_iovec(vec, arg2, arg3, 0);
7329             } else {
7330                 ret = -host_to_target_errno(errno);
7331             }
7332         }
7333         break;
7334     case TARGET_NR_getsid:
7335         ret = get_errno(getsid(arg1));
7336         break;
7337 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
7338     case TARGET_NR_fdatasync:
7339         ret = get_errno(fdatasync(arg1));
7340         break;
7341 #endif
7342     case TARGET_NR__sysctl:
7343         /* We don't implement this, but ENOTDIR is always a safe
7344            return value. */
7345         ret = -TARGET_ENOTDIR;
7346         break;
7347     case TARGET_NR_sched_getaffinity:
7348         {
7349             unsigned int mask_size;
7350             unsigned long *mask;
7351
7352             /*
7353              * sched_getaffinity needs multiples of ulong, so need to take
7354              * care of mismatches between target ulong and host ulong sizes.
7355              */
7356             if (arg2 & (sizeof(abi_ulong) - 1)) {
7357                 ret = -TARGET_EINVAL;
7358                 break;
7359             }
7360             mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
7361
7362             mask = alloca(mask_size);
7363             ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
7364
7365             if (!is_error(ret)) {
7366                 if (copy_to_user(arg3, mask, ret)) {
7367                     goto efault;
7368                 }
7369             }
7370         }
7371         break;
7372     case TARGET_NR_sched_setaffinity:
7373         {
7374             unsigned int mask_size;
7375             unsigned long *mask;
7376
7377             /*
7378              * sched_setaffinity needs multiples of ulong, so need to take
7379              * care of mismatches between target ulong and host ulong sizes.
7380              */
7381             if (arg2 & (sizeof(abi_ulong) - 1)) {
7382                 ret = -TARGET_EINVAL;
7383                 break;
7384             }
7385             mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
7386
7387             mask = alloca(mask_size);
7388             if (!lock_user_struct(VERIFY_READ, p, arg3, 1)) {
7389                 goto efault;
7390             }
7391             memcpy(mask, p, arg2);
7392             unlock_user_struct(p, arg2, 0);
7393
7394             ret = get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
7395         }
7396         break;
7397     case TARGET_NR_sched_setparam:
7398         {
7399             struct sched_param *target_schp;
7400             struct sched_param schp;
7401
7402             if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
7403                 goto efault;
7404             schp.sched_priority = tswap32(target_schp->sched_priority);
7405             unlock_user_struct(target_schp, arg2, 0);
7406             ret = get_errno(sched_setparam(arg1, &schp));
7407         }
7408         break;
7409     case TARGET_NR_sched_getparam:
7410         {
7411             struct sched_param *target_schp;
7412             struct sched_param schp;
7413             ret = get_errno(sched_getparam(arg1, &schp));
7414             if (!is_error(ret)) {
7415                 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
7416                     goto efault;
7417                 target_schp->sched_priority = tswap32(schp.sched_priority);
7418                 unlock_user_struct(target_schp, arg2, 1);
7419             }
7420         }
7421         break;
7422     case TARGET_NR_sched_setscheduler:
7423         {
7424             struct sched_param *target_schp;
7425             struct sched_param schp;
7426             if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
7427                 goto efault;
7428             schp.sched_priority = tswap32(target_schp->sched_priority);
7429             unlock_user_struct(target_schp, arg3, 0);
7430             ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
7431         }
7432         break;
7433     case TARGET_NR_sched_getscheduler:
7434         ret = get_errno(sched_getscheduler(arg1));
7435         break;
7436     case TARGET_NR_sched_yield:
7437         ret = get_errno(sched_yield());
7438         break;
7439     case TARGET_NR_sched_get_priority_max:
7440         ret = get_errno(sched_get_priority_max(arg1));
7441         break;
7442     case TARGET_NR_sched_get_priority_min:
7443         ret = get_errno(sched_get_priority_min(arg1));
7444         break;
7445     case TARGET_NR_sched_rr_get_interval:
7446         {
7447             struct timespec ts;
7448             ret = get_errno(sched_rr_get_interval(arg1, &ts));
7449             if (!is_error(ret)) {
7450                 host_to_target_timespec(arg2, &ts);
7451             }
7452         }
7453         break;
7454     case TARGET_NR_nanosleep:
7455         {
7456             struct timespec req, rem;
7457             target_to_host_timespec(&req, arg1);
7458             ret = get_errno(nanosleep(&req, &rem));
7459             if (is_error(ret) && arg2) {
7460                 host_to_target_timespec(arg2, &rem);
7461             }
7462         }
7463         break;
7464 #ifdef TARGET_NR_query_module
7465     case TARGET_NR_query_module:
7466         goto unimplemented;
7467 #endif
7468 #ifdef TARGET_NR_nfsservctl
7469     case TARGET_NR_nfsservctl:
7470         goto unimplemented;
7471 #endif
7472     case TARGET_NR_prctl:
7473         switch (arg1) {
7474         case PR_GET_PDEATHSIG:
7475         {
7476             int deathsig;
7477             ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
7478             if (!is_error(ret) && arg2
7479                 && put_user_ual(deathsig, arg2)) {
7480                 goto efault;
7481             }
7482             break;
7483         }
7484 #ifdef PR_GET_NAME
7485         case PR_GET_NAME:
7486         {
7487             void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
7488             if (!name) {
7489                 goto efault;
7490             }
7491             ret = get_errno(prctl(arg1, (unsigned long)name,
7492                                   arg3, arg4, arg5));
7493             unlock_user(name, arg2, 16);
7494             break;
7495         }
7496         case PR_SET_NAME:
7497         {
7498             void *name = lock_user(VERIFY_READ, arg2, 16, 1);
7499             if (!name) {
7500                 goto efault;
7501             }
7502             ret = get_errno(prctl(arg1, (unsigned long)name,
7503                                   arg3, arg4, arg5));
7504             unlock_user(name, arg2, 0);
7505             break;
7506         }
7507 #endif
7508         default:
7509             /* Most prctl options have no pointer arguments */
7510             ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
7511             break;
7512         }
7513         break;
7514 #ifdef TARGET_NR_arch_prctl
7515     case TARGET_NR_arch_prctl:
7516 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
7517         ret = do_arch_prctl(cpu_env, arg1, arg2);
7518         break;
7519 #else
7520         goto unimplemented;
7521 #endif
7522 #endif
7523 #ifdef TARGET_NR_pread64
7524     case TARGET_NR_pread64:
7525         if (regpairs_aligned(cpu_env)) {
7526             arg4 = arg5;
7527             arg5 = arg6;
7528         }
7529         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
7530             goto efault;
7531         ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
7532         unlock_user(p, arg2, ret);
7533         break;
7534     case TARGET_NR_pwrite64:
7535         if (regpairs_aligned(cpu_env)) {
7536             arg4 = arg5;
7537             arg5 = arg6;
7538         }
7539         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
7540             goto efault;
7541         ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
7542         unlock_user(p, arg2, 0);
7543         break;
7544 #endif
7545     case TARGET_NR_getcwd:
7546         if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
7547             goto efault;
7548         ret = get_errno(sys_getcwd1(p, arg2));
7549         unlock_user(p, arg1, ret);
7550         break;
7551     case TARGET_NR_capget:
7552         goto unimplemented;
7553     case TARGET_NR_capset:
7554         goto unimplemented;
7555     case TARGET_NR_sigaltstack:
7556 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
7557     defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \
7558     defined(TARGET_M68K) || defined(TARGET_S390X) || defined(TARGET_OPENRISC)
7559         ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUArchState *)cpu_env));
7560         break;
7561 #else
7562         goto unimplemented;
7563 #endif
7564
7565 #ifdef CONFIG_SENDFILE
7566     case TARGET_NR_sendfile:
7567     {
7568         off_t *offp = NULL;
7569         off_t off;
7570         if (arg3) {
7571             ret = get_user_sal(off, arg3);
7572             if (is_error(ret)) {
7573                 break;
7574             }
7575             offp = &off;
7576         }
7577         ret = get_errno(sendfile(arg1, arg2, offp, arg4));
7578         if (!is_error(ret) && arg3) {
7579             abi_long ret2 = put_user_sal(off, arg3);
7580             if (is_error(ret2)) {
7581                 ret = ret2;
7582             }
7583         }
7584         break;
7585     }
7586 #ifdef TARGET_NR_sendfile64
7587     case TARGET_NR_sendfile64:
7588     {
7589         off_t *offp = NULL;
7590         off_t off;
7591         if (arg3) {
7592             ret = get_user_s64(off, arg3);
7593             if (is_error(ret)) {
7594                 break;
7595             }
7596             offp = &off;
7597         }
7598         ret = get_errno(sendfile(arg1, arg2, offp, arg4));
7599         if (!is_error(ret) && arg3) {
7600             abi_long ret2 = put_user_s64(off, arg3);
7601             if (is_error(ret2)) {
7602                 ret = ret2;
7603             }
7604         }
7605         break;
7606     }
7607 #endif
7608 #else
7609     case TARGET_NR_sendfile:
7610 #ifdef TARGET_NR_sendfile64
7611     case TARGET_NR_sendfile64:
7612 #endif
7613         goto unimplemented;
7614 #endif
7615
7616 #ifdef TARGET_NR_getpmsg
7617     case TARGET_NR_getpmsg:
7618         goto unimplemented;
7619 #endif
7620 #ifdef TARGET_NR_putpmsg
7621     case TARGET_NR_putpmsg:
7622         goto unimplemented;
7623 #endif
7624 #ifdef TARGET_NR_vfork
7625     case TARGET_NR_vfork:
7626         ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
7627                         0, 0, 0, 0));
7628         break;
7629 #endif
7630 #ifdef TARGET_NR_ugetrlimit
7631     case TARGET_NR_ugetrlimit:
7632     {
7633         struct rlimit rlim;
7634         int resource = target_to_host_resource(arg1);
7635         ret = get_errno(getrlimit(resource, &rlim));
7636         if (!is_error(ret)) {
7637             struct target_rlimit *target_rlim;
7638             if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
7639                 goto efault;
7640             target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
7641             target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
7642             unlock_user_struct(target_rlim, arg2, 1);
7643         }
7644         break;
7645     }
7646 #endif
7647 #ifdef TARGET_NR_truncate64
7648     case TARGET_NR_truncate64:
7649         if (!(p = lock_user_string(arg1)))
7650             goto efault;
7651         ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
7652         unlock_user(p, arg1, 0);
7653         break;
7654 #endif
7655 #ifdef TARGET_NR_ftruncate64
7656     case TARGET_NR_ftruncate64:
7657         ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
7658         break;
7659 #endif
7660 #ifdef TARGET_NR_stat64
7661     case TARGET_NR_stat64:
7662         if (!(p = lock_user_string(arg1)))
7663             goto efault;
7664         ret = get_errno(stat(path(p), &st));
7665         unlock_user(p, arg1, 0);
7666         if (!is_error(ret))
7667             ret = host_to_target_stat64(cpu_env, arg2, &st);
7668         break;
7669 #endif
7670 #ifdef TARGET_NR_lstat64
7671     case TARGET_NR_lstat64:
7672         if (!(p = lock_user_string(arg1)))
7673             goto efault;
7674         ret = get_errno(lstat(path(p), &st));
7675         unlock_user(p, arg1, 0);
7676         if (!is_error(ret))
7677             ret = host_to_target_stat64(cpu_env, arg2, &st);
7678         break;
7679 #endif
7680 #ifdef TARGET_NR_fstat64
7681     case TARGET_NR_fstat64:
7682         ret = get_errno(fstat(arg1, &st));
7683         if (!is_error(ret))
7684             ret = host_to_target_stat64(cpu_env, arg2, &st);
7685         break;
7686 #endif
7687 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
7688 #ifdef TARGET_NR_fstatat64
7689     case TARGET_NR_fstatat64:
7690 #endif
7691 #ifdef TARGET_NR_newfstatat
7692     case TARGET_NR_newfstatat:
7693 #endif
7694         if (!(p = lock_user_string(arg2)))
7695             goto efault;
7696         ret = get_errno(fstatat(arg1, path(p), &st, arg4));
7697         if (!is_error(ret))
7698             ret = host_to_target_stat64(cpu_env, arg3, &st);
7699         break;
7700 #endif
7701     case TARGET_NR_lchown:
7702         if (!(p = lock_user_string(arg1)))
7703             goto efault;
7704         ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
7705         unlock_user(p, arg1, 0);
7706         break;
7707 #ifdef TARGET_NR_getuid
7708     case TARGET_NR_getuid:
7709         ret = get_errno(high2lowuid(getuid()));
7710         break;
7711 #endif
7712 #ifdef TARGET_NR_getgid
7713     case TARGET_NR_getgid:
7714         ret = get_errno(high2lowgid(getgid()));
7715         break;
7716 #endif
7717 #ifdef TARGET_NR_geteuid
7718     case TARGET_NR_geteuid:
7719         ret = get_errno(high2lowuid(geteuid()));
7720         break;
7721 #endif
7722 #ifdef TARGET_NR_getegid
7723     case TARGET_NR_getegid:
7724         ret = get_errno(high2lowgid(getegid()));
7725         break;
7726 #endif
7727     case TARGET_NR_setreuid:
7728         ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
7729         break;
7730     case TARGET_NR_setregid:
7731         ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
7732         break;
7733     case TARGET_NR_getgroups:
7734         {
7735             int gidsetsize = arg1;
7736             target_id *target_grouplist;
7737             gid_t *grouplist;
7738             int i;
7739
7740             grouplist = alloca(gidsetsize * sizeof(gid_t));
7741             ret = get_errno(getgroups(gidsetsize, grouplist));
7742             if (gidsetsize == 0)
7743                 break;
7744             if (!is_error(ret)) {
7745                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
7746                 if (!target_grouplist)
7747                     goto efault;
7748                 for(i = 0;i < ret; i++)
7749                     target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
7750                 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
7751             }
7752         }
7753         break;
7754     case TARGET_NR_setgroups:
7755         {
7756             int gidsetsize = arg1;
7757             target_id *target_grouplist;
7758             gid_t *grouplist = NULL;
7759             int i;
7760             if (gidsetsize) {
7761                 grouplist = alloca(gidsetsize * sizeof(gid_t));
7762                 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
7763                 if (!target_grouplist) {
7764                     ret = -TARGET_EFAULT;
7765                     goto fail;
7766                 }
7767                 for (i = 0; i < gidsetsize; i++) {
7768                     grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
7769                 }
7770                 unlock_user(target_grouplist, arg2, 0);
7771             }
7772             ret = get_errno(setgroups(gidsetsize, grouplist));
7773         }
7774         break;
7775     case TARGET_NR_fchown:
7776         ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
7777         break;
7778 #if defined(TARGET_NR_fchownat)
7779     case TARGET_NR_fchownat:
7780         if (!(p = lock_user_string(arg2)))
7781             goto efault;
7782         ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
7783                                  low2highgid(arg4), arg5));
7784         unlock_user(p, arg2, 0);
7785         break;
7786 #endif
7787 #ifdef TARGET_NR_setresuid
7788     case TARGET_NR_setresuid:
7789         ret = get_errno(setresuid(low2highuid(arg1),
7790                                   low2highuid(arg2),
7791                                   low2highuid(arg3)));
7792         break;
7793 #endif
7794 #ifdef TARGET_NR_getresuid
7795     case TARGET_NR_getresuid:
7796         {
7797             uid_t ruid, euid, suid;
7798             ret = get_errno(getresuid(&ruid, &euid, &suid));
7799             if (!is_error(ret)) {
7800                 if (put_user_u16(high2lowuid(ruid), arg1)
7801                     || put_user_u16(high2lowuid(euid), arg2)
7802                     || put_user_u16(high2lowuid(suid), arg3))
7803                     goto efault;
7804             }
7805         }
7806         break;
7807 #endif
7808 #ifdef TARGET_NR_getresgid
7809     case TARGET_NR_setresgid:
7810         ret = get_errno(setresgid(low2highgid(arg1),
7811                                   low2highgid(arg2),
7812                                   low2highgid(arg3)));
7813         break;
7814 #endif
7815 #ifdef TARGET_NR_getresgid
7816     case TARGET_NR_getresgid:
7817         {
7818             gid_t rgid, egid, sgid;
7819             ret = get_errno(getresgid(&rgid, &egid, &sgid));
7820             if (!is_error(ret)) {
7821                 if (put_user_u16(high2lowgid(rgid), arg1)
7822                     || put_user_u16(high2lowgid(egid), arg2)
7823                     || put_user_u16(high2lowgid(sgid), arg3))
7824                     goto efault;
7825             }
7826         }
7827         break;
7828 #endif
7829     case TARGET_NR_chown:
7830         if (!(p = lock_user_string(arg1)))
7831             goto efault;
7832         ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
7833         unlock_user(p, arg1, 0);
7834         break;
7835     case TARGET_NR_setuid:
7836         ret = get_errno(setuid(low2highuid(arg1)));
7837         break;
7838     case TARGET_NR_setgid:
7839         ret = get_errno(setgid(low2highgid(arg1)));
7840         break;
7841     case TARGET_NR_setfsuid:
7842         ret = get_errno(setfsuid(arg1));
7843         break;
7844     case TARGET_NR_setfsgid:
7845         ret = get_errno(setfsgid(arg1));
7846         break;
7847
7848 #ifdef TARGET_NR_lchown32
7849     case TARGET_NR_lchown32:
7850         if (!(p = lock_user_string(arg1)))
7851             goto efault;
7852         ret = get_errno(lchown(p, arg2, arg3));
7853         unlock_user(p, arg1, 0);
7854         break;
7855 #endif
7856 #ifdef TARGET_NR_getuid32
7857     case TARGET_NR_getuid32:
7858         ret = get_errno(getuid());
7859         break;
7860 #endif
7861
7862 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
7863    /* Alpha specific */
7864     case TARGET_NR_getxuid:
7865          {
7866             uid_t euid;
7867             euid=geteuid();
7868             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
7869          }
7870         ret = get_errno(getuid());
7871         break;
7872 #endif
7873 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
7874    /* Alpha specific */
7875     case TARGET_NR_getxgid:
7876          {
7877             uid_t egid;
7878             egid=getegid();
7879             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
7880          }
7881         ret = get_errno(getgid());
7882         break;
7883 #endif
7884 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
7885     /* Alpha specific */
7886     case TARGET_NR_osf_getsysinfo:
7887         ret = -TARGET_EOPNOTSUPP;
7888         switch (arg1) {
7889           case TARGET_GSI_IEEE_FP_CONTROL:
7890             {
7891                 uint64_t swcr, fpcr = cpu_alpha_load_fpcr (cpu_env);
7892
7893                 /* Copied from linux ieee_fpcr_to_swcr.  */
7894                 swcr = (fpcr >> 35) & SWCR_STATUS_MASK;
7895                 swcr |= (fpcr >> 36) & SWCR_MAP_DMZ;
7896                 swcr |= (~fpcr >> 48) & (SWCR_TRAP_ENABLE_INV
7897                                         | SWCR_TRAP_ENABLE_DZE
7898                                         | SWCR_TRAP_ENABLE_OVF);
7899                 swcr |= (~fpcr >> 57) & (SWCR_TRAP_ENABLE_UNF
7900                                         | SWCR_TRAP_ENABLE_INE);
7901                 swcr |= (fpcr >> 47) & SWCR_MAP_UMZ;
7902                 swcr |= (~fpcr >> 41) & SWCR_TRAP_ENABLE_DNO;
7903
7904                 if (put_user_u64 (swcr, arg2))
7905                         goto efault;
7906                 ret = 0;
7907             }
7908             break;
7909
7910           /* case GSI_IEEE_STATE_AT_SIGNAL:
7911              -- Not implemented in linux kernel.
7912              case GSI_UACPROC:
7913              -- Retrieves current unaligned access state; not much used.
7914              case GSI_PROC_TYPE:
7915              -- Retrieves implver information; surely not used.
7916              case GSI_GET_HWRPB:
7917              -- Grabs a copy of the HWRPB; surely not used.
7918           */
7919         }
7920         break;
7921 #endif
7922 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
7923     /* Alpha specific */
7924     case TARGET_NR_osf_setsysinfo:
7925         ret = -TARGET_EOPNOTSUPP;
7926         switch (arg1) {
7927           case TARGET_SSI_IEEE_FP_CONTROL:
7928             {
7929                 uint64_t swcr, fpcr, orig_fpcr;
7930
7931                 if (get_user_u64 (swcr, arg2)) {
7932                     goto efault;
7933                 }
7934                 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
7935                 fpcr = orig_fpcr & FPCR_DYN_MASK;
7936
7937                 /* Copied from linux ieee_swcr_to_fpcr.  */
7938                 fpcr |= (swcr & SWCR_STATUS_MASK) << 35;
7939                 fpcr |= (swcr & SWCR_MAP_DMZ) << 36;
7940                 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_INV
7941                                   | SWCR_TRAP_ENABLE_DZE
7942                                   | SWCR_TRAP_ENABLE_OVF)) << 48;
7943                 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_UNF
7944                                   | SWCR_TRAP_ENABLE_INE)) << 57;
7945                 fpcr |= (swcr & SWCR_MAP_UMZ ? FPCR_UNDZ | FPCR_UNFD : 0);
7946                 fpcr |= (~swcr & SWCR_TRAP_ENABLE_DNO) << 41;
7947
7948                 cpu_alpha_store_fpcr(cpu_env, fpcr);
7949                 ret = 0;
7950             }
7951             break;
7952
7953           case TARGET_SSI_IEEE_RAISE_EXCEPTION:
7954             {
7955                 uint64_t exc, fpcr, orig_fpcr;
7956                 int si_code;
7957
7958                 if (get_user_u64(exc, arg2)) {
7959                     goto efault;
7960                 }
7961
7962                 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
7963
7964                 /* We only add to the exception status here.  */
7965                 fpcr = orig_fpcr | ((exc & SWCR_STATUS_MASK) << 35);
7966
7967                 cpu_alpha_store_fpcr(cpu_env, fpcr);
7968                 ret = 0;
7969
7970                 /* Old exceptions are not signaled.  */
7971                 fpcr &= ~(orig_fpcr & FPCR_STATUS_MASK);
7972
7973                 /* If any exceptions set by this call,
7974                    and are unmasked, send a signal.  */
7975                 si_code = 0;
7976                 if ((fpcr & (FPCR_INE | FPCR_INED)) == FPCR_INE) {
7977                     si_code = TARGET_FPE_FLTRES;
7978                 }
7979                 if ((fpcr & (FPCR_UNF | FPCR_UNFD)) == FPCR_UNF) {
7980                     si_code = TARGET_FPE_FLTUND;
7981                 }
7982                 if ((fpcr & (FPCR_OVF | FPCR_OVFD)) == FPCR_OVF) {
7983                     si_code = TARGET_FPE_FLTOVF;
7984                 }
7985                 if ((fpcr & (FPCR_DZE | FPCR_DZED)) == FPCR_DZE) {
7986                     si_code = TARGET_FPE_FLTDIV;
7987                 }
7988                 if ((fpcr & (FPCR_INV | FPCR_INVD)) == FPCR_INV) {
7989                     si_code = TARGET_FPE_FLTINV;
7990                 }
7991                 if (si_code != 0) {
7992                     target_siginfo_t info;
7993                     info.si_signo = SIGFPE;
7994                     info.si_errno = 0;
7995                     info.si_code = si_code;
7996                     info._sifields._sigfault._addr
7997                         = ((CPUArchState *)cpu_env)->pc;
7998                     queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
7999                 }
8000             }
8001             break;
8002
8003           /* case SSI_NVPAIRS:
8004              -- Used with SSIN_UACPROC to enable unaligned accesses.
8005              case SSI_IEEE_STATE_AT_SIGNAL:
8006              case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
8007              -- Not implemented in linux kernel
8008           */
8009         }
8010         break;
8011 #endif
8012 #ifdef TARGET_NR_osf_sigprocmask
8013     /* Alpha specific.  */
8014     case TARGET_NR_osf_sigprocmask:
8015         {
8016             abi_ulong mask;
8017             int how;
8018             sigset_t set, oldset;
8019
8020             switch(arg1) {
8021             case TARGET_SIG_BLOCK:
8022                 how = SIG_BLOCK;
8023                 break;
8024             case TARGET_SIG_UNBLOCK:
8025                 how = SIG_UNBLOCK;
8026                 break;
8027             case TARGET_SIG_SETMASK:
8028                 how = SIG_SETMASK;
8029                 break;
8030             default:
8031                 ret = -TARGET_EINVAL;
8032                 goto fail;
8033             }
8034             mask = arg2;
8035             target_to_host_old_sigset(&set, &mask);
8036             sigprocmask(how, &set, &oldset);
8037             host_to_target_old_sigset(&mask, &oldset);
8038             ret = mask;
8039         }
8040         break;
8041 #endif
8042
8043 #ifdef TARGET_NR_getgid32
8044     case TARGET_NR_getgid32:
8045         ret = get_errno(getgid());
8046         break;
8047 #endif
8048 #ifdef TARGET_NR_geteuid32
8049     case TARGET_NR_geteuid32:
8050         ret = get_errno(geteuid());
8051         break;
8052 #endif
8053 #ifdef TARGET_NR_getegid32
8054     case TARGET_NR_getegid32:
8055         ret = get_errno(getegid());
8056         break;
8057 #endif
8058 #ifdef TARGET_NR_setreuid32
8059     case TARGET_NR_setreuid32:
8060         ret = get_errno(setreuid(arg1, arg2));
8061         break;
8062 #endif
8063 #ifdef TARGET_NR_setregid32
8064     case TARGET_NR_setregid32:
8065         ret = get_errno(setregid(arg1, arg2));
8066         break;
8067 #endif
8068 #ifdef TARGET_NR_getgroups32
8069     case TARGET_NR_getgroups32:
8070         {
8071             int gidsetsize = arg1;
8072             uint32_t *target_grouplist;
8073             gid_t *grouplist;
8074             int i;
8075
8076             grouplist = alloca(gidsetsize * sizeof(gid_t));
8077             ret = get_errno(getgroups(gidsetsize, grouplist));
8078             if (gidsetsize == 0)
8079                 break;
8080             if (!is_error(ret)) {
8081                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
8082                 if (!target_grouplist) {
8083                     ret = -TARGET_EFAULT;
8084                     goto fail;
8085                 }
8086                 for(i = 0;i < ret; i++)
8087                     target_grouplist[i] = tswap32(grouplist[i]);
8088                 unlock_user(target_grouplist, arg2, gidsetsize * 4);
8089             }
8090         }
8091         break;
8092 #endif
8093 #ifdef TARGET_NR_setgroups32
8094     case TARGET_NR_setgroups32:
8095         {
8096             int gidsetsize = arg1;
8097             uint32_t *target_grouplist;
8098             gid_t *grouplist;
8099             int i;
8100
8101             grouplist = alloca(gidsetsize * sizeof(gid_t));
8102             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
8103             if (!target_grouplist) {
8104                 ret = -TARGET_EFAULT;
8105                 goto fail;
8106             }
8107             for(i = 0;i < gidsetsize; i++)
8108                 grouplist[i] = tswap32(target_grouplist[i]);
8109             unlock_user(target_grouplist, arg2, 0);
8110             ret = get_errno(setgroups(gidsetsize, grouplist));
8111         }
8112         break;
8113 #endif
8114 #ifdef TARGET_NR_fchown32
8115     case TARGET_NR_fchown32:
8116         ret = get_errno(fchown(arg1, arg2, arg3));
8117         break;
8118 #endif
8119 #ifdef TARGET_NR_setresuid32
8120     case TARGET_NR_setresuid32:
8121         ret = get_errno(setresuid(arg1, arg2, arg3));
8122         break;
8123 #endif
8124 #ifdef TARGET_NR_getresuid32
8125     case TARGET_NR_getresuid32:
8126         {
8127             uid_t ruid, euid, suid;
8128             ret = get_errno(getresuid(&ruid, &euid, &suid));
8129             if (!is_error(ret)) {
8130                 if (put_user_u32(ruid, arg1)
8131                     || put_user_u32(euid, arg2)
8132                     || put_user_u32(suid, arg3))
8133                     goto efault;
8134             }
8135         }
8136         break;
8137 #endif
8138 #ifdef TARGET_NR_setresgid32
8139     case TARGET_NR_setresgid32:
8140         ret = get_errno(setresgid(arg1, arg2, arg3));
8141         break;
8142 #endif
8143 #ifdef TARGET_NR_getresgid32
8144     case TARGET_NR_getresgid32:
8145         {
8146             gid_t rgid, egid, sgid;
8147             ret = get_errno(getresgid(&rgid, &egid, &sgid));
8148             if (!is_error(ret)) {
8149                 if (put_user_u32(rgid, arg1)
8150                     || put_user_u32(egid, arg2)
8151                     || put_user_u32(sgid, arg3))
8152                     goto efault;
8153             }
8154         }
8155         break;
8156 #endif
8157 #ifdef TARGET_NR_chown32
8158     case TARGET_NR_chown32:
8159         if (!(p = lock_user_string(arg1)))
8160             goto efault;
8161         ret = get_errno(chown(p, arg2, arg3));
8162         unlock_user(p, arg1, 0);
8163         break;
8164 #endif
8165 #ifdef TARGET_NR_setuid32
8166     case TARGET_NR_setuid32:
8167         ret = get_errno(setuid(arg1));
8168         break;
8169 #endif
8170 #ifdef TARGET_NR_setgid32
8171     case TARGET_NR_setgid32:
8172         ret = get_errno(setgid(arg1));
8173         break;
8174 #endif
8175 #ifdef TARGET_NR_setfsuid32
8176     case TARGET_NR_setfsuid32:
8177         ret = get_errno(setfsuid(arg1));
8178         break;
8179 #endif
8180 #ifdef TARGET_NR_setfsgid32
8181     case TARGET_NR_setfsgid32:
8182         ret = get_errno(setfsgid(arg1));
8183         break;
8184 #endif
8185
8186     case TARGET_NR_pivot_root:
8187         goto unimplemented;
8188 #ifdef TARGET_NR_mincore
8189     case TARGET_NR_mincore:
8190         {
8191             void *a;
8192             ret = -TARGET_EFAULT;
8193             if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
8194                 goto efault;
8195             if (!(p = lock_user_string(arg3)))
8196                 goto mincore_fail;
8197             ret = get_errno(mincore(a, arg2, p));
8198             unlock_user(p, arg3, ret);
8199             mincore_fail:
8200             unlock_user(a, arg1, 0);
8201         }
8202         break;
8203 #endif
8204 #ifdef TARGET_NR_arm_fadvise64_64
8205     case TARGET_NR_arm_fadvise64_64:
8206         {
8207                 /*
8208                  * arm_fadvise64_64 looks like fadvise64_64 but
8209                  * with different argument order
8210                  */
8211                 abi_long temp;
8212                 temp = arg3;
8213                 arg3 = arg4;
8214                 arg4 = temp;
8215         }
8216 #endif
8217 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)
8218 #ifdef TARGET_NR_fadvise64_64
8219     case TARGET_NR_fadvise64_64:
8220 #endif
8221 #ifdef TARGET_NR_fadvise64
8222     case TARGET_NR_fadvise64:
8223 #endif
8224 #ifdef TARGET_S390X
8225         switch (arg4) {
8226         case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
8227         case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
8228         case 6: arg4 = POSIX_FADV_DONTNEED; break;
8229         case 7: arg4 = POSIX_FADV_NOREUSE; break;
8230         default: break;
8231         }
8232 #endif
8233         ret = -posix_fadvise(arg1, arg2, arg3, arg4);
8234         break;
8235 #endif
8236 #ifdef TARGET_NR_madvise
8237     case TARGET_NR_madvise:
8238         /* A straight passthrough may not be safe because qemu sometimes
8239            turns private file-backed mappings into anonymous mappings.
8240            This will break MADV_DONTNEED.
8241            This is a hint, so ignoring and returning success is ok.  */
8242         ret = get_errno(0);
8243         break;
8244 #endif
8245 #if TARGET_ABI_BITS == 32
8246     case TARGET_NR_fcntl64:
8247     {
8248         int cmd;
8249         struct flock64 fl;
8250         struct target_flock64 *target_fl;
8251 #ifdef TARGET_ARM
8252         struct target_eabi_flock64 *target_efl;
8253 #endif
8254
8255         cmd = target_to_host_fcntl_cmd(arg2);
8256         if (cmd == -TARGET_EINVAL) {
8257             ret = cmd;
8258             break;
8259         }
8260
8261         switch(arg2) {
8262         case TARGET_F_GETLK64:
8263 #ifdef TARGET_ARM
8264             if (((CPUARMState *)cpu_env)->eabi) {
8265                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
8266                     goto efault;
8267                 fl.l_type = tswap16(target_efl->l_type);
8268                 fl.l_whence = tswap16(target_efl->l_whence);
8269                 fl.l_start = tswap64(target_efl->l_start);
8270                 fl.l_len = tswap64(target_efl->l_len);
8271                 fl.l_pid = tswap32(target_efl->l_pid);
8272                 unlock_user_struct(target_efl, arg3, 0);
8273             } else
8274 #endif
8275             {
8276                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
8277                     goto efault;
8278                 fl.l_type = tswap16(target_fl->l_type);
8279                 fl.l_whence = tswap16(target_fl->l_whence);
8280                 fl.l_start = tswap64(target_fl->l_start);
8281                 fl.l_len = tswap64(target_fl->l_len);
8282                 fl.l_pid = tswap32(target_fl->l_pid);
8283                 unlock_user_struct(target_fl, arg3, 0);
8284             }
8285             ret = get_errno(fcntl(arg1, cmd, &fl));
8286             if (ret == 0) {
8287 #ifdef TARGET_ARM
8288                 if (((CPUARMState *)cpu_env)->eabi) {
8289                     if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
8290                         goto efault;
8291                     target_efl->l_type = tswap16(fl.l_type);
8292                     target_efl->l_whence = tswap16(fl.l_whence);
8293                     target_efl->l_start = tswap64(fl.l_start);
8294                     target_efl->l_len = tswap64(fl.l_len);
8295                     target_efl->l_pid = tswap32(fl.l_pid);
8296                     unlock_user_struct(target_efl, arg3, 1);
8297                 } else
8298 #endif
8299                 {
8300                     if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
8301                         goto efault;
8302                     target_fl->l_type = tswap16(fl.l_type);
8303                     target_fl->l_whence = tswap16(fl.l_whence);
8304                     target_fl->l_start = tswap64(fl.l_start);
8305                     target_fl->l_len = tswap64(fl.l_len);
8306                     target_fl->l_pid = tswap32(fl.l_pid);
8307                     unlock_user_struct(target_fl, arg3, 1);
8308                 }
8309             }
8310             break;
8311
8312         case TARGET_F_SETLK64:
8313         case TARGET_F_SETLKW64:
8314 #ifdef TARGET_ARM
8315             if (((CPUARMState *)cpu_env)->eabi) {
8316                 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
8317                     goto efault;
8318                 fl.l_type = tswap16(target_efl->l_type);
8319                 fl.l_whence = tswap16(target_efl->l_whence);
8320                 fl.l_start = tswap64(target_efl->l_start);
8321                 fl.l_len = tswap64(target_efl->l_len);
8322                 fl.l_pid = tswap32(target_efl->l_pid);
8323                 unlock_user_struct(target_efl, arg3, 0);
8324             } else
8325 #endif
8326             {
8327                 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
8328                     goto efault;
8329                 fl.l_type = tswap16(target_fl->l_type);
8330                 fl.l_whence = tswap16(target_fl->l_whence);
8331                 fl.l_start = tswap64(target_fl->l_start);
8332                 fl.l_len = tswap64(target_fl->l_len);
8333                 fl.l_pid = tswap32(target_fl->l_pid);
8334                 unlock_user_struct(target_fl, arg3, 0);
8335             }
8336             ret = get_errno(fcntl(arg1, cmd, &fl));
8337             break;
8338         default:
8339             ret = do_fcntl(arg1, arg2, arg3);
8340             break;
8341         }
8342         break;
8343     }
8344 #endif
8345 #ifdef TARGET_NR_cacheflush
8346     case TARGET_NR_cacheflush:
8347         /* self-modifying code is handled automatically, so nothing needed */
8348         ret = 0;
8349         break;
8350 #endif
8351 #ifdef TARGET_NR_security
8352     case TARGET_NR_security:
8353         goto unimplemented;
8354 #endif
8355 #ifdef TARGET_NR_getpagesize
8356     case TARGET_NR_getpagesize:
8357         ret = TARGET_PAGE_SIZE;
8358         break;
8359 #endif
8360     case TARGET_NR_gettid:
8361         ret = get_errno(gettid());
8362         break;
8363 #ifdef TARGET_NR_readahead
8364     case TARGET_NR_readahead:
8365 #if TARGET_ABI_BITS == 32
8366         if (regpairs_aligned(cpu_env)) {
8367             arg2 = arg3;
8368             arg3 = arg4;
8369             arg4 = arg5;
8370         }
8371         ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
8372 #else
8373         ret = get_errno(readahead(arg1, arg2, arg3));
8374 #endif
8375         break;
8376 #endif
8377 #ifdef CONFIG_ATTR
8378 #ifdef TARGET_NR_setxattr
8379     case TARGET_NR_listxattr:
8380     case TARGET_NR_llistxattr:
8381     {
8382         void *p, *b = 0;
8383         if (arg2) {
8384             b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
8385             if (!b) {
8386                 ret = -TARGET_EFAULT;
8387                 break;
8388             }
8389         }
8390         p = lock_user_string(arg1);
8391         if (p) {
8392             if (num == TARGET_NR_listxattr) {
8393                 ret = get_errno(listxattr(p, b, arg3));
8394             } else {
8395                 ret = get_errno(llistxattr(p, b, arg3));
8396             }
8397         } else {
8398             ret = -TARGET_EFAULT;
8399         }
8400         unlock_user(p, arg1, 0);
8401         unlock_user(b, arg2, arg3);
8402         break;
8403     }
8404     case TARGET_NR_flistxattr:
8405     {
8406         void *b = 0;
8407         if (arg2) {
8408             b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
8409             if (!b) {
8410                 ret = -TARGET_EFAULT;
8411                 break;
8412             }
8413         }
8414         ret = get_errno(flistxattr(arg1, b, arg3));
8415         unlock_user(b, arg2, arg3);
8416         break;
8417     }
8418     case TARGET_NR_setxattr:
8419     case TARGET_NR_lsetxattr:
8420         {
8421             void *p, *n, *v = 0;
8422             if (arg3) {
8423                 v = lock_user(VERIFY_READ, arg3, arg4, 1);
8424                 if (!v) {
8425                     ret = -TARGET_EFAULT;
8426                     break;
8427                 }
8428             }
8429             p = lock_user_string(arg1);
8430             n = lock_user_string(arg2);
8431             if (p && n) {
8432                 if (num == TARGET_NR_setxattr) {
8433                     ret = get_errno(setxattr(p, n, v, arg4, arg5));
8434                 } else {
8435                     ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
8436                 }
8437             } else {
8438                 ret = -TARGET_EFAULT;
8439             }
8440             unlock_user(p, arg1, 0);
8441             unlock_user(n, arg2, 0);
8442             unlock_user(v, arg3, 0);
8443         }
8444         break;
8445     case TARGET_NR_fsetxattr:
8446         {
8447             void *n, *v = 0;
8448             if (arg3) {
8449                 v = lock_user(VERIFY_READ, arg3, arg4, 1);
8450                 if (!v) {
8451                     ret = -TARGET_EFAULT;
8452                     break;
8453                 }
8454             }
8455             n = lock_user_string(arg2);
8456             if (n) {
8457                 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
8458             } else {
8459                 ret = -TARGET_EFAULT;
8460             }
8461             unlock_user(n, arg2, 0);
8462             unlock_user(v, arg3, 0);
8463         }
8464         break;
8465     case TARGET_NR_getxattr:
8466     case TARGET_NR_lgetxattr:
8467         {
8468             void *p, *n, *v = 0;
8469             if (arg3) {
8470                 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
8471                 if (!v) {
8472                     ret = -TARGET_EFAULT;
8473                     break;
8474                 }
8475             }
8476             p = lock_user_string(arg1);
8477             n = lock_user_string(arg2);
8478             if (p && n) {
8479                 if (num == TARGET_NR_getxattr) {
8480                     ret = get_errno(getxattr(p, n, v, arg4));
8481                 } else {
8482                     ret = get_errno(lgetxattr(p, n, v, arg4));
8483                 }
8484             } else {
8485                 ret = -TARGET_EFAULT;
8486             }
8487             unlock_user(p, arg1, 0);
8488             unlock_user(n, arg2, 0);
8489             unlock_user(v, arg3, arg4);
8490         }
8491         break;
8492     case TARGET_NR_fgetxattr:
8493         {
8494             void *n, *v = 0;
8495             if (arg3) {
8496                 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
8497                 if (!v) {
8498                     ret = -TARGET_EFAULT;
8499                     break;
8500                 }
8501             }
8502             n = lock_user_string(arg2);
8503             if (n) {
8504                 ret = get_errno(fgetxattr(arg1, n, v, arg4));
8505             } else {
8506                 ret = -TARGET_EFAULT;
8507             }
8508             unlock_user(n, arg2, 0);
8509             unlock_user(v, arg3, arg4);
8510         }
8511         break;
8512     case TARGET_NR_removexattr:
8513     case TARGET_NR_lremovexattr:
8514         {
8515             void *p, *n;
8516             p = lock_user_string(arg1);
8517             n = lock_user_string(arg2);
8518             if (p && n) {
8519                 if (num == TARGET_NR_removexattr) {
8520                     ret = get_errno(removexattr(p, n));
8521                 } else {
8522                     ret = get_errno(lremovexattr(p, n));
8523                 }
8524             } else {
8525                 ret = -TARGET_EFAULT;
8526             }
8527             unlock_user(p, arg1, 0);
8528             unlock_user(n, arg2, 0);
8529         }
8530         break;
8531     case TARGET_NR_fremovexattr:
8532         {
8533             void *n;
8534             n = lock_user_string(arg2);
8535             if (n) {
8536                 ret = get_errno(fremovexattr(arg1, n));
8537             } else {
8538                 ret = -TARGET_EFAULT;
8539             }
8540             unlock_user(n, arg2, 0);
8541         }
8542         break;
8543 #endif
8544 #endif /* CONFIG_ATTR */
8545 #ifdef TARGET_NR_set_thread_area
8546     case TARGET_NR_set_thread_area:
8547 #if defined(TARGET_MIPS)
8548       ((CPUMIPSState *) cpu_env)->tls_value = arg1;
8549       ret = 0;
8550       break;
8551 #elif defined(TARGET_CRIS)
8552       if (arg1 & 0xff)
8553           ret = -TARGET_EINVAL;
8554       else {
8555           ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
8556           ret = 0;
8557       }
8558       break;
8559 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
8560       ret = do_set_thread_area(cpu_env, arg1);
8561       break;
8562 #elif defined(TARGET_M68K)
8563       {
8564           TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
8565           ts->tp_value = arg1;
8566           ret = 0;
8567           break;
8568       }
8569 #else
8570       goto unimplemented_nowarn;
8571 #endif
8572 #endif
8573 #ifdef TARGET_NR_get_thread_area
8574     case TARGET_NR_get_thread_area:
8575 #if defined(TARGET_I386) && defined(TARGET_ABI32)
8576         ret = do_get_thread_area(cpu_env, arg1);
8577         break;
8578 #elif defined(TARGET_M68K)
8579         {
8580             TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
8581             ret = ts->tp_value;
8582             break;
8583         }
8584 #else
8585         goto unimplemented_nowarn;
8586 #endif
8587 #endif
8588 #ifdef TARGET_NR_getdomainname
8589     case TARGET_NR_getdomainname:
8590         goto unimplemented_nowarn;
8591 #endif
8592
8593 #ifdef TARGET_NR_clock_gettime
8594     case TARGET_NR_clock_gettime:
8595     {
8596         struct timespec ts;
8597         ret = get_errno(clock_gettime(arg1, &ts));
8598         if (!is_error(ret)) {
8599             host_to_target_timespec(arg2, &ts);
8600         }
8601         break;
8602     }
8603 #endif
8604 #ifdef TARGET_NR_clock_getres
8605     case TARGET_NR_clock_getres:
8606     {
8607         struct timespec ts;
8608         ret = get_errno(clock_getres(arg1, &ts));
8609         if (!is_error(ret)) {
8610             host_to_target_timespec(arg2, &ts);
8611         }
8612         break;
8613     }
8614 #endif
8615 #ifdef TARGET_NR_clock_nanosleep
8616     case TARGET_NR_clock_nanosleep:
8617     {
8618         struct timespec ts;
8619         target_to_host_timespec(&ts, arg3);
8620         ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
8621         if (arg4)
8622             host_to_target_timespec(arg4, &ts);
8623         break;
8624     }
8625 #endif
8626
8627 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
8628     case TARGET_NR_set_tid_address:
8629         ret = get_errno(set_tid_address((int *)g2h(arg1)));
8630         break;
8631 #endif
8632
8633 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
8634     case TARGET_NR_tkill:
8635         ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
8636         break;
8637 #endif
8638
8639 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
8640     case TARGET_NR_tgkill:
8641         ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
8642                         target_to_host_signal(arg3)));
8643         break;
8644 #endif
8645
8646 #ifdef TARGET_NR_set_robust_list
8647     case TARGET_NR_set_robust_list:
8648     case TARGET_NR_get_robust_list:
8649         /* The ABI for supporting robust futexes has userspace pass
8650          * the kernel a pointer to a linked list which is updated by
8651          * userspace after the syscall; the list is walked by the kernel
8652          * when the thread exits. Since the linked list in QEMU guest
8653          * memory isn't a valid linked list for the host and we have
8654          * no way to reliably intercept the thread-death event, we can't
8655          * support these. Silently return ENOSYS so that guest userspace
8656          * falls back to a non-robust futex implementation (which should
8657          * be OK except in the corner case of the guest crashing while
8658          * holding a mutex that is shared with another process via
8659          * shared memory).
8660          */
8661         goto unimplemented_nowarn;
8662 #endif
8663
8664 #if defined(TARGET_NR_utimensat)
8665     case TARGET_NR_utimensat:
8666         {
8667             struct timespec *tsp, ts[2];
8668             if (!arg3) {
8669                 tsp = NULL;
8670             } else {
8671                 target_to_host_timespec(ts, arg3);
8672                 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
8673                 tsp = ts;
8674             }
8675             if (!arg2)
8676                 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
8677             else {
8678                 if (!(p = lock_user_string(arg2))) {
8679                     ret = -TARGET_EFAULT;
8680                     goto fail;
8681                 }
8682                 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
8683                 unlock_user(p, arg2, 0);
8684             }
8685         }
8686         break;
8687 #endif
8688     case TARGET_NR_futex:
8689         ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
8690         break;
8691 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
8692     case TARGET_NR_inotify_init:
8693         ret = get_errno(sys_inotify_init());
8694         break;
8695 #endif
8696 #ifdef CONFIG_INOTIFY1
8697 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
8698     case TARGET_NR_inotify_init1:
8699         ret = get_errno(sys_inotify_init1(arg1));
8700         break;
8701 #endif
8702 #endif
8703 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
8704     case TARGET_NR_inotify_add_watch:
8705         p = lock_user_string(arg2);
8706         ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
8707         unlock_user(p, arg2, 0);
8708         break;
8709 #endif
8710 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
8711     case TARGET_NR_inotify_rm_watch:
8712         ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
8713         break;
8714 #endif
8715
8716 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
8717     case TARGET_NR_mq_open:
8718         {
8719             struct mq_attr posix_mq_attr;
8720
8721             p = lock_user_string(arg1 - 1);
8722             if (arg4 != 0)
8723                 copy_from_user_mq_attr (&posix_mq_attr, arg4);
8724             ret = get_errno(mq_open(p, arg2, arg3, &posix_mq_attr));
8725             unlock_user (p, arg1, 0);
8726         }
8727         break;
8728
8729     case TARGET_NR_mq_unlink:
8730         p = lock_user_string(arg1 - 1);
8731         ret = get_errno(mq_unlink(p));
8732         unlock_user (p, arg1, 0);
8733         break;
8734
8735     case TARGET_NR_mq_timedsend:
8736         {
8737             struct timespec ts;
8738
8739             p = lock_user (VERIFY_READ, arg2, arg3, 1);
8740             if (arg5 != 0) {
8741                 target_to_host_timespec(&ts, arg5);
8742                 ret = get_errno(mq_timedsend(arg1, p, arg3, arg4, &ts));
8743                 host_to_target_timespec(arg5, &ts);
8744             }
8745             else
8746                 ret = get_errno(mq_send(arg1, p, arg3, arg4));
8747             unlock_user (p, arg2, arg3);
8748         }
8749         break;
8750
8751     case TARGET_NR_mq_timedreceive:
8752         {
8753             struct timespec ts;
8754             unsigned int prio;
8755
8756             p = lock_user (VERIFY_READ, arg2, arg3, 1);
8757             if (arg5 != 0) {
8758                 target_to_host_timespec(&ts, arg5);
8759                 ret = get_errno(mq_timedreceive(arg1, p, arg3, &prio, &ts));
8760                 host_to_target_timespec(arg5, &ts);
8761             }
8762             else
8763                 ret = get_errno(mq_receive(arg1, p, arg3, &prio));
8764             unlock_user (p, arg2, arg3);
8765             if (arg4 != 0)
8766                 put_user_u32(prio, arg4);
8767         }
8768         break;
8769
8770     /* Not implemented for now... */
8771 /*     case TARGET_NR_mq_notify: */
8772 /*         break; */
8773
8774     case TARGET_NR_mq_getsetattr:
8775         {
8776             struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
8777             ret = 0;
8778             if (arg3 != 0) {
8779                 ret = mq_getattr(arg1, &posix_mq_attr_out);
8780                 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
8781             }
8782             if (arg2 != 0) {
8783                 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
8784                 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
8785             }
8786
8787         }
8788         break;
8789 #endif
8790
8791 #ifdef CONFIG_SPLICE
8792 #ifdef TARGET_NR_tee
8793     case TARGET_NR_tee:
8794         {
8795             ret = get_errno(tee(arg1,arg2,arg3,arg4));
8796         }
8797         break;
8798 #endif
8799 #ifdef TARGET_NR_splice
8800     case TARGET_NR_splice:
8801         {
8802             loff_t loff_in, loff_out;
8803             loff_t *ploff_in = NULL, *ploff_out = NULL;
8804             if(arg2) {
8805                 get_user_u64(loff_in, arg2);
8806                 ploff_in = &loff_in;
8807             }
8808             if(arg4) {
8809                 get_user_u64(loff_out, arg2);
8810                 ploff_out = &loff_out;
8811             }
8812             ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
8813         }
8814         break;
8815 #endif
8816 #ifdef TARGET_NR_vmsplice
8817         case TARGET_NR_vmsplice:
8818         {
8819             struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
8820             if (vec != NULL) {
8821                 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
8822                 unlock_iovec(vec, arg2, arg3, 0);
8823             } else {
8824                 ret = -host_to_target_errno(errno);
8825             }
8826         }
8827         break;
8828 #endif
8829 #endif /* CONFIG_SPLICE */
8830 #ifdef CONFIG_EVENTFD
8831 #if defined(TARGET_NR_eventfd)
8832     case TARGET_NR_eventfd:
8833         ret = get_errno(eventfd(arg1, 0));
8834         break;
8835 #endif
8836 #if defined(TARGET_NR_eventfd2)
8837     case TARGET_NR_eventfd2:
8838     {
8839         int host_flags = arg2 & (~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC));
8840         if (arg2 & TARGET_O_NONBLOCK) {
8841             host_flags |= O_NONBLOCK;
8842         }
8843         if (arg2 & TARGET_O_CLOEXEC) {
8844             host_flags |= O_CLOEXEC;
8845         }
8846         ret = get_errno(eventfd(arg1, host_flags));
8847         break;
8848     }
8849 #endif
8850 #endif /* CONFIG_EVENTFD  */
8851 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
8852     case TARGET_NR_fallocate:
8853 #if TARGET_ABI_BITS == 32
8854         ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
8855                                   target_offset64(arg5, arg6)));
8856 #else
8857         ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
8858 #endif
8859         break;
8860 #endif
8861 #if defined(CONFIG_SYNC_FILE_RANGE)
8862 #if defined(TARGET_NR_sync_file_range)
8863     case TARGET_NR_sync_file_range:
8864 #if TARGET_ABI_BITS == 32
8865 #if defined(TARGET_MIPS)
8866         ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
8867                                         target_offset64(arg5, arg6), arg7));
8868 #else
8869         ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
8870                                         target_offset64(arg4, arg5), arg6));
8871 #endif /* !TARGET_MIPS */
8872 #else
8873         ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
8874 #endif
8875         break;
8876 #endif
8877 #if defined(TARGET_NR_sync_file_range2)
8878     case TARGET_NR_sync_file_range2:
8879         /* This is like sync_file_range but the arguments are reordered */
8880 #if TARGET_ABI_BITS == 32
8881         ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
8882                                         target_offset64(arg5, arg6), arg2));
8883 #else
8884         ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
8885 #endif
8886         break;
8887 #endif
8888 #endif
8889 #if defined(CONFIG_EPOLL)
8890 #if defined(TARGET_NR_epoll_create)
8891     case TARGET_NR_epoll_create:
8892         ret = get_errno(epoll_create(arg1));
8893         break;
8894 #endif
8895 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
8896     case TARGET_NR_epoll_create1:
8897         ret = get_errno(epoll_create1(arg1));
8898         break;
8899 #endif
8900 #if defined(TARGET_NR_epoll_ctl)
8901     case TARGET_NR_epoll_ctl:
8902     {
8903         struct epoll_event ep;
8904         struct epoll_event *epp = 0;
8905         if (arg4) {
8906             struct target_epoll_event *target_ep;
8907             if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
8908                 goto efault;
8909             }
8910             ep.events = tswap32(target_ep->events);
8911             /* The epoll_data_t union is just opaque data to the kernel,
8912              * so we transfer all 64 bits across and need not worry what
8913              * actual data type it is.
8914              */
8915             ep.data.u64 = tswap64(target_ep->data.u64);
8916             unlock_user_struct(target_ep, arg4, 0);
8917             epp = &ep;
8918         }
8919         ret = get_errno(epoll_ctl(arg1, arg2, arg3, epp));
8920         break;
8921     }
8922 #endif
8923
8924 #if defined(TARGET_NR_epoll_pwait) && defined(CONFIG_EPOLL_PWAIT)
8925 #define IMPLEMENT_EPOLL_PWAIT
8926 #endif
8927 #if defined(TARGET_NR_epoll_wait) || defined(IMPLEMENT_EPOLL_PWAIT)
8928 #if defined(TARGET_NR_epoll_wait)
8929     case TARGET_NR_epoll_wait:
8930 #endif
8931 #if defined(IMPLEMENT_EPOLL_PWAIT)
8932     case TARGET_NR_epoll_pwait:
8933 #endif
8934     {
8935         struct target_epoll_event *target_ep;
8936         struct epoll_event *ep;
8937         int epfd = arg1;
8938         int maxevents = arg3;
8939         int timeout = arg4;
8940
8941         target_ep = lock_user(VERIFY_WRITE, arg2,
8942                               maxevents * sizeof(struct target_epoll_event), 1);
8943         if (!target_ep) {
8944             goto efault;
8945         }
8946
8947         ep = alloca(maxevents * sizeof(struct epoll_event));
8948
8949         switch (num) {
8950 #if defined(IMPLEMENT_EPOLL_PWAIT)
8951         case TARGET_NR_epoll_pwait:
8952         {
8953             target_sigset_t *target_set;
8954             sigset_t _set, *set = &_set;
8955
8956             if (arg5) {
8957                 target_set = lock_user(VERIFY_READ, arg5,
8958                                        sizeof(target_sigset_t), 1);
8959                 if (!target_set) {
8960                     unlock_user(target_ep, arg2, 0);
8961                     goto efault;
8962                 }
8963                 target_to_host_sigset(set, target_set);
8964                 unlock_user(target_set, arg5, 0);
8965             } else {
8966                 set = NULL;
8967             }
8968
8969             ret = get_errno(epoll_pwait(epfd, ep, maxevents, timeout, set));
8970             break;
8971         }
8972 #endif
8973 #if defined(TARGET_NR_epoll_wait)
8974         case TARGET_NR_epoll_wait:
8975             ret = get_errno(epoll_wait(epfd, ep, maxevents, timeout));
8976             break;
8977 #endif
8978         default:
8979             ret = -TARGET_ENOSYS;
8980         }
8981         if (!is_error(ret)) {
8982             int i;
8983             for (i = 0; i < ret; i++) {
8984                 target_ep[i].events = tswap32(ep[i].events);
8985                 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
8986             }
8987         }
8988         unlock_user(target_ep, arg2, ret * sizeof(struct target_epoll_event));
8989         break;
8990     }
8991 #endif
8992 #endif
8993 #ifdef TARGET_NR_prlimit64
8994     case TARGET_NR_prlimit64:
8995     {
8996         /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
8997         struct target_rlimit64 *target_rnew, *target_rold;
8998         struct host_rlimit64 rnew, rold, *rnewp = 0;
8999         if (arg3) {
9000             if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
9001                 goto efault;
9002             }
9003             rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
9004             rnew.rlim_max = tswap64(target_rnew->rlim_max);
9005             unlock_user_struct(target_rnew, arg3, 0);
9006             rnewp = &rnew;
9007         }
9008
9009         ret = get_errno(sys_prlimit64(arg1, arg2, rnewp, arg4 ? &rold : 0));
9010         if (!is_error(ret) && arg4) {
9011             if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
9012                 goto efault;
9013             }
9014             target_rold->rlim_cur = tswap64(rold.rlim_cur);
9015             target_rold->rlim_max = tswap64(rold.rlim_max);
9016             unlock_user_struct(target_rold, arg4, 1);
9017         }
9018         break;
9019     }
9020 #endif
9021 #ifdef TARGET_NR_gethostname
9022     case TARGET_NR_gethostname:
9023     {
9024         char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
9025         if (name) {
9026             ret = get_errno(gethostname(name, arg2));
9027             unlock_user(name, arg1, arg2);
9028         } else {
9029             ret = -TARGET_EFAULT;
9030         }
9031         break;
9032     }
9033 #endif
9034 #ifdef TARGET_NR_atomic_cmpxchg_32
9035     case TARGET_NR_atomic_cmpxchg_32:
9036     {
9037         /* should use start_exclusive from main.c */
9038         abi_ulong mem_value;
9039         if (get_user_u32(mem_value, arg6)) {
9040             target_siginfo_t info;
9041             info.si_signo = SIGSEGV;
9042             info.si_errno = 0;
9043             info.si_code = TARGET_SEGV_MAPERR;
9044             info._sifields._sigfault._addr = arg6;
9045             queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
9046             ret = 0xdeadbeef;
9047
9048         }
9049         if (mem_value == arg2)
9050             put_user_u32(arg1, arg6);
9051         ret = mem_value;
9052         break;
9053     }
9054 #endif
9055 #ifdef TARGET_NR_atomic_barrier
9056     case TARGET_NR_atomic_barrier:
9057     {
9058         /* Like the kernel implementation and the qemu arm barrier, no-op this? */
9059         break;
9060     }
9061 #endif
9062
9063 #ifdef TARGET_NR_timer_create
9064     case TARGET_NR_timer_create:
9065     {
9066         /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
9067
9068         struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
9069         struct target_sigevent *ptarget_sevp;
9070         struct target_timer_t *ptarget_timer;
9071
9072         int clkid = arg1;
9073         int timer_index = next_free_host_timer();
9074
9075         if (timer_index < 0) {
9076             ret = -TARGET_EAGAIN;
9077         } else {
9078             timer_t *phtimer = g_posix_timers  + timer_index;
9079
9080             if (arg2) {
9081                 if (!lock_user_struct(VERIFY_READ, ptarget_sevp, arg2, 1)) {
9082                     goto efault;
9083                 }
9084
9085                 host_sevp.sigev_signo = tswap32(ptarget_sevp->sigev_signo);
9086                 host_sevp.sigev_notify = tswap32(ptarget_sevp->sigev_notify);
9087
9088                 phost_sevp = &host_sevp;
9089             }
9090
9091             ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
9092             if (ret) {
9093                 phtimer = NULL;
9094             } else {
9095                 if (!lock_user_struct(VERIFY_WRITE, ptarget_timer, arg3, 1)) {
9096                     goto efault;
9097                 }
9098                 ptarget_timer->ptr = tswap32(0xcafe0000 | timer_index);
9099                 unlock_user_struct(ptarget_timer, arg3, 1);
9100             }
9101         }
9102         break;
9103     }
9104 #endif
9105
9106 #ifdef TARGET_NR_timer_settime
9107     case TARGET_NR_timer_settime:
9108     {
9109         /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
9110          * struct itimerspec * old_value */
9111         arg1 &= 0xffff;
9112         if (arg3 == 0 || arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
9113             ret = -TARGET_EINVAL;
9114         } else {
9115             timer_t htimer = g_posix_timers[arg1];
9116             struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
9117
9118             target_to_host_itimerspec(&hspec_new, arg3);
9119             ret = get_errno(
9120                           timer_settime(htimer, arg2, &hspec_new, &hspec_old));
9121             host_to_target_itimerspec(arg2, &hspec_old);
9122         }
9123         break;
9124     }
9125 #endif
9126
9127 #ifdef TARGET_NR_timer_gettime
9128     case TARGET_NR_timer_gettime:
9129     {
9130         /* args: timer_t timerid, struct itimerspec *curr_value */
9131         arg1 &= 0xffff;
9132         if (!arg2) {
9133             return -TARGET_EFAULT;
9134         } else if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
9135             ret = -TARGET_EINVAL;
9136         } else {
9137             timer_t htimer = g_posix_timers[arg1];
9138             struct itimerspec hspec;
9139             ret = get_errno(timer_gettime(htimer, &hspec));
9140
9141             if (host_to_target_itimerspec(arg2, &hspec)) {
9142                 ret = -TARGET_EFAULT;
9143             }
9144         }
9145         break;
9146     }
9147 #endif
9148
9149 #ifdef TARGET_NR_timer_getoverrun
9150     case TARGET_NR_timer_getoverrun:
9151     {
9152         /* args: timer_t timerid */
9153         arg1 &= 0xffff;
9154         if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
9155             ret = -TARGET_EINVAL;
9156         } else {
9157             timer_t htimer = g_posix_timers[arg1];
9158             ret = get_errno(timer_getoverrun(htimer));
9159         }
9160         break;
9161     }
9162 #endif
9163
9164 #ifdef TARGET_NR_timer_delete
9165     case TARGET_NR_timer_delete:
9166     {
9167         /* args: timer_t timerid */
9168         arg1 &= 0xffff;
9169         if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
9170             ret = -TARGET_EINVAL;
9171         } else {
9172             timer_t htimer = g_posix_timers[arg1];
9173             ret = get_errno(timer_delete(htimer));
9174             g_posix_timers[arg1] = 0;
9175         }
9176         break;
9177     }
9178 #endif
9179
9180     default:
9181     unimplemented:
9182         gemu_log("qemu: Unsupported syscall: %d\n", num);
9183 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
9184     unimplemented_nowarn:
9185 #endif
9186         ret = -TARGET_ENOSYS;
9187         break;
9188     }
9189 fail:
9190 #ifdef DEBUG
9191     gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
9192 #endif
9193     if(do_strace)
9194         print_syscall_ret(num, ret);
9195     return ret;
9196 efault:
9197     ret = -TARGET_EFAULT;
9198     goto fail;
9199 }