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