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 "qemu/osdep.h"
  21 #include "qemu/cutils.h"
  22 #include "qemu/path.h"
  23 #include "qemu/memfd.h"
  24 #include "qemu/queue.h"
  25 #include <elf.h>
  26 #include <endian.h>
  27 #include <grp.h>
  28 #include <sys/ipc.h>
  29 #include <sys/msg.h>
  30 #include <sys/wait.h>
  31 #include <sys/mount.h>
  32 #include <sys/file.h>
  33 #include <sys/fsuid.h>
  34 #include <sys/personality.h>
  35 #include <sys/prctl.h>
  36 #include <sys/resource.h>
  37 #include <sys/swap.h>
  38 #include <linux/capability.h>
  39 #include <sched.h>
  40 #include <sys/timex.h>
  41 #include <sys/socket.h>
  42 #include <linux/sockios.h>
  43 #include <sys/un.h>
  44 #include <sys/uio.h>
  45 #include <poll.h>
  46 #include <sys/times.h>
  47 #include <sys/shm.h>
  48 #include <sys/sem.h>
  49 #include <sys/statfs.h>
  50 #include <utime.h>
  51 #include <sys/sysinfo.h>
  52 #include <sys/signalfd.h>
  53 //#include <sys/user.h>
  54 #include <netinet/in.h>
  55 #include <netinet/ip.h>
  56 #include <netinet/tcp.h>
  57 #include <netinet/udp.h>
  58 #include <linux/wireless.h>
  59 #include <linux/icmp.h>
  60 #include <linux/icmpv6.h>
  61 #include <linux/if_tun.h>
  62 #include <linux/in6.h>
  63 #include <linux/errqueue.h>
  64 #include <linux/random.h>
  65 #ifdef CONFIG_TIMERFD
  66 #include <sys/timerfd.h>
  67 #endif
  68 #ifdef CONFIG_EVENTFD
  69 #include <sys/eventfd.h>
  70 #endif
  71 #ifdef CONFIG_EPOLL
  72 #include <sys/epoll.h>
  73 #endif
  74 #ifdef CONFIG_ATTR
  75 #include "qemu/xattr.h"
  76 #endif
  77 #ifdef CONFIG_SENDFILE
  78 #include <sys/sendfile.h>
  79 #endif
  80 #ifdef HAVE_SYS_KCOV_H
  81 #include <sys/kcov.h>
  82 #endif
  83
  84 #define termios host_termios
  85 #define winsize host_winsize
  86 #define termio host_termio
  87 #define sgttyb host_sgttyb /* same as target */
  88 #define tchars host_tchars /* same as target */
  89 #define ltchars host_ltchars /* same as target */
  90
  91 #include <linux/termios.h>
  92 #include <linux/unistd.h>
  93 #include <linux/cdrom.h>
  94 #include <linux/hdreg.h>
  95 #include <linux/soundcard.h>
  96 #include <linux/kd.h>
  97 #include <linux/mtio.h>
  98 #include <linux/fs.h>
  99 #include <linux/fd.h>
 100 #if defined(CONFIG_FIEMAP)
 101 #include <linux/fiemap.h>
 102 #endif
 103 #include <linux/fb.h>
 104 #if defined(CONFIG_USBFS)
 105 #include <linux/usbdevice_fs.h>
 106 #include <linux/usb/ch9.h>
 107 #endif
 108 #include <linux/vt.h>
 109 #include <linux/dm-ioctl.h>
 110 #include <linux/reboot.h>
 111 #include <linux/route.h>
 112 #include <linux/filter.h>
 113 #include <linux/blkpg.h>
 114 #include <netpacket/packet.h>
 115 #include <linux/netlink.h>
 116 #include <linux/if_alg.h>
 117 #include <linux/rtc.h>
 118 #include <sound/asound.h>
 119 #ifdef HAVE_BTRFS_H
 120 #include <linux/btrfs.h>
 121 #endif
 122 #ifdef HAVE_DRM_H
 123 #include <libdrm/drm.h>
 124 #include <libdrm/i915_drm.h>
 125 #endif
 126 #include "linux_loop.h"
 127 #include "uname.h"
 128
 129 #include "qemu.h"
 130 #include "user-internals.h"
 131 #include "strace.h"
 132 #include "signal-common.h"
 133 #include "loader.h"
 134 #include "user-mmap.h"
 135 #include "user/safe-syscall.h"
 136 #include "qemu/guest-random.h"
 137 #include "qemu/selfmap.h"
 138 #include "user/syscall-trace.h"
 139 #include "special-errno.h"
 140 #include "qapi/error.h"
 141 #include "fd-trans.h"
 142 #include "tcg/tcg.h"
 143
 144 #ifndef CLONE_IO
 145 #define CLONE_IO                0x80000000      /* Clone io context */
 146 #endif
 147
 148 /* We can't directly call the host clone syscall, because this will
 149  * badly confuse libc (breaking mutexes, for example). So we must
 150  * divide clone flags into:
 151  *  * flag combinations that look like pthread_create()
 152  *  * flag combinations that look like fork()
 153  *  * flags we can implement within QEMU itself
 154  *  * flags we can't support and will return an error for
 155  */
 156 /* For thread creation, all these flags must be present; for
 157  * fork, none must be present.
 158  */
 159 #define CLONE_THREAD_FLAGS                              \
 160     (CLONE_VM | CLONE_FS | CLONE_FILES |                \
 161      CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
 162
 163 /* These flags are ignored:
 164  * CLONE_DETACHED is now ignored by the kernel;
 165  * CLONE_IO is just an optimisation hint to the I/O scheduler
 166  */
 167 #define CLONE_IGNORED_FLAGS                     \
 168     (CLONE_DETACHED | CLONE_IO)
 169
 170 /* Flags for fork which we can implement within QEMU itself */
 171 #define CLONE_OPTIONAL_FORK_FLAGS               \
 172     (CLONE_SETTLS | CLONE_PARENT_SETTID |       \
 173      CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
 174
 175 /* Flags for thread creation which we can implement within QEMU itself */
 176 #define CLONE_OPTIONAL_THREAD_FLAGS                             \
 177     (CLONE_SETTLS | CLONE_PARENT_SETTID |                       \
 178      CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
 179
 180 #define CLONE_INVALID_FORK_FLAGS                                        \
 181     (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
 182
 183 #define CLONE_INVALID_THREAD_FLAGS                                      \
 184     (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS |     \
 185        CLONE_IGNORED_FLAGS))
 186
 187 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
 188  * have almost all been allocated. We cannot support any of
 189  * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
 190  * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
 191  * The checks against the invalid thread masks above will catch these.
 192  * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
 193  */
 194
 195 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
 196  * once. This exercises the codepaths for restart.
 197  */
 198 //#define DEBUG_ERESTARTSYS
 199
 200 //#include <linux/msdos_fs.h>
 201 #define VFAT_IOCTL_READDIR_BOTH \
 202     _IOC(_IOC_READ, 'r', 1, (sizeof(struct linux_dirent) + 256) * 2)
 203 #define VFAT_IOCTL_READDIR_SHORT \
 204     _IOC(_IOC_READ, 'r', 2, (sizeof(struct linux_dirent) + 256) * 2)
 205
 206 #undef _syscall0
 207 #undef _syscall1
 208 #undef _syscall2
 209 #undef _syscall3
 210 #undef _syscall4
 211 #undef _syscall5
 212 #undef _syscall6
 213
 214 #define _syscall0(type,name)            \
 215 static type name (void)                 \
 216 {                                       \
 217         return syscall(__NR_##name);    \
 218 }
 219
 220 #define _syscall1(type,name,type1,arg1)         \
 221 static type name (type1 arg1)                   \
 222 {                                               \
 223         return syscall(__NR_##name, arg1);      \
 224 }
 225
 226 #define _syscall2(type,name,type1,arg1,type2,arg2)      \
 227 static type name (type1 arg1,type2 arg2)                \
 228 {                                                       \
 229         return syscall(__NR_##name, arg1, arg2);        \
 230 }
 231
 232 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)   \
 233 static type name (type1 arg1,type2 arg2,type3 arg3)             \
 234 {                                                               \
 235         return syscall(__NR_##name, arg1, arg2, arg3);          \
 236 }
 237
 238 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)        \
 239 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4)                  \
 240 {                                                                               \
 241         return syscall(__NR_##name, arg1, arg2, arg3, arg4);                    \
 242 }
 243
 244 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 245                   type5,arg5)                                                   \
 246 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5)       \
 247 {                                                                               \
 248         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5);              \
 249 }
 250
 251
 252 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,        \
 253                   type5,arg5,type6,arg6)                                        \
 254 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,       \
 255                   type6 arg6)                                                   \
 256 {                                                                               \
 257         return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6);        \
 258 }
 259
 260
 261 #define __NR_sys_uname __NR_uname
 262 #define __NR_sys_getcwd1 __NR_getcwd
 263 #define __NR_sys_getdents __NR_getdents
 264 #define __NR_sys_getdents64 __NR_getdents64
 265 #define __NR_sys_getpriority __NR_getpriority
 266 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
 267 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
 268 #define __NR_sys_syslog __NR_syslog
 269 #if defined(__NR_futex)
 270 # define __NR_sys_futex __NR_futex
 271 #endif
 272 #if defined(__NR_futex_time64)
 273 # define __NR_sys_futex_time64 __NR_futex_time64
 274 #endif
 275 #define __NR_sys_statx __NR_statx
 276
 277 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
 278 #define __NR__llseek __NR_lseek
 279 #endif
 280
 281 /* Newer kernel ports have llseek() instead of _llseek() */
 282 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
 283 #define TARGET_NR__llseek TARGET_NR_llseek
 284 #endif
 285
 286 /* some platforms need to mask more bits than just TARGET_O_NONBLOCK */
 287 #ifndef TARGET_O_NONBLOCK_MASK
 288 #define TARGET_O_NONBLOCK_MASK TARGET_O_NONBLOCK
 289 #endif
 290
 291 #define __NR_sys_gettid __NR_gettid
 292 _syscall0(int, sys_gettid)
 293
 294 /* For the 64-bit guest on 32-bit host case we must emulate
 295  * getdents using getdents64, because otherwise the host
 296  * might hand us back more dirent records than we can fit
 297  * into the guest buffer after structure format conversion.
 298  * Otherwise we emulate getdents with getdents if the host has it.
 299  */
 300 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
 301 #define EMULATE_GETDENTS_WITH_GETDENTS
 302 #endif
 303
 304 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
 305 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
 306 #endif
 307 #if (defined(TARGET_NR_getdents) && \
 308       !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
 309     (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
 310 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
 311 #endif
 312 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
 313 _syscall5(int, _llseek,  uint,  fd, ulong, hi, ulong, lo,
 314           loff_t *, res, uint, wh);
 315 #endif
 316 _syscall3(int, sys_rt_sigqueueinfo, pid_t, pid, int, sig, siginfo_t *, uinfo)
 317 _syscall4(int, sys_rt_tgsigqueueinfo, pid_t, pid, pid_t, tid, int, sig,
 318           siginfo_t *, uinfo)
 319 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
 320 #ifdef __NR_exit_group
 321 _syscall1(int,exit_group,int,error_code)
 322 #endif
 323 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
 324 _syscall1(int,set_tid_address,int *,tidptr)
 325 #endif
 326 #if defined(__NR_futex)
 327 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
 328           const struct timespec *,timeout,int *,uaddr2,int,val3)
 329 #endif
 330 #if defined(__NR_futex_time64)
 331 _syscall6(int,sys_futex_time64,int *,uaddr,int,op,int,val,
 332           const struct timespec *,timeout,int *,uaddr2,int,val3)
 333 #endif
 334 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
 335 _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len,
 336           unsigned long *, user_mask_ptr);
 337 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
 338 _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len,
 339           unsigned long *, user_mask_ptr);
 340 /* sched_attr is not defined in glibc */
 341 struct sched_attr {
 342     uint32_t size;
 343     uint32_t sched_policy;
 344     uint64_t sched_flags;
 345     int32_t sched_nice;
 346     uint32_t sched_priority;
 347     uint64_t sched_runtime;
 348     uint64_t sched_deadline;
 349     uint64_t sched_period;
 350     uint32_t sched_util_min;
 351     uint32_t sched_util_max;
 352 };
 353 #define __NR_sys_sched_getattr __NR_sched_getattr
 354 _syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr,
 355           unsigned int, size, unsigned int, flags);
 356 #define __NR_sys_sched_setattr __NR_sched_setattr
 357 _syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr,
 358           unsigned int, flags);
 359 #define __NR_sys_sched_getscheduler __NR_sched_getscheduler
 360 _syscall1(int, sys_sched_getscheduler, pid_t, pid);
 361 #define __NR_sys_sched_setscheduler __NR_sched_setscheduler
 362 _syscall3(int, sys_sched_setscheduler, pid_t, pid, int, policy,
 363           const struct sched_param *, param);
 364 #define __NR_sys_sched_getparam __NR_sched_getparam
 365 _syscall2(int, sys_sched_getparam, pid_t, pid,
 366           struct sched_param *, param);
 367 #define __NR_sys_sched_setparam __NR_sched_setparam
 368 _syscall2(int, sys_sched_setparam, pid_t, pid,
 369           const struct sched_param *, param);
 370 #define __NR_sys_getcpu __NR_getcpu
 371 _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache);
 372 _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd,
 373           void *, arg);
 374 _syscall2(int, capget, struct __user_cap_header_struct *, header,
 375           struct __user_cap_data_struct *, data);
 376 _syscall2(int, capset, struct __user_cap_header_struct *, header,
 377           struct __user_cap_data_struct *, data);
 378 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
 379 _syscall2(int, ioprio_get, int, which, int, who)
 380 #endif
 381 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
 382 _syscall3(int, ioprio_set, int, which, int, who, int, ioprio)
 383 #endif
 384 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
 385 _syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags)
 386 #endif
 387
 388 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
 389 _syscall5(int, kcmp, pid_t, pid1, pid_t, pid2, int, type,
 390           unsigned long, idx1, unsigned long, idx2)
 391 #endif
 392
 393 /*
 394  * It is assumed that struct statx is architecture independent.
 395  */
 396 #if defined(TARGET_NR_statx) && defined(__NR_statx)
 397 _syscall5(int, sys_statx, int, dirfd, const char *, pathname, int, flags,
 398           unsigned int, mask, struct target_statx *, statxbuf)
 399 #endif
 400 #if defined(TARGET_NR_membarrier) && defined(__NR_membarrier)
 401 _syscall2(int, membarrier, int, cmd, int, flags)
 402 #endif
 403
 404 static const bitmask_transtbl fcntl_flags_tbl[] = {
 405   { TARGET_O_ACCMODE,   TARGET_O_WRONLY,    O_ACCMODE,   O_WRONLY,    },
 406   { TARGET_O_ACCMODE,   TARGET_O_RDWR,      O_ACCMODE,   O_RDWR,      },
 407   { TARGET_O_CREAT,     TARGET_O_CREAT,     O_CREAT,     O_CREAT,     },
 408   { TARGET_O_EXCL,      TARGET_O_EXCL,      O_EXCL,      O_EXCL,      },
 409   { TARGET_O_NOCTTY,    TARGET_O_NOCTTY,    O_NOCTTY,    O_NOCTTY,    },
 410   { TARGET_O_TRUNC,     TARGET_O_TRUNC,     O_TRUNC,     O_TRUNC,     },
 411   { TARGET_O_APPEND,    TARGET_O_APPEND,    O_APPEND,    O_APPEND,    },
 412   { TARGET_O_NONBLOCK,  TARGET_O_NONBLOCK,  O_NONBLOCK,  O_NONBLOCK,  },
 413   { TARGET_O_SYNC,      TARGET_O_DSYNC,     O_SYNC,      O_DSYNC,     },
 414   { TARGET_O_SYNC,      TARGET_O_SYNC,      O_SYNC,      O_SYNC,      },
 415   { TARGET_FASYNC,      TARGET_FASYNC,      FASYNC,      FASYNC,      },
 416   { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
 417   { TARGET_O_NOFOLLOW,  TARGET_O_NOFOLLOW,  O_NOFOLLOW,  O_NOFOLLOW,  },
 418 #if defined(O_DIRECT)
 419   { TARGET_O_DIRECT,    TARGET_O_DIRECT,    O_DIRECT,    O_DIRECT,    },
 420 #endif
 421 #if defined(O_NOATIME)
 422   { TARGET_O_NOATIME,   TARGET_O_NOATIME,   O_NOATIME,   O_NOATIME    },
 423 #endif
 424 #if defined(O_CLOEXEC)
 425   { TARGET_O_CLOEXEC,   TARGET_O_CLOEXEC,   O_CLOEXEC,   O_CLOEXEC    },
 426 #endif
 427 #if defined(O_PATH)
 428   { TARGET_O_PATH,      TARGET_O_PATH,      O_PATH,      O_PATH       },
 429 #endif
 430 #if defined(O_TMPFILE)
 431   { TARGET_O_TMPFILE,   TARGET_O_TMPFILE,   O_TMPFILE,   O_TMPFILE    },
 432 #endif
 433   /* Don't terminate the list prematurely on 64-bit host+guest.  */
 434 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
 435   { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
 436 #endif
 437   { 0, 0, 0, 0 }
 438 };
 439
 440 _syscall2(int, sys_getcwd1, char *, buf, size_t, size)
 441
 442 #if defined(TARGET_NR_utimensat) || defined(TARGET_NR_utimensat_time64)
 443 #if defined(__NR_utimensat)
 444 #define __NR_sys_utimensat __NR_utimensat
 445 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
 446           const struct timespec *,tsp,int,flags)
 447 #else
 448 static int sys_utimensat(int dirfd, const char *pathname,
 449                          const struct timespec times[2], int flags)
 450 {
 451     errno = ENOSYS;
 452     return -1;
 453 }
 454 #endif
 455 #endif /* TARGET_NR_utimensat */
 456
 457 #ifdef TARGET_NR_renameat2
 458 #if defined(__NR_renameat2)
 459 #define __NR_sys_renameat2 __NR_renameat2
 460 _syscall5(int, sys_renameat2, int, oldfd, const char *, old, int, newfd,
 461           const char *, new, unsigned int, flags)
 462 #else
 463 static int sys_renameat2(int oldfd, const char *old,
 464                          int newfd, const char *new, int flags)
 465 {
 466     if (flags == 0) {
 467         return renameat(oldfd, old, newfd, new);
 468     }
 469     errno = ENOSYS;
 470     return -1;
 471 }
 472 #endif
 473 #endif /* TARGET_NR_renameat2 */
 474
 475 #ifdef CONFIG_INOTIFY
 476 #include <sys/inotify.h>
 477 #else
 478 /* Userspace can usually survive runtime without inotify */
 479 #undef TARGET_NR_inotify_init
 480 #undef TARGET_NR_inotify_init1
 481 #undef TARGET_NR_inotify_add_watch
 482 #undef TARGET_NR_inotify_rm_watch
 483 #endif /* CONFIG_INOTIFY  */
 484
 485 #if defined(TARGET_NR_prlimit64)
 486 #ifndef __NR_prlimit64
 487 # define __NR_prlimit64 -1
 488 #endif
 489 #define __NR_sys_prlimit64 __NR_prlimit64
 490 /* The glibc rlimit structure may not be that used by the underlying syscall */
 491 struct host_rlimit64 {
 492     uint64_t rlim_cur;
 493     uint64_t rlim_max;
 494 };
 495 _syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
 496           const struct host_rlimit64 *, new_limit,
 497           struct host_rlimit64 *, old_limit)
 498 #endif
 499
 500
 501 #if defined(TARGET_NR_timer_create)
 502 /* Maximum of 32 active POSIX timers allowed at any one time. */
 503 static timer_t g_posix_timers[32] = { 0, } ;
 504
 505 static inline int next_free_host_timer(void)
 506 {
 507     int k ;
 508     /* FIXME: Does finding the next free slot require a lock? */
 509     for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) {
 510         if (g_posix_timers[k] == 0) {
 511             g_posix_timers[k] = (timer_t) 1;
 512             return k;
 513         }
 514     }
 515     return -1;
 516 }
 517 #endif
 518
 519 static inline int host_to_target_errno(int host_errno)
 520 {
 521     switch (host_errno) {
 522 #define E(X)  case X: return TARGET_##X;
 523 #include "errnos.c.inc"
 524 #undef E
 525     default:
 526         return host_errno;
 527     }
 528 }
 529
 530 static inline int target_to_host_errno(int target_errno)
 531 {
 532     switch (target_errno) {
 533 #define E(X)  case TARGET_##X: return X;
 534 #include "errnos.c.inc"
 535 #undef E
 536     default:
 537         return target_errno;
 538     }
 539 }
 540
 541 static inline abi_long get_errno(abi_long ret)
 542 {
 543     if (ret == -1)
 544         return -host_to_target_errno(errno);
 545     else
 546         return ret;
 547 }
 548
 549 const char *target_strerror(int err)
 550 {
 551     if (err == QEMU_ERESTARTSYS) {
 552         return "To be restarted";
 553     }
 554     if (err == QEMU_ESIGRETURN) {
 555         return "Successful exit from sigreturn";
 556     }
 557
 558     return strerror(target_to_host_errno(err));
 559 }
 560
 561 static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize)
 562 {
 563     int i;
 564     uint8_t b;
 565     if (usize <= ksize) {
 566         return 1;
 567     }
 568     for (i = ksize; i < usize; i++) {
 569         if (get_user_u8(b, addr + i)) {
 570             return -TARGET_EFAULT;
 571         }
 572         if (b != 0) {
 573             return 0;
 574         }
 575     }
 576     return 1;
 577 }
 578
 579 #define safe_syscall0(type, name) \
 580 static type safe_##name(void) \
 581 { \
 582     return safe_syscall(__NR_##name); \
 583 }
 584
 585 #define safe_syscall1(type, name, type1, arg1) \
 586 static type safe_##name(type1 arg1) \
 587 { \
 588     return safe_syscall(__NR_##name, arg1); \
 589 }
 590
 591 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
 592 static type safe_##name(type1 arg1, type2 arg2) \
 593 { \
 594     return safe_syscall(__NR_##name, arg1, arg2); \
 595 }
 596
 597 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
 598 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
 599 { \
 600     return safe_syscall(__NR_##name, arg1, arg2, arg3); \
 601 }
 602
 603 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
 604     type4, arg4) \
 605 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
 606 { \
 607     return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
 608 }
 609
 610 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
 611     type4, arg4, type5, arg5) \
 612 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
 613     type5 arg5) \
 614 { \
 615     return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
 616 }
 617
 618 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
 619     type4, arg4, type5, arg5, type6, arg6) \
 620 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
 621     type5 arg5, type6 arg6) \
 622 { \
 623     return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
 624 }
 625
 626 safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count)
 627 safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)
 628 safe_syscall4(int, openat, int, dirfd, const char *, pathname, \
 629               int, flags, mode_t, mode)
 630 #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid)
 631 safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \
 632               struct rusage *, rusage)
 633 #endif
 634 safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
 635               int, options, struct rusage *, rusage)
 636 safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
 637 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
 638     defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
 639 safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
 640               fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
 641 #endif
 642 #if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
 643 safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
 644               struct timespec *, tsp, const sigset_t *, sigmask,
 645               size_t, sigsetsize)
 646 #endif
 647 safe_syscall6(int, epoll_pwait, int, epfd, struct epoll_event *, events,
 648               int, maxevents, int, timeout, const sigset_t *, sigmask,
 649               size_t, sigsetsize)
 650 #if defined(__NR_futex)
 651 safe_syscall6(int,futex,int *,uaddr,int,op,int,val, \
 652               const struct timespec *,timeout,int *,uaddr2,int,val3)
 653 #endif
 654 #if defined(__NR_futex_time64)
 655 safe_syscall6(int,futex_time64,int *,uaddr,int,op,int,val, \
 656               const struct timespec *,timeout,int *,uaddr2,int,val3)
 657 #endif
 658 safe_syscall2(int, rt_sigsuspend, sigset_t *, newset, size_t, sigsetsize)
 659 safe_syscall2(int, kill, pid_t, pid, int, sig)
 660 safe_syscall2(int, tkill, int, tid, int, sig)
 661 safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig)
 662 safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt)
 663 safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt)
 664 safe_syscall5(ssize_t, preadv, int, fd, const struct iovec *, iov, int, iovcnt,
 665               unsigned long, pos_l, unsigned long, pos_h)
 666 safe_syscall5(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt,
 667               unsigned long, pos_l, unsigned long, pos_h)
 668 safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr,
 669               socklen_t, addrlen)
 670 safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len,
 671               int, flags, const struct sockaddr *, addr, socklen_t, addrlen)
 672 safe_syscall6(ssize_t, recvfrom, int, fd, void *, buf, size_t, len,
 673               int, flags, struct sockaddr *, addr, socklen_t *, addrlen)
 674 safe_syscall3(ssize_t, sendmsg, int, fd, const struct msghdr *, msg, int, flags)
 675 safe_syscall3(ssize_t, recvmsg, int, fd, struct msghdr *, msg, int, flags)
 676 safe_syscall2(int, flock, int, fd, int, operation)
 677 #if defined(TARGET_NR_rt_sigtimedwait) || defined(TARGET_NR_rt_sigtimedwait_time64)
 678 safe_syscall4(int, rt_sigtimedwait, const sigset_t *, these, siginfo_t *, uinfo,
 679               const struct timespec *, uts, size_t, sigsetsize)
 680 #endif
 681 safe_syscall4(int, accept4, int, fd, struct sockaddr *, addr, socklen_t *, len,
 682               int, flags)
 683 #if defined(TARGET_NR_nanosleep)
 684 safe_syscall2(int, nanosleep, const struct timespec *, req,
 685               struct timespec *, rem)
 686 #endif
 687 #if defined(TARGET_NR_clock_nanosleep) || \
 688     defined(TARGET_NR_clock_nanosleep_time64)
 689 safe_syscall4(int, clock_nanosleep, const clockid_t, clock, int, flags,
 690               const struct timespec *, req, struct timespec *, rem)
 691 #endif
 692 #ifdef __NR_ipc
 693 #ifdef __s390x__
 694 safe_syscall5(int, ipc, int, call, long, first, long, second, long, third,
 695               void *, ptr)
 696 #else
 697 safe_syscall6(int, ipc, int, call, long, first, long, second, long, third,
 698               void *, ptr, long, fifth)
 699 #endif
 700 #endif
 701 #ifdef __NR_msgsnd
 702 safe_syscall4(int, msgsnd, int, msgid, const void *, msgp, size_t, sz,
 703               int, flags)
 704 #endif
 705 #ifdef __NR_msgrcv
 706 safe_syscall5(int, msgrcv, int, msgid, void *, msgp, size_t, sz,
 707               long, msgtype, int, flags)
 708 #endif
 709 #ifdef __NR_semtimedop
 710 safe_syscall4(int, semtimedop, int, semid, struct sembuf *, tsops,
 711               unsigned, nsops, const struct timespec *, timeout)
 712 #endif
 713 #if defined(TARGET_NR_mq_timedsend) || \
 714     defined(TARGET_NR_mq_timedsend_time64)
 715 safe_syscall5(int, mq_timedsend, int, mqdes, const char *, msg_ptr,
 716               size_t, len, unsigned, prio, const struct timespec *, timeout)
 717 #endif
 718 #if defined(TARGET_NR_mq_timedreceive) || \
 719     defined(TARGET_NR_mq_timedreceive_time64)
 720 safe_syscall5(int, mq_timedreceive, int, mqdes, char *, msg_ptr,
 721               size_t, len, unsigned *, prio, const struct timespec *, timeout)
 722 #endif
 723 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range)
 724 safe_syscall6(ssize_t, copy_file_range, int, infd, loff_t *, pinoff,
 725               int, outfd, loff_t *, poutoff, size_t, length,
 726               unsigned int, flags)
 727 #endif
 728
 729 /* We do ioctl like this rather than via safe_syscall3 to preserve the
 730  * "third argument might be integer or pointer or not present" behaviour of
 731  * the libc function.
 732  */
 733 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
 734 /* Similarly for fcntl. Note that callers must always:
 735  *  pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
 736  *  use the flock64 struct rather than unsuffixed flock
 737  * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
 738  */
 739 #ifdef __NR_fcntl64
 740 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
 741 #else
 742 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
 743 #endif
 744
 745 static inline int host_to_target_sock_type(int host_type)
 746 {
 747     int target_type;
 748
 749     switch (host_type & 0xf /* SOCK_TYPE_MASK */) {
 750     case SOCK_DGRAM:
 751         target_type = TARGET_SOCK_DGRAM;
 752         break;
 753     case SOCK_STREAM:
 754         target_type = TARGET_SOCK_STREAM;
 755         break;
 756     default:
 757         target_type = host_type & 0xf /* SOCK_TYPE_MASK */;
 758         break;
 759     }
 760
 761 #if defined(SOCK_CLOEXEC)
 762     if (host_type & SOCK_CLOEXEC) {
 763         target_type |= TARGET_SOCK_CLOEXEC;
 764     }
 765 #endif
 766
 767 #if defined(SOCK_NONBLOCK)
 768     if (host_type & SOCK_NONBLOCK) {
 769         target_type |= TARGET_SOCK_NONBLOCK;
 770     }
 771 #endif
 772
 773     return target_type;
 774 }
 775
 776 static abi_ulong target_brk;
 777 static abi_ulong target_original_brk;
 778 static abi_ulong brk_page;
 779
 780 void target_set_brk(abi_ulong new_brk)
 781 {
 782     target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
 783     brk_page = HOST_PAGE_ALIGN(target_brk);
 784 }
 785
 786 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
 787 #define DEBUGF_BRK(message, args...)
 788
 789 /* do_brk() must return target values and target errnos. */
 790 abi_long do_brk(abi_ulong new_brk)
 791 {
 792     abi_long mapped_addr;
 793     abi_ulong new_alloc_size;
 794
 795     /* brk pointers are always untagged */
 796
 797     DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk);
 798
 799     if (!new_brk) {
 800         DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk);
 801         return target_brk;
 802     }
 803     if (new_brk < target_original_brk) {
 804         DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n",
 805                    target_brk);
 806         return target_brk;
 807     }
 808
 809     /* If the new brk is less than the highest page reserved to the
 810      * target heap allocation, set it and we're almost done...  */
 811     if (new_brk <= brk_page) {
 812         /* Heap contents are initialized to zero, as for anonymous
 813          * mapped pages.  */
 814         if (new_brk > target_brk) {
 815             memset(g2h_untagged(target_brk), 0, new_brk - target_brk);
 816         }
 817         target_brk = new_brk;
 818         DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk);
 819         return target_brk;
 820     }
 821
 822     /* We need to allocate more memory after the brk... Note that
 823      * we don't use MAP_FIXED because that will map over the top of
 824      * any existing mapping (like the one with the host libc or qemu
 825      * itself); instead we treat "mapped but at wrong address" as
 826      * a failure and unmap again.
 827      */
 828     new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page);
 829     mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
 830                                         PROT_READ|PROT_WRITE,
 831                                         MAP_ANON|MAP_PRIVATE, 0, 0));
 832
 833     if (mapped_addr == brk_page) {
 834         /* Heap contents are initialized to zero, as for anonymous
 835          * mapped pages.  Technically the new pages are already
 836          * initialized to zero since they *are* anonymous mapped
 837          * pages, however we have to take care with the contents that
 838          * come from the remaining part of the previous page: it may
 839          * contains garbage data due to a previous heap usage (grown
 840          * then shrunken).  */
 841         memset(g2h_untagged(target_brk), 0, brk_page - target_brk);
 842
 843         target_brk = new_brk;
 844         brk_page = HOST_PAGE_ALIGN(target_brk);
 845         DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n",
 846             target_brk);
 847         return target_brk;
 848     } else if (mapped_addr != -1) {
 849         /* Mapped but at wrong address, meaning there wasn't actually
 850          * enough space for this brk.
 851          */
 852         target_munmap(mapped_addr, new_alloc_size);
 853         mapped_addr = -1;
 854         DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk);
 855     }
 856     else {
 857         DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk);
 858     }
 859
 860 #if defined(TARGET_ALPHA)
 861     /* We (partially) emulate OSF/1 on Alpha, which requires we
 862        return a proper errno, not an unchanged brk value.  */
 863     return -TARGET_ENOMEM;
 864 #endif
 865     /* For everything else, return the previous break. */
 866     return target_brk;
 867 }
 868
 869 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
 870     defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
 871 static inline abi_long copy_from_user_fdset(fd_set *fds,
 872                                             abi_ulong target_fds_addr,
 873                                             int n)
 874 {
 875     int i, nw, j, k;
 876     abi_ulong b, *target_fds;
 877
 878     nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
 879     if (!(target_fds = lock_user(VERIFY_READ,
 880                                  target_fds_addr,
 881                                  sizeof(abi_ulong) * nw,
 882                                  1)))
 883         return -TARGET_EFAULT;
 884
 885     FD_ZERO(fds);
 886     k = 0;
 887     for (i = 0; i < nw; i++) {
 888         /* grab the abi_ulong */
 889         __get_user(b, &target_fds[i]);
 890         for (j = 0; j < TARGET_ABI_BITS; j++) {
 891             /* check the bit inside the abi_ulong */
 892             if ((b >> j) & 1)
 893                 FD_SET(k, fds);
 894             k++;
 895         }
 896     }
 897
 898     unlock_user(target_fds, target_fds_addr, 0);
 899
 900     return 0;
 901 }
 902
 903 static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr,
 904                                                  abi_ulong target_fds_addr,
 905                                                  int n)
 906 {
 907     if (target_fds_addr) {
 908         if (copy_from_user_fdset(fds, target_fds_addr, n))
 909             return -TARGET_EFAULT;
 910         *fds_ptr = fds;
 911     } else {
 912         *fds_ptr = NULL;
 913     }
 914     return 0;
 915 }
 916
 917 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
 918                                           const fd_set *fds,
 919                                           int n)
 920 {
 921     int i, nw, j, k;
 922     abi_long v;
 923     abi_ulong *target_fds;
 924
 925     nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
 926     if (!(target_fds = lock_user(VERIFY_WRITE,
 927                                  target_fds_addr,
 928                                  sizeof(abi_ulong) * nw,
 929                                  0)))
 930         return -TARGET_EFAULT;
 931
 932     k = 0;
 933     for (i = 0; i < nw; i++) {
 934         v = 0;
 935         for (j = 0; j < TARGET_ABI_BITS; j++) {
 936             v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j);
 937             k++;
 938         }
 939         __put_user(v, &target_fds[i]);
 940     }
 941
 942     unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
 943
 944     return 0;
 945 }
 946 #endif
 947
 948 #if defined(__alpha__)
 949 #define HOST_HZ 1024
 950 #else
 951 #define HOST_HZ 100
 952 #endif
 953
 954 static inline abi_long host_to_target_clock_t(long ticks)
 955 {
 956 #if HOST_HZ == TARGET_HZ
 957     return ticks;
 958 #else
 959     return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
 960 #endif
 961 }
 962
 963 static inline abi_long host_to_target_rusage(abi_ulong target_addr,
 964                                              const struct rusage *rusage)
 965 {
 966     struct target_rusage *target_rusage;
 967
 968     if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
 969         return -TARGET_EFAULT;
 970     target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec);
 971     target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec);
 972     target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec);
 973     target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec);
 974     target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss);
 975     target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss);
 976     target_rusage->ru_idrss = tswapal(rusage->ru_idrss);
 977     target_rusage->ru_isrss = tswapal(rusage->ru_isrss);
 978     target_rusage->ru_minflt = tswapal(rusage->ru_minflt);
 979     target_rusage->ru_majflt = tswapal(rusage->ru_majflt);
 980     target_rusage->ru_nswap = tswapal(rusage->ru_nswap);
 981     target_rusage->ru_inblock = tswapal(rusage->ru_inblock);
 982     target_rusage->ru_oublock = tswapal(rusage->ru_oublock);
 983     target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd);
 984     target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv);
 985     target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals);
 986     target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw);
 987     target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw);
 988     unlock_user_struct(target_rusage, target_addr, 1);
 989
 990     return 0;
 991 }
 992
 993 #ifdef TARGET_NR_setrlimit
 994 static inline rlim_t target_to_host_rlim(abi_ulong target_rlim)
 995 {
 996     abi_ulong target_rlim_swap;
 997     rlim_t result;
 998
 999     target_rlim_swap = tswapal(target_rlim);
1000     if (target_rlim_swap == TARGET_RLIM_INFINITY)
1001         return RLIM_INFINITY;
1002
1003     result = target_rlim_swap;
1004     if (target_rlim_swap != (rlim_t)result)
1005         return RLIM_INFINITY;
1006
1007     return result;
1008 }
1009 #endif
1010
1011 #if defined(TARGET_NR_getrlimit) || defined(TARGET_NR_ugetrlimit)
1012 static inline abi_ulong host_to_target_rlim(rlim_t rlim)
1013 {
1014     abi_ulong target_rlim_swap;
1015     abi_ulong result;
1016
1017     if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim)
1018         target_rlim_swap = TARGET_RLIM_INFINITY;
1019     else
1020         target_rlim_swap = rlim;
1021     result = tswapal(target_rlim_swap);
1022
1023     return result;
1024 }
1025 #endif
1026
1027 static inline int target_to_host_resource(int code)
1028 {
1029     switch (code) {
1030     case TARGET_RLIMIT_AS:
1031         return RLIMIT_AS;
1032     case TARGET_RLIMIT_CORE:
1033         return RLIMIT_CORE;
1034     case TARGET_RLIMIT_CPU:
1035         return RLIMIT_CPU;
1036     case TARGET_RLIMIT_DATA:
1037         return RLIMIT_DATA;
1038     case TARGET_RLIMIT_FSIZE:
1039         return RLIMIT_FSIZE;
1040     case TARGET_RLIMIT_LOCKS:
1041         return RLIMIT_LOCKS;
1042     case TARGET_RLIMIT_MEMLOCK:
1043         return RLIMIT_MEMLOCK;
1044     case TARGET_RLIMIT_MSGQUEUE:
1045         return RLIMIT_MSGQUEUE;
1046     case TARGET_RLIMIT_NICE:
1047         return RLIMIT_NICE;
1048     case TARGET_RLIMIT_NOFILE:
1049         return RLIMIT_NOFILE;
1050     case TARGET_RLIMIT_NPROC:
1051         return RLIMIT_NPROC;
1052     case TARGET_RLIMIT_RSS:
1053         return RLIMIT_RSS;
1054     case TARGET_RLIMIT_RTPRIO:
1055         return RLIMIT_RTPRIO;
1056     case TARGET_RLIMIT_SIGPENDING:
1057         return RLIMIT_SIGPENDING;
1058     case TARGET_RLIMIT_STACK:
1059         return RLIMIT_STACK;
1060     default:
1061         return code;
1062     }
1063 }
1064
1065 static inline abi_long copy_from_user_timeval(struct timeval *tv,
1066                                               abi_ulong target_tv_addr)
1067 {
1068     struct target_timeval *target_tv;
1069
1070     if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) {
1071         return -TARGET_EFAULT;
1072     }
1073
1074     __get_user(tv->tv_sec, &target_tv->tv_sec);
1075     __get_user(tv->tv_usec, &target_tv->tv_usec);
1076
1077     unlock_user_struct(target_tv, target_tv_addr, 0);
1078
1079     return 0;
1080 }
1081
1082 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
1083                                             const struct timeval *tv)
1084 {
1085     struct target_timeval *target_tv;
1086
1087     if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) {
1088         return -TARGET_EFAULT;
1089     }
1090
1091     __put_user(tv->tv_sec, &target_tv->tv_sec);
1092     __put_user(tv->tv_usec, &target_tv->tv_usec);
1093
1094     unlock_user_struct(target_tv, target_tv_addr, 1);
1095
1096     return 0;
1097 }
1098
1099 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
1100 static inline abi_long copy_from_user_timeval64(struct timeval *tv,
1101                                                 abi_ulong target_tv_addr)
1102 {
1103     struct target__kernel_sock_timeval *target_tv;
1104
1105     if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) {
1106         return -TARGET_EFAULT;
1107     }
1108
1109     __get_user(tv->tv_sec, &target_tv->tv_sec);
1110     __get_user(tv->tv_usec, &target_tv->tv_usec);
1111
1112     unlock_user_struct(target_tv, target_tv_addr, 0);
1113
1114     return 0;
1115 }
1116 #endif
1117
1118 static inline abi_long copy_to_user_timeval64(abi_ulong target_tv_addr,
1119                                               const struct timeval *tv)
1120 {
1121     struct target__kernel_sock_timeval *target_tv;
1122
1123     if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) {
1124         return -TARGET_EFAULT;
1125     }
1126
1127     __put_user(tv->tv_sec, &target_tv->tv_sec);
1128     __put_user(tv->tv_usec, &target_tv->tv_usec);
1129
1130     unlock_user_struct(target_tv, target_tv_addr, 1);
1131
1132     return 0;
1133 }
1134
1135 #if defined(TARGET_NR_futex) || \
1136     defined(TARGET_NR_rt_sigtimedwait) || \
1137     defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6) || \
1138     defined(TARGET_NR_nanosleep) || defined(TARGET_NR_clock_settime) || \
1139     defined(TARGET_NR_utimensat) || defined(TARGET_NR_mq_timedsend) || \
1140     defined(TARGET_NR_mq_timedreceive) || defined(TARGET_NR_ipc) || \
1141     defined(TARGET_NR_semop) || defined(TARGET_NR_semtimedop) || \
1142     defined(TARGET_NR_timer_settime) || \
1143     (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
1144 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
1145                                                abi_ulong target_addr)
1146 {
1147     struct target_timespec *target_ts;
1148
1149     if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) {
1150         return -TARGET_EFAULT;
1151     }
1152     __get_user(host_ts->tv_sec, &target_ts->tv_sec);
1153     __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1154     unlock_user_struct(target_ts, target_addr, 0);
1155     return 0;
1156 }
1157 #endif
1158
1159 #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
1160     defined(TARGET_NR_timer_settime64) || \
1161     defined(TARGET_NR_mq_timedsend_time64) || \
1162     defined(TARGET_NR_mq_timedreceive_time64) || \
1163     (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)) || \
1164     defined(TARGET_NR_clock_nanosleep_time64) || \
1165     defined(TARGET_NR_rt_sigtimedwait_time64) || \
1166     defined(TARGET_NR_utimensat) || \
1167     defined(TARGET_NR_utimensat_time64) || \
1168     defined(TARGET_NR_semtimedop_time64) || \
1169     defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
1170 static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
1171                                                  abi_ulong target_addr)
1172 {
1173     struct target__kernel_timespec *target_ts;
1174
1175     if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) {
1176         return -TARGET_EFAULT;
1177     }
1178     __get_user(host_ts->tv_sec, &target_ts->tv_sec);
1179     __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1180     /* in 32bit mode, this drops the padding */
1181     host_ts->tv_nsec = (long)(abi_long)host_ts->tv_nsec;
1182     unlock_user_struct(target_ts, target_addr, 0);
1183     return 0;
1184 }
1185 #endif
1186
1187 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
1188                                                struct timespec *host_ts)
1189 {
1190     struct target_timespec *target_ts;
1191
1192     if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) {
1193         return -TARGET_EFAULT;
1194     }
1195     __put_user(host_ts->tv_sec, &target_ts->tv_sec);
1196     __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1197     unlock_user_struct(target_ts, target_addr, 1);
1198     return 0;
1199 }
1200
1201 static inline abi_long host_to_target_timespec64(abi_ulong target_addr,
1202                                                  struct timespec *host_ts)
1203 {
1204     struct target__kernel_timespec *target_ts;
1205
1206     if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) {
1207         return -TARGET_EFAULT;
1208     }
1209     __put_user(host_ts->tv_sec, &target_ts->tv_sec);
1210     __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1211     unlock_user_struct(target_ts, target_addr, 1);
1212     return 0;
1213 }
1214
1215 #if defined(TARGET_NR_gettimeofday)
1216 static inline abi_long copy_to_user_timezone(abi_ulong target_tz_addr,
1217                                              struct timezone *tz)
1218 {
1219     struct target_timezone *target_tz;
1220
1221     if (!lock_user_struct(VERIFY_WRITE, target_tz, target_tz_addr, 1)) {
1222         return -TARGET_EFAULT;
1223     }
1224
1225     __put_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1226     __put_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1227
1228     unlock_user_struct(target_tz, target_tz_addr, 1);
1229
1230     return 0;
1231 }
1232 #endif
1233
1234 #if defined(TARGET_NR_settimeofday)
1235 static inline abi_long copy_from_user_timezone(struct timezone *tz,
1236                                                abi_ulong target_tz_addr)
1237 {
1238     struct target_timezone *target_tz;
1239
1240     if (!lock_user_struct(VERIFY_READ, target_tz, target_tz_addr, 1)) {
1241         return -TARGET_EFAULT;
1242     }
1243
1244     __get_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1245     __get_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1246
1247     unlock_user_struct(target_tz, target_tz_addr, 0);
1248
1249     return 0;
1250 }
1251 #endif
1252
1253 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1254 #include <mqueue.h>
1255
1256 static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr,
1257                                               abi_ulong target_mq_attr_addr)
1258 {
1259     struct target_mq_attr *target_mq_attr;
1260
1261     if (!lock_user_struct(VERIFY_READ, target_mq_attr,
1262                           target_mq_attr_addr, 1))
1263         return -TARGET_EFAULT;
1264
1265     __get_user(attr->mq_flags, &target_mq_attr->mq_flags);
1266     __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1267     __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1268     __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1269
1270     unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0);
1271
1272     return 0;
1273 }
1274
1275 static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr,
1276                                             const struct mq_attr *attr)
1277 {
1278     struct target_mq_attr *target_mq_attr;
1279
1280     if (!lock_user_struct(VERIFY_WRITE, target_mq_attr,
1281                           target_mq_attr_addr, 0))
1282         return -TARGET_EFAULT;
1283
1284     __put_user(attr->mq_flags, &target_mq_attr->mq_flags);
1285     __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1286     __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1287     __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1288
1289     unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1);
1290
1291     return 0;
1292 }
1293 #endif
1294
1295 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1296 /* do_select() must return target values and target errnos. */
1297 static abi_long do_select(int n,
1298                           abi_ulong rfd_addr, abi_ulong wfd_addr,
1299                           abi_ulong efd_addr, abi_ulong target_tv_addr)
1300 {
1301     fd_set rfds, wfds, efds;
1302     fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
1303     struct timeval tv;
1304     struct timespec ts, *ts_ptr;
1305     abi_long ret;
1306
1307     ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
1308     if (ret) {
1309         return ret;
1310     }
1311     ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
1312     if (ret) {
1313         return ret;
1314     }
1315     ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
1316     if (ret) {
1317         return ret;
1318     }
1319
1320     if (target_tv_addr) {
1321         if (copy_from_user_timeval(&tv, target_tv_addr))
1322             return -TARGET_EFAULT;
1323         ts.tv_sec = tv.tv_sec;
1324         ts.tv_nsec = tv.tv_usec * 1000;
1325         ts_ptr = &ts;
1326     } else {
1327         ts_ptr = NULL;
1328     }
1329
1330     ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
1331                                   ts_ptr, NULL));
1332
1333     if (!is_error(ret)) {
1334         if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
1335             return -TARGET_EFAULT;
1336         if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
1337             return -TARGET_EFAULT;
1338         if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
1339             return -TARGET_EFAULT;
1340
1341         if (target_tv_addr) {
1342             tv.tv_sec = ts.tv_sec;
1343             tv.tv_usec = ts.tv_nsec / 1000;
1344             if (copy_to_user_timeval(target_tv_addr, &tv)) {
1345                 return -TARGET_EFAULT;
1346             }
1347         }
1348     }
1349
1350     return ret;
1351 }
1352
1353 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1354 static abi_long do_old_select(abi_ulong arg1)
1355 {
1356     struct target_sel_arg_struct *sel;
1357     abi_ulong inp, outp, exp, tvp;
1358     long nsel;
1359
1360     if (!lock_user_struct(VERIFY_READ, sel, arg1, 1)) {
1361         return -TARGET_EFAULT;
1362     }
1363
1364     nsel = tswapal(sel->n);
1365     inp = tswapal(sel->inp);
1366     outp = tswapal(sel->outp);
1367     exp = tswapal(sel->exp);
1368     tvp = tswapal(sel->tvp);
1369
1370     unlock_user_struct(sel, arg1, 0);
1371
1372     return do_select(nsel, inp, outp, exp, tvp);
1373 }
1374 #endif
1375 #endif
1376
1377 #if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
1378 static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
1379                             abi_long arg4, abi_long arg5, abi_long arg6,
1380                             bool time64)
1381 {
1382     abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
1383     fd_set rfds, wfds, efds;
1384     fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
1385     struct timespec ts, *ts_ptr;
1386     abi_long ret;
1387
1388     /*
1389      * The 6th arg is actually two args smashed together,
1390      * so we cannot use the C library.
1391      */
1392     sigset_t set;
1393     struct {
1394         sigset_t *set;
1395         size_t size;
1396     } sig, *sig_ptr;
1397
1398     abi_ulong arg_sigset, arg_sigsize, *arg7;
1399     target_sigset_t *target_sigset;
1400
1401     n = arg1;
1402     rfd_addr = arg2;
1403     wfd_addr = arg3;
1404     efd_addr = arg4;
1405     ts_addr = arg5;
1406
1407     ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
1408     if (ret) {
1409         return ret;
1410     }
1411     ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
1412     if (ret) {
1413         return ret;
1414     }
1415     ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
1416     if (ret) {
1417         return ret;
1418     }
1419
1420     /*
1421      * This takes a timespec, and not a timeval, so we cannot
1422      * use the do_select() helper ...
1423      */
1424     if (ts_addr) {
1425         if (time64) {
1426             if (target_to_host_timespec64(&ts, ts_addr)) {
1427                 return -TARGET_EFAULT;
1428             }
1429         } else {
1430             if (target_to_host_timespec(&ts, ts_addr)) {
1431                 return -TARGET_EFAULT;
1432             }
1433         }
1434             ts_ptr = &ts;
1435     } else {
1436         ts_ptr = NULL;
1437     }
1438
1439     /* Extract the two packed args for the sigset */
1440     if (arg6) {
1441         sig_ptr = &sig;
1442         sig.size = SIGSET_T_SIZE;
1443
1444         arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
1445         if (!arg7) {
1446             return -TARGET_EFAULT;
1447         }
1448         arg_sigset = tswapal(arg7[0]);
1449         arg_sigsize = tswapal(arg7[1]);
1450         unlock_user(arg7, arg6, 0);
1451
1452         if (arg_sigset) {
1453             sig.set = &set;
1454             if (arg_sigsize != sizeof(*target_sigset)) {
1455                 /* Like the kernel, we enforce correct size sigsets */
1456                 return -TARGET_EINVAL;
1457             }
1458             target_sigset = lock_user(VERIFY_READ, arg_sigset,
1459                                       sizeof(*target_sigset), 1);
1460             if (!target_sigset) {
1461                 return -TARGET_EFAULT;
1462             }
1463             target_to_host_sigset(&set, target_sigset);
1464             unlock_user(target_sigset, arg_sigset, 0);
1465         } else {
1466             sig.set = NULL;
1467         }
1468     } else {
1469         sig_ptr = NULL;
1470     }
1471
1472     ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
1473                                   ts_ptr, sig_ptr));
1474
1475     if (!is_error(ret)) {
1476         if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
1477             return -TARGET_EFAULT;
1478         }
1479         if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
1480             return -TARGET_EFAULT;
1481         }
1482         if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
1483             return -TARGET_EFAULT;
1484         }
1485         if (time64) {
1486             if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
1487                 return -TARGET_EFAULT;
1488             }
1489         } else {
1490             if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
1491                 return -TARGET_EFAULT;
1492             }
1493         }
1494     }
1495     return ret;
1496 }
1497 #endif
1498
1499 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
1500     defined(TARGET_NR_ppoll_time64)
1501 static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
1502                          abi_long arg4, abi_long arg5, bool ppoll, bool time64)
1503 {
1504     struct target_pollfd *target_pfd;
1505     unsigned int nfds = arg2;
1506     struct pollfd *pfd;
1507     unsigned int i;
1508     abi_long ret;
1509
1510     pfd = NULL;
1511     target_pfd = NULL;
1512     if (nfds) {
1513         if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
1514             return -TARGET_EINVAL;
1515         }
1516         target_pfd = lock_user(VERIFY_WRITE, arg1,
1517                                sizeof(struct target_pollfd) * nfds, 1);
1518         if (!target_pfd) {
1519             return -TARGET_EFAULT;
1520         }
1521
1522         pfd = alloca(sizeof(struct pollfd) * nfds);
1523         for (i = 0; i < nfds; i++) {
1524             pfd[i].fd = tswap32(target_pfd[i].fd);
1525             pfd[i].events = tswap16(target_pfd[i].events);
1526         }
1527     }
1528     if (ppoll) {
1529         struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
1530         target_sigset_t *target_set;
1531         sigset_t _set, *set = &_set;
1532
1533         if (arg3) {
1534             if (time64) {
1535                 if (target_to_host_timespec64(timeout_ts, arg3)) {
1536                     unlock_user(target_pfd, arg1, 0);
1537                     return -TARGET_EFAULT;
1538                 }
1539             } else {
1540                 if (target_to_host_timespec(timeout_ts, arg3)) {
1541                     unlock_user(target_pfd, arg1, 0);
1542                     return -TARGET_EFAULT;
1543                 }
1544             }
1545         } else {
1546             timeout_ts = NULL;
1547         }
1548
1549         if (arg4) {
1550             if (arg5 != sizeof(target_sigset_t)) {
1551                 unlock_user(target_pfd, arg1, 0);
1552                 return -TARGET_EINVAL;
1553             }
1554
1555             target_set = lock_user(VERIFY_READ, arg4,
1556                                    sizeof(target_sigset_t), 1);
1557             if (!target_set) {
1558                 unlock_user(target_pfd, arg1, 0);
1559                 return -TARGET_EFAULT;
1560             }
1561             target_to_host_sigset(set, target_set);
1562         } else {
1563             set = NULL;
1564         }
1565
1566         ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
1567                                    set, SIGSET_T_SIZE));
1568
1569         if (!is_error(ret) && arg3) {
1570             if (time64) {
1571                 if (host_to_target_timespec64(arg3, timeout_ts)) {
1572                     return -TARGET_EFAULT;
1573                 }
1574             } else {
1575                 if (host_to_target_timespec(arg3, timeout_ts)) {
1576                     return -TARGET_EFAULT;
1577                 }
1578             }
1579         }
1580         if (arg4) {
1581             unlock_user(target_set, arg4, 0);
1582         }
1583     } else {
1584           struct timespec ts, *pts;
1585
1586           if (arg3 >= 0) {
1587               /* Convert ms to secs, ns */
1588               ts.tv_sec = arg3 / 1000;
1589               ts.tv_nsec = (arg3 % 1000) * 1000000LL;
1590               pts = &ts;
1591           } else {
1592               /* -ve poll() timeout means "infinite" */
1593               pts = NULL;
1594           }
1595           ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
1596     }
1597
1598     if (!is_error(ret)) {
1599         for (i = 0; i < nfds; i++) {
1600             target_pfd[i].revents = tswap16(pfd[i].revents);
1601         }
1602     }
1603     unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
1604     return ret;
1605 }
1606 #endif
1607
1608 static abi_long do_pipe2(int host_pipe[], int flags)
1609 {
1610 #ifdef CONFIG_PIPE2
1611     return pipe2(host_pipe, flags);
1612 #else
1613     return -ENOSYS;
1614 #endif
1615 }
1616
1617 static abi_long do_pipe(void *cpu_env, abi_ulong pipedes,
1618                         int flags, int is_pipe2)
1619 {
1620     int host_pipe[2];
1621     abi_long ret;
1622     ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe);
1623
1624     if (is_error(ret))
1625         return get_errno(ret);
1626
1627     /* Several targets have special calling conventions for the original
1628        pipe syscall, but didn't replicate this into the pipe2 syscall.  */
1629     if (!is_pipe2) {
1630 #if defined(TARGET_ALPHA)
1631         ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1];
1632         return host_pipe[0];
1633 #elif defined(TARGET_MIPS)
1634         ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1];
1635         return host_pipe[0];
1636 #elif defined(TARGET_SH4)
1637         ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
1638         return host_pipe[0];
1639 #elif defined(TARGET_SPARC)
1640         ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1];
1641         return host_pipe[0];
1642 #endif
1643     }
1644
1645     if (put_user_s32(host_pipe[0], pipedes)
1646         || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0])))
1647         return -TARGET_EFAULT;
1648     return get_errno(ret);
1649 }
1650
1651 static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn,
1652                                               abi_ulong target_addr,
1653                                               socklen_t len)
1654 {
1655     struct target_ip_mreqn *target_smreqn;
1656
1657     target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1);
1658     if (!target_smreqn)
1659         return -TARGET_EFAULT;
1660     mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr;
1661     mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr;
1662     if (len == sizeof(struct target_ip_mreqn))
1663         mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex);
1664     unlock_user(target_smreqn, target_addr, 0);
1665
1666     return 0;
1667 }
1668
1669 static inline abi_long target_to_host_sockaddr(int fd, struct sockaddr *addr,
1670                                                abi_ulong target_addr,
1671                                                socklen_t len)
1672 {
1673     const socklen_t unix_maxlen = sizeof (struct sockaddr_un);
1674     sa_family_t sa_family;
1675     struct target_sockaddr *target_saddr;
1676
1677     if (fd_trans_target_to_host_addr(fd)) {
1678         return fd_trans_target_to_host_addr(fd)(addr, target_addr, len);
1679     }
1680
1681     target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1682     if (!target_saddr)
1683         return -TARGET_EFAULT;
1684
1685     sa_family = tswap16(target_saddr->sa_family);
1686
1687     /* Oops. The caller might send a incomplete sun_path; sun_path
1688      * must be terminated by \0 (see the manual page), but
1689      * unfortunately it is quite common to specify sockaddr_un
1690      * length as "strlen(x->sun_path)" while it should be
1691      * "strlen(...) + 1". We'll fix that here if needed.
1692      * Linux kernel has a similar feature.
1693      */
1694
1695     if (sa_family == AF_UNIX) {
1696         if (len < unix_maxlen && len > 0) {
1697             char *cp = (char*)target_saddr;
1698
1699             if ( cp[len-1] && !cp[len] )
1700                 len++;
1701         }
1702         if (len > unix_maxlen)
1703             len = unix_maxlen;
1704     }
1705
1706     memcpy(addr, target_saddr, len);
1707     addr->sa_family = sa_family;
1708     if (sa_family == AF_NETLINK) {
1709         struct sockaddr_nl *nladdr;
1710
1711         nladdr = (struct sockaddr_nl *)addr;
1712         nladdr->nl_pid = tswap32(nladdr->nl_pid);
1713         nladdr->nl_groups = tswap32(nladdr->nl_groups);
1714     } else if (sa_family == AF_PACKET) {
1715         struct target_sockaddr_ll *lladdr;
1716
1717         lladdr = (struct target_sockaddr_ll *)addr;
1718         lladdr->sll_ifindex = tswap32(lladdr->sll_ifindex);
1719         lladdr->sll_hatype = tswap16(lladdr->sll_hatype);
1720     }
1721     unlock_user(target_saddr, target_addr, 0);
1722
1723     return 0;
1724 }
1725
1726 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
1727                                                struct sockaddr *addr,
1728                                                socklen_t len)
1729 {
1730     struct target_sockaddr *target_saddr;
1731
1732     if (len == 0) {
1733         return 0;
1734     }
1735     assert(addr);
1736
1737     target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
1738     if (!target_saddr)
1739         return -TARGET_EFAULT;
1740     memcpy(target_saddr, addr, len);
1741     if (len >= offsetof(struct target_sockaddr, sa_family) +
1742         sizeof(target_saddr->sa_family)) {
1743         target_saddr->sa_family = tswap16(addr->sa_family);
1744     }
1745     if (addr->sa_family == AF_NETLINK &&
1746         len >= sizeof(struct target_sockaddr_nl)) {
1747         struct target_sockaddr_nl *target_nl =
1748                (struct target_sockaddr_nl *)target_saddr;
1749         target_nl->nl_pid = tswap32(target_nl->nl_pid);
1750         target_nl->nl_groups = tswap32(target_nl->nl_groups);
1751     } else if (addr->sa_family == AF_PACKET) {
1752         struct sockaddr_ll *target_ll = (struct sockaddr_ll *)target_saddr;
1753         target_ll->sll_ifindex = tswap32(target_ll->sll_ifindex);
1754         target_ll->sll_hatype = tswap16(target_ll->sll_hatype);
1755     } else if (addr->sa_family == AF_INET6 &&
1756                len >= sizeof(struct target_sockaddr_in6)) {
1757         struct target_sockaddr_in6 *target_in6 =
1758                (struct target_sockaddr_in6 *)target_saddr;
1759         target_in6->sin6_scope_id = tswap16(target_in6->sin6_scope_id);
1760     }
1761     unlock_user(target_saddr, target_addr, len);
1762
1763     return 0;
1764 }
1765
1766 static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
1767                                            struct target_msghdr *target_msgh)
1768 {
1769     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1770     abi_long msg_controllen;
1771     abi_ulong target_cmsg_addr;
1772     struct target_cmsghdr *target_cmsg, *target_cmsg_start;
1773     socklen_t space = 0;
1774
1775     msg_controllen = tswapal(target_msgh->msg_controllen);
1776     if (msg_controllen < sizeof (struct target_cmsghdr))
1777         goto the_end;
1778     target_cmsg_addr = tswapal(target_msgh->msg_control);
1779     target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
1780     target_cmsg_start = target_cmsg;
1781     if (!target_cmsg)
1782         return -TARGET_EFAULT;
1783
1784     while (cmsg && target_cmsg) {
1785         void *data = CMSG_DATA(cmsg);
1786         void *target_data = TARGET_CMSG_DATA(target_cmsg);
1787
1788         int len = tswapal(target_cmsg->cmsg_len)
1789             - sizeof(struct target_cmsghdr);
1790
1791         space += CMSG_SPACE(len);
1792         if (space > msgh->msg_controllen) {
1793             space -= CMSG_SPACE(len);
1794             /* This is a QEMU bug, since we allocated the payload
1795              * area ourselves (unlike overflow in host-to-target
1796              * conversion, which is just the guest giving us a buffer
1797              * that's too small). It can't happen for the payload types
1798              * we currently support; if it becomes an issue in future
1799              * we would need to improve our allocation strategy to
1800              * something more intelligent than "twice the size of the
1801              * target buffer we're reading from".
1802              */
1803             qemu_log_mask(LOG_UNIMP,
1804                           ("Unsupported ancillary data %d/%d: "
1805                            "unhandled msg size\n"),
1806                           tswap32(target_cmsg->cmsg_level),
1807                           tswap32(target_cmsg->cmsg_type));
1808             break;
1809         }
1810
1811         if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) {
1812             cmsg->cmsg_level = SOL_SOCKET;
1813         } else {
1814             cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
1815         }
1816         cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
1817         cmsg->cmsg_len = CMSG_LEN(len);
1818
1819         if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1820             int *fd = (int *)data;
1821             int *target_fd = (int *)target_data;
1822             int i, numfds = len / sizeof(int);
1823
1824             for (i = 0; i < numfds; i++) {
1825                 __get_user(fd[i], target_fd + i);
1826             }
1827         } else if (cmsg->cmsg_level == SOL_SOCKET
1828                &&  cmsg->cmsg_type == SCM_CREDENTIALS) {
1829             struct ucred *cred = (struct ucred *)data;
1830             struct target_ucred *target_cred =
1831                 (struct target_ucred *)target_data;
1832
1833             __get_user(cred->pid, &target_cred->pid);
1834             __get_user(cred->uid, &target_cred->uid);
1835             __get_user(cred->gid, &target_cred->gid);
1836         } else {
1837             qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n",
1838                           cmsg->cmsg_level, cmsg->cmsg_type);
1839             memcpy(data, target_data, len);
1840         }
1841
1842         cmsg = CMSG_NXTHDR(msgh, cmsg);
1843         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1844                                          target_cmsg_start);
1845     }
1846     unlock_user(target_cmsg, target_cmsg_addr, 0);
1847  the_end:
1848     msgh->msg_controllen = space;
1849     return 0;
1850 }
1851
1852 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
1853                                            struct msghdr *msgh)
1854 {
1855     struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1856     abi_long msg_controllen;
1857     abi_ulong target_cmsg_addr;
1858     struct target_cmsghdr *target_cmsg, *target_cmsg_start;
1859     socklen_t space = 0;
1860
1861     msg_controllen = tswapal(target_msgh->msg_controllen);
1862     if (msg_controllen < sizeof (struct target_cmsghdr))
1863         goto the_end;
1864     target_cmsg_addr = tswapal(target_msgh->msg_control);
1865     target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
1866     target_cmsg_start = target_cmsg;
1867     if (!target_cmsg)
1868         return -TARGET_EFAULT;
1869
1870     while (cmsg && target_cmsg) {
1871         void *data = CMSG_DATA(cmsg);
1872         void *target_data = TARGET_CMSG_DATA(target_cmsg);
1873
1874         int len = cmsg->cmsg_len - sizeof(struct cmsghdr);
1875         int tgt_len, tgt_space;
1876
1877         /* We never copy a half-header but may copy half-data;
1878          * this is Linux's behaviour in put_cmsg(). Note that
1879          * truncation here is a guest problem (which we report
1880          * to the guest via the CTRUNC bit), unlike truncation
1881          * in target_to_host_cmsg, which is a QEMU bug.
1882          */
1883         if (msg_controllen < sizeof(struct target_cmsghdr)) {
1884             target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1885             break;
1886         }
1887
1888         if (cmsg->cmsg_level == SOL_SOCKET) {
1889             target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET);
1890         } else {
1891             target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
1892         }
1893         target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
1894
1895         /* Payload types which need a different size of payload on
1896          * the target must adjust tgt_len here.
1897          */
1898         tgt_len = len;
1899         switch (cmsg->cmsg_level) {
1900         case SOL_SOCKET:
1901             switch (cmsg->cmsg_type) {
1902             case SO_TIMESTAMP:
1903                 tgt_len = sizeof(struct target_timeval);
1904                 break;
1905             default:
1906                 break;
1907             }
1908             break;
1909         default:
1910             break;
1911         }
1912
1913         if (msg_controllen < TARGET_CMSG_LEN(tgt_len)) {
1914             target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1915             tgt_len = msg_controllen - sizeof(struct target_cmsghdr);
1916         }
1917
1918         /* We must now copy-and-convert len bytes of payload
1919          * into tgt_len bytes of destination space. Bear in mind
1920          * that in both source and destination we may be dealing
1921          * with a truncated value!
1922          */
1923         switch (cmsg->cmsg_level) {
1924         case SOL_SOCKET:
1925             switch (cmsg->cmsg_type) {
1926             case SCM_RIGHTS:
1927             {
1928                 int *fd = (int *)data;
1929                 int *target_fd = (int *)target_data;
1930                 int i, numfds = tgt_len / sizeof(int);
1931
1932                 for (i = 0; i < numfds; i++) {
1933                     __put_user(fd[i], target_fd + i);
1934                 }
1935                 break;
1936             }
1937             case SO_TIMESTAMP:
1938             {
1939                 struct timeval *tv = (struct timeval *)data;
1940                 struct target_timeval *target_tv =
1941                     (struct target_timeval *)target_data;
1942
1943                 if (len != sizeof(struct timeval) ||
1944                     tgt_len != sizeof(struct target_timeval)) {
1945                     goto unimplemented;
1946                 }
1947
1948                 /* copy struct timeval to target */
1949                 __put_user(tv->tv_sec, &target_tv->tv_sec);
1950                 __put_user(tv->tv_usec, &target_tv->tv_usec);
1951                 break;
1952             }
1953             case SCM_CREDENTIALS:
1954             {
1955                 struct ucred *cred = (struct ucred *)data;
1956                 struct target_ucred *target_cred =
1957                     (struct target_ucred *)target_data;
1958
1959                 __put_user(cred->pid, &target_cred->pid);
1960                 __put_user(cred->uid, &target_cred->uid);
1961                 __put_user(cred->gid, &target_cred->gid);
1962                 break;
1963             }
1964             default:
1965                 goto unimplemented;
1966             }
1967             break;
1968
1969         case SOL_IP:
1970             switch (cmsg->cmsg_type) {
1971             case IP_TTL:
1972             {
1973                 uint32_t *v = (uint32_t *)data;
1974                 uint32_t *t_int = (uint32_t *)target_data;
1975
1976                 if (len != sizeof(uint32_t) ||
1977                     tgt_len != sizeof(uint32_t)) {
1978                     goto unimplemented;
1979                 }
1980                 __put_user(*v, t_int);
1981                 break;
1982             }
1983             case IP_RECVERR:
1984             {
1985                 struct errhdr_t {
1986                    struct sock_extended_err ee;
1987                    struct sockaddr_in offender;
1988                 };
1989                 struct errhdr_t *errh = (struct errhdr_t *)data;
1990                 struct errhdr_t *target_errh =
1991                     (struct errhdr_t *)target_data;
1992
1993                 if (len != sizeof(struct errhdr_t) ||
1994                     tgt_len != sizeof(struct errhdr_t)) {
1995                     goto unimplemented;
1996                 }
1997                 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
1998                 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
1999                 __put_user(errh->ee.ee_type,  &target_errh->ee.ee_type);
2000                 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
2001                 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
2002                 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
2003                 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
2004                 host_to_target_sockaddr((unsigned long) &target_errh->offender,
2005                     (void *) &errh->offender, sizeof(errh->offender));
2006                 break;
2007             }
2008             default:
2009                 goto unimplemented;
2010             }
2011             break;
2012
2013         case SOL_IPV6:
2014             switch (cmsg->cmsg_type) {
2015             case IPV6_HOPLIMIT:
2016             {
2017                 uint32_t *v = (uint32_t *)data;
2018                 uint32_t *t_int = (uint32_t *)target_data;
2019
2020                 if (len != sizeof(uint32_t) ||
2021                     tgt_len != sizeof(uint32_t)) {
2022                     goto unimplemented;
2023                 }
2024                 __put_user(*v, t_int);
2025                 break;
2026             }
2027             case IPV6_RECVERR:
2028             {
2029                 struct errhdr6_t {
2030                    struct sock_extended_err ee;
2031                    struct sockaddr_in6 offender;
2032                 };
2033                 struct errhdr6_t *errh = (struct errhdr6_t *)data;
2034                 struct errhdr6_t *target_errh =
2035                     (struct errhdr6_t *)target_data;
2036
2037                 if (len != sizeof(struct errhdr6_t) ||
2038                     tgt_len != sizeof(struct errhdr6_t)) {
2039                     goto unimplemented;
2040                 }
2041                 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
2042                 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
2043                 __put_user(errh->ee.ee_type,  &target_errh->ee.ee_type);
2044                 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
2045                 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
2046                 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
2047                 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
2048                 host_to_target_sockaddr((unsigned long) &target_errh->offender,
2049                     (void *) &errh->offender, sizeof(errh->offender));
2050                 break;
2051             }
2052             default:
2053                 goto unimplemented;
2054             }
2055             break;
2056
2057         default:
2058         unimplemented:
2059             qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n",
2060                           cmsg->cmsg_level, cmsg->cmsg_type);
2061             memcpy(target_data, data, MIN(len, tgt_len));
2062             if (tgt_len > len) {
2063                 memset(target_data + len, 0, tgt_len - len);
2064             }
2065         }
2066
2067         target_cmsg->cmsg_len = tswapal(TARGET_CMSG_LEN(tgt_len));
2068         tgt_space = TARGET_CMSG_SPACE(tgt_len);
2069         if (msg_controllen < tgt_space) {
2070             tgt_space = msg_controllen;
2071         }
2072         msg_controllen -= tgt_space;
2073         space += tgt_space;
2074         cmsg = CMSG_NXTHDR(msgh, cmsg);
2075         target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
2076                                          target_cmsg_start);
2077     }
2078     unlock_user(target_cmsg, target_cmsg_addr, space);
2079  the_end:
2080     target_msgh->msg_controllen = tswapal(space);
2081     return 0;
2082 }
2083
2084 /* do_setsockopt() Must return target values and target errnos. */
2085 static abi_long do_setsockopt(int sockfd, int level, int optname,
2086                               abi_ulong optval_addr, socklen_t optlen)
2087 {
2088     abi_long ret;
2089     int val;
2090     struct ip_mreqn *ip_mreq;
2091     struct ip_mreq_source *ip_mreq_source;
2092
2093     switch(level) {
2094     case SOL_TCP:
2095     case SOL_UDP:
2096         /* TCP and UDP options all take an 'int' value.  */
2097         if (optlen < sizeof(uint32_t))
2098             return -TARGET_EINVAL;
2099
2100         if (get_user_u32(val, optval_addr))
2101             return -TARGET_EFAULT;
2102         ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2103         break;
2104     case SOL_IP:
2105         switch(optname) {
2106         case IP_TOS:
2107         case IP_TTL:
2108         case IP_HDRINCL:
2109         case IP_ROUTER_ALERT:
2110         case IP_RECVOPTS:
2111         case IP_RETOPTS:
2112         case IP_PKTINFO:
2113         case IP_MTU_DISCOVER:
2114         case IP_RECVERR:
2115         case IP_RECVTTL:
2116         case IP_RECVTOS:
2117 #ifdef IP_FREEBIND
2118         case IP_FREEBIND:
2119 #endif
2120         case IP_MULTICAST_TTL:
2121         case IP_MULTICAST_LOOP:
2122             val = 0;
2123             if (optlen >= sizeof(uint32_t)) {
2124                 if (get_user_u32(val, optval_addr))
2125                     return -TARGET_EFAULT;
2126             } else if (optlen >= 1) {
2127                 if (get_user_u8(val, optval_addr))
2128                     return -TARGET_EFAULT;
2129             }
2130             ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2131             break;
2132         case IP_ADD_MEMBERSHIP:
2133         case IP_DROP_MEMBERSHIP:
2134             if (optlen < sizeof (struct target_ip_mreq) ||
2135                 optlen > sizeof (struct target_ip_mreqn))
2136                 return -TARGET_EINVAL;
2137
2138             ip_mreq = (struct ip_mreqn *) alloca(optlen);
2139             target_to_host_ip_mreq(ip_mreq, optval_addr, optlen);
2140             ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen));
2141             break;
2142
2143         case IP_BLOCK_SOURCE:
2144         case IP_UNBLOCK_SOURCE:
2145         case IP_ADD_SOURCE_MEMBERSHIP:
2146         case IP_DROP_SOURCE_MEMBERSHIP:
2147             if (optlen != sizeof (struct target_ip_mreq_source))
2148                 return -TARGET_EINVAL;
2149
2150             ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2151             if (!ip_mreq_source) {
2152                 return -TARGET_EFAULT;
2153             }
2154             ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen));
2155             unlock_user (ip_mreq_source, optval_addr, 0);
2156             break;
2157
2158         default:
2159             goto unimplemented;
2160         }
2161         break;
2162     case SOL_IPV6:
2163         switch (optname) {
2164         case IPV6_MTU_DISCOVER:
2165         case IPV6_MTU:
2166         case IPV6_V6ONLY:
2167         case IPV6_RECVPKTINFO:
2168         case IPV6_UNICAST_HOPS:
2169         case IPV6_MULTICAST_HOPS:
2170         case IPV6_MULTICAST_LOOP:
2171         case IPV6_RECVERR:
2172         case IPV6_RECVHOPLIMIT:
2173         case IPV6_2292HOPLIMIT:
2174         case IPV6_CHECKSUM:
2175         case IPV6_ADDRFORM:
2176         case IPV6_2292PKTINFO:
2177         case IPV6_RECVTCLASS:
2178         case IPV6_RECVRTHDR:
2179         case IPV6_2292RTHDR:
2180         case IPV6_RECVHOPOPTS:
2181         case IPV6_2292HOPOPTS:
2182         case IPV6_RECVDSTOPTS:
2183         case IPV6_2292DSTOPTS:
2184         case IPV6_TCLASS:
2185         case IPV6_ADDR_PREFERENCES:
2186 #ifdef IPV6_RECVPATHMTU
2187         case IPV6_RECVPATHMTU:
2188 #endif
2189 #ifdef IPV6_TRANSPARENT
2190         case IPV6_TRANSPARENT:
2191 #endif
2192 #ifdef IPV6_FREEBIND
2193         case IPV6_FREEBIND:
2194 #endif
2195 #ifdef IPV6_RECVORIGDSTADDR
2196         case IPV6_RECVORIGDSTADDR:
2197 #endif
2198             val = 0;
2199             if (optlen < sizeof(uint32_t)) {
2200                 return -TARGET_EINVAL;
2201             }
2202             if (get_user_u32(val, optval_addr)) {
2203                 return -TARGET_EFAULT;
2204             }
2205             ret = get_errno(setsockopt(sockfd, level, optname,
2206                                        &val, sizeof(val)));
2207             break;
2208         case IPV6_PKTINFO:
2209         {
2210             struct in6_pktinfo pki;
2211
2212             if (optlen < sizeof(pki)) {
2213                 return -TARGET_EINVAL;
2214             }
2215
2216             if (copy_from_user(&pki, optval_addr, sizeof(pki))) {
2217                 return -TARGET_EFAULT;
2218             }
2219
2220             pki.ipi6_ifindex = tswap32(pki.ipi6_ifindex);
2221
2222             ret = get_errno(setsockopt(sockfd, level, optname,
2223                                        &pki, sizeof(pki)));
2224             break;
2225         }
2226         case IPV6_ADD_MEMBERSHIP:
2227         case IPV6_DROP_MEMBERSHIP:
2228         {
2229             struct ipv6_mreq ipv6mreq;
2230
2231             if (optlen < sizeof(ipv6mreq)) {
2232                 return -TARGET_EINVAL;
2233             }
2234
2235             if (copy_from_user(&ipv6mreq, optval_addr, sizeof(ipv6mreq))) {
2236                 return -TARGET_EFAULT;
2237             }
2238
2239             ipv6mreq.ipv6mr_interface = tswap32(ipv6mreq.ipv6mr_interface);
2240
2241             ret = get_errno(setsockopt(sockfd, level, optname,
2242                                        &ipv6mreq, sizeof(ipv6mreq)));
2243             break;
2244         }
2245         default:
2246             goto unimplemented;
2247         }
2248         break;
2249     case SOL_ICMPV6:
2250         switch (optname) {
2251         case ICMPV6_FILTER:
2252         {
2253             struct icmp6_filter icmp6f;
2254
2255             if (optlen > sizeof(icmp6f)) {
2256                 optlen = sizeof(icmp6f);
2257             }
2258
2259             if (copy_from_user(&icmp6f, optval_addr, optlen)) {
2260                 return -TARGET_EFAULT;
2261             }
2262
2263             for (val = 0; val < 8; val++) {
2264                 icmp6f.data[val] = tswap32(icmp6f.data[val]);
2265             }
2266
2267             ret = get_errno(setsockopt(sockfd, level, optname,
2268                                        &icmp6f, optlen));
2269             break;
2270         }
2271         default:
2272             goto unimplemented;
2273         }
2274         break;
2275     case SOL_RAW:
2276         switch (optname) {
2277         case ICMP_FILTER:
2278         case IPV6_CHECKSUM:
2279             /* those take an u32 value */
2280             if (optlen < sizeof(uint32_t)) {
2281                 return -TARGET_EINVAL;
2282             }
2283
2284             if (get_user_u32(val, optval_addr)) {
2285                 return -TARGET_EFAULT;
2286             }
2287             ret = get_errno(setsockopt(sockfd, level, optname,
2288                                        &val, sizeof(val)));
2289             break;
2290
2291         default:
2292             goto unimplemented;
2293         }
2294         break;
2295 #if defined(SOL_ALG) && defined(ALG_SET_KEY) && defined(ALG_SET_AEAD_AUTHSIZE)
2296     case SOL_ALG:
2297         switch (optname) {
2298         case ALG_SET_KEY:
2299         {
2300             char *alg_key = g_malloc(optlen);
2301
2302             if (!alg_key) {
2303                 return -TARGET_ENOMEM;
2304             }
2305             if (copy_from_user(alg_key, optval_addr, optlen)) {
2306                 g_free(alg_key);
2307                 return -TARGET_EFAULT;
2308             }
2309             ret = get_errno(setsockopt(sockfd, level, optname,
2310                                        alg_key, optlen));
2311             g_free(alg_key);
2312             break;
2313         }
2314         case ALG_SET_AEAD_AUTHSIZE:
2315         {
2316             ret = get_errno(setsockopt(sockfd, level, optname,
2317                                        NULL, optlen));
2318             break;
2319         }
2320         default:
2321             goto unimplemented;
2322         }
2323         break;
2324 #endif
2325     case TARGET_SOL_SOCKET:
2326         switch (optname) {
2327         case TARGET_SO_RCVTIMEO:
2328         {
2329                 struct timeval tv;
2330
2331                 optname = SO_RCVTIMEO;
2332
2333 set_timeout:
2334                 if (optlen != sizeof(struct target_timeval)) {
2335                     return -TARGET_EINVAL;
2336                 }
2337
2338                 if (copy_from_user_timeval(&tv, optval_addr)) {
2339                     return -TARGET_EFAULT;
2340                 }
2341
2342                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2343                                 &tv, sizeof(tv)));
2344                 return ret;
2345         }
2346         case TARGET_SO_SNDTIMEO:
2347                 optname = SO_SNDTIMEO;
2348                 goto set_timeout;
2349         case TARGET_SO_ATTACH_FILTER:
2350         {
2351                 struct target_sock_fprog *tfprog;
2352                 struct target_sock_filter *tfilter;
2353                 struct sock_fprog fprog;
2354                 struct sock_filter *filter;
2355                 int i;
2356
2357                 if (optlen != sizeof(*tfprog)) {
2358                     return -TARGET_EINVAL;
2359                 }
2360                 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) {
2361                     return -TARGET_EFAULT;
2362                 }
2363                 if (!lock_user_struct(VERIFY_READ, tfilter,
2364                                       tswapal(tfprog->filter), 0)) {
2365                     unlock_user_struct(tfprog, optval_addr, 1);
2366                     return -TARGET_EFAULT;
2367                 }
2368
2369                 fprog.len = tswap16(tfprog->len);
2370                 filter = g_try_new(struct sock_filter, fprog.len);
2371                 if (filter == NULL) {
2372                     unlock_user_struct(tfilter, tfprog->filter, 1);
2373                     unlock_user_struct(tfprog, optval_addr, 1);
2374                     return -TARGET_ENOMEM;
2375                 }
2376                 for (i = 0; i < fprog.len; i++) {
2377                     filter[i].code = tswap16(tfilter[i].code);
2378                     filter[i].jt = tfilter[i].jt;
2379                     filter[i].jf = tfilter[i].jf;
2380                     filter[i].k = tswap32(tfilter[i].k);
2381                 }
2382                 fprog.filter = filter;
2383
2384                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET,
2385                                 SO_ATTACH_FILTER, &fprog, sizeof(fprog)));
2386                 g_free(filter);
2387
2388                 unlock_user_struct(tfilter, tfprog->filter, 1);
2389                 unlock_user_struct(tfprog, optval_addr, 1);
2390                 return ret;
2391         }
2392         case TARGET_SO_BINDTODEVICE:
2393         {
2394                 char *dev_ifname, *addr_ifname;
2395
2396                 if (optlen > IFNAMSIZ - 1) {
2397                     optlen = IFNAMSIZ - 1;
2398                 }
2399                 dev_ifname = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2400                 if (!dev_ifname) {
2401                     return -TARGET_EFAULT;
2402                 }
2403                 optname = SO_BINDTODEVICE;
2404                 addr_ifname = alloca(IFNAMSIZ);
2405                 memcpy(addr_ifname, dev_ifname, optlen);
2406                 addr_ifname[optlen] = 0;
2407                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2408                                            addr_ifname, optlen));
2409                 unlock_user (dev_ifname, optval_addr, 0);
2410                 return ret;
2411         }
2412         case TARGET_SO_LINGER:
2413         {
2414                 struct linger lg;
2415                 struct target_linger *tlg;
2416
2417                 if (optlen != sizeof(struct target_linger)) {
2418                     return -TARGET_EINVAL;
2419                 }
2420                 if (!lock_user_struct(VERIFY_READ, tlg, optval_addr, 1)) {
2421                     return -TARGET_EFAULT;
2422                 }
2423                 __get_user(lg.l_onoff, &tlg->l_onoff);
2424                 __get_user(lg.l_linger, &tlg->l_linger);
2425                 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, SO_LINGER,
2426                                 &lg, sizeof(lg)));
2427                 unlock_user_struct(tlg, optval_addr, 0);
2428                 return ret;
2429         }
2430             /* Options with 'int' argument.  */
2431         case TARGET_SO_DEBUG:
2432                 optname = SO_DEBUG;
2433                 break;
2434         case TARGET_SO_REUSEADDR:
2435                 optname = SO_REUSEADDR;
2436                 break;
2437 #ifdef SO_REUSEPORT
2438         case TARGET_SO_REUSEPORT:
2439                 optname = SO_REUSEPORT;
2440                 break;
2441 #endif
2442         case TARGET_SO_TYPE:
2443                 optname = SO_TYPE;
2444                 break;
2445         case TARGET_SO_ERROR:
2446                 optname = SO_ERROR;
2447                 break;
2448         case TARGET_SO_DONTROUTE:
2449                 optname = SO_DONTROUTE;
2450                 break;
2451         case TARGET_SO_BROADCAST:
2452                 optname = SO_BROADCAST;
2453                 break;
2454         case TARGET_SO_SNDBUF:
2455                 optname = SO_SNDBUF;
2456                 break;
2457         case TARGET_SO_SNDBUFFORCE:
2458                 optname = SO_SNDBUFFORCE;
2459                 break;
2460         case TARGET_SO_RCVBUF:
2461                 optname = SO_RCVBUF;
2462                 break;
2463         case TARGET_SO_RCVBUFFORCE:
2464                 optname = SO_RCVBUFFORCE;
2465                 break;
2466         case TARGET_SO_KEEPALIVE:
2467                 optname = SO_KEEPALIVE;
2468                 break;
2469         case TARGET_SO_OOBINLINE:
2470                 optname = SO_OOBINLINE;
2471                 break;
2472         case TARGET_SO_NO_CHECK:
2473                 optname = SO_NO_CHECK;
2474                 break;
2475         case TARGET_SO_PRIORITY:
2476                 optname = SO_PRIORITY;
2477                 break;
2478 #ifdef SO_BSDCOMPAT
2479         case TARGET_SO_BSDCOMPAT:
2480                 optname = SO_BSDCOMPAT;
2481                 break;
2482 #endif
2483         case TARGET_SO_PASSCRED:
2484                 optname = SO_PASSCRED;
2485                 break;
2486         case TARGET_SO_PASSSEC:
2487                 optname = SO_PASSSEC;
2488                 break;
2489         case TARGET_SO_TIMESTAMP:
2490                 optname = SO_TIMESTAMP;
2491                 break;
2492         case TARGET_SO_RCVLOWAT:
2493                 optname = SO_RCVLOWAT;
2494                 break;
2495         default:
2496             goto unimplemented;
2497         }
2498         if (optlen < sizeof(uint32_t))
2499             return -TARGET_EINVAL;
2500
2501         if (get_user_u32(val, optval_addr))
2502             return -TARGET_EFAULT;
2503         ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
2504         break;
2505 #ifdef SOL_NETLINK
2506     case SOL_NETLINK:
2507         switch (optname) {
2508         case NETLINK_PKTINFO:
2509         case NETLINK_ADD_MEMBERSHIP:
2510         case NETLINK_DROP_MEMBERSHIP:
2511         case NETLINK_BROADCAST_ERROR:
2512         case NETLINK_NO_ENOBUFS:
2513 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2514         case NETLINK_LISTEN_ALL_NSID:
2515         case NETLINK_CAP_ACK:
2516 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2517 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2518         case NETLINK_EXT_ACK:
2519 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2520 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2521         case NETLINK_GET_STRICT_CHK:
2522 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2523             break;
2524         default:
2525             goto unimplemented;
2526         }
2527         val = 0;
2528         if (optlen < sizeof(uint32_t)) {
2529             return -TARGET_EINVAL;
2530         }
2531         if (get_user_u32(val, optval_addr)) {
2532             return -TARGET_EFAULT;
2533         }
2534         ret = get_errno(setsockopt(sockfd, SOL_NETLINK, optname, &val,
2535                                    sizeof(val)));
2536         break;
2537 #endif /* SOL_NETLINK */
2538     default:
2539     unimplemented:
2540         qemu_log_mask(LOG_UNIMP, "Unsupported setsockopt level=%d optname=%d\n",
2541                       level, optname);
2542         ret = -TARGET_ENOPROTOOPT;
2543     }
2544     return ret;
2545 }
2546
2547 /* do_getsockopt() Must return target values and target errnos. */
2548 static abi_long do_getsockopt(int sockfd, int level, int optname,
2549                               abi_ulong optval_addr, abi_ulong optlen)
2550 {
2551     abi_long ret;
2552     int len, val;
2553     socklen_t lv;
2554
2555     switch(level) {
2556     case TARGET_SOL_SOCKET:
2557         level = SOL_SOCKET;
2558         switch (optname) {
2559         /* These don't just return a single integer */
2560         case TARGET_SO_PEERNAME:
2561             goto unimplemented;
2562         case TARGET_SO_RCVTIMEO: {
2563             struct timeval tv;
2564             socklen_t tvlen;
2565
2566             optname = SO_RCVTIMEO;
2567
2568 get_timeout:
2569             if (get_user_u32(len, optlen)) {
2570                 return -TARGET_EFAULT;
2571             }
2572             if (len < 0) {
2573                 return -TARGET_EINVAL;
2574             }
2575
2576             tvlen = sizeof(tv);
2577             ret = get_errno(getsockopt(sockfd, level, optname,
2578                                        &tv, &tvlen));
2579             if (ret < 0) {
2580                 return ret;
2581             }
2582             if (len > sizeof(struct target_timeval)) {
2583                 len = sizeof(struct target_timeval);
2584             }
2585             if (copy_to_user_timeval(optval_addr, &tv)) {
2586                 return -TARGET_EFAULT;
2587             }
2588             if (put_user_u32(len, optlen)) {
2589                 return -TARGET_EFAULT;
2590             }
2591             break;
2592         }
2593         case TARGET_SO_SNDTIMEO:
2594             optname = SO_SNDTIMEO;
2595             goto get_timeout;
2596         case TARGET_SO_PEERCRED: {
2597             struct ucred cr;
2598             socklen_t crlen;
2599             struct target_ucred *tcr;
2600
2601             if (get_user_u32(len, optlen)) {
2602                 return -TARGET_EFAULT;
2603             }
2604             if (len < 0) {
2605                 return -TARGET_EINVAL;
2606             }
2607
2608             crlen = sizeof(cr);
2609             ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED,
2610                                        &cr, &crlen));
2611             if (ret < 0) {
2612                 return ret;
2613             }
2614             if (len > crlen) {
2615                 len = crlen;
2616             }
2617             if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) {
2618                 return -TARGET_EFAULT;
2619             }
2620             __put_user(cr.pid, &tcr->pid);
2621             __put_user(cr.uid, &tcr->uid);
2622             __put_user(cr.gid, &tcr->gid);
2623             unlock_user_struct(tcr, optval_addr, 1);
2624             if (put_user_u32(len, optlen)) {
2625                 return -TARGET_EFAULT;
2626             }
2627             break;
2628         }
2629         case TARGET_SO_PEERSEC: {
2630             char *name;
2631
2632             if (get_user_u32(len, optlen)) {
2633                 return -TARGET_EFAULT;
2634             }
2635             if (len < 0) {
2636                 return -TARGET_EINVAL;
2637             }
2638             name = lock_user(VERIFY_WRITE, optval_addr, len, 0);
2639             if (!name) {
2640                 return -TARGET_EFAULT;
2641             }
2642             lv = len;
2643             ret = get_errno(getsockopt(sockfd, level, SO_PEERSEC,
2644                                        name, &lv));
2645             if (put_user_u32(lv, optlen)) {
2646                 ret = -TARGET_EFAULT;
2647             }
2648             unlock_user(name, optval_addr, lv);
2649             break;
2650         }
2651         case TARGET_SO_LINGER:
2652         {
2653             struct linger lg;
2654             socklen_t lglen;
2655             struct target_linger *tlg;
2656
2657             if (get_user_u32(len, optlen)) {
2658                 return -TARGET_EFAULT;
2659             }
2660             if (len < 0) {
2661                 return -TARGET_EINVAL;
2662             }
2663
2664             lglen = sizeof(lg);
2665             ret = get_errno(getsockopt(sockfd, level, SO_LINGER,
2666                                        &lg, &lglen));
2667             if (ret < 0) {
2668                 return ret;
2669             }
2670             if (len > lglen) {
2671                 len = lglen;
2672             }
2673             if (!lock_user_struct(VERIFY_WRITE, tlg, optval_addr, 0)) {
2674                 return -TARGET_EFAULT;
2675             }
2676             __put_user(lg.l_onoff, &tlg->l_onoff);
2677             __put_user(lg.l_linger, &tlg->l_linger);
2678             unlock_user_struct(tlg, optval_addr, 1);
2679             if (put_user_u32(len, optlen)) {
2680                 return -TARGET_EFAULT;
2681             }
2682             break;
2683         }
2684         /* Options with 'int' argument.  */
2685         case TARGET_SO_DEBUG:
2686             optname = SO_DEBUG;
2687             goto int_case;
2688         case TARGET_SO_REUSEADDR:
2689             optname = SO_REUSEADDR;
2690             goto int_case;
2691 #ifdef SO_REUSEPORT
2692         case TARGET_SO_REUSEPORT:
2693             optname = SO_REUSEPORT;
2694             goto int_case;
2695 #endif
2696         case TARGET_SO_TYPE:
2697             optname = SO_TYPE;
2698             goto int_case;
2699         case TARGET_SO_ERROR:
2700             optname = SO_ERROR;
2701             goto int_case;
2702         case TARGET_SO_DONTROUTE:
2703             optname = SO_DONTROUTE;
2704             goto int_case;
2705         case TARGET_SO_BROADCAST:
2706             optname = SO_BROADCAST;
2707             goto int_case;
2708         case TARGET_SO_SNDBUF:
2709             optname = SO_SNDBUF;
2710             goto int_case;
2711         case TARGET_SO_RCVBUF:
2712             optname = SO_RCVBUF;
2713             goto int_case;
2714         case TARGET_SO_KEEPALIVE:
2715             optname = SO_KEEPALIVE;
2716             goto int_case;
2717         case TARGET_SO_OOBINLINE:
2718             optname = SO_OOBINLINE;
2719             goto int_case;
2720         case TARGET_SO_NO_CHECK:
2721             optname = SO_NO_CHECK;
2722             goto int_case;
2723         case TARGET_SO_PRIORITY:
2724             optname = SO_PRIORITY;
2725             goto int_case;
2726 #ifdef SO_BSDCOMPAT
2727         case TARGET_SO_BSDCOMPAT:
2728             optname = SO_BSDCOMPAT;
2729             goto int_case;
2730 #endif
2731         case TARGET_SO_PASSCRED:
2732             optname = SO_PASSCRED;
2733             goto int_case;
2734         case TARGET_SO_TIMESTAMP:
2735             optname = SO_TIMESTAMP;
2736             goto int_case;
2737         case TARGET_SO_RCVLOWAT:
2738             optname = SO_RCVLOWAT;
2739             goto int_case;
2740         case TARGET_SO_ACCEPTCONN:
2741             optname = SO_ACCEPTCONN;
2742             goto int_case;
2743         case TARGET_SO_PROTOCOL:
2744             optname = SO_PROTOCOL;
2745             goto int_case;
2746         case TARGET_SO_DOMAIN:
2747             optname = SO_DOMAIN;
2748             goto int_case;
2749         default:
2750             goto int_case;
2751         }
2752         break;
2753     case SOL_TCP:
2754     case SOL_UDP:
2755         /* TCP and UDP options all take an 'int' value.  */
2756     int_case:
2757         if (get_user_u32(len, optlen))
2758             return -TARGET_EFAULT;
2759         if (len < 0)
2760             return -TARGET_EINVAL;
2761         lv = sizeof(lv);
2762         ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2763         if (ret < 0)
2764             return ret;
2765         if (optname == SO_TYPE) {
2766             val = host_to_target_sock_type(val);
2767         }
2768         if (len > lv)
2769             len = lv;
2770         if (len == 4) {
2771             if (put_user_u32(val, optval_addr))
2772                 return -TARGET_EFAULT;
2773         } else {
2774             if (put_user_u8(val, optval_addr))
2775                 return -TARGET_EFAULT;
2776         }
2777         if (put_user_u32(len, optlen))
2778             return -TARGET_EFAULT;
2779         break;
2780     case SOL_IP:
2781         switch(optname) {
2782         case IP_TOS:
2783         case IP_TTL:
2784         case IP_HDRINCL:
2785         case IP_ROUTER_ALERT:
2786         case IP_RECVOPTS:
2787         case IP_RETOPTS:
2788         case IP_PKTINFO:
2789         case IP_MTU_DISCOVER:
2790         case IP_RECVERR:
2791         case IP_RECVTOS:
2792 #ifdef IP_FREEBIND
2793         case IP_FREEBIND:
2794 #endif
2795         case IP_MULTICAST_TTL:
2796         case IP_MULTICAST_LOOP:
2797             if (get_user_u32(len, optlen))
2798                 return -TARGET_EFAULT;
2799             if (len < 0)
2800                 return -TARGET_EINVAL;
2801             lv = sizeof(lv);
2802             ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2803             if (ret < 0)
2804                 return ret;
2805             if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2806                 len = 1;
2807                 if (put_user_u32(len, optlen)
2808                     || put_user_u8(val, optval_addr))
2809                     return -TARGET_EFAULT;
2810             } else {
2811                 if (len > sizeof(int))
2812                     len = sizeof(int);
2813                 if (put_user_u32(len, optlen)
2814                     || put_user_u32(val, optval_addr))
2815                     return -TARGET_EFAULT;
2816             }
2817             break;
2818         default:
2819             ret = -TARGET_ENOPROTOOPT;
2820             break;
2821         }
2822         break;
2823     case SOL_IPV6:
2824         switch (optname) {
2825         case IPV6_MTU_DISCOVER:
2826         case IPV6_MTU:
2827         case IPV6_V6ONLY:
2828         case IPV6_RECVPKTINFO:
2829         case IPV6_UNICAST_HOPS:
2830         case IPV6_MULTICAST_HOPS:
2831         case IPV6_MULTICAST_LOOP:
2832         case IPV6_RECVERR:
2833         case IPV6_RECVHOPLIMIT:
2834         case IPV6_2292HOPLIMIT:
2835         case IPV6_CHECKSUM:
2836         case IPV6_ADDRFORM:
2837         case IPV6_2292PKTINFO:
2838         case IPV6_RECVTCLASS:
2839         case IPV6_RECVRTHDR:
2840         case IPV6_2292RTHDR:
2841         case IPV6_RECVHOPOPTS:
2842         case IPV6_2292HOPOPTS:
2843         case IPV6_RECVDSTOPTS:
2844         case IPV6_2292DSTOPTS:
2845         case IPV6_TCLASS:
2846         case IPV6_ADDR_PREFERENCES:
2847 #ifdef IPV6_RECVPATHMTU
2848         case IPV6_RECVPATHMTU:
2849 #endif
2850 #ifdef IPV6_TRANSPARENT
2851         case IPV6_TRANSPARENT:
2852 #endif
2853 #ifdef IPV6_FREEBIND
2854         case IPV6_FREEBIND:
2855 #endif
2856 #ifdef IPV6_RECVORIGDSTADDR
2857         case IPV6_RECVORIGDSTADDR:
2858 #endif
2859             if (get_user_u32(len, optlen))
2860                 return -TARGET_EFAULT;
2861             if (len < 0)
2862                 return -TARGET_EINVAL;
2863             lv = sizeof(lv);
2864             ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2865             if (ret < 0)
2866                 return ret;
2867             if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2868                 len = 1;
2869                 if (put_user_u32(len, optlen)
2870                     || put_user_u8(val, optval_addr))
2871                     return -TARGET_EFAULT;
2872             } else {
2873                 if (len > sizeof(int))
2874                     len = sizeof(int);
2875                 if (put_user_u32(len, optlen)
2876                     || put_user_u32(val, optval_addr))
2877                     return -TARGET_EFAULT;
2878             }
2879             break;
2880         default:
2881             ret = -TARGET_ENOPROTOOPT;
2882             break;
2883         }
2884         break;
2885 #ifdef SOL_NETLINK
2886     case SOL_NETLINK:
2887         switch (optname) {
2888         case NETLINK_PKTINFO:
2889         case NETLINK_BROADCAST_ERROR:
2890         case NETLINK_NO_ENOBUFS:
2891 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2892         case NETLINK_LISTEN_ALL_NSID:
2893         case NETLINK_CAP_ACK:
2894 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2895 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2896         case NETLINK_EXT_ACK:
2897 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2898 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2899         case NETLINK_GET_STRICT_CHK:
2900 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2901             if (get_user_u32(len, optlen)) {
2902                 return -TARGET_EFAULT;
2903             }
2904             if (len != sizeof(val)) {
2905                 return -TARGET_EINVAL;
2906             }
2907             lv = len;
2908             ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2909             if (ret < 0) {
2910                 return ret;
2911             }
2912             if (put_user_u32(lv, optlen)
2913                 || put_user_u32(val, optval_addr)) {
2914                 return -TARGET_EFAULT;
2915             }
2916             break;
2917 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2918         case NETLINK_LIST_MEMBERSHIPS:
2919         {
2920             uint32_t *results;
2921             int i;
2922             if (get_user_u32(len, optlen)) {
2923                 return -TARGET_EFAULT;
2924             }
2925             if (len < 0) {
2926                 return -TARGET_EINVAL;
2927             }
2928             results = lock_user(VERIFY_WRITE, optval_addr, len, 1);
2929             if (!results && len > 0) {
2930                 return -TARGET_EFAULT;
2931             }
2932             lv = len;
2933             ret = get_errno(getsockopt(sockfd, level, optname, results, &lv));
2934             if (ret < 0) {
2935                 unlock_user(results, optval_addr, 0);
2936                 return ret;
2937             }
2938             /* swap host endianess to target endianess. */
2939             for (i = 0; i < (len / sizeof(uint32_t)); i++) {
2940                 results[i] = tswap32(results[i]);
2941             }
2942             if (put_user_u32(lv, optlen)) {
2943                 return -TARGET_EFAULT;
2944             }
2945             unlock_user(results, optval_addr, 0);
2946             break;
2947         }
2948 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2949         default:
2950             goto unimplemented;
2951         }
2952         break;
2953 #endif /* SOL_NETLINK */
2954     default:
2955     unimplemented:
2956         qemu_log_mask(LOG_UNIMP,
2957                       "getsockopt level=%d optname=%d not yet supported\n",
2958                       level, optname);
2959         ret = -TARGET_EOPNOTSUPP;
2960         break;
2961     }
2962     return ret;
2963 }
2964
2965 /* Convert target low/high pair representing file offset into the host
2966  * low/high pair. This function doesn't handle offsets bigger than 64 bits
2967  * as the kernel doesn't handle them either.
2968  */
2969 static void target_to_host_low_high(abi_ulong tlow,
2970                                     abi_ulong thigh,
2971                                     unsigned long *hlow,
2972                                     unsigned long *hhigh)
2973 {
2974     uint64_t off = tlow |
2975         ((unsigned long long)thigh << TARGET_LONG_BITS / 2) <<
2976         TARGET_LONG_BITS / 2;
2977
2978     *hlow = off;
2979     *hhigh = (off >> HOST_LONG_BITS / 2) >> HOST_LONG_BITS / 2;
2980 }
2981
2982 static struct iovec *lock_iovec(int type, abi_ulong target_addr,
2983                                 abi_ulong count, int copy)
2984 {
2985     struct target_iovec *target_vec;
2986     struct iovec *vec;
2987     abi_ulong total_len, max_len;
2988     int i;
2989     int err = 0;
2990     bool bad_address = false;
2991
2992     if (count == 0) {
2993         errno = 0;
2994         return NULL;
2995     }
2996     if (count > IOV_MAX) {
2997         errno = EINVAL;
2998         return NULL;
2999     }
3000
3001     vec = g_try_new0(struct iovec, count);
3002     if (vec == NULL) {
3003         errno = ENOMEM;
3004         return NULL;
3005     }
3006
3007     target_vec = lock_user(VERIFY_READ, target_addr,
3008                            count * sizeof(struct target_iovec), 1);
3009     if (target_vec == NULL) {
3010         err = EFAULT;
3011         goto fail2;
3012     }
3013
3014     /* ??? If host page size > target page size, this will result in a
3015        value larger than what we can actually support.  */
3016     max_len = 0x7fffffff & TARGET_PAGE_MASK;
3017     total_len = 0;
3018
3019     for (i = 0; i < count; i++) {
3020         abi_ulong base = tswapal(target_vec[i].iov_base);
3021         abi_long len = tswapal(target_vec[i].iov_len);
3022
3023         if (len < 0) {
3024             err = EINVAL;
3025             goto fail;
3026         } else if (len == 0) {
3027             /* Zero length pointer is ignored.  */
3028             vec[i].iov_base = 0;
3029         } else {
3030             vec[i].iov_base = lock_user(type, base, len, copy);
3031             /* If the first buffer pointer is bad, this is a fault.  But
3032              * subsequent bad buffers will result in a partial write; this
3033              * is realized by filling the vector with null pointers and
3034              * zero lengths. */
3035             if (!vec[i].iov_base) {
3036                 if (i == 0) {
3037                     err = EFAULT;
3038                     goto fail;
3039                 } else {
3040                     bad_address = true;
3041                 }
3042             }
3043             if (bad_address) {
3044                 len = 0;
3045             }
3046             if (len > max_len - total_len) {
3047                 len = max_len - total_len;
3048             }
3049         }
3050         vec[i].iov_len = len;
3051         total_len += len;
3052     }
3053
3054     unlock_user(target_vec, target_addr, 0);
3055     return vec;
3056
3057  fail:
3058     while (--i >= 0) {
3059         if (tswapal(target_vec[i].iov_len) > 0) {
3060             unlock_user(vec[i].iov_base, tswapal(target_vec[i].iov_base), 0);
3061         }
3062     }
3063     unlock_user(target_vec, target_addr, 0);
3064  fail2:
3065     g_free(vec);
3066     errno = err;
3067     return NULL;
3068 }
3069
3070 static void unlock_iovec(struct iovec *vec, abi_ulong target_addr,
3071                          abi_ulong count, int copy)
3072 {
3073     struct target_iovec *target_vec;
3074     int i;
3075
3076     target_vec = lock_user(VERIFY_READ, target_addr,
3077                            count * sizeof(struct target_iovec), 1);
3078     if (target_vec) {
3079         for (i = 0; i < count; i++) {
3080             abi_ulong base = tswapal(target_vec[i].iov_base);
3081             abi_long len = tswapal(target_vec[i].iov_len);
3082             if (len < 0) {
3083                 break;
3084             }
3085             unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
3086         }
3087         unlock_user(target_vec, target_addr, 0);
3088     }
3089
3090     g_free(vec);
3091 }
3092
3093 static inline int target_to_host_sock_type(int *type)
3094 {
3095     int host_type = 0;
3096     int target_type = *type;
3097
3098     switch (target_type & TARGET_SOCK_TYPE_MASK) {
3099     case TARGET_SOCK_DGRAM:
3100         host_type = SOCK_DGRAM;
3101         break;
3102     case TARGET_SOCK_STREAM:
3103         host_type = SOCK_STREAM;
3104         break;
3105     default:
3106         host_type = target_type & TARGET_SOCK_TYPE_MASK;
3107         break;
3108     }
3109     if (target_type & TARGET_SOCK_CLOEXEC) {
3110 #if defined(SOCK_CLOEXEC)
3111         host_type |= SOCK_CLOEXEC;
3112 #else
3113         return -TARGET_EINVAL;
3114 #endif
3115     }
3116     if (target_type & TARGET_SOCK_NONBLOCK) {
3117 #if defined(SOCK_NONBLOCK)
3118         host_type |= SOCK_NONBLOCK;
3119 #elif !defined(O_NONBLOCK)
3120         return -TARGET_EINVAL;
3121 #endif
3122     }
3123     *type = host_type;
3124     return 0;
3125 }
3126
3127 /* Try to emulate socket type flags after socket creation.  */
3128 static int sock_flags_fixup(int fd, int target_type)
3129 {
3130 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3131     if (target_type & TARGET_SOCK_NONBLOCK) {
3132         int flags = fcntl(fd, F_GETFL);
3133         if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) {
3134             close(fd);
3135             return -TARGET_EINVAL;
3136         }
3137     }
3138 #endif
3139     return fd;
3140 }
3141
3142 /* do_socket() Must return target values and target errnos. */
3143 static abi_long do_socket(int domain, int type, int protocol)
3144 {
3145     int target_type = type;
3146     int ret;
3147
3148     ret = target_to_host_sock_type(&type);
3149     if (ret) {
3150         return ret;
3151     }
3152
3153     if (domain == PF_NETLINK && !(
3154 #ifdef CONFIG_RTNETLINK
3155          protocol == NETLINK_ROUTE ||
3156 #endif
3157          protocol == NETLINK_KOBJECT_UEVENT ||
3158          protocol == NETLINK_AUDIT)) {
3159         return -TARGET_EPROTONOSUPPORT;
3160     }
3161
3162     if (domain == AF_PACKET ||
3163         (domain == AF_INET && type == SOCK_PACKET)) {
3164         protocol = tswap16(protocol);
3165     }
3166
3167     ret = get_errno(socket(domain, type, protocol));
3168     if (ret >= 0) {
3169         ret = sock_flags_fixup(ret, target_type);
3170         if (type == SOCK_PACKET) {
3171             /* Manage an obsolete case :
3172              * if socket type is SOCK_PACKET, bind by name
3173              */
3174             fd_trans_register(ret, &target_packet_trans);
3175         } else if (domain == PF_NETLINK) {
3176             switch (protocol) {
3177 #ifdef CONFIG_RTNETLINK
3178             case NETLINK_ROUTE:
3179                 fd_trans_register(ret, &target_netlink_route_trans);
3180                 break;
3181 #endif
3182             case NETLINK_KOBJECT_UEVENT:
3183                 /* nothing to do: messages are strings */
3184                 break;
3185             case NETLINK_AUDIT:
3186                 fd_trans_register(ret, &target_netlink_audit_trans);
3187                 break;
3188             default:
3189                 g_assert_not_reached();
3190             }
3191         }
3192     }
3193     return ret;
3194 }
3195
3196 /* do_bind() Must return target values and target errnos. */
3197 static abi_long do_bind(int sockfd, abi_ulong target_addr,
3198                         socklen_t addrlen)
3199 {
3200     void *addr;
3201     abi_long ret;
3202
3203     if ((int)addrlen < 0) {
3204         return -TARGET_EINVAL;
3205     }
3206
3207     addr = alloca(addrlen+1);
3208
3209     ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
3210     if (ret)
3211         return ret;
3212
3213     return get_errno(bind(sockfd, addr, addrlen));
3214 }
3215
3216 /* do_connect() Must return target values and target errnos. */
3217 static abi_long do_connect(int sockfd, abi_ulong target_addr,
3218                            socklen_t addrlen)
3219 {
3220     void *addr;
3221     abi_long ret;
3222
3223     if ((int)addrlen < 0) {
3224         return -TARGET_EINVAL;
3225     }
3226
3227     addr = alloca(addrlen+1);
3228
3229     ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
3230     if (ret)
3231         return ret;
3232
3233     return get_errno(safe_connect(sockfd, addr, addrlen));
3234 }
3235
3236 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
3237 static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp,
3238                                       int flags, int send)
3239 {
3240     abi_long ret, len;
3241     struct msghdr msg;
3242     abi_ulong count;
3243     struct iovec *vec;
3244     abi_ulong target_vec;
3245
3246     if (msgp->msg_name) {
3247         msg.msg_namelen = tswap32(msgp->msg_namelen);
3248         msg.msg_name = alloca(msg.msg_namelen+1);
3249         ret = target_to_host_sockaddr(fd, msg.msg_name,
3250                                       tswapal(msgp->msg_name),
3251                                       msg.msg_namelen);
3252         if (ret == -TARGET_EFAULT) {
3253             /* For connected sockets msg_name and msg_namelen must
3254              * be ignored, so returning EFAULT immediately is wrong.
3255              * Instead, pass a bad msg_name to the host kernel, and
3256              * let it decide whether to return EFAULT or not.
3257              */
3258             msg.msg_name = (void *)-1;
3259         } else if (ret) {
3260             goto out2;
3261         }
3262     } else {
3263         msg.msg_name = NULL;
3264         msg.msg_namelen = 0;
3265     }
3266     msg.msg_controllen = 2 * tswapal(msgp->msg_controllen);
3267     msg.msg_control = alloca(msg.msg_controllen);
3268     memset(msg.msg_control, 0, msg.msg_controllen);
3269
3270     msg.msg_flags = tswap32(msgp->msg_flags);
3271
3272     count = tswapal(msgp->msg_iovlen);
3273     target_vec = tswapal(msgp->msg_iov);
3274
3275     if (count > IOV_MAX) {
3276         /* sendrcvmsg returns a different errno for this condition than
3277          * readv/writev, so we must catch it here before lock_iovec() does.
3278          */
3279         ret = -TARGET_EMSGSIZE;
3280         goto out2;
3281     }
3282
3283     vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,
3284                      target_vec, count, send);
3285     if (vec == NULL) {
3286         ret = -host_to_target_errno(errno);
3287         goto out2;
3288     }
3289     msg.msg_iovlen = count;
3290     msg.msg_iov = vec;
3291
3292     if (send) {
3293         if (fd_trans_target_to_host_data(fd)) {
3294             void *host_msg;
3295
3296             host_msg = g_malloc(msg.msg_iov->iov_len);
3297             memcpy(host_msg, msg.msg_iov->iov_base, msg.msg_iov->iov_len);
3298             ret = fd_trans_target_to_host_data(fd)(host_msg,
3299                                                    msg.msg_iov->iov_len);
3300             if (ret >= 0) {
3301                 msg.msg_iov->iov_base = host_msg;
3302                 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3303             }
3304             g_free(host_msg);
3305         } else {
3306             ret = target_to_host_cmsg(&msg, msgp);
3307             if (ret == 0) {
3308                 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3309             }
3310         }
3311     } else {
3312         ret = get_errno(safe_recvmsg(fd, &msg, flags));
3313         if (!is_error(ret)) {
3314             len = ret;
3315             if (fd_trans_host_to_target_data(fd)) {
3316                 ret = fd_trans_host_to_target_data(fd)(msg.msg_iov->iov_base,
3317                                                MIN(msg.msg_iov->iov_len, len));
3318             } else {
3319                 ret = host_to_target_cmsg(msgp, &msg);
3320             }
3321             if (!is_error(ret)) {
3322                 msgp->msg_namelen = tswap32(msg.msg_namelen);
3323                 msgp->msg_flags = tswap32(msg.msg_flags);
3324                 if (msg.msg_name != NULL && msg.msg_name != (void *)-1) {
3325                     ret = host_to_target_sockaddr(tswapal(msgp->msg_name),
3326                                     msg.msg_name, msg.msg_namelen);
3327                     if (ret) {
3328                         goto out;
3329                     }
3330                 }
3331
3332                 ret = len;
3333             }
3334         }
3335     }
3336
3337 out:
3338     unlock_iovec(vec, target_vec, count, !send);
3339 out2:
3340     return ret;
3341 }
3342
3343 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
3344                                int flags, int send)
3345 {
3346     abi_long ret;
3347     struct target_msghdr *msgp;
3348
3349     if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
3350                           msgp,
3351                           target_msg,
3352                           send ? 1 : 0)) {
3353         return -TARGET_EFAULT;
3354     }
3355     ret = do_sendrecvmsg_locked(fd, msgp, flags, send);
3356     unlock_user_struct(msgp, target_msg, send ? 0 : 1);
3357     return ret;
3358 }
3359
3360 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
3361  * so it might not have this *mmsg-specific flag either.
3362  */
3363 #ifndef MSG_WAITFORONE
3364 #define MSG_WAITFORONE 0x10000
3365 #endif
3366
3367 static abi_long do_sendrecvmmsg(int fd, abi_ulong target_msgvec,
3368                                 unsigned int vlen, unsigned int flags,
3369                                 int send)
3370 {
3371     struct target_mmsghdr *mmsgp;
3372     abi_long ret = 0;
3373     int i;
3374
3375     if (vlen > UIO_MAXIOV) {
3376         vlen = UIO_MAXIOV;
3377     }
3378
3379     mmsgp = lock_user(VERIFY_WRITE, target_msgvec, sizeof(*mmsgp) * vlen, 1);
3380     if (!mmsgp) {
3381         return -TARGET_EFAULT;
3382     }
3383
3384     for (i = 0; i < vlen; i++) {
3385         ret = do_sendrecvmsg_locked(fd, &mmsgp[i].msg_hdr, flags, send);
3386         if (is_error(ret)) {
3387             break;
3388         }
3389         mmsgp[i].msg_len = tswap32(ret);
3390         /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3391         if (flags & MSG_WAITFORONE) {
3392             flags |= MSG_DONTWAIT;
3393         }
3394     }
3395
3396     unlock_user(mmsgp, target_msgvec, sizeof(*mmsgp) * i);
3397
3398     /* Return number of datagrams sent if we sent any at all;
3399      * otherwise return the error.
3400      */
3401     if (i) {
3402         return i;
3403     }
3404     return ret;
3405 }
3406
3407 /* do_accept4() Must return target values and target errnos. */
3408 static abi_long do_accept4(int fd, abi_ulong target_addr,
3409                            abi_ulong target_addrlen_addr, int flags)
3410 {
3411     socklen_t addrlen, ret_addrlen;
3412     void *addr;
3413     abi_long ret;
3414     int host_flags;
3415
3416     host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
3417
3418     if (target_addr == 0) {
3419         return get_errno(safe_accept4(fd, NULL, NULL, host_flags));
3420     }
3421
3422     /* linux returns EFAULT if addrlen pointer is invalid */
3423     if (get_user_u32(addrlen, target_addrlen_addr))
3424         return -TARGET_EFAULT;
3425
3426     if ((int)addrlen < 0) {
3427         return -TARGET_EINVAL;
3428     }
3429
3430     if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) {
3431         return -TARGET_EFAULT;
3432     }
3433
3434     addr = alloca(addrlen);
3435
3436     ret_addrlen = addrlen;
3437     ret = get_errno(safe_accept4(fd, addr, &ret_addrlen, host_flags));
3438     if (!is_error(ret)) {
3439         host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3440         if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3441             ret = -TARGET_EFAULT;
3442         }
3443     }
3444     return ret;
3445 }
3446
3447 /* do_getpeername() Must return target values and target errnos. */
3448 static abi_long do_getpeername(int fd, abi_ulong target_addr,
3449                                abi_ulong target_addrlen_addr)
3450 {
3451     socklen_t addrlen, ret_addrlen;
3452     void *addr;
3453     abi_long ret;
3454
3455     if (get_user_u32(addrlen, target_addrlen_addr))
3456         return -TARGET_EFAULT;
3457
3458     if ((int)addrlen < 0) {
3459         return -TARGET_EINVAL;
3460     }
3461
3462     if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) {
3463         return -TARGET_EFAULT;
3464     }
3465
3466     addr = alloca(addrlen);
3467
3468     ret_addrlen = addrlen;
3469     ret = get_errno(getpeername(fd, addr, &ret_addrlen));
3470     if (!is_error(ret)) {
3471         host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3472         if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3473             ret = -TARGET_EFAULT;
3474         }
3475     }
3476     return ret;
3477 }
3478
3479 /* do_getsockname() Must return target values and target errnos. */
3480 static abi_long do_getsockname(int fd, abi_ulong target_addr,
3481                                abi_ulong target_addrlen_addr)
3482 {
3483     socklen_t addrlen, ret_addrlen;
3484     void *addr;
3485     abi_long ret;
3486
3487     if (get_user_u32(addrlen, target_addrlen_addr))
3488         return -TARGET_EFAULT;
3489
3490     if ((int)addrlen < 0) {
3491         return -TARGET_EINVAL;
3492     }
3493
3494     if (!access_ok(thread_cpu, VERIFY_WRITE, target_addr, addrlen)) {
3495         return -TARGET_EFAULT;
3496     }
3497
3498     addr = alloca(addrlen);
3499
3500     ret_addrlen = addrlen;
3501     ret = get_errno(getsockname(fd, addr, &ret_addrlen));
3502     if (!is_error(ret)) {
3503         host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3504         if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3505             ret = -TARGET_EFAULT;
3506         }
3507     }
3508     return ret;
3509 }
3510
3511 /* do_socketpair() Must return target values and target errnos. */
3512 static abi_long do_socketpair(int domain, int type, int protocol,
3513                               abi_ulong target_tab_addr)
3514 {
3515     int tab[2];
3516     abi_long ret;
3517
3518     target_to_host_sock_type(&type);
3519
3520     ret = get_errno(socketpair(domain, type, protocol, tab));
3521     if (!is_error(ret)) {
3522         if (put_user_s32(tab[0], target_tab_addr)
3523             || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
3524             ret = -TARGET_EFAULT;
3525     }
3526     return ret;
3527 }
3528
3529 /* do_sendto() Must return target values and target errnos. */
3530 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
3531                           abi_ulong target_addr, socklen_t addrlen)
3532 {
3533     void *addr;
3534     void *host_msg;
3535     void *copy_msg = NULL;
3536     abi_long ret;
3537
3538     if ((int)addrlen < 0) {
3539         return -TARGET_EINVAL;
3540     }
3541
3542     host_msg = lock_user(VERIFY_READ, msg, len, 1);
3543     if (!host_msg)
3544         return -TARGET_EFAULT;
3545     if (fd_trans_target_to_host_data(fd)) {
3546         copy_msg = host_msg;
3547         host_msg = g_malloc(len);
3548         memcpy(host_msg, copy_msg, len);
3549         ret = fd_trans_target_to_host_data(fd)(host_msg, len);
3550         if (ret < 0) {
3551             goto fail;
3552         }
3553     }
3554     if (target_addr) {
3555         addr = alloca(addrlen+1);
3556         ret = target_to_host_sockaddr(fd, addr, target_addr, addrlen);
3557         if (ret) {
3558             goto fail;
3559         }
3560         ret = get_errno(safe_sendto(fd, host_msg, len, flags, addr, addrlen));
3561     } else {
3562         ret = get_errno(safe_sendto(fd, host_msg, len, flags, NULL, 0));
3563     }
3564 fail:
3565     if (copy_msg) {
3566         g_free(host_msg);
3567         host_msg = copy_msg;
3568     }
3569     unlock_user(host_msg, msg, 0);
3570     return ret;
3571 }
3572
3573 /* do_recvfrom() Must return target values and target errnos. */
3574 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
3575                             abi_ulong target_addr,
3576                             abi_ulong target_addrlen)
3577 {
3578     socklen_t addrlen, ret_addrlen;
3579     void *addr;
3580     void *host_msg;
3581     abi_long ret;
3582
3583     if (!msg) {
3584         host_msg = NULL;
3585     } else {
3586         host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
3587         if (!host_msg) {
3588             return -TARGET_EFAULT;
3589         }
3590     }
3591     if (target_addr) {
3592         if (get_user_u32(addrlen, target_addrlen)) {
3593             ret = -TARGET_EFAULT;
3594             goto fail;
3595         }
3596         if ((int)addrlen < 0) {
3597             ret = -TARGET_EINVAL;
3598             goto fail;
3599         }
3600         addr = alloca(addrlen);
3601         ret_addrlen = addrlen;
3602         ret = get_errno(safe_recvfrom(fd, host_msg, len, flags,
3603                                       addr, &ret_addrlen));
3604     } else {
3605         addr = NULL; /* To keep compiler quiet.  */
3606         addrlen = 0; /* To keep compiler quiet.  */
3607         ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, NULL, 0));
3608     }
3609     if (!is_error(ret)) {
3610         if (fd_trans_host_to_target_data(fd)) {
3611             abi_long trans;
3612             trans = fd_trans_host_to_target_data(fd)(host_msg, MIN(ret, len));
3613             if (is_error(trans)) {
3614                 ret = trans;
3615                 goto fail;
3616             }
3617         }
3618         if (target_addr) {
3619             host_to_target_sockaddr(target_addr, addr,
3620                                     MIN(addrlen, ret_addrlen));
3621             if (put_user_u32(ret_addrlen, target_addrlen)) {
3622                 ret = -TARGET_EFAULT;
3623                 goto fail;
3624             }
3625         }
3626         unlock_user(host_msg, msg, len);
3627     } else {
3628 fail:
3629         unlock_user(host_msg, msg, 0);
3630     }
3631     return ret;
3632 }
3633
3634 #ifdef TARGET_NR_socketcall
3635 /* do_socketcall() must return target values and target errnos. */
3636 static abi_long do_socketcall(int num, abi_ulong vptr)
3637 {
3638     static const unsigned nargs[] = { /* number of arguments per operation */
3639         [TARGET_SYS_SOCKET] = 3,      /* domain, type, protocol */
3640         [TARGET_SYS_BIND] = 3,        /* fd, addr, addrlen */
3641         [TARGET_SYS_CONNECT] = 3,     /* fd, addr, addrlen */
3642         [TARGET_SYS_LISTEN] = 2,      /* fd, backlog */
3643         [TARGET_SYS_ACCEPT] = 3,      /* fd, addr, addrlen */
3644         [TARGET_SYS_GETSOCKNAME] = 3, /* fd, addr, addrlen */
3645         [TARGET_SYS_GETPEERNAME] = 3, /* fd, addr, addrlen */
3646         [TARGET_SYS_SOCKETPAIR] = 4,  /* domain, type, protocol, tab */
3647         [TARGET_SYS_SEND] = 4,        /* fd, msg, len, flags */
3648         [TARGET_SYS_RECV] = 4,        /* fd, msg, len, flags */
3649         [TARGET_SYS_SENDTO] = 6,      /* fd, msg, len, flags, addr, addrlen */
3650         [TARGET_SYS_RECVFROM] = 6,    /* fd, msg, len, flags, addr, addrlen */
3651         [TARGET_SYS_SHUTDOWN] = 2,    /* fd, how */
3652         [TARGET_SYS_SETSOCKOPT] = 5,  /* fd, level, optname, optval, optlen */
3653         [TARGET_SYS_GETSOCKOPT] = 5,  /* fd, level, optname, optval, optlen */
3654         [TARGET_SYS_SENDMSG] = 3,     /* fd, msg, flags */
3655         [TARGET_SYS_RECVMSG] = 3,     /* fd, msg, flags */
3656         [TARGET_SYS_ACCEPT4] = 4,     /* fd, addr, addrlen, flags */
3657         [TARGET_SYS_RECVMMSG] = 4,    /* fd, msgvec, vlen, flags */
3658         [TARGET_SYS_SENDMMSG] = 4,    /* fd, msgvec, vlen, flags */
3659     };
3660     abi_long a[6]; /* max 6 args */
3661     unsigned i;
3662
3663     /* check the range of the first argument num */
3664     /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
3665     if (num < 1 || num > TARGET_SYS_SENDMMSG) {
3666         return -TARGET_EINVAL;
3667     }
3668     /* ensure we have space for args */
3669     if (nargs[num] > ARRAY_SIZE(a)) {
3670         return -TARGET_EINVAL;
3671     }
3672     /* collect the arguments in a[] according to nargs[] */
3673     for (i = 0; i < nargs[num]; ++i) {
3674         if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
3675             return -TARGET_EFAULT;
3676         }
3677     }
3678     /* now when we have the args, invoke the appropriate underlying function */
3679     switch (num) {
3680     case TARGET_SYS_SOCKET: /* domain, type, protocol */
3681         return do_socket(a[0], a[1], a[2]);
3682     case TARGET_SYS_BIND: /* sockfd, addr, addrlen */
3683         return do_bind(a[0], a[1], a[2]);
3684     case TARGET_SYS_CONNECT: /* sockfd, addr, addrlen */
3685         return do_connect(a[0], a[1], a[2]);
3686     case TARGET_SYS_LISTEN: /* sockfd, backlog */
3687         return get_errno(listen(a[0], a[1]));
3688     case TARGET_SYS_ACCEPT: /* sockfd, addr, addrlen */
3689         return do_accept4(a[0], a[1], a[2], 0);
3690     case TARGET_SYS_GETSOCKNAME: /* sockfd, addr, addrlen */
3691         return do_getsockname(a[0], a[1], a[2]);
3692     case TARGET_SYS_GETPEERNAME: /* sockfd, addr, addrlen */
3693         return do_getpeername(a[0], a[1], a[2]);
3694     case TARGET_SYS_SOCKETPAIR: /* domain, type, protocol, tab */
3695         return do_socketpair(a[0], a[1], a[2], a[3]);
3696     case TARGET_SYS_SEND: /* sockfd, msg, len, flags */
3697         return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
3698     case TARGET_SYS_RECV: /* sockfd, msg, len, flags */
3699         return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
3700     case TARGET_SYS_SENDTO: /* sockfd, msg, len, flags, addr, addrlen */
3701         return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
3702     case TARGET_SYS_RECVFROM: /* sockfd, msg, len, flags, addr, addrlen */
3703         return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
3704     case TARGET_SYS_SHUTDOWN: /* sockfd, how */
3705         return get_errno(shutdown(a[0], a[1]));
3706     case TARGET_SYS_SETSOCKOPT: /* sockfd, level, optname, optval, optlen */
3707         return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
3708     case TARGET_SYS_GETSOCKOPT: /* sockfd, level, optname, optval, optlen */
3709         return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
3710     case TARGET_SYS_SENDMSG: /* sockfd, msg, flags */
3711         return do_sendrecvmsg(a[0], a[1], a[2], 1);
3712     case TARGET_SYS_RECVMSG: /* sockfd, msg, flags */
3713         return do_sendrecvmsg(a[0], a[1], a[2], 0);
3714     case TARGET_SYS_ACCEPT4: /* sockfd, addr, addrlen, flags */
3715         return do_accept4(a[0], a[1], a[2], a[3]);
3716     case TARGET_SYS_RECVMMSG: /* sockfd, msgvec, vlen, flags */
3717         return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
3718     case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */
3719         return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
3720     default:
3721         qemu_log_mask(LOG_UNIMP, "Unsupported socketcall: %d\n", num);
3722         return -TARGET_EINVAL;
3723     }
3724 }
3725 #endif
3726
3727 #define N_SHM_REGIONS   32
3728
3729 static struct shm_region {
3730     abi_ulong start;
3731     abi_ulong size;
3732     bool in_use;
3733 } shm_regions[N_SHM_REGIONS];
3734
3735 #ifndef TARGET_SEMID64_DS
3736 /* asm-generic version of this struct */
3737 struct target_semid64_ds
3738 {
3739   struct target_ipc_perm sem_perm;
3740   abi_ulong sem_otime;
3741 #if TARGET_ABI_BITS == 32
3742   abi_ulong __unused1;
3743 #endif
3744   abi_ulong sem_ctime;
3745 #if TARGET_ABI_BITS == 32
3746   abi_ulong __unused2;
3747 #endif
3748   abi_ulong sem_nsems;
3749   abi_ulong __unused3;
3750   abi_ulong __unused4;
3751 };
3752 #endif
3753
3754 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
3755                                                abi_ulong target_addr)
3756 {
3757     struct target_ipc_perm *target_ip;
3758     struct target_semid64_ds *target_sd;
3759
3760     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3761         return -TARGET_EFAULT;
3762     target_ip = &(target_sd->sem_perm);
3763     host_ip->__key = tswap32(target_ip->__key);
3764     host_ip->uid = tswap32(target_ip->uid);
3765     host_ip->gid = tswap32(target_ip->gid);
3766     host_ip->cuid = tswap32(target_ip->cuid);
3767     host_ip->cgid = tswap32(target_ip->cgid);
3768 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3769     host_ip->mode = tswap32(target_ip->mode);
3770 #else
3771     host_ip->mode = tswap16(target_ip->mode);
3772 #endif
3773 #if defined(TARGET_PPC)
3774     host_ip->__seq = tswap32(target_ip->__seq);
3775 #else
3776     host_ip->__seq = tswap16(target_ip->__seq);
3777 #endif
3778     unlock_user_struct(target_sd, target_addr, 0);
3779     return 0;
3780 }
3781
3782 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
3783                                                struct ipc_perm *host_ip)
3784 {
3785     struct target_ipc_perm *target_ip;
3786     struct target_semid64_ds *target_sd;
3787
3788     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3789         return -TARGET_EFAULT;
3790     target_ip = &(target_sd->sem_perm);
3791     target_ip->__key = tswap32(host_ip->__key);
3792     target_ip->uid = tswap32(host_ip->uid);
3793     target_ip->gid = tswap32(host_ip->gid);
3794     target_ip->cuid = tswap32(host_ip->cuid);
3795     target_ip->cgid = tswap32(host_ip->cgid);
3796 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3797     target_ip->mode = tswap32(host_ip->mode);
3798 #else
3799     target_ip->mode = tswap16(host_ip->mode);
3800 #endif
3801 #if defined(TARGET_PPC)
3802     target_ip->__seq = tswap32(host_ip->__seq);
3803 #else
3804     target_ip->__seq = tswap16(host_ip->__seq);
3805 #endif
3806     unlock_user_struct(target_sd, target_addr, 1);
3807     return 0;
3808 }
3809
3810 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
3811                                                abi_ulong target_addr)
3812 {
3813     struct target_semid64_ds *target_sd;
3814
3815     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3816         return -TARGET_EFAULT;
3817     if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr))
3818         return -TARGET_EFAULT;
3819     host_sd->sem_nsems = tswapal(target_sd->sem_nsems);
3820     host_sd->sem_otime = tswapal(target_sd->sem_otime);
3821     host_sd->sem_ctime = tswapal(target_sd->sem_ctime);
3822     unlock_user_struct(target_sd, target_addr, 0);
3823     return 0;
3824 }
3825
3826 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
3827                                                struct semid_ds *host_sd)
3828 {
3829     struct target_semid64_ds *target_sd;
3830
3831     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3832         return -TARGET_EFAULT;
3833     if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)))
3834         return -TARGET_EFAULT;
3835     target_sd->sem_nsems = tswapal(host_sd->sem_nsems);
3836     target_sd->sem_otime = tswapal(host_sd->sem_otime);
3837     target_sd->sem_ctime = tswapal(host_sd->sem_ctime);
3838     unlock_user_struct(target_sd, target_addr, 1);
3839     return 0;
3840 }
3841
3842 struct target_seminfo {
3843     int semmap;
3844     int semmni;
3845     int semmns;
3846     int semmnu;
3847     int semmsl;
3848     int semopm;
3849     int semume;
3850     int semusz;
3851     int semvmx;
3852     int semaem;
3853 };
3854
3855 static inline abi_long host_to_target_seminfo(abi_ulong target_addr,
3856                                               struct seminfo *host_seminfo)
3857 {
3858     struct target_seminfo *target_seminfo;
3859     if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0))
3860         return -TARGET_EFAULT;
3861     __put_user(host_seminfo->semmap, &target_seminfo->semmap);
3862     __put_user(host_seminfo->semmni, &target_seminfo->semmni);
3863     __put_user(host_seminfo->semmns, &target_seminfo->semmns);
3864     __put_user(host_seminfo->semmnu, &target_seminfo->semmnu);
3865     __put_user(host_seminfo->semmsl, &target_seminfo->semmsl);
3866     __put_user(host_seminfo->semopm, &target_seminfo->semopm);
3867     __put_user(host_seminfo->semume, &target_seminfo->semume);
3868     __put_user(host_seminfo->semusz, &target_seminfo->semusz);
3869     __put_user(host_seminfo->semvmx, &target_seminfo->semvmx);
3870     __put_user(host_seminfo->semaem, &target_seminfo->semaem);
3871     unlock_user_struct(target_seminfo, target_addr, 1);
3872     return 0;
3873 }
3874
3875 union semun {
3876         int val;
3877         struct semid_ds *buf;
3878         unsigned short *array;
3879         struct seminfo *__buf;
3880 };
3881
3882 union target_semun {
3883         int val;
3884         abi_ulong buf;
3885         abi_ulong array;
3886         abi_ulong __buf;
3887 };
3888
3889 static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array,
3890                                                abi_ulong target_addr)
3891 {
3892     int nsems;
3893     unsigned short *array;
3894     union semun semun;
3895     struct semid_ds semid_ds;
3896     int i, ret;
3897
3898     semun.buf = &semid_ds;
3899
3900     ret = semctl(semid, 0, IPC_STAT, semun);
3901     if (ret == -1)
3902         return get_errno(ret);
3903
3904     nsems = semid_ds.sem_nsems;
3905
3906     *host_array = g_try_new(unsigned short, nsems);
3907     if (!*host_array) {
3908         return -TARGET_ENOMEM;
3909     }
3910     array = lock_user(VERIFY_READ, target_addr,
3911                       nsems*sizeof(unsigned short), 1);
3912     if (!array) {
3913         g_free(*host_array);
3914         return -TARGET_EFAULT;
3915     }
3916
3917     for(i=0; i<nsems; i++) {
3918         __get_user((*host_array)[i], &array[i]);
3919     }
3920     unlock_user(array, target_addr, 0);
3921
3922     return 0;
3923 }
3924
3925 static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr,
3926                                                unsigned short **host_array)
3927 {
3928     int nsems;
3929     unsigned short *array;
3930     union semun semun;
3931     struct semid_ds semid_ds;
3932     int i, ret;
3933
3934     semun.buf = &semid_ds;
3935
3936     ret = semctl(semid, 0, IPC_STAT, semun);
3937     if (ret == -1)
3938         return get_errno(ret);
3939
3940     nsems = semid_ds.sem_nsems;
3941
3942     array = lock_user(VERIFY_WRITE, target_addr,
3943                       nsems*sizeof(unsigned short), 0);
3944     if (!array)
3945         return -TARGET_EFAULT;
3946
3947     for(i=0; i<nsems; i++) {
3948         __put_user((*host_array)[i], &array[i]);
3949     }
3950     g_free(*host_array);
3951     unlock_user(array, target_addr, 1);
3952
3953     return 0;
3954 }
3955
3956 static inline abi_long do_semctl(int semid, int semnum, int cmd,
3957                                  abi_ulong target_arg)
3958 {
3959     union target_semun target_su = { .buf = target_arg };
3960     union semun arg;
3961     struct semid_ds dsarg;
3962     unsigned short *array = NULL;
3963     struct seminfo seminfo;
3964     abi_long ret = -TARGET_EINVAL;
3965     abi_long err;
3966     cmd &= 0xff;
3967
3968     switch( cmd ) {
3969         case GETVAL:
3970         case SETVAL:
3971             /* In 64 bit cross-endian situations, we will erroneously pick up
3972              * the wrong half of the union for the "val" element.  To rectify
3973              * this, the entire 8-byte structure is byteswapped, followed by
3974              * a swap of the 4 byte val field. In other cases, the data is
3975              * already in proper host byte order. */
3976             if (sizeof(target_su.val) != (sizeof(target_su.buf))) {
3977                 target_su.buf = tswapal(target_su.buf);
3978                 arg.val = tswap32(target_su.val);
3979             } else {
3980                 arg.val = target_su.val;
3981             }
3982             ret = get_errno(semctl(semid, semnum, cmd, arg));
3983             break;
3984         case GETALL:
3985         case SETALL:
3986             err = target_to_host_semarray(semid, &array, target_su.array);
3987             if (err)
3988                 return err;
3989             arg.array = array;
3990             ret = get_errno(semctl(semid, semnum, cmd, arg));
3991             err = host_to_target_semarray(semid, target_su.array, &array);
3992             if (err)
3993                 return err;
3994             break;
3995         case IPC_STAT:
3996         case IPC_SET:
3997         case SEM_STAT:
3998             err = target_to_host_semid_ds(&dsarg, target_su.buf);
3999             if (err)
4000                 return err;
4001             arg.buf = &dsarg;
4002             ret = get_errno(semctl(semid, semnum, cmd, arg));
4003             err = host_to_target_semid_ds(target_su.buf, &dsarg);
4004             if (err)
4005                 return err;
4006             break;
4007         case IPC_INFO:
4008         case SEM_INFO:
4009             arg.__buf = &seminfo;
4010             ret = get_errno(semctl(semid, semnum, cmd, arg));
4011             err = host_to_target_seminfo(target_su.__buf, &seminfo);
4012             if (err)
4013                 return err;
4014             break;
4015         case IPC_RMID:
4016         case GETPID:
4017         case GETNCNT:
4018         case GETZCNT:
4019             ret = get_errno(semctl(semid, semnum, cmd, NULL));
4020             break;
4021     }
4022
4023     return ret;
4024 }
4025
4026 struct target_sembuf {
4027     unsigned short sem_num;
4028     short sem_op;
4029     short sem_flg;
4030 };
4031
4032 static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
4033                                              abi_ulong target_addr,
4034                                              unsigned nsops)
4035 {
4036     struct target_sembuf *target_sembuf;
4037     int i;
4038
4039     target_sembuf = lock_user(VERIFY_READ, target_addr,
4040                               nsops*sizeof(struct target_sembuf), 1);
4041     if (!target_sembuf)
4042         return -TARGET_EFAULT;
4043
4044     for(i=0; i<nsops; i++) {
4045         __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num);
4046         __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op);
4047         __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg);
4048     }
4049
4050     unlock_user(target_sembuf, target_addr, 0);
4051
4052     return 0;
4053 }
4054
4055 #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
4056     defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
4057
4058 /*
4059  * This macro is required to handle the s390 variants, which passes the
4060  * arguments in a different order than default.
4061  */
4062 #ifdef __s390x__
4063 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
4064   (__nsops), (__timeout), (__sops)
4065 #else
4066 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
4067   (__nsops), 0, (__sops), (__timeout)
4068 #endif
4069
4070 static inline abi_long do_semtimedop(int semid,
4071                                      abi_long ptr,
4072                                      unsigned nsops,
4073                                      abi_long timeout, bool time64)
4074 {
4075     struct sembuf *sops;
4076     struct timespec ts, *pts = NULL;
4077     abi_long ret;
4078
4079     if (timeout) {
4080         pts = &ts;
4081         if (time64) {
4082             if (target_to_host_timespec64(pts, timeout)) {
4083                 return -TARGET_EFAULT;
4084             }
4085         } else {
4086             if (target_to_host_timespec(pts, timeout)) {
4087                 return -TARGET_EFAULT;
4088             }
4089         }
4090     }
4091
4092     if (nsops > TARGET_SEMOPM) {
4093         return -TARGET_E2BIG;
4094     }
4095
4096     sops = g_new(struct sembuf, nsops);
4097
4098     if (target_to_host_sembuf(sops, ptr, nsops)) {
4099         g_free(sops);
4100         return -TARGET_EFAULT;
4101     }
4102
4103     ret = -TARGET_ENOSYS;
4104 #ifdef __NR_semtimedop
4105     ret = get_errno(safe_semtimedop(semid, sops, nsops, pts));
4106 #endif
4107 #ifdef __NR_ipc
4108     if (ret == -TARGET_ENOSYS) {
4109         ret = get_errno(safe_ipc(IPCOP_semtimedop, semid,
4110                                  SEMTIMEDOP_IPC_ARGS(nsops, sops, (long)pts)));
4111     }
4112 #endif
4113     g_free(sops);
4114     return ret;
4115 }
4116 #endif
4117
4118 struct target_msqid_ds
4119 {
4120     struct target_ipc_perm msg_perm;
4121     abi_ulong msg_stime;
4122 #if TARGET_ABI_BITS == 32
4123     abi_ulong __unused1;
4124 #endif
4125     abi_ulong msg_rtime;
4126 #if TARGET_ABI_BITS == 32
4127     abi_ulong __unused2;
4128 #endif
4129     abi_ulong msg_ctime;
4130 #if TARGET_ABI_BITS == 32
4131     abi_ulong __unused3;
4132 #endif
4133     abi_ulong __msg_cbytes;
4134     abi_ulong msg_qnum;
4135     abi_ulong msg_qbytes;
4136     abi_ulong msg_lspid;
4137     abi_ulong msg_lrpid;
4138     abi_ulong __unused4;
4139     abi_ulong __unused5;
4140 };
4141
4142 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
4143                                                abi_ulong target_addr)
4144 {
4145     struct target_msqid_ds *target_md;
4146
4147     if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
4148         return -TARGET_EFAULT;
4149     if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
4150         return -TARGET_EFAULT;
4151     host_md->msg_stime = tswapal(target_md->msg_stime);
4152     host_md->msg_rtime = tswapal(target_md->msg_rtime);
4153     host_md->msg_ctime = tswapal(target_md->msg_ctime);
4154     host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes);
4155     host_md->msg_qnum = tswapal(target_md->msg_qnum);
4156     host_md->msg_qbytes = tswapal(target_md->msg_qbytes);
4157     host_md->msg_lspid = tswapal(target_md->msg_lspid);
4158     host_md->msg_lrpid = tswapal(target_md->msg_lrpid);
4159     unlock_user_struct(target_md, target_addr, 0);
4160     return 0;
4161 }
4162
4163 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
4164                                                struct msqid_ds *host_md)
4165 {
4166     struct target_msqid_ds *target_md;
4167
4168     if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
4169         return -TARGET_EFAULT;
4170     if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
4171         return -TARGET_EFAULT;
4172     target_md->msg_stime = tswapal(host_md->msg_stime);
4173     target_md->msg_rtime = tswapal(host_md->msg_rtime);
4174     target_md->msg_ctime = tswapal(host_md->msg_ctime);
4175     target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes);
4176     target_md->msg_qnum = tswapal(host_md->msg_qnum);
4177     target_md->msg_qbytes = tswapal(host_md->msg_qbytes);
4178     target_md->msg_lspid = tswapal(host_md->msg_lspid);
4179     target_md->msg_lrpid = tswapal(host_md->msg_lrpid);
4180     unlock_user_struct(target_md, target_addr, 1);
4181     return 0;
4182 }
4183
4184 struct target_msginfo {
4185     int msgpool;
4186     int msgmap;
4187     int msgmax;
4188     int msgmnb;
4189     int msgmni;
4190     int msgssz;
4191     int msgtql;
4192     unsigned short int msgseg;
4193 };
4194
4195 static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
4196                                               struct msginfo *host_msginfo)
4197 {
4198     struct target_msginfo *target_msginfo;
4199     if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
4200         return -TARGET_EFAULT;
4201     __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
4202     __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
4203     __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
4204     __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
4205     __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
4206     __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
4207     __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
4208     __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
4209     unlock_user_struct(target_msginfo, target_addr, 1);
4210     return 0;
4211 }
4212
4213 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
4214 {
4215     struct msqid_ds dsarg;
4216     struct msginfo msginfo;
4217     abi_long ret = -TARGET_EINVAL;
4218
4219     cmd &= 0xff;
4220
4221     switch (cmd) {
4222     case IPC_STAT:
4223     case IPC_SET:
4224     case MSG_STAT:
4225         if (target_to_host_msqid_ds(&dsarg,ptr))
4226             return -TARGET_EFAULT;
4227         ret = get_errno(msgctl(msgid, cmd, &dsarg));
4228         if (host_to_target_msqid_ds(ptr,&dsarg))
4229             return -TARGET_EFAULT;
4230         break;
4231     case IPC_RMID:
4232         ret = get_errno(msgctl(msgid, cmd, NULL));
4233         break;
4234     case IPC_INFO:
4235     case MSG_INFO:
4236         ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
4237         if (host_to_target_msginfo(ptr, &msginfo))
4238             return -TARGET_EFAULT;
4239         break;
4240     }
4241
4242     return ret;
4243 }
4244
4245 struct target_msgbuf {
4246     abi_long mtype;
4247     char        mtext[1];
4248 };
4249
4250 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
4251                                  ssize_t msgsz, int msgflg)
4252 {
4253     struct target_msgbuf *target_mb;
4254     struct msgbuf *host_mb;
4255     abi_long ret = 0;
4256
4257     if (msgsz < 0) {
4258         return -TARGET_EINVAL;
4259     }
4260
4261     if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
4262         return -TARGET_EFAULT;
4263     host_mb = g_try_malloc(msgsz + sizeof(long));
4264     if (!host_mb) {
4265         unlock_user_struct(target_mb, msgp, 0);
4266         return -TARGET_ENOMEM;
4267     }
4268     host_mb->mtype = (abi_long) tswapal(target_mb->mtype);
4269     memcpy(host_mb->mtext, target_mb->mtext, msgsz);
4270     ret = -TARGET_ENOSYS;
4271 #ifdef __NR_msgsnd
4272     ret = get_errno(safe_msgsnd(msqid, host_mb, msgsz, msgflg));
4273 #endif
4274 #ifdef __NR_ipc
4275     if (ret == -TARGET_ENOSYS) {
4276 #ifdef __s390x__
4277         ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg,
4278                                  host_mb));
4279 #else
4280         ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg,
4281                                  host_mb, 0));
4282 #endif
4283     }
4284 #endif
4285     g_free(host_mb);
4286     unlock_user_struct(target_mb, msgp, 0);
4287
4288     return ret;
4289 }
4290
4291 #ifdef __NR_ipc
4292 #if defined(__sparc__)
4293 /* SPARC for msgrcv it does not use the kludge on final 2 arguments.  */
4294 #define MSGRCV_ARGS(__msgp, __msgtyp) __msgp, __msgtyp
4295 #elif defined(__s390x__)
4296 /* The s390 sys_ipc variant has only five parameters.  */
4297 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4298     ((long int[]){(long int)__msgp, __msgtyp})
4299 #else
4300 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4301     ((long int[]){(long int)__msgp, __msgtyp}), 0
4302 #endif
4303 #endif
4304
4305 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
4306                                  ssize_t msgsz, abi_long msgtyp,
4307                                  int msgflg)
4308 {
4309     struct target_msgbuf *target_mb;
4310     char *target_mtext;
4311     struct msgbuf *host_mb;
4312     abi_long ret = 0;
4313
4314     if (msgsz < 0) {
4315         return -TARGET_EINVAL;
4316     }
4317
4318     if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
4319         return -TARGET_EFAULT;
4320
4321     host_mb = g_try_malloc(msgsz + sizeof(long));
4322     if (!host_mb) {
4323         ret = -TARGET_ENOMEM;
4324         goto end;
4325     }
4326     ret = -TARGET_ENOSYS;
4327 #ifdef __NR_msgrcv
4328     ret = get_errno(safe_msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg));
4329 #endif
4330 #ifdef __NR_ipc
4331     if (ret == -TARGET_ENOSYS) {
4332         ret = get_errno(safe_ipc(IPCOP_CALL(1, IPCOP_msgrcv), msqid, msgsz,
4333                         msgflg, MSGRCV_ARGS(host_mb, msgtyp)));
4334     }
4335 #endif
4336
4337     if (ret > 0) {
4338         abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
4339         target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
4340         if (!target_mtext) {
4341             ret = -TARGET_EFAULT;
4342             goto end;
4343         }
4344         memcpy(target_mb->mtext, host_mb->mtext, ret);
4345         unlock_user(target_mtext, target_mtext_addr, ret);
4346     }
4347
4348     target_mb->mtype = tswapal(host_mb->mtype);
4349
4350 end:
4351     if (target_mb)
4352         unlock_user_struct(target_mb, msgp, 1);
4353     g_free(host_mb);
4354     return ret;
4355 }
4356
4357 static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
4358                                                abi_ulong target_addr)
4359 {
4360     struct target_shmid_ds *target_sd;
4361
4362     if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4363         return -TARGET_EFAULT;
4364     if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr))
4365         return -TARGET_EFAULT;
4366     __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4367     __get_user(host_sd->shm_atime, &target_sd->shm_atime);
4368     __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4369     __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4370     __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4371     __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4372     __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4373     unlock_user_struct(target_sd, target_addr, 0);
4374     return 0;
4375 }
4376
4377 static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr,
4378                                                struct shmid_ds *host_sd)
4379 {
4380     struct target_shmid_ds *target_sd;
4381
4382     if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4383         return -TARGET_EFAULT;
4384     if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm)))
4385         return -TARGET_EFAULT;
4386     __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4387     __put_user(host_sd->shm_atime, &target_sd->shm_atime);
4388     __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4389     __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4390     __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4391     __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4392     __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4393     unlock_user_struct(target_sd, target_addr, 1);
4394     return 0;
4395 }
4396
4397 struct  target_shminfo {
4398     abi_ulong shmmax;
4399     abi_ulong shmmin;
4400     abi_ulong shmmni;
4401     abi_ulong shmseg;
4402     abi_ulong shmall;
4403 };
4404
4405 static inline abi_long host_to_target_shminfo(abi_ulong target_addr,
4406                                               struct shminfo *host_shminfo)
4407 {
4408     struct target_shminfo *target_shminfo;
4409     if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0))
4410         return -TARGET_EFAULT;
4411     __put_user(host_shminfo->shmmax, &target_shminfo->shmmax);
4412     __put_user(host_shminfo->shmmin, &target_shminfo->shmmin);
4413     __put_user(host_shminfo->shmmni, &target_shminfo->shmmni);
4414     __put_user(host_shminfo->shmseg, &target_shminfo->shmseg);
4415     __put_user(host_shminfo->shmall, &target_shminfo->shmall);
4416     unlock_user_struct(target_shminfo, target_addr, 1);
4417     return 0;
4418 }
4419
4420 struct target_shm_info {
4421     int used_ids;
4422     abi_ulong shm_tot;
4423     abi_ulong shm_rss;
4424     abi_ulong shm_swp;
4425     abi_ulong swap_attempts;
4426     abi_ulong swap_successes;
4427 };
4428
4429 static inline abi_long host_to_target_shm_info(abi_ulong target_addr,
4430                                                struct shm_info *host_shm_info)
4431 {
4432     struct target_shm_info *target_shm_info;
4433     if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0))
4434         return -TARGET_EFAULT;
4435     __put_user(host_shm_info->used_ids, &target_shm_info->used_ids);
4436     __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot);
4437     __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss);
4438     __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp);
4439     __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts);
4440     __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes);
4441     unlock_user_struct(target_shm_info, target_addr, 1);
4442     return 0;
4443 }
4444
4445 static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf)
4446 {
4447     struct shmid_ds dsarg;
4448     struct shminfo shminfo;
4449     struct shm_info shm_info;
4450     abi_long ret = -TARGET_EINVAL;
4451
4452     cmd &= 0xff;
4453
4454     switch(cmd) {
4455     case IPC_STAT:
4456     case IPC_SET:
4457     case SHM_STAT:
4458         if (target_to_host_shmid_ds(&dsarg, buf))
4459             return -TARGET_EFAULT;
4460         ret = get_errno(shmctl(shmid, cmd, &dsarg));
4461         if (host_to_target_shmid_ds(buf, &dsarg))
4462             return -TARGET_EFAULT;
4463         break;
4464     case IPC_INFO:
4465         ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo));
4466         if (host_to_target_shminfo(buf, &shminfo))
4467             return -TARGET_EFAULT;
4468         break;
4469     case SHM_INFO:
4470         ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info));
4471         if (host_to_target_shm_info(buf, &shm_info))
4472             return -TARGET_EFAULT;
4473         break;
4474     case IPC_RMID:
4475     case SHM_LOCK:
4476     case SHM_UNLOCK:
4477         ret = get_errno(shmctl(shmid, cmd, NULL));
4478         break;
4479     }
4480
4481     return ret;
4482 }
4483
4484 #ifndef TARGET_FORCE_SHMLBA
4485 /* For most architectures, SHMLBA is the same as the page size;
4486  * some architectures have larger values, in which case they should
4487  * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
4488  * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
4489  * and defining its own value for SHMLBA.
4490  *
4491  * The kernel also permits SHMLBA to be set by the architecture to a
4492  * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
4493  * this means that addresses are rounded to the large size if
4494  * SHM_RND is set but addresses not aligned to that size are not rejected
4495  * as long as they are at least page-aligned. Since the only architecture
4496  * which uses this is ia64 this code doesn't provide for that oddity.
4497  */
4498 static inline abi_ulong target_shmlba(CPUArchState *cpu_env)
4499 {
4500     return TARGET_PAGE_SIZE;
4501 }
4502 #endif
4503
4504 static inline abi_ulong do_shmat(CPUArchState *cpu_env,
4505                                  int shmid, abi_ulong shmaddr, int shmflg)
4506 {
4507     CPUState *cpu = env_cpu(cpu_env);
4508     abi_long raddr;
4509     void *host_raddr;
4510     struct shmid_ds shm_info;
4511     int i,ret;
4512     abi_ulong shmlba;
4513
4514     /* shmat pointers are always untagged */
4515
4516     /* find out the length of the shared memory segment */
4517     ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
4518     if (is_error(ret)) {
4519         /* can't get length, bail out */
4520         return ret;
4521     }
4522
4523     shmlba = target_shmlba(cpu_env);
4524
4525     if (shmaddr & (shmlba - 1)) {
4526         if (shmflg & SHM_RND) {
4527             shmaddr &= ~(shmlba - 1);
4528         } else {
4529             return -TARGET_EINVAL;
4530         }
4531     }
4532     if (!guest_range_valid_untagged(shmaddr, shm_info.shm_segsz)) {
4533         return -TARGET_EINVAL;
4534     }
4535
4536     mmap_lock();
4537
4538     /*
4539      * We're mapping shared memory, so ensure we generate code for parallel
4540      * execution and flush old translations.  This will work up to the level
4541      * supported by the host -- anything that requires EXCP_ATOMIC will not
4542      * be atomic with respect to an external process.
4543      */
4544     if (!(cpu->tcg_cflags & CF_PARALLEL)) {
4545         cpu->tcg_cflags |= CF_PARALLEL;
4546         tb_flush(cpu);
4547     }
4548
4549     if (shmaddr)
4550         host_raddr = shmat(shmid, (void *)g2h_untagged(shmaddr), shmflg);
4551     else {
4552         abi_ulong mmap_start;
4553
4554         /* In order to use the host shmat, we need to honor host SHMLBA.  */
4555         mmap_start = mmap_find_vma(0, shm_info.shm_segsz, MAX(SHMLBA, shmlba));
4556
4557         if (mmap_start == -1) {
4558             errno = ENOMEM;
4559             host_raddr = (void *)-1;
4560         } else
4561             host_raddr = shmat(shmid, g2h_untagged(mmap_start),
4562                                shmflg | SHM_REMAP);
4563     }
4564
4565     if (host_raddr == (void *)-1) {
4566         mmap_unlock();
4567         return get_errno((long)host_raddr);
4568     }
4569     raddr=h2g((unsigned long)host_raddr);
4570
4571     page_set_flags(raddr, raddr + shm_info.shm_segsz,
4572                    PAGE_VALID | PAGE_RESET | PAGE_READ |
4573                    (shmflg & SHM_RDONLY ? 0 : PAGE_WRITE));
4574
4575     for (i = 0; i < N_SHM_REGIONS; i++) {
4576         if (!shm_regions[i].in_use) {
4577             shm_regions[i].in_use = true;
4578             shm_regions[i].start = raddr;
4579             shm_regions[i].size = shm_info.shm_segsz;
4580             break;
4581         }
4582     }
4583
4584     mmap_unlock();
4585     return raddr;
4586
4587 }
4588
4589 static inline abi_long do_shmdt(abi_ulong shmaddr)
4590 {
4591     int i;
4592     abi_long rv;
4593
4594     /* shmdt pointers are always untagged */
4595
4596     mmap_lock();
4597
4598     for (i = 0; i < N_SHM_REGIONS; ++i) {
4599         if (shm_regions[i].in_use && shm_regions[i].start == shmaddr) {
4600             shm_regions[i].in_use = false;
4601             page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0);
4602             break;
4603         }
4604     }
4605     rv = get_errno(shmdt(g2h_untagged(shmaddr)));
4606
4607     mmap_unlock();
4608
4609     return rv;
4610 }
4611
4612 #ifdef TARGET_NR_ipc
4613 /* ??? This only works with linear mappings.  */
4614 /* do_ipc() must return target values and target errnos. */
4615 static abi_long do_ipc(CPUArchState *cpu_env,
4616                        unsigned int call, abi_long first,
4617                        abi_long second, abi_long third,
4618                        abi_long ptr, abi_long fifth)
4619 {
4620     int version;
4621     abi_long ret = 0;
4622
4623     version = call >> 16;
4624     call &= 0xffff;
4625
4626     switch (call) {
4627     case IPCOP_semop:
4628         ret = do_semtimedop(first, ptr, second, 0, false);
4629         break;
4630     case IPCOP_semtimedop:
4631     /*
4632      * The s390 sys_ipc variant has only five parameters instead of six
4633      * (as for default variant) and the only difference is the handling of
4634      * SEMTIMEDOP where on s390 the third parameter is used as a pointer
4635      * to a struct timespec where the generic variant uses fifth parameter.
4636      */
4637 #if defined(TARGET_S390X)
4638         ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
4639 #else
4640         ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
4641 #endif
4642         break;
4643
4644     case IPCOP_semget:
4645         ret = get_errno(semget(first, second, third));
4646         break;
4647
4648     case IPCOP_semctl: {
4649         /* The semun argument to semctl is passed by value, so dereference the
4650          * ptr argument. */
4651         abi_ulong atptr;
4652         get_user_ual(atptr, ptr);
4653         ret = do_semctl(first, second, third, atptr);
4654         break;
4655     }
4656
4657     case IPCOP_msgget:
4658         ret = get_errno(msgget(first, second));
4659         break;
4660
4661     case IPCOP_msgsnd:
4662         ret = do_msgsnd(first, ptr, second, third);
4663         break;
4664
4665     case IPCOP_msgctl:
4666         ret = do_msgctl(first, second, ptr);
4667         break;
4668
4669     case IPCOP_msgrcv:
4670         switch (version) {
4671         case 0:
4672             {
4673                 struct target_ipc_kludge {
4674                     abi_long msgp;
4675                     abi_long msgtyp;
4676                 } *tmp;
4677
4678                 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
4679                     ret = -TARGET_EFAULT;
4680                     break;
4681                 }
4682
4683                 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third);
4684
4685                 unlock_user_struct(tmp, ptr, 0);
4686                 break;
4687             }
4688         default:
4689             ret = do_msgrcv(first, ptr, second, fifth, third);
4690         }
4691         break;
4692
4693     case IPCOP_shmat:
4694         switch (version) {
4695         default:
4696         {
4697             abi_ulong raddr;
4698             raddr = do_shmat(cpu_env, first, ptr, second);
4699             if (is_error(raddr))
4700                 return get_errno(raddr);
4701             if (put_user_ual(raddr, third))
4702                 return -TARGET_EFAULT;
4703             break;
4704         }
4705         case 1:
4706             ret = -TARGET_EINVAL;
4707             break;
4708         }
4709         break;
4710     case IPCOP_shmdt:
4711         ret = do_shmdt(ptr);
4712         break;
4713
4714     case IPCOP_shmget:
4715         /* IPC_* flag values are the same on all linux platforms */
4716         ret = get_errno(shmget(first, second, third));
4717         break;
4718
4719         /* IPC_* and SHM_* command values are the same on all linux platforms */
4720     case IPCOP_shmctl:
4721         ret = do_shmctl(first, second, ptr);
4722         break;
4723     default:
4724         qemu_log_mask(LOG_UNIMP, "Unsupported ipc call: %d (version %d)\n",
4725                       call, version);
4726         ret = -TARGET_ENOSYS;
4727         break;
4728     }
4729     return ret;
4730 }
4731 #endif
4732
4733 /* kernel structure types definitions */
4734
4735 #define STRUCT(name, ...) STRUCT_ ## name,
4736 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
4737 enum {
4738 #include "syscall_types.h"
4739 STRUCT_MAX
4740 };
4741 #undef STRUCT
4742 #undef STRUCT_SPECIAL
4743
4744 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = {  __VA_ARGS__, TYPE_NULL };
4745 #define STRUCT_SPECIAL(name)
4746 #include "syscall_types.h"
4747 #undef STRUCT
4748 #undef STRUCT_SPECIAL
4749
4750 #define MAX_STRUCT_SIZE 4096
4751
4752 #ifdef CONFIG_FIEMAP
4753 /* So fiemap access checks don't overflow on 32 bit systems.
4754  * This is very slightly smaller than the limit imposed by
4755  * the underlying kernel.
4756  */
4757 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap))  \
4758                             / sizeof(struct fiemap_extent))
4759
4760 static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
4761                                        int fd, int cmd, abi_long arg)
4762 {
4763     /* The parameter for this ioctl is a struct fiemap followed
4764      * by an array of struct fiemap_extent whose size is set
4765      * in fiemap->fm_extent_count. The array is filled in by the
4766      * ioctl.
4767      */
4768     int target_size_in, target_size_out;
4769     struct fiemap *fm;
4770     const argtype *arg_type = ie->arg_type;
4771     const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) };
4772     void *argptr, *p;
4773     abi_long ret;
4774     int i, extent_size = thunk_type_size(extent_arg_type, 0);
4775     uint32_t outbufsz;
4776     int free_fm = 0;
4777
4778     assert(arg_type[0] == TYPE_PTR);
4779     assert(ie->access == IOC_RW);
4780     arg_type++;
4781     target_size_in = thunk_type_size(arg_type, 0);
4782     argptr = lock_user(VERIFY_READ, arg, target_size_in, 1);
4783     if (!argptr) {
4784         return -TARGET_EFAULT;
4785     }
4786     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4787     unlock_user(argptr, arg, 0);
4788     fm = (struct fiemap *)buf_temp;
4789     if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) {
4790         return -TARGET_EINVAL;
4791     }
4792
4793     outbufsz = sizeof (*fm) +
4794         (sizeof(struct fiemap_extent) * fm->fm_extent_count);
4795
4796     if (outbufsz > MAX_STRUCT_SIZE) {
4797         /* We can't fit all the extents into the fixed size buffer.
4798          * Allocate one that is large enough and use it instead.
4799          */
4800         fm = g_try_malloc(outbufsz);
4801         if (!fm) {
4802             return -TARGET_ENOMEM;
4803         }
4804         memcpy(fm, buf_temp, sizeof(struct fiemap));
4805         free_fm = 1;
4806     }
4807     ret = get_errno(safe_ioctl(fd, ie->host_cmd, fm));
4808     if (!is_error(ret)) {
4809         target_size_out = target_size_in;
4810         /* An extent_count of 0 means we were only counting the extents
4811          * so there are no structs to copy
4812          */
4813         if (fm->fm_extent_count != 0) {
4814             target_size_out += fm->fm_mapped_extents * extent_size;
4815         }
4816         argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0);
4817         if (!argptr) {
4818             ret = -TARGET_EFAULT;
4819         } else {
4820             /* Convert the struct fiemap */
4821             thunk_convert(argptr, fm, arg_type, THUNK_TARGET);
4822             if (fm->fm_extent_count != 0) {
4823                 p = argptr + target_size_in;
4824                 /* ...and then all the struct fiemap_extents */
4825                 for (i = 0; i < fm->fm_mapped_extents; i++) {
4826                     thunk_convert(p, &fm->fm_extents[i], extent_arg_type,
4827                                   THUNK_TARGET);
4828                     p += extent_size;
4829                 }
4830             }
4831             unlock_user(argptr, arg, target_size_out);
4832         }
4833     }
4834     if (free_fm) {
4835         g_free(fm);
4836     }
4837     return ret;
4838 }
4839 #endif
4840
4841 static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp,
4842                                 int fd, int cmd, abi_long arg)
4843 {
4844     const argtype *arg_type = ie->arg_type;
4845     int target_size;
4846     void *argptr;
4847     int ret;
4848     struct ifconf *host_ifconf;
4849     uint32_t outbufsz;
4850     const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) };
4851     const argtype ifreq_max_type[] = { MK_STRUCT(STRUCT_ifmap_ifreq) };
4852     int target_ifreq_size;
4853     int nb_ifreq;
4854     int free_buf = 0;
4855     int i;
4856     int target_ifc_len;
4857     abi_long target_ifc_buf;
4858     int host_ifc_len;
4859     char *host_ifc_buf;
4860
4861     assert(arg_type[0] == TYPE_PTR);
4862     assert(ie->access == IOC_RW);
4863
4864     arg_type++;
4865     target_size = thunk_type_size(arg_type, 0);
4866
4867     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4868     if (!argptr)
4869         return -TARGET_EFAULT;
4870     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4871     unlock_user(argptr, arg, 0);
4872
4873     host_ifconf = (struct ifconf *)(unsigned long)buf_temp;
4874     target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf;
4875     target_ifreq_size = thunk_type_size(ifreq_max_type, 0);
4876
4877     if (target_ifc_buf != 0) {
4878         target_ifc_len = host_ifconf->ifc_len;
4879         nb_ifreq = target_ifc_len / target_ifreq_size;
4880         host_ifc_len = nb_ifreq * sizeof(struct ifreq);
4881
4882         outbufsz = sizeof(*host_ifconf) + host_ifc_len;
4883         if (outbufsz > MAX_STRUCT_SIZE) {
4884             /*
4885              * We can't fit all the extents into the fixed size buffer.
4886              * Allocate one that is large enough and use it instead.
4887              */
4888             host_ifconf = g_try_malloc(outbufsz);
4889             if (!host_ifconf) {
4890                 return -TARGET_ENOMEM;
4891             }
4892             memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf));
4893             free_buf = 1;
4894         }
4895         host_ifc_buf = (char *)host_ifconf + sizeof(*host_ifconf);
4896
4897         host_ifconf->ifc_len = host_ifc_len;
4898     } else {
4899       host_ifc_buf = NULL;
4900     }
4901     host_ifconf->ifc_buf = host_ifc_buf;
4902
4903     ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_ifconf));
4904     if (!is_error(ret)) {
4905         /* convert host ifc_len to target ifc_len */
4906
4907         nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq);
4908         target_ifc_len = nb_ifreq * target_ifreq_size;
4909         host_ifconf->ifc_len = target_ifc_len;
4910
4911         /* restore target ifc_buf */
4912
4913         host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf;
4914
4915         /* copy struct ifconf to target user */
4916
4917         argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
4918         if (!argptr)
4919             return -TARGET_EFAULT;
4920         thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET);
4921         unlock_user(argptr, arg, target_size);
4922
4923         if (target_ifc_buf != 0) {
4924             /* copy ifreq[] to target user */
4925             argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0);
4926             for (i = 0; i < nb_ifreq ; i++) {
4927                 thunk_convert(argptr + i * target_ifreq_size,
4928                               host_ifc_buf + i * sizeof(struct ifreq),
4929                               ifreq_arg_type, THUNK_TARGET);
4930             }
4931             unlock_user(argptr, target_ifc_buf, target_ifc_len);
4932         }
4933     }
4934
4935     if (free_buf) {
4936         g_free(host_ifconf);
4937     }
4938
4939     return ret;
4940 }
4941
4942 #if defined(CONFIG_USBFS)
4943 #if HOST_LONG_BITS > 64
4944 #error USBDEVFS thunks do not support >64 bit hosts yet.
4945 #endif
4946 struct live_urb {
4947     uint64_t target_urb_adr;
4948     uint64_t target_buf_adr;
4949     char *target_buf_ptr;
4950     struct usbdevfs_urb host_urb;
4951 };
4952
4953 static GHashTable *usbdevfs_urb_hashtable(void)
4954 {
4955     static GHashTable *urb_hashtable;
4956
4957     if (!urb_hashtable) {
4958         urb_hashtable = g_hash_table_new(g_int64_hash, g_int64_equal);
4959     }
4960     return urb_hashtable;
4961 }
4962
4963 static void urb_hashtable_insert(struct live_urb *urb)
4964 {
4965     GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4966     g_hash_table_insert(urb_hashtable, urb, urb);
4967 }
4968
4969 static struct live_urb *urb_hashtable_lookup(uint64_t target_urb_adr)
4970 {
4971     GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4972     return g_hash_table_lookup(urb_hashtable, &target_urb_adr);
4973 }
4974
4975 static void urb_hashtable_remove(struct live_urb *urb)
4976 {
4977     GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4978     g_hash_table_remove(urb_hashtable, urb);
4979 }
4980
4981 static abi_long
4982 do_ioctl_usbdevfs_reapurb(const IOCTLEntry *ie, uint8_t *buf_temp,
4983                           int fd, int cmd, abi_long arg)
4984 {
4985     const argtype usbfsurb_arg_type[] = { MK_STRUCT(STRUCT_usbdevfs_urb) };
4986     const argtype ptrvoid_arg_type[] = { TYPE_PTRVOID, 0, 0 };
4987     struct live_urb *lurb;
4988     void *argptr;
4989     uint64_t hurb;
4990     int target_size;
4991     uintptr_t target_urb_adr;
4992     abi_long ret;
4993
4994     target_size = thunk_type_size(usbfsurb_arg_type, THUNK_TARGET);
4995
4996     memset(buf_temp, 0, sizeof(uint64_t));
4997     ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
4998     if (is_error(ret)) {
4999         return ret;
5000     }
5001
5002     memcpy(&hurb, buf_temp, sizeof(uint64_t));
5003     lurb = (void *)((uintptr_t)hurb - offsetof(struct live_urb, host_urb));
5004     if (!lurb->target_urb_adr) {
5005         return -TARGET_EFAULT;
5006     }
5007     urb_hashtable_remove(lurb);
5008     unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr,
5009         lurb->host_urb.buffer_length);
5010     lurb->target_buf_ptr = NULL;
5011
5012     /* restore the guest buffer pointer */
5013     lurb->host_urb.buffer = (void *)(uintptr_t)lurb->target_buf_adr;
5014
5015     /* update the guest urb struct */
5016     argptr = lock_user(VERIFY_WRITE, lurb->target_urb_adr, target_size, 0);
5017     if (!argptr) {
5018         g_free(lurb);
5019         return -TARGET_EFAULT;
5020     }
5021     thunk_convert(argptr, &lurb->host_urb, usbfsurb_arg_type, THUNK_TARGET);
5022     unlock_user(argptr, lurb->target_urb_adr, target_size);
5023
5024     target_size = thunk_type_size(ptrvoid_arg_type, THUNK_TARGET);
5025     /* write back the urb handle */
5026     argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5027     if (!argptr) {
5028         g_free(lurb);
5029         return -TARGET_EFAULT;
5030     }
5031
5032     /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */
5033     target_urb_adr = lurb->target_urb_adr;
5034     thunk_convert(argptr, &target_urb_adr, ptrvoid_arg_type, THUNK_TARGET);
5035     unlock_user(argptr, arg, target_size);
5036
5037     g_free(lurb);
5038     return ret;
5039 }
5040
5041 static abi_long
5042 do_ioctl_usbdevfs_discardurb(const IOCTLEntry *ie,
5043                              uint8_t *buf_temp __attribute__((unused)),
5044                              int fd, int cmd, abi_long arg)
5045 {
5046     struct live_urb *lurb;
5047
5048     /* map target address back to host URB with metadata. */
5049     lurb = urb_hashtable_lookup(arg);
5050     if (!lurb) {
5051         return -TARGET_EFAULT;
5052     }
5053     return get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb));
5054 }
5055
5056 static abi_long
5057 do_ioctl_usbdevfs_submiturb(const IOCTLEntry *ie, uint8_t *buf_temp,
5058                             int fd, int cmd, abi_long arg)
5059 {
5060     const argtype *arg_type = ie->arg_type;
5061     int target_size;
5062     abi_long ret;
5063     void *argptr;
5064     int rw_dir;
5065     struct live_urb *lurb;
5066
5067     /*
5068      * each submitted URB needs to map to a unique ID for the
5069      * kernel, and that unique ID needs to be a pointer to
5070      * host memory.  hence, we need to malloc for each URB.
5071      * isochronous transfers have a variable length struct.
5072      */
5073     arg_type++;
5074     target_size = thunk_type_size(arg_type, THUNK_TARGET);
5075
5076     /* construct host copy of urb and metadata */
5077     lurb = g_try_malloc0(sizeof(struct live_urb));
5078     if (!lurb) {
5079         return -TARGET_ENOMEM;
5080     }
5081
5082     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5083     if (!argptr) {
5084         g_free(lurb);
5085         return -TARGET_EFAULT;
5086     }
5087     thunk_convert(&lurb->host_urb, argptr, arg_type, THUNK_HOST);
5088     unlock_user(argptr, arg, 0);
5089
5090     lurb->target_urb_adr = arg;
5091     lurb->target_buf_adr = (uintptr_t)lurb->host_urb.buffer;
5092
5093     /* buffer space used depends on endpoint type so lock the entire buffer */
5094     /* control type urbs should check the buffer contents for true direction */
5095     rw_dir = lurb->host_urb.endpoint & USB_DIR_IN ? VERIFY_WRITE : VERIFY_READ;
5096     lurb->target_buf_ptr = lock_user(rw_dir, lurb->target_buf_adr,
5097         lurb->host_urb.buffer_length, 1);
5098     if (lurb->target_buf_ptr == NULL) {
5099         g_free(lurb);
5100         return -TARGET_EFAULT;
5101     }
5102
5103     /* update buffer pointer in host copy */
5104     lurb->host_urb.buffer = lurb->target_buf_ptr;
5105
5106     ret = get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb));
5107     if (is_error(ret)) {
5108         unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr, 0);
5109         g_free(lurb);
5110     } else {
5111         urb_hashtable_insert(lurb);
5112     }
5113
5114     return ret;
5115 }
5116 #endif /* CONFIG_USBFS */
5117
5118 static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
5119                             int cmd, abi_long arg)
5120 {
5121     void *argptr;
5122     struct dm_ioctl *host_dm;
5123     abi_long guest_data;
5124     uint32_t guest_data_size;
5125     int target_size;
5126     const argtype *arg_type = ie->arg_type;
5127     abi_long ret;
5128     void *big_buf = NULL;
5129     char *host_data;
5130
5131     arg_type++;
5132     target_size = thunk_type_size(arg_type, 0);
5133     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5134     if (!argptr) {
5135         ret = -TARGET_EFAULT;
5136         goto out;
5137     }
5138     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5139     unlock_user(argptr, arg, 0);
5140
5141     /* buf_temp is too small, so fetch things into a bigger buffer */
5142     big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2);
5143     memcpy(big_buf, buf_temp, target_size);
5144     buf_temp = big_buf;
5145     host_dm = big_buf;
5146
5147     guest_data = arg + host_dm->data_start;
5148     if ((guest_data - arg) < 0) {
5149         ret = -TARGET_EINVAL;
5150         goto out;
5151     }
5152     guest_data_size = host_dm->data_size - host_dm->data_start;
5153     host_data = (char*)host_dm + host_dm->data_start;
5154
5155     argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1);
5156     if (!argptr) {
5157         ret = -TARGET_EFAULT;
5158         goto out;
5159     }
5160
5161     switch (ie->host_cmd) {
5162     case DM_REMOVE_ALL:
5163     case DM_LIST_DEVICES:
5164     case DM_DEV_CREATE:
5165     case DM_DEV_REMOVE:
5166     case DM_DEV_SUSPEND:
5167     case DM_DEV_STATUS:
5168     case DM_DEV_WAIT:
5169     case DM_TABLE_STATUS:
5170     case DM_TABLE_CLEAR:
5171     case DM_TABLE_DEPS:
5172     case DM_LIST_VERSIONS:
5173         /* no input data */
5174         break;
5175     case DM_DEV_RENAME:
5176     case DM_DEV_SET_GEOMETRY:
5177         /* data contains only strings */
5178         memcpy(host_data, argptr, guest_data_size);
5179         break;
5180     case DM_TARGET_MSG:
5181         memcpy(host_data, argptr, guest_data_size);
5182         *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr);
5183         break;
5184     case DM_TABLE_LOAD:
5185     {
5186         void *gspec = argptr;
5187         void *cur_data = host_data;
5188         const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5189         int spec_size = thunk_type_size(arg_type, 0);
5190         int i;
5191
5192         for (i = 0; i < host_dm->target_count; i++) {
5193             struct dm_target_spec *spec = cur_data;
5194             uint32_t next;
5195             int slen;
5196
5197             thunk_convert(spec, gspec, arg_type, THUNK_HOST);
5198             slen = strlen((char*)gspec + spec_size) + 1;
5199             next = spec->next;
5200             spec->next = sizeof(*spec) + slen;
5201             strcpy((char*)&spec[1], gspec + spec_size);
5202             gspec += next;
5203             cur_data += spec->next;
5204         }
5205         break;
5206     }
5207     default:
5208         ret = -TARGET_EINVAL;
5209         unlock_user(argptr, guest_data, 0);
5210         goto out;
5211     }
5212     unlock_user(argptr, guest_data, 0);
5213
5214     ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5215     if (!is_error(ret)) {
5216         guest_data = arg + host_dm->data_start;
5217         guest_data_size = host_dm->data_size - host_dm->data_start;
5218         argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0);
5219         switch (ie->host_cmd) {
5220         case DM_REMOVE_ALL:
5221         case DM_DEV_CREATE:
5222         case DM_DEV_REMOVE:
5223         case DM_DEV_RENAME:
5224         case DM_DEV_SUSPEND:
5225         case DM_DEV_STATUS:
5226         case DM_TABLE_LOAD:
5227         case DM_TABLE_CLEAR:
5228         case DM_TARGET_MSG:
5229         case DM_DEV_SET_GEOMETRY:
5230             /* no return data */
5231             break;
5232         case DM_LIST_DEVICES:
5233         {
5234             struct dm_name_list *nl = (void*)host_dm + host_dm->data_start;
5235             uint32_t remaining_data = guest_data_size;
5236             void *cur_data = argptr;
5237             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) };
5238             int nl_size = 12; /* can't use thunk_size due to alignment */
5239
5240             while (1) {
5241                 uint32_t next = nl->next;
5242                 if (next) {
5243                     nl->next = nl_size + (strlen(nl->name) + 1);
5244                 }
5245                 if (remaining_data < nl->next) {
5246                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
5247                     break;
5248                 }
5249                 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET);
5250                 strcpy(cur_data + nl_size, nl->name);
5251                 cur_data += nl->next;
5252                 remaining_data -= nl->next;
5253                 if (!next) {
5254                     break;
5255                 }
5256                 nl = (void*)nl + next;
5257             }
5258             break;
5259         }
5260         case DM_DEV_WAIT:
5261         case DM_TABLE_STATUS:
5262         {
5263             struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start;
5264             void *cur_data = argptr;
5265             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5266             int spec_size = thunk_type_size(arg_type, 0);
5267             int i;
5268
5269             for (i = 0; i < host_dm->target_count; i++) {
5270                 uint32_t next = spec->next;
5271                 int slen = strlen((char*)&spec[1]) + 1;
5272                 spec->next = (cur_data - argptr) + spec_size + slen;
5273                 if (guest_data_size < spec->next) {
5274                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
5275                     break;
5276                 }
5277                 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET);
5278                 strcpy(cur_data + spec_size, (char*)&spec[1]);
5279                 cur_data = argptr + spec->next;
5280                 spec = (void*)host_dm + host_dm->data_start + next;
5281             }
5282             break;
5283         }
5284         case DM_TABLE_DEPS:
5285         {
5286             void *hdata = (void*)host_dm + host_dm->data_start;
5287             int count = *(uint32_t*)hdata;
5288             uint64_t *hdev = hdata + 8;
5289             uint64_t *gdev = argptr + 8;
5290             int i;
5291
5292             *(uint32_t*)argptr = tswap32(count);
5293             for (i = 0; i < count; i++) {
5294                 *gdev = tswap64(*hdev);
5295                 gdev++;
5296                 hdev++;
5297             }
5298             break;
5299         }
5300         case DM_LIST_VERSIONS:
5301         {
5302             struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start;
5303             uint32_t remaining_data = guest_data_size;
5304             void *cur_data = argptr;
5305             const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) };
5306             int vers_size = thunk_type_size(arg_type, 0);
5307
5308             while (1) {
5309                 uint32_t next = vers->next;
5310                 if (next) {
5311                     vers->next = vers_size + (strlen(vers->name) + 1);
5312                 }
5313                 if (remaining_data < vers->next) {
5314                     host_dm->flags |= DM_BUFFER_FULL_FLAG;
5315                     break;
5316                 }
5317                 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET);
5318                 strcpy(cur_data + vers_size, vers->name);
5319                 cur_data += vers->next;
5320                 remaining_data -= vers->next;
5321                 if (!next) {
5322                     break;
5323                 }
5324                 vers = (void*)vers + next;
5325             }
5326             break;
5327         }
5328         default:
5329             unlock_user(argptr, guest_data, 0);
5330             ret = -TARGET_EINVAL;
5331             goto out;
5332         }
5333         unlock_user(argptr, guest_data, guest_data_size);
5334
5335         argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5336         if (!argptr) {
5337             ret = -TARGET_EFAULT;
5338             goto out;
5339         }
5340         thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5341         unlock_user(argptr, arg, target_size);
5342     }
5343 out:
5344     g_free(big_buf);
5345     return ret;
5346 }
5347
5348 static abi_long do_ioctl_blkpg(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
5349                                int cmd, abi_long arg)
5350 {
5351     void *argptr;
5352     int target_size;
5353     const argtype *arg_type = ie->arg_type;
5354     const argtype part_arg_type[] = { MK_STRUCT(STRUCT_blkpg_partition) };
5355     abi_long ret;
5356
5357     struct blkpg_ioctl_arg *host_blkpg = (void*)buf_temp;
5358     struct blkpg_partition host_part;
5359
5360     /* Read and convert blkpg */
5361     arg_type++;
5362     target_size = thunk_type_size(arg_type, 0);
5363     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5364     if (!argptr) {
5365         ret = -TARGET_EFAULT;
5366         goto out;
5367     }
5368     thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5369     unlock_user(argptr, arg, 0);
5370
5371     switch (host_blkpg->op) {
5372     case BLKPG_ADD_PARTITION:
5373     case BLKPG_DEL_PARTITION:
5374         /* payload is struct blkpg_partition */
5375         break;
5376     default:
5377         /* Unknown opcode */
5378         ret = -TARGET_EINVAL;
5379         goto out;
5380     }
5381
5382     /* Read and convert blkpg->data */
5383     arg = (abi_long)(uintptr_t)host_blkpg->data;
5384     target_size = thunk_type_size(part_arg_type, 0);
5385     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5386     if (!argptr) {
5387         ret = -TARGET_EFAULT;
5388         goto out;
5389     }
5390     thunk_convert(&host_part, argptr, part_arg_type, THUNK_HOST);
5391     unlock_user(argptr, arg, 0);
5392
5393     /* Swizzle the data pointer to our local copy and call! */
5394     host_blkpg->data = &host_part;
5395     ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_blkpg));
5396
5397 out:
5398     return ret;
5399 }
5400
5401 static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
5402                                 int fd, int cmd, abi_long arg)
5403 {
5404     const argtype *arg_type = ie->arg_type;
5405     const StructEntry *se;
5406     const argtype *field_types;
5407     const int *dst_offsets, *src_offsets;
5408     int target_size;
5409     void *argptr;
5410     abi_ulong *target_rt_dev_ptr = NULL;
5411     unsigned long *host_rt_dev_ptr = NULL;
5412     abi_long ret;
5413     int i;
5414
5415     assert(ie->access == IOC_W);
5416     assert(*arg_type == TYPE_PTR);
5417     arg_type++;
5418     assert(*arg_type == TYPE_STRUCT);
5419     target_size = thunk_type_size(arg_type, 0);
5420     argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5421     if (!argptr) {
5422         return -TARGET_EFAULT;
5423     }
5424     arg_type++;
5425     assert(*arg_type == (int)STRUCT_rtentry);
5426     se = struct_entries + *arg_type++;
5427     assert(se->convert[0] == NULL);
5428     /* convert struct here to be able to catch rt_dev string */
5429     field_types = se->field_types;
5430     dst_offsets = se->field_offsets[THUNK_HOST];
5431     src_offsets = se->field_offsets[THUNK_TARGET];
5432     for (i = 0; i < se->nb_fields; i++) {
5433         if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) {
5434             assert(*field_types == TYPE_PTRVOID);
5435             target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]);
5436             host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]);
5437             if (*target_rt_dev_ptr != 0) {
5438                 *host_rt_dev_ptr = (unsigned long)lock_user_string(
5439                                                   tswapal(*target_rt_dev_ptr));
5440                 if (!*host_rt_dev_ptr) {
5441                     unlock_user(argptr, arg, 0);
5442                     return -TARGET_EFAULT;
5443                 }
5444             } else {
5445                 *host_rt_dev_ptr = 0;
5446             }
5447             field_types++;
5448             continue;
5449         }
5450         field_types = thunk_convert(buf_temp + dst_offsets[i],
5451                                     argptr + src_offsets[i],
5452                                     field_types, THUNK_HOST);
5453     }
5454     unlock_user(argptr, arg, 0);
5455
5456     ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5457
5458     assert(host_rt_dev_ptr != NULL);
5459     assert(target_rt_dev_ptr != NULL);
5460     if (*host_rt_dev_ptr != 0) {
5461         unlock_user((void *)*host_rt_dev_ptr,
5462                     *target_rt_dev_ptr, 0);
5463     }
5464     return ret;
5465 }
5466
5467 static abi_long do_ioctl_kdsigaccept(const IOCTLEntry *ie, uint8_t *buf_temp,
5468                                      int fd, int cmd, abi_long arg)
5469 {
5470     int sig = target_to_host_signal(arg);
5471     return get_errno(safe_ioctl(fd, ie->host_cmd, sig));
5472 }
5473
5474 static abi_long do_ioctl_SIOCGSTAMP(const IOCTLEntry *ie, uint8_t *buf_temp,
5475                                     int fd, int cmd, abi_long arg)
5476 {
5477     struct timeval tv;
5478     abi_long ret;
5479
5480     ret = get_errno(safe_ioctl(fd, SIOCGSTAMP, &tv));
5481     if (is_error(ret)) {
5482         return ret;
5483     }
5484
5485     if (cmd == (int)TARGET_SIOCGSTAMP_OLD) {
5486         if (copy_to_user_timeval(arg, &tv)) {
5487             return -TARGET_EFAULT;
5488         }
5489     } else {
5490         if (copy_to_user_timeval64(arg, &tv)) {
5491             return -TARGET_EFAULT;
5492         }
5493     }
5494
5495     return ret;
5496 }
5497
5498 static abi_long do_ioctl_SIOCGSTAMPNS(const IOCTLEntry *ie, uint8_t *buf_temp,
5499                                       int fd, int cmd, abi_long arg)
5500 {
5501     struct timespec ts;
5502     abi_long ret;
5503
5504     ret = get_errno(safe_ioctl(fd, SIOCGSTAMPNS, &ts));
5505     if (is_error(ret)) {
5506         return ret;
5507     }
5508
5509     if (cmd == (int)TARGET_SIOCGSTAMPNS_OLD) {
5510         if (host_to_target_timespec(arg, &ts)) {
5511             return -TARGET_EFAULT;
5512         }
5513     } else{
5514         if (host_to_target_timespec64(arg, &ts)) {
5515             return -TARGET_EFAULT;
5516         }
5517     }
5518
5519     return ret;
5520 }
5521
5522 #ifdef TIOCGPTPEER
5523 static abi_long do_ioctl_tiocgptpeer(const IOCTLEntry *ie, uint8_t *buf_temp,
5524                                      int fd, int cmd, abi_long arg)
5525 {
5526     int flags = target_to_host_bitmask(arg, fcntl_flags_tbl);
5527     return get_errno(safe_ioctl(fd, ie->host_cmd, flags));
5528 }
5529 #endif
5530
5531 #ifdef HAVE_DRM_H
5532
5533 static void unlock_drm_version(struct drm_version *host_ver,
5534                                struct target_drm_version *target_ver,
5535                                bool copy)
5536 {
5537     unlock_user(host_ver->name, target_ver->name,
5538                                 copy ? host_ver->name_len : 0);
5539     unlock_user(host_ver->date, target_ver->date,
5540                                 copy ? host_ver->date_len : 0);
5541     unlock_user(host_ver->desc, target_ver->desc,
5542                                 copy ? host_ver->desc_len : 0);
5543 }
5544
5545 static inline abi_long target_to_host_drmversion(struct drm_version *host_ver,
5546                                           struct target_drm_version *target_ver)
5547 {
5548     memset(host_ver, 0, sizeof(*host_ver));
5549
5550     __get_user(host_ver->name_len, &target_ver->name_len);
5551     if (host_ver->name_len) {
5552         host_ver->name = lock_user(VERIFY_WRITE, target_ver->name,
5553                                    target_ver->name_len, 0);
5554         if (!host_ver->name) {
5555             return -EFAULT;
5556         }
5557     }
5558
5559     __get_user(host_ver->date_len, &target_ver->date_len);
5560     if (host_ver->date_len) {
5561         host_ver->date = lock_user(VERIFY_WRITE, target_ver->date,
5562                                    target_ver->date_len, 0);
5563         if (!host_ver->date) {
5564             goto err;
5565         }
5566     }
5567
5568     __get_user(host_ver->desc_len, &target_ver->desc_len);
5569     if (host_ver->desc_len) {
5570         host_ver->desc = lock_user(VERIFY_WRITE, target_ver->desc,
5571                                    target_ver->desc_len, 0);
5572         if (!host_ver->desc) {
5573             goto err;
5574         }
5575     }
5576
5577     return 0;
5578 err:
5579     unlock_drm_version(host_ver, target_ver, false);
5580     return -EFAULT;
5581 }
5582
5583 static inline void host_to_target_drmversion(
5584                                           struct target_drm_version *target_ver,
5585                                           struct drm_version *host_ver)
5586 {
5587     __put_user(host_ver->version_major, &target_ver->version_major);
5588     __put_user(host_ver->version_minor, &target_ver->version_minor);
5589     __put_user(host_ver->version_patchlevel, &target_ver->version_patchlevel);
5590     __put_user(host_ver->name_len, &target_ver->name_len);
5591     __put_user(host_ver->date_len, &target_ver->date_len);
5592     __put_user(host_ver->desc_len, &target_ver->desc_len);
5593     unlock_drm_version(host_ver, target_ver, true);
5594 }
5595
5596 static abi_long do_ioctl_drm(const IOCTLEntry *ie, uint8_t *buf_temp,
5597                              int fd, int cmd, abi_long arg)
5598 {
5599     struct drm_version *ver;
5600     struct target_drm_version *target_ver;
5601     abi_long ret;
5602
5603     switch (ie->host_cmd) {
5604     case DRM_IOCTL_VERSION:
5605         if (!lock_user_struct(VERIFY_WRITE, target_ver, arg, 0)) {
5606             return -TARGET_EFAULT;
5607         }
5608         ver = (struct drm_version *)buf_temp;
5609         ret = target_to_host_drmversion(ver, target_ver);
5610         if (!is_error(ret)) {
5611             ret = get_errno(safe_ioctl(fd, ie->host_cmd, ver));
5612             if (is_error(ret)) {
5613                 unlock_drm_version(ver, target_ver, false);
5614             } else {
5615                 host_to_target_drmversion(target_ver, ver);
5616             }
5617         }
5618         unlock_user_struct(target_ver, arg, 0);
5619         return ret;
5620     }
5621     return -TARGET_ENOSYS;
5622 }
5623
5624 static abi_long do_ioctl_drm_i915_getparam(const IOCTLEntry *ie,
5625                                            struct drm_i915_getparam *gparam,
5626                                            int fd, abi_long arg)
5627 {
5628     abi_long ret;
5629     int value;
5630     struct target_drm_i915_getparam *target_gparam;
5631
5632     if (!lock_user_struct(VERIFY_READ, target_gparam, arg, 0)) {
5633         return -TARGET_EFAULT;
5634     }
5635
5636     __get_user(gparam->param, &target_gparam->param);
5637     gparam->value = &value;
5638     ret = get_errno(safe_ioctl(fd, ie->host_cmd, gparam));
5639     put_user_s32(value, target_gparam->value);
5640
5641     unlock_user_struct(target_gparam, arg, 0);
5642     return ret;
5643 }
5644
5645 static abi_long do_ioctl_drm_i915(const IOCTLEntry *ie, uint8_t *buf_temp,
5646                                   int fd, int cmd, abi_long arg)
5647 {
5648     switch (ie->host_cmd) {
5649     case DRM_IOCTL_I915_GETPARAM:
5650         return do_ioctl_drm_i915_getparam(ie,
5651                                           (struct drm_i915_getparam *)buf_temp,
5652                                           fd, arg);
5653     default:
5654         return -TARGET_ENOSYS;
5655     }
5656 }
5657
5658 #endif
5659
5660 static abi_long do_ioctl_TUNSETTXFILTER(const IOCTLEntry *ie, uint8_t *buf_temp,
5661                                         int fd, int cmd, abi_long arg)
5662 {
5663     struct tun_filter *filter = (struct tun_filter *)buf_temp;
5664     struct tun_filter *target_filter;
5665     char *target_addr;
5666
5667     assert(ie->access == IOC_W);
5668
5669     target_filter = lock_user(VERIFY_READ, arg, sizeof(*target_filter), 1);
5670     if (!target_filter) {
5671         return -TARGET_EFAULT;
5672     }
5673     filter->flags = tswap16(target_filter->flags);
5674     filter->count = tswap16(target_filter->count);
5675     unlock_user(target_filter, arg, 0);
5676
5677     if (filter->count) {
5678         if (offsetof(struct tun_filter, addr) + filter->count * ETH_ALEN >
5679             MAX_STRUCT_SIZE) {
5680             return -TARGET_EFAULT;
5681         }
5682
5683         target_addr = lock_user(VERIFY_READ,
5684                                 arg + offsetof(struct tun_filter, addr),
5685                                 filter->count * ETH_ALEN, 1);
5686         if (!target_addr) {
5687             return -TARGET_EFAULT;
5688         }
5689         memcpy(filter->addr, target_addr, filter->count * ETH_ALEN);
5690         unlock_user(target_addr, arg + offsetof(struct tun_filter, addr), 0);
5691     }
5692
5693     return get_errno(safe_ioctl(fd, ie->host_cmd, filter));
5694 }
5695
5696 IOCTLEntry ioctl_entries[] = {
5697 #define IOCTL(cmd, access, ...) \
5698     { TARGET_ ## cmd, cmd, #cmd, access, 0, {  __VA_ARGS__ } },
5699 #define IOCTL_SPECIAL(cmd, access, dofn, ...)                      \
5700     { TARGET_ ## cmd, cmd, #cmd, access, dofn, {  __VA_ARGS__ } },
5701 #define IOCTL_IGNORE(cmd) \
5702     { TARGET_ ## cmd, 0, #cmd },
5703 #include "ioctls.h"
5704     { 0, 0, },
5705 };
5706
5707 /* ??? Implement proper locking for ioctls.  */
5708 /* do_ioctl() Must return target values and target errnos. */
5709 static abi_long do_ioctl(int fd, int cmd, abi_long arg)
5710 {
5711     const IOCTLEntry *ie;
5712     const argtype *arg_type;
5713     abi_long ret;
5714     uint8_t buf_temp[MAX_STRUCT_SIZE];
5715     int target_size;
5716     void *argptr;
5717
5718     ie = ioctl_entries;
5719     for(;;) {
5720         if (ie->target_cmd == 0) {
5721             qemu_log_mask(
5722                 LOG_UNIMP, "Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
5723             return -TARGET_ENOSYS;
5724         }
5725         if (ie->target_cmd == cmd)
5726             break;
5727         ie++;
5728     }
5729     arg_type = ie->arg_type;
5730     if (ie->do_ioctl) {
5731         return ie->do_ioctl(ie, buf_temp, fd, cmd, arg);
5732     } else if (!ie->host_cmd) {
5733         /* Some architectures define BSD ioctls in their headers
5734            that are not implemented in Linux.  */
5735         return -TARGET_ENOSYS;
5736     }
5737
5738     switch(arg_type[0]) {
5739     case TYPE_NULL:
5740         /* no argument */
5741         ret = get_errno(safe_ioctl(fd, ie->host_cmd));
5742         break;
5743     case TYPE_PTRVOID:
5744     case TYPE_INT:
5745     case TYPE_LONG:
5746     case TYPE_ULONG:
5747         ret = get_errno(safe_ioctl(fd, ie->host_cmd, arg));
5748         break;
5749     case TYPE_PTR:
5750         arg_type++;
5751         target_size = thunk_type_size(arg_type, 0);
5752         switch(ie->access) {
5753         case IOC_R:
5754             ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5755             if (!is_error(ret)) {
5756                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5757                 if (!argptr)
5758                     return -TARGET_EFAULT;
5759                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5760                 unlock_user(argptr, arg, target_size);
5761             }
5762             break;
5763         case IOC_W:
5764             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5765             if (!argptr)
5766                 return -TARGET_EFAULT;
5767             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5768             unlock_user(argptr, arg, 0);
5769             ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5770             break;
5771         default:
5772         case IOC_RW:
5773             argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5774             if (!argptr)
5775                 return -TARGET_EFAULT;
5776             thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5777             unlock_user(argptr, arg, 0);
5778             ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5779             if (!is_error(ret)) {
5780                 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5781                 if (!argptr)
5782                     return -TARGET_EFAULT;
5783                 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5784                 unlock_user(argptr, arg, target_size);
5785             }
5786             break;
5787         }
5788         break;
5789     default:
5790         qemu_log_mask(LOG_UNIMP,
5791                       "Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5792                       (long)cmd, arg_type[0]);
5793         ret = -TARGET_ENOSYS;
5794         break;
5795     }
5796     return ret;
5797 }
5798
5799 static const bitmask_transtbl iflag_tbl[] = {
5800         { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
5801         { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
5802         { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
5803         { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
5804         { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
5805         { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
5806         { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
5807         { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
5808         { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
5809         { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
5810         { TARGET_IXON, TARGET_IXON, IXON, IXON },
5811         { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
5812         { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
5813         { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
5814         { TARGET_IUTF8, TARGET_IUTF8, IUTF8, IUTF8},
5815         { 0, 0, 0, 0 }
5816 };
5817
5818 static const bitmask_transtbl oflag_tbl[] = {
5819         { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
5820         { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
5821         { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
5822         { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
5823         { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
5824         { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
5825         { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
5826         { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
5827         { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
5828         { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
5829         { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
5830         { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
5831         { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
5832         { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
5833         { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
5834         { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
5835         { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
5836         { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
5837         { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
5838         { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
5839         { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
5840         { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
5841         { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
5842         { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
5843         { 0, 0, 0, 0 }
5844 };
5845
5846 static const bitmask_transtbl cflag_tbl[] = {
5847         { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
5848         { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
5849         { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
5850         { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
5851         { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
5852         { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
5853         { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
5854         { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
5855         { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
5856         { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
5857         { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
5858         { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
5859         { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
5860         { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
5861         { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
5862         { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
5863         { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
5864         { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
5865         { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
5866         { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
5867         { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
5868         { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
5869         { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
5870         { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
5871         { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
5872         { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
5873         { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
5874         { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
5875         { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
5876         { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
5877         { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
5878         { 0, 0, 0, 0 }
5879 };
5880
5881 static const bitmask_transtbl lflag_tbl[] = {
5882   { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
5883   { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
5884   { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
5885   { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
5886   { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
5887   { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
5888   { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
5889   { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
5890   { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
5891   { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
5892   { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
5893   { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
5894   { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
5895   { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
5896   { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
5897   { TARGET_EXTPROC, TARGET_EXTPROC, EXTPROC, EXTPROC},
5898   { 0, 0, 0, 0 }
5899 };
5900
5901 static void target_to_host_termios (void *dst, const void *src)
5902 {
5903     struct host_termios *host = dst;
5904     const struct target_termios *target = src;
5905
5906     host->c_iflag =
5907         target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
5908     host->c_oflag =
5909         target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
5910     host->c_cflag =
5911         target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
5912     host->c_lflag =
5913         target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
5914     host->c_line = target->c_line;
5915
5916     memset(host->c_cc, 0, sizeof(host->c_cc));
5917     host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
5918     host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
5919     host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
5920     host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
5921     host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
5922     host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
5923     host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
5924     host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
5925     host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
5926     host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
5927     host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
5928     host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
5929     host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
5930     host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
5931     host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
5932     host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
5933     host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
5934 }
5935
5936 static void host_to_target_termios (void *dst, const void *src)
5937 {
5938     struct target_termios *target = dst;
5939     const struct host_termios *host = src;
5940
5941     target->c_iflag =
5942         tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
5943     target->c_oflag =
5944         tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
5945     target->c_cflag =
5946         tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
5947     target->c_lflag =
5948         tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
5949     target->c_line = host->c_line;
5950
5951     memset(target->c_cc, 0, sizeof(target->c_cc));
5952     target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
5953     target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
5954     target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
5955     target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
5956     target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
5957     target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
5958     target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
5959     target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
5960     target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
5961     target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
5962     target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
5963     target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
5964     target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
5965     target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
5966     target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
5967     target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
5968     target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
5969 }
5970
5971 static const StructEntry struct_termios_def = {
5972     .convert = { host_to_target_termios, target_to_host_termios },
5973     .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
5974     .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
5975     .print = print_termios,
5976 };
5977
5978 static const bitmask_transtbl mmap_flags_tbl[] = {
5979     { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
5980     { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
5981     { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
5982     { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS,
5983       MAP_ANONYMOUS, MAP_ANONYMOUS },
5984     { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN,
5985       MAP_GROWSDOWN, MAP_GROWSDOWN },
5986     { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE,
5987       MAP_DENYWRITE, MAP_DENYWRITE },
5988     { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE,
5989       MAP_EXECUTABLE, MAP_EXECUTABLE },
5990     { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
5991     { TARGET_MAP_NORESERVE, TARGET_MAP_NORESERVE,
5992       MAP_NORESERVE, MAP_NORESERVE },
5993     { TARGET_MAP_HUGETLB, TARGET_MAP_HUGETLB, MAP_HUGETLB, MAP_HUGETLB },
5994     /* MAP_STACK had been ignored by the kernel for quite some time.
5995        Recognize it for the target insofar as we do not want to pass
5996        it through to the host.  */
5997     { TARGET_MAP_STACK, TARGET_MAP_STACK, 0, 0 },
5998     { 0, 0, 0, 0 }
5999 };
6000
6001 /*
6002  * NOTE: TARGET_ABI32 is defined for TARGET_I386 (but not for TARGET_X86_64)
6003  *       TARGET_I386 is defined if TARGET_X86_64 is defined
6004  */
6005 #if defined(TARGET_I386)
6006
6007 /* NOTE: there is really one LDT for all the threads */
6008 static uint8_t *ldt_table;
6009
6010 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
6011 {
6012     int size;
6013     void *p;
6014
6015     if (!ldt_table)
6016         return 0;
6017     size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
6018     if (size > bytecount)
6019         size = bytecount;
6020     p = lock_user(VERIFY_WRITE, ptr, size, 0);
6021     if (!p)
6022         return -TARGET_EFAULT;
6023     /* ??? Should this by byteswapped?  */
6024     memcpy(p, ldt_table, size);
6025     unlock_user(p, ptr, size);
6026     return size;
6027 }
6028
6029 /* XXX: add locking support */
6030 static abi_long write_ldt(CPUX86State *env,
6031                           abi_ulong ptr, unsigned long bytecount, int oldmode)
6032 {
6033     struct target_modify_ldt_ldt_s ldt_info;
6034     struct target_modify_ldt_ldt_s *target_ldt_info;
6035     int seg_32bit, contents, read_exec_only, limit_in_pages;
6036     int seg_not_present, useable, lm;
6037     uint32_t *lp, entry_1, entry_2;
6038
6039     if (bytecount != sizeof(ldt_info))
6040         return -TARGET_EINVAL;
6041     if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
6042         return -TARGET_EFAULT;
6043     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
6044     ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
6045     ldt_info.limit = tswap32(target_ldt_info->limit);
6046     ldt_info.flags = tswap32(target_ldt_info->flags);
6047     unlock_user_struct(target_ldt_info, ptr, 0);
6048
6049     if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
6050         return -TARGET_EINVAL;
6051     seg_32bit = ldt_info.flags & 1;
6052     contents = (ldt_info.flags >> 1) & 3;
6053     read_exec_only = (ldt_info.flags >> 3) & 1;
6054     limit_in_pages = (ldt_info.flags >> 4) & 1;
6055     seg_not_present = (ldt_info.flags >> 5) & 1;
6056     useable = (ldt_info.flags >> 6) & 1;
6057 #ifdef TARGET_ABI32
6058     lm = 0;
6059 #else
6060     lm = (ldt_info.flags >> 7) & 1;
6061 #endif
6062     if (contents == 3) {
6063         if (oldmode)
6064             return -TARGET_EINVAL;
6065         if (seg_not_present == 0)
6066             return -TARGET_EINVAL;
6067     }
6068     /* allocate the LDT */
6069     if (!ldt_table) {
6070         env->ldt.base = target_mmap(0,
6071                                     TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
6072                                     PROT_READ|PROT_WRITE,
6073                                     MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
6074         if (env->ldt.base == -1)
6075             return -TARGET_ENOMEM;
6076         memset(g2h_untagged(env->ldt.base), 0,
6077                TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
6078         env->ldt.limit = 0xffff;
6079         ldt_table = g2h_untagged(env->ldt.base);
6080     }
6081
6082     /* NOTE: same code as Linux kernel */
6083     /* Allow LDTs to be cleared by the user. */
6084     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
6085         if (oldmode ||
6086             (contents == 0              &&
6087              read_exec_only == 1        &&
6088              seg_32bit == 0             &&
6089              limit_in_pages == 0        &&
6090              seg_not_present == 1       &&
6091              useable == 0 )) {
6092             entry_1 = 0;
6093             entry_2 = 0;
6094             goto install;
6095         }
6096     }
6097
6098     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
6099         (ldt_info.limit & 0x0ffff);
6100     entry_2 = (ldt_info.base_addr & 0xff000000) |
6101         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
6102         (ldt_info.limit & 0xf0000) |
6103         ((read_exec_only ^ 1) << 9) |
6104         (contents << 10) |
6105         ((seg_not_present ^ 1) << 15) |
6106         (seg_32bit << 22) |
6107         (limit_in_pages << 23) |
6108         (lm << 21) |
6109         0x7000;
6110     if (!oldmode)
6111         entry_2 |= (useable << 20);
6112
6113     /* Install the new entry ...  */
6114 install:
6115     lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
6116     lp[0] = tswap32(entry_1);
6117     lp[1] = tswap32(entry_2);
6118     return 0;
6119 }
6120
6121 /* specific and weird i386 syscalls */
6122 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
6123                               unsigned long bytecount)
6124 {
6125     abi_long ret;
6126
6127     switch (func) {
6128     case 0:
6129         ret = read_ldt(ptr, bytecount);
6130         break;
6131     case 1:
6132         ret = write_ldt(env, ptr, bytecount, 1);
6133         break;
6134     case 0x11:
6135         ret = write_ldt(env, ptr, bytecount, 0);
6136         break;
6137     default:
6138         ret = -TARGET_ENOSYS;
6139         break;
6140     }
6141     return ret;
6142 }
6143
6144 #if defined(TARGET_ABI32)
6145 abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
6146 {
6147     uint64_t *gdt_table = g2h_untagged(env->gdt.base);
6148     struct target_modify_ldt_ldt_s ldt_info;
6149     struct target_modify_ldt_ldt_s *target_ldt_info;
6150     int seg_32bit, contents, read_exec_only, limit_in_pages;
6151     int seg_not_present, useable, lm;
6152     uint32_t *lp, entry_1, entry_2;
6153     int i;
6154
6155     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
6156     if (!target_ldt_info)
6157         return -TARGET_EFAULT;
6158     ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
6159     ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
6160     ldt_info.limit = tswap32(target_ldt_info->limit);
6161     ldt_info.flags = tswap32(target_ldt_info->flags);
6162     if (ldt_info.entry_number == -1) {
6163         for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
6164             if (gdt_table[i] == 0) {
6165                 ldt_info.entry_number = i;
6166                 target_ldt_info->entry_number = tswap32(i);
6167                 break;
6168             }
6169         }
6170     }
6171     unlock_user_struct(target_ldt_info, ptr, 1);
6172
6173     if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
6174         ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
6175            return -TARGET_EINVAL;
6176     seg_32bit = ldt_info.flags & 1;
6177     contents = (ldt_info.flags >> 1) & 3;
6178     read_exec_only = (ldt_info.flags >> 3) & 1;
6179     limit_in_pages = (ldt_info.flags >> 4) & 1;
6180     seg_not_present = (ldt_info.flags >> 5) & 1;
6181     useable = (ldt_info.flags >> 6) & 1;
6182 #ifdef TARGET_ABI32
6183     lm = 0;
6184 #else
6185     lm = (ldt_info.flags >> 7) & 1;
6186 #endif
6187
6188     if (contents == 3) {
6189         if (seg_not_present == 0)
6190             return -TARGET_EINVAL;
6191     }
6192
6193     /* NOTE: same code as Linux kernel */
6194     /* Allow LDTs to be cleared by the user. */
6195     if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
6196         if ((contents == 0             &&
6197              read_exec_only == 1       &&
6198              seg_32bit == 0            &&
6199              limit_in_pages == 0       &&
6200              seg_not_present == 1      &&
6201              useable == 0 )) {
6202             entry_1 = 0;
6203             entry_2 = 0;
6204             goto install;
6205         }
6206     }
6207
6208     entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
6209         (ldt_info.limit & 0x0ffff);
6210     entry_2 = (ldt_info.base_addr & 0xff000000) |
6211         ((ldt_info.base_addr & 0x00ff0000) >> 16) |
6212         (ldt_info.limit & 0xf0000) |
6213         ((read_exec_only ^ 1) << 9) |
6214         (contents << 10) |
6215         ((seg_not_present ^ 1) << 15) |
6216         (seg_32bit << 22) |
6217         (limit_in_pages << 23) |
6218         (useable << 20) |
6219         (lm << 21) |
6220         0x7000;
6221
6222     /* Install the new entry ...  */
6223 install:
6224     lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
6225     lp[0] = tswap32(entry_1);
6226     lp[1] = tswap32(entry_2);
6227     return 0;
6228 }
6229
6230 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
6231 {
6232     struct target_modify_ldt_ldt_s *target_ldt_info;
6233     uint64_t *gdt_table = g2h_untagged(env->gdt.base);
6234     uint32_t base_addr, limit, flags;
6235     int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
6236     int seg_not_present, useable, lm;
6237     uint32_t *lp, entry_1, entry_2;
6238
6239     lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
6240     if (!target_ldt_info)
6241         return -TARGET_EFAULT;
6242     idx = tswap32(target_ldt_info->entry_number);
6243     if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
6244         idx > TARGET_GDT_ENTRY_TLS_MAX) {
6245         unlock_user_struct(target_ldt_info, ptr, 1);
6246         return -TARGET_EINVAL;
6247     }
6248     lp = (uint32_t *)(gdt_table + idx);
6249     entry_1 = tswap32(lp[0]);
6250     entry_2 = tswap32(lp[1]);
6251
6252     read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
6253     contents = (entry_2 >> 10) & 3;
6254     seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
6255     seg_32bit = (entry_2 >> 22) & 1;
6256     limit_in_pages = (entry_2 >> 23) & 1;
6257     useable = (entry_2 >> 20) & 1;
6258 #ifdef TARGET_ABI32
6259     lm = 0;
6260 #else
6261     lm = (entry_2 >> 21) & 1;
6262 #endif
6263     flags = (seg_32bit << 0) | (contents << 1) |
6264         (read_exec_only << 3) | (limit_in_pages << 4) |
6265         (seg_not_present << 5) | (useable << 6) | (lm << 7);
6266     limit = (entry_1 & 0xffff) | (entry_2  & 0xf0000);
6267     base_addr = (entry_1 >> 16) |
6268         (entry_2 & 0xff000000) |
6269         ((entry_2 & 0xff) << 16);
6270     target_ldt_info->base_addr = tswapal(base_addr);
6271     target_ldt_info->limit = tswap32(limit);
6272     target_ldt_info->flags = tswap32(flags);
6273     unlock_user_struct(target_ldt_info, ptr, 1);
6274     return 0;
6275 }
6276
6277 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
6278 {
6279     return -TARGET_ENOSYS;
6280 }
6281 #else
6282 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
6283 {
6284     abi_long ret = 0;
6285     abi_ulong val;
6286     int idx;
6287
6288     switch(code) {
6289     case TARGET_ARCH_SET_GS:
6290     case TARGET_ARCH_SET_FS:
6291         if (code == TARGET_ARCH_SET_GS)
6292             idx = R_GS;
6293         else
6294             idx = R_FS;
6295         cpu_x86_load_seg(env, idx, 0);
6296         env->segs[idx].base = addr;
6297         break;
6298     case TARGET_ARCH_GET_GS:
6299     case TARGET_ARCH_GET_FS:
6300         if (code == TARGET_ARCH_GET_GS)
6301             idx = R_GS;
6302         else
6303             idx = R_FS;
6304         val = env->segs[idx].base;
6305         if (put_user(val, addr, abi_ulong))
6306             ret = -TARGET_EFAULT;
6307         break;
6308     default:
6309         ret = -TARGET_EINVAL;
6310         break;
6311     }
6312     return ret;
6313 }
6314 #endif /* defined(TARGET_ABI32 */
6315 #endif /* defined(TARGET_I386) */
6316
6317 /*
6318  * These constants are generic.  Supply any that are missing from the host.
6319  */
6320 #ifndef PR_SET_NAME
6321 # define PR_SET_NAME    15
6322 # define PR_GET_NAME    16
6323 #endif
6324 #ifndef PR_SET_FP_MODE
6325 # define PR_SET_FP_MODE 45
6326 # define PR_GET_FP_MODE 46
6327 # define PR_FP_MODE_FR   (1 << 0)
6328 # define PR_FP_MODE_FRE  (1 << 1)
6329 #endif
6330 #ifndef PR_SVE_SET_VL
6331 # define PR_SVE_SET_VL  50
6332 # define PR_SVE_GET_VL  51
6333 # define PR_SVE_VL_LEN_MASK  0xffff
6334 # define PR_SVE_VL_INHERIT   (1 << 17)
6335 #endif
6336 #ifndef PR_PAC_RESET_KEYS
6337 # define PR_PAC_RESET_KEYS  54
6338 # define PR_PAC_APIAKEY   (1 << 0)
6339 # define PR_PAC_APIBKEY   (1 << 1)
6340 # define PR_PAC_APDAKEY   (1 << 2)
6341 # define PR_PAC_APDBKEY   (1 << 3)
6342 # define PR_PAC_APGAKEY   (1 << 4)
6343 #endif
6344 #ifndef PR_SET_TAGGED_ADDR_CTRL
6345 # define PR_SET_TAGGED_ADDR_CTRL 55
6346 # define PR_GET_TAGGED_ADDR_CTRL 56
6347 # define PR_TAGGED_ADDR_ENABLE  (1UL << 0)
6348 #endif
6349 #ifndef PR_MTE_TCF_SHIFT
6350 # define PR_MTE_TCF_SHIFT       1
6351 # define PR_MTE_TCF_NONE        (0UL << PR_MTE_TCF_SHIFT)
6352 # define PR_MTE_TCF_SYNC        (1UL << PR_MTE_TCF_SHIFT)
6353 # define PR_MTE_TCF_ASYNC       (2UL << PR_MTE_TCF_SHIFT)
6354 # define PR_MTE_TCF_MASK        (3UL << PR_MTE_TCF_SHIFT)
6355 # define PR_MTE_TAG_SHIFT       3
6356 # define PR_MTE_TAG_MASK        (0xffffUL << PR_MTE_TAG_SHIFT)
6357 #endif
6358 #ifndef PR_SET_IO_FLUSHER
6359 # define PR_SET_IO_FLUSHER 57
6360 # define PR_GET_IO_FLUSHER 58
6361 #endif
6362 #ifndef PR_SET_SYSCALL_USER_DISPATCH
6363 # define PR_SET_SYSCALL_USER_DISPATCH 59
6364 #endif
6365
6366 #include "target_prctl.h"
6367
6368 static abi_long do_prctl_inval0(CPUArchState *env)
6369 {
6370     return -TARGET_EINVAL;
6371 }
6372
6373 static abi_long do_prctl_inval1(CPUArchState *env, abi_long arg2)
6374 {
6375     return -TARGET_EINVAL;
6376 }
6377
6378 #ifndef do_prctl_get_fp_mode
6379 #define do_prctl_get_fp_mode do_prctl_inval0
6380 #endif
6381 #ifndef do_prctl_set_fp_mode
6382 #define do_prctl_set_fp_mode do_prctl_inval1
6383 #endif
6384 #ifndef do_prctl_get_vl
6385 #define do_prctl_get_vl do_prctl_inval0
6386 #endif
6387 #ifndef do_prctl_set_vl
6388 #define do_prctl_set_vl do_prctl_inval1
6389 #endif
6390 #ifndef do_prctl_reset_keys
6391 #define do_prctl_reset_keys do_prctl_inval1
6392 #endif
6393 #ifndef do_prctl_set_tagged_addr_ctrl
6394 #define do_prctl_set_tagged_addr_ctrl do_prctl_inval1
6395 #endif
6396 #ifndef do_prctl_get_tagged_addr_ctrl
6397 #define do_prctl_get_tagged_addr_ctrl do_prctl_inval0
6398 #endif
6399 #ifndef do_prctl_get_unalign
6400 #define do_prctl_get_unalign do_prctl_inval1
6401 #endif
6402 #ifndef do_prctl_set_unalign
6403 #define do_prctl_set_unalign do_prctl_inval1
6404 #endif
6405
6406 static abi_long do_prctl(CPUArchState *env, abi_long option, abi_long arg2,
6407                          abi_long arg3, abi_long arg4, abi_long arg5)
6408 {
6409     abi_long ret;
6410
6411     switch (option) {
6412     case PR_GET_PDEATHSIG:
6413         {
6414             int deathsig;
6415             ret = get_errno(prctl(PR_GET_PDEATHSIG, &deathsig,
6416                                   arg3, arg4, arg5));
6417             if (!is_error(ret) &&
6418                 put_user_s32(host_to_target_signal(deathsig), arg2)) {
6419                 return -TARGET_EFAULT;
6420             }
6421             return ret;
6422         }
6423     case PR_SET_PDEATHSIG:
6424         return get_errno(prctl(PR_SET_PDEATHSIG, target_to_host_signal(arg2),
6425                                arg3, arg4, arg5));
6426     case PR_GET_NAME:
6427         {
6428             void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
6429             if (!name) {
6430                 return -TARGET_EFAULT;
6431             }
6432             ret = get_errno(prctl(PR_GET_NAME, (uintptr_t)name,
6433                                   arg3, arg4, arg5));
6434             unlock_user(name, arg2, 16);
6435             return ret;
6436         }
6437     case PR_SET_NAME:
6438         {
6439             void *name = lock_user(VERIFY_READ, arg2, 16, 1);
6440             if (!name) {
6441                 return -TARGET_EFAULT;
6442             }
6443             ret = get_errno(prctl(PR_SET_NAME, (uintptr_t)name,
6444                                   arg3, arg4, arg5));
6445             unlock_user(name, arg2, 0);
6446             return ret;
6447         }
6448     case PR_GET_FP_MODE:
6449         return do_prctl_get_fp_mode(env);
6450     case PR_SET_FP_MODE:
6451         return do_prctl_set_fp_mode(env, arg2);
6452     case PR_SVE_GET_VL:
6453         return do_prctl_get_vl(env);
6454     case PR_SVE_SET_VL:
6455         return do_prctl_set_vl(env, arg2);
6456     case PR_PAC_RESET_KEYS:
6457         if (arg3 || arg4 || arg5) {
6458             return -TARGET_EINVAL;
6459         }
6460         return do_prctl_reset_keys(env, arg2);
6461     case PR_SET_TAGGED_ADDR_CTRL:
6462         if (arg3 || arg4 || arg5) {
6463             return -TARGET_EINVAL;
6464         }
6465         return do_prctl_set_tagged_addr_ctrl(env, arg2);
6466     case PR_GET_TAGGED_ADDR_CTRL:
6467         if (arg2 || arg3 || arg4 || arg5) {
6468             return -TARGET_EINVAL;
6469         }
6470         return do_prctl_get_tagged_addr_ctrl(env);
6471
6472     case PR_GET_UNALIGN:
6473         return do_prctl_get_unalign(env, arg2);
6474     case PR_SET_UNALIGN:
6475         return do_prctl_set_unalign(env, arg2);
6476
6477     case PR_CAP_AMBIENT:
6478     case PR_CAPBSET_READ:
6479     case PR_CAPBSET_DROP:
6480     case PR_GET_DUMPABLE:
6481     case PR_SET_DUMPABLE:
6482     case PR_GET_KEEPCAPS:
6483     case PR_SET_KEEPCAPS:
6484     case PR_GET_SECUREBITS:
6485     case PR_SET_SECUREBITS:
6486     case PR_GET_TIMING:
6487     case PR_SET_TIMING:
6488     case PR_GET_TIMERSLACK:
6489     case PR_SET_TIMERSLACK:
6490     case PR_MCE_KILL:
6491     case PR_MCE_KILL_GET:
6492     case PR_GET_NO_NEW_PRIVS:
6493     case PR_SET_NO_NEW_PRIVS:
6494     case PR_GET_IO_FLUSHER:
6495     case PR_SET_IO_FLUSHER:
6496         /* Some prctl options have no pointer arguments and we can pass on. */
6497         return get_errno(prctl(option, arg2, arg3, arg4, arg5));
6498
6499     case PR_GET_CHILD_SUBREAPER:
6500     case PR_SET_CHILD_SUBREAPER:
6501     case PR_GET_SPECULATION_CTRL:
6502     case PR_SET_SPECULATION_CTRL:
6503     case PR_GET_TID_ADDRESS:
6504         /* TODO */
6505         return -TARGET_EINVAL;
6506
6507     case PR_GET_FPEXC:
6508     case PR_SET_FPEXC:
6509         /* Was used for SPE on PowerPC. */
6510         return -TARGET_EINVAL;
6511
6512     case PR_GET_ENDIAN:
6513     case PR_SET_ENDIAN:
6514     case PR_GET_FPEMU:
6515     case PR_SET_FPEMU:
6516     case PR_SET_MM:
6517     case PR_GET_SECCOMP:
6518     case PR_SET_SECCOMP:
6519     case PR_SET_SYSCALL_USER_DISPATCH:
6520     case PR_GET_THP_DISABLE:
6521     case PR_SET_THP_DISABLE:
6522     case PR_GET_TSC:
6523     case PR_SET_TSC:
6524         /* Disable to prevent the target disabling stuff we need. */
6525         return -TARGET_EINVAL;
6526
6527     default:
6528         qemu_log_mask(LOG_UNIMP, "Unsupported prctl: " TARGET_ABI_FMT_ld "\n",
6529                       option);
6530         return -TARGET_EINVAL;
6531     }
6532 }
6533
6534 #define NEW_STACK_SIZE 0x40000
6535
6536
6537 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
6538 typedef struct {
6539     CPUArchState *env;
6540     pthread_mutex_t mutex;
6541     pthread_cond_t cond;
6542     pthread_t thread;
6543     uint32_t tid;
6544     abi_ulong child_tidptr;
6545     abi_ulong parent_tidptr;
6546     sigset_t sigmask;
6547 } new_thread_info;
6548
6549 static void *clone_func(void *arg)
6550 {
6551     new_thread_info *info = arg;
6552     CPUArchState *env;
6553     CPUState *cpu;
6554     TaskState *ts;
6555
6556     rcu_register_thread();
6557     tcg_register_thread();
6558     env = info->env;
6559     cpu = env_cpu(env);
6560     thread_cpu = cpu;
6561     ts = (TaskState *)cpu->opaque;
6562     info->tid = sys_gettid();
6563     task_settid(ts);
6564     if (info->child_tidptr)
6565         put_user_u32(info->tid, info->child_tidptr);
6566     if (info->parent_tidptr)
6567         put_user_u32(info->tid, info->parent_tidptr);
6568     qemu_guest_random_seed_thread_part2(cpu->random_seed);
6569     /* Enable signals.  */
6570     sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
6571     /* Signal to the parent that we're ready.  */
6572     pthread_mutex_lock(&info->mutex);
6573     pthread_cond_broadcast(&info->cond);
6574     pthread_mutex_unlock(&info->mutex);
6575     /* Wait until the parent has finished initializing the tls state.  */
6576     pthread_mutex_lock(&clone_lock);
6577     pthread_mutex_unlock(&clone_lock);
6578     cpu_loop(env);
6579     /* never exits */
6580     return NULL;
6581 }
6582
6583 /* do_fork() Must return host values and target errnos (unlike most
6584    do_*() functions). */
6585 static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
6586                    abi_ulong parent_tidptr, target_ulong newtls,
6587                    abi_ulong child_tidptr)
6588 {
6589     CPUState *cpu = env_cpu(env);
6590     int ret;
6591     TaskState *ts;
6592     CPUState *new_cpu;
6593     CPUArchState *new_env;
6594     sigset_t sigmask;
6595
6596     flags &= ~CLONE_IGNORED_FLAGS;
6597
6598     /* Emulate vfork() with fork() */
6599     if (flags & CLONE_VFORK)
6600         flags &= ~(CLONE_VFORK | CLONE_VM);
6601
6602     if (flags & CLONE_VM) {
6603         TaskState *parent_ts = (TaskState *)cpu->opaque;
6604         new_thread_info info;
6605         pthread_attr_t attr;
6606
6607         if (((flags & CLONE_THREAD_FLAGS) != CLONE_THREAD_FLAGS) ||
6608             (flags & CLONE_INVALID_THREAD_FLAGS)) {
6609             return -TARGET_EINVAL;
6610         }
6611
6612         ts = g_new0(TaskState, 1);
6613         init_task_state(ts);
6614
6615         /* Grab a mutex so that thread setup appears atomic.  */
6616         pthread_mutex_lock(&clone_lock);
6617
6618         /*
6619          * If this is our first additional thread, we need to ensure we
6620          * generate code for parallel execution and flush old translations.
6621          * Do this now so that the copy gets CF_PARALLEL too.
6622          */
6623         if (!(cpu->tcg_cflags & CF_PARALLEL)) {
6624             cpu->tcg_cflags |= CF_PARALLEL;
6625             tb_flush(cpu);
6626         }
6627
6628         /* we create a new CPU instance. */
6629         new_env = cpu_copy(env);
6630         /* Init regs that differ from the parent.  */
6631         cpu_clone_regs_child(new_env, newsp, flags);
6632         cpu_clone_regs_parent(env, flags);
6633         new_cpu = env_cpu(new_env);
6634         new_cpu->opaque = ts;
6635         ts->bprm = parent_ts->bprm;
6636         ts->info = parent_ts->info;
6637         ts->signal_mask = parent_ts->signal_mask;
6638
6639         if (flags & CLONE_CHILD_CLEARTID) {
6640             ts->child_tidptr = child_tidptr;
6641         }
6642
6643         if (flags & CLONE_SETTLS) {
6644             cpu_set_tls (new_env, newtls);
6645         }
6646
6647         memset(&info, 0, sizeof(info));
6648         pthread_mutex_init(&info.mutex, NULL);
6649         pthread_mutex_lock(&info.mutex);
6650         pthread_cond_init(&info.cond, NULL);
6651         info.env = new_env;
6652         if (flags & CLONE_CHILD_SETTID) {
6653             info.child_tidptr = child_tidptr;
6654         }
6655         if (flags & CLONE_PARENT_SETTID) {
6656             info.parent_tidptr = parent_tidptr;
6657         }
6658
6659         ret = pthread_attr_init(&attr);
6660         ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE);
6661         ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
6662         /* It is not safe to deliver signals until the child has finished
6663            initializing, so temporarily block all signals.  */
6664         sigfillset(&sigmask);
6665         sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
6666         cpu->random_seed = qemu_guest_random_seed_thread_part1();
6667
6668         ret = pthread_create(&info.thread, &attr, clone_func, &info);
6669         /* TODO: Free new CPU state if thread creation failed.  */
6670
6671         sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
6672         pthread_attr_destroy(&attr);
6673         if (ret == 0) {
6674             /* Wait for the child to initialize.  */
6675             pthread_cond_wait(&info.cond, &info.mutex);
6676             ret = info.tid;
6677         } else {
6678             ret = -1;
6679         }
6680         pthread_mutex_unlock(&info.mutex);
6681         pthread_cond_destroy(&info.cond);
6682         pthread_mutex_destroy(&info.mutex);
6683         pthread_mutex_unlock(&clone_lock);
6684     } else {
6685         /* if no CLONE_VM, we consider it is a fork */
6686         if (flags & CLONE_INVALID_FORK_FLAGS) {
6687             return -TARGET_EINVAL;
6688         }
6689
6690         /* We can't support custom termination signals */
6691         if ((flags & CSIGNAL) != TARGET_SIGCHLD) {
6692             return -TARGET_EINVAL;
6693         }
6694
6695         if (block_signals()) {
6696             return -QEMU_ERESTARTSYS;
6697         }
6698
6699         fork_start();
6700         ret = fork();
6701         if (ret == 0) {
6702             /* Child Process.  */
6703             cpu_clone_regs_child(env, newsp, flags);
6704             fork_end(1);
6705             /* There is a race condition here.  The parent process could
6706                theoretically read the TID in the child process before the child
6707                tid is set.  This would require using either ptrace
6708                (not implemented) or having *_tidptr to point at a shared memory
6709                mapping.  We can't repeat the spinlock hack used above because
6710                the child process gets its own copy of the lock.  */
6711             if (flags & CLONE_CHILD_SETTID)
6712                 put_user_u32(sys_gettid(), child_tidptr);
6713             if (flags & CLONE_PARENT_SETTID)
6714                 put_user_u32(sys_gettid(), parent_tidptr);
6715             ts = (TaskState *)cpu->opaque;
6716             if (flags & CLONE_SETTLS)
6717                 cpu_set_tls (env, newtls);
6718             if (flags & CLONE_CHILD_CLEARTID)
6719                 ts->child_tidptr = child_tidptr;
6720         } else {
6721             cpu_clone_regs_parent(env, flags);
6722             fork_end(0);
6723         }
6724     }
6725     return ret;
6726 }
6727
6728 /* warning : doesn't handle linux specific flags... */
6729 static int target_to_host_fcntl_cmd(int cmd)
6730 {
6731     int ret;
6732
6733     switch(cmd) {
6734     case TARGET_F_DUPFD:
6735     case TARGET_F_GETFD:
6736     case TARGET_F_SETFD:
6737     case TARGET_F_GETFL:
6738     case TARGET_F_SETFL:
6739     case TARGET_F_OFD_GETLK:
6740     case TARGET_F_OFD_SETLK:
6741     case TARGET_F_OFD_SETLKW:
6742         ret = cmd;
6743         break;
6744     case TARGET_F_GETLK:
6745         ret = F_GETLK64;
6746         break;
6747     case TARGET_F_SETLK:
6748         ret = F_SETLK64;
6749         break;
6750     case TARGET_F_SETLKW:
6751         ret = F_SETLKW64;
6752         break;
6753     case TARGET_F_GETOWN:
6754         ret = F_GETOWN;
6755         break;
6756     case TARGET_F_SETOWN:
6757         ret = F_SETOWN;
6758         break;
6759     case TARGET_F_GETSIG:
6760         ret = F_GETSIG;
6761         break;
6762     case TARGET_F_SETSIG:
6763         ret = F_SETSIG;
6764         break;
6765 #if TARGET_ABI_BITS == 32
6766     case TARGET_F_GETLK64:
6767         ret = F_GETLK64;
6768         break;
6769     case TARGET_F_SETLK64:
6770         ret = F_SETLK64;
6771         break;
6772     case TARGET_F_SETLKW64:
6773         ret = F_SETLKW64;
6774         break;
6775 #endif
6776     case TARGET_F_SETLEASE:
6777         ret = F_SETLEASE;
6778         break;
6779     case TARGET_F_GETLEASE:
6780         ret = F_GETLEASE;
6781         break;
6782 #ifdef F_DUPFD_CLOEXEC
6783     case TARGET_F_DUPFD_CLOEXEC:
6784         ret = F_DUPFD_CLOEXEC;
6785         break;
6786 #endif
6787     case TARGET_F_NOTIFY:
6788         ret = F_NOTIFY;
6789         break;
6790 #ifdef F_GETOWN_EX
6791     case TARGET_F_GETOWN_EX:
6792         ret = F_GETOWN_EX;
6793         break;
6794 #endif
6795 #ifdef F_SETOWN_EX
6796     case TARGET_F_SETOWN_EX:
6797         ret = F_SETOWN_EX;
6798         break;
6799 #endif
6800 #ifdef F_SETPIPE_SZ
6801     case TARGET_F_SETPIPE_SZ:
6802         ret = F_SETPIPE_SZ;
6803         break;
6804     case TARGET_F_GETPIPE_SZ:
6805         ret = F_GETPIPE_SZ;
6806         break;
6807 #endif
6808 #ifdef F_ADD_SEALS
6809     case TARGET_F_ADD_SEALS:
6810         ret = F_ADD_SEALS;
6811         break;
6812     case TARGET_F_GET_SEALS:
6813         ret = F_GET_SEALS;
6814         break;
6815 #endif
6816     default:
6817         ret = -TARGET_EINVAL;
6818         break;
6819     }
6820
6821 #if defined(__powerpc64__)
6822     /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and
6823      * is not supported by kernel. The glibc fcntl call actually adjusts
6824      * them to 5, 6 and 7 before making the syscall(). Since we make the
6825      * syscall directly, adjust to what is supported by the kernel.
6826      */
6827     if (ret >= F_GETLK64 && ret <= F_SETLKW64) {
6828         ret -= F_GETLK64 - 5;
6829     }
6830 #endif
6831
6832     return ret;
6833 }
6834
6835 #define FLOCK_TRANSTBL \
6836     switch (type) { \
6837     TRANSTBL_CONVERT(F_RDLCK); \
6838     TRANSTBL_CONVERT(F_WRLCK); \
6839     TRANSTBL_CONVERT(F_UNLCK); \
6840     }
6841
6842 static int target_to_host_flock(int type)
6843 {
6844 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
6845     FLOCK_TRANSTBL
6846 #undef  TRANSTBL_CONVERT
6847     return -TARGET_EINVAL;
6848 }
6849
6850 static int host_to_target_flock(int type)
6851 {
6852 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
6853     FLOCK_TRANSTBL
6854 #undef  TRANSTBL_CONVERT
6855     /* if we don't know how to convert the value coming
6856      * from the host we copy to the target field as-is
6857      */
6858     return type;
6859 }
6860
6861 static inline abi_long copy_from_user_flock(struct flock64 *fl,
6862                                             abi_ulong target_flock_addr)
6863 {
6864     struct target_flock *target_fl;
6865     int l_type;
6866
6867     if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6868         return -TARGET_EFAULT;
6869     }
6870
6871     __get_user(l_type, &target_fl->l_type);
6872     l_type = target_to_host_flock(l_type);
6873     if (l_type < 0) {
6874         return l_type;
6875     }
6876     fl->l_type = l_type;
6877     __get_user(fl->l_whence, &target_fl->l_whence);
6878     __get_user(fl->l_start, &target_fl->l_start);
6879     __get_user(fl->l_len, &target_fl->l_len);
6880     __get_user(fl->l_pid, &target_fl->l_pid);
6881     unlock_user_struct(target_fl, target_flock_addr, 0);
6882     return 0;
6883 }
6884
6885 static inline abi_long copy_to_user_flock(abi_ulong target_flock_addr,
6886                                           const struct flock64 *fl)
6887 {
6888     struct target_flock *target_fl;
6889     short l_type;
6890
6891     if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6892         return -TARGET_EFAULT;
6893     }
6894
6895     l_type = host_to_target_flock(fl->l_type);
6896     __put_user(l_type, &target_fl->l_type);
6897     __put_user(fl->l_whence, &target_fl->l_whence);
6898     __put_user(fl->l_start, &target_fl->l_start);
6899     __put_user(fl->l_len, &target_fl->l_len);
6900     __put_user(fl->l_pid, &target_fl->l_pid);
6901     unlock_user_struct(target_fl, target_flock_addr, 1);
6902     return 0;
6903 }
6904
6905 typedef abi_long from_flock64_fn(struct flock64 *fl, abi_ulong target_addr);
6906 typedef abi_long to_flock64_fn(abi_ulong target_addr, const struct flock64 *fl);
6907
6908 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6909 struct target_oabi_flock64 {
6910     abi_short l_type;
6911     abi_short l_whence;
6912     abi_llong l_start;
6913     abi_llong l_len;
6914     abi_int   l_pid;
6915 } QEMU_PACKED;
6916
6917 static inline abi_long copy_from_user_oabi_flock64(struct flock64 *fl,
6918                                                    abi_ulong target_flock_addr)
6919 {
6920     struct target_oabi_flock64 *target_fl;
6921     int l_type;
6922
6923     if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6924         return -TARGET_EFAULT;
6925     }
6926
6927     __get_user(l_type, &target_fl->l_type);
6928     l_type = target_to_host_flock(l_type);
6929     if (l_type < 0) {
6930         return l_type;
6931     }
6932     fl->l_type = l_type;
6933     __get_user(fl->l_whence, &target_fl->l_whence);
6934     __get_user(fl->l_start, &target_fl->l_start);
6935     __get_user(fl->l_len, &target_fl->l_len);
6936     __get_user(fl->l_pid, &target_fl->l_pid);
6937     unlock_user_struct(target_fl, target_flock_addr, 0);
6938     return 0;
6939 }
6940
6941 static inline abi_long copy_to_user_oabi_flock64(abi_ulong target_flock_addr,
6942                                                  const struct flock64 *fl)
6943 {
6944     struct target_oabi_flock64 *target_fl;
6945     short l_type;
6946
6947     if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6948         return -TARGET_EFAULT;
6949     }
6950
6951     l_type = host_to_target_flock(fl->l_type);
6952     __put_user(l_type, &target_fl->l_type);
6953     __put_user(fl->l_whence, &target_fl->l_whence);
6954     __put_user(fl->l_start, &target_fl->l_start);
6955     __put_user(fl->l_len, &target_fl->l_len);
6956     __put_user(fl->l_pid, &target_fl->l_pid);
6957     unlock_user_struct(target_fl, target_flock_addr, 1);
6958     return 0;
6959 }
6960 #endif
6961
6962 static inline abi_long copy_from_user_flock64(struct flock64 *fl,
6963                                               abi_ulong target_flock_addr)
6964 {
6965     struct target_flock64 *target_fl;
6966     int l_type;
6967
6968     if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6969         return -TARGET_EFAULT;
6970     }
6971
6972     __get_user(l_type, &target_fl->l_type);
6973     l_type = target_to_host_flock(l_type);
6974     if (l_type < 0) {
6975         return l_type;
6976     }
6977     fl->l_type = l_type;
6978     __get_user(fl->l_whence, &target_fl->l_whence);
6979     __get_user(fl->l_start, &target_fl->l_start);
6980     __get_user(fl->l_len, &target_fl->l_len);
6981     __get_user(fl->l_pid, &target_fl->l_pid);
6982     unlock_user_struct(target_fl, target_flock_addr, 0);
6983     return 0;
6984 }
6985
6986 static inline abi_long copy_to_user_flock64(abi_ulong target_flock_addr,
6987                                             const struct flock64 *fl)
6988 {
6989     struct target_flock64 *target_fl;
6990     short l_type;
6991
6992     if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6993         return -TARGET_EFAULT;
6994     }
6995
6996     l_type = host_to_target_flock(fl->l_type);
6997     __put_user(l_type, &target_fl->l_type);
6998     __put_user(fl->l_whence, &target_fl->l_whence);
6999     __put_user(fl->l_start, &target_fl->l_start);
7000     __put_user(fl->l_len, &target_fl->l_len);
7001     __put_user(fl->l_pid, &target_fl->l_pid);
7002     unlock_user_struct(target_fl, target_flock_addr, 1);
7003     return 0;
7004 }
7005
7006 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
7007 {
7008     struct flock64 fl64;
7009 #ifdef F_GETOWN_EX
7010     struct f_owner_ex fox;
7011     struct target_f_owner_ex *target_fox;
7012 #endif
7013     abi_long ret;
7014     int host_cmd = target_to_host_fcntl_cmd(cmd);
7015
7016     if (host_cmd == -TARGET_EINVAL)
7017             return host_cmd;
7018
7019     switch(cmd) {
7020     case TARGET_F_GETLK:
7021         ret = copy_from_user_flock(&fl64, arg);
7022         if (ret) {
7023             return ret;
7024         }
7025         ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7026         if (ret == 0) {
7027             ret = copy_to_user_flock(arg, &fl64);
7028         }
7029         break;
7030
7031     case TARGET_F_SETLK:
7032     case TARGET_F_SETLKW:
7033         ret = copy_from_user_flock(&fl64, arg);
7034         if (ret) {
7035             return ret;
7036         }
7037         ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7038         break;
7039
7040     case TARGET_F_GETLK64:
7041     case TARGET_F_OFD_GETLK:
7042         ret = copy_from_user_flock64(&fl64, arg);
7043         if (ret) {
7044             return ret;
7045         }
7046         ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7047         if (ret == 0) {
7048             ret = copy_to_user_flock64(arg, &fl64);
7049         }
7050         break;
7051     case TARGET_F_SETLK64:
7052     case TARGET_F_SETLKW64:
7053     case TARGET_F_OFD_SETLK:
7054     case TARGET_F_OFD_SETLKW:
7055         ret = copy_from_user_flock64(&fl64, arg);
7056         if (ret) {
7057             return ret;
7058         }
7059         ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7060         break;
7061
7062     case TARGET_F_GETFL:
7063         ret = get_errno(safe_fcntl(fd, host_cmd, arg));
7064         if (ret >= 0) {
7065             ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
7066         }
7067         break;
7068
7069     case TARGET_F_SETFL:
7070         ret = get_errno(safe_fcntl(fd, host_cmd,
7071                                    target_to_host_bitmask(arg,
7072                                                           fcntl_flags_tbl)));
7073         break;
7074
7075 #ifdef F_GETOWN_EX
7076     case TARGET_F_GETOWN_EX:
7077         ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
7078         if (ret >= 0) {
7079             if (!lock_user_struct(VERIFY_WRITE, target_fox, arg, 0))
7080                 return -TARGET_EFAULT;
7081             target_fox->type = tswap32(fox.type);
7082             target_fox->pid = tswap32(fox.pid);
7083             unlock_user_struct(target_fox, arg, 1);
7084         }
7085         break;
7086 #endif
7087
7088 #ifdef F_SETOWN_EX
7089     case TARGET_F_SETOWN_EX:
7090         if (!lock_user_struct(VERIFY_READ, target_fox, arg, 1))
7091             return -TARGET_EFAULT;
7092         fox.type = tswap32(target_fox->type);
7093         fox.pid = tswap32(target_fox->pid);
7094         unlock_user_struct(target_fox, arg, 0);
7095         ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
7096         break;
7097 #endif
7098
7099     case TARGET_F_SETSIG:
7100         ret = get_errno(safe_fcntl(fd, host_cmd, target_to_host_signal(arg)));
7101         break;
7102
7103     case TARGET_F_GETSIG:
7104         ret = host_to_target_signal(get_errno(safe_fcntl(fd, host_cmd, arg)));
7105         break;
7106
7107     case TARGET_F_SETOWN:
7108     case TARGET_F_GETOWN:
7109     case TARGET_F_SETLEASE:
7110     case TARGET_F_GETLEASE:
7111     case TARGET_F_SETPIPE_SZ:
7112     case TARGET_F_GETPIPE_SZ:
7113     case TARGET_F_ADD_SEALS:
7114     case TARGET_F_GET_SEALS:
7115         ret = get_errno(safe_fcntl(fd, host_cmd, arg));
7116         break;
7117
7118     default:
7119         ret = get_errno(safe_fcntl(fd, cmd, arg));
7120         break;
7121     }
7122     return ret;
7123 }
7124
7125 #ifdef USE_UID16
7126
7127 static inline int high2lowuid(int uid)
7128 {
7129     if (uid > 65535)
7130         return 65534;
7131     else
7132         return uid;
7133 }
7134
7135 static inline int high2lowgid(int gid)
7136 {
7137     if (gid > 65535)
7138         return 65534;
7139     else
7140         return gid;
7141 }
7142
7143 static inline int low2highuid(int uid)
7144 {
7145     if ((int16_t)uid == -1)
7146         return -1;
7147     else
7148         return uid;
7149 }
7150
7151 static inline int low2highgid(int gid)
7152 {
7153     if ((int16_t)gid == -1)
7154         return -1;
7155     else
7156         return gid;
7157 }
7158 static inline int tswapid(int id)
7159 {
7160     return tswap16(id);
7161 }
7162
7163 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
7164
7165 #else /* !USE_UID16 */
7166 static inline int high2lowuid(int uid)
7167 {
7168     return uid;
7169 }
7170 static inline int high2lowgid(int gid)
7171 {
7172     return gid;
7173 }
7174 static inline int low2highuid(int uid)
7175 {
7176     return uid;
7177 }
7178 static inline int low2highgid(int gid)
7179 {
7180     return gid;
7181 }
7182 static inline int tswapid(int id)
7183 {
7184     return tswap32(id);
7185 }
7186
7187 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
7188
7189 #endif /* USE_UID16 */
7190
7191 /* We must do direct syscalls for setting UID/GID, because we want to
7192  * implement the Linux system call semantics of "change only for this thread",
7193  * not the libc/POSIX semantics of "change for all threads in process".
7194  * (See http://ewontfix.com/17/ for more details.)
7195  * We use the 32-bit version of the syscalls if present; if it is not
7196  * then either the host architecture supports 32-bit UIDs natively with
7197  * the standard syscall, or the 16-bit UID is the best we can do.
7198  */
7199 #ifdef __NR_setuid32
7200 #define __NR_sys_setuid __NR_setuid32
7201 #else
7202 #define __NR_sys_setuid __NR_setuid
7203 #endif
7204 #ifdef __NR_setgid32
7205 #define __NR_sys_setgid __NR_setgid32
7206 #else
7207 #define __NR_sys_setgid __NR_setgid
7208 #endif
7209 #ifdef __NR_setresuid32
7210 #define __NR_sys_setresuid __NR_setresuid32
7211 #else
7212 #define __NR_sys_setresuid __NR_setresuid
7213 #endif
7214 #ifdef __NR_setresgid32
7215 #define __NR_sys_setresgid __NR_setresgid32
7216 #else
7217 #define __NR_sys_setresgid __NR_setresgid
7218 #endif
7219
7220 _syscall1(int, sys_setuid, uid_t, uid)
7221 _syscall1(int, sys_setgid, gid_t, gid)
7222 _syscall3(int, sys_setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
7223 _syscall3(int, sys_setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
7224
7225 void syscall_init(void)
7226 {
7227     IOCTLEntry *ie;
7228     const argtype *arg_type;
7229     int size;
7230
7231     thunk_init(STRUCT_MAX);
7232
7233 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
7234 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
7235 #include "syscall_types.h"
7236 #undef STRUCT
7237 #undef STRUCT_SPECIAL
7238
7239     /* we patch the ioctl size if necessary. We rely on the fact that
7240        no ioctl has all the bits at '1' in the size field */
7241     ie = ioctl_entries;
7242     while (ie->target_cmd != 0) {
7243         if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
7244             TARGET_IOC_SIZEMASK) {
7245             arg_type = ie->arg_type;
7246             if (arg_type[0] != TYPE_PTR) {
7247                 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
7248                         ie->target_cmd);
7249                 exit(1);
7250             }
7251             arg_type++;
7252             size = thunk_type_size(arg_type, 0);
7253             ie->target_cmd = (ie->target_cmd &
7254                               ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
7255                 (size << TARGET_IOC_SIZESHIFT);
7256         }
7257
7258         /* automatic consistency check if same arch */
7259 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
7260     (defined(__x86_64__) && defined(TARGET_X86_64))
7261         if (unlikely(ie->target_cmd != ie->host_cmd)) {
7262             fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
7263                     ie->name, ie->target_cmd, ie->host_cmd);
7264         }
7265 #endif
7266         ie++;
7267     }
7268 }
7269
7270 #ifdef TARGET_NR_truncate64
7271 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
7272                                          abi_long arg2,
7273                                          abi_long arg3,
7274                                          abi_long arg4)
7275 {
7276     if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) {
7277         arg2 = arg3;
7278         arg3 = arg4;
7279     }
7280     return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
7281 }
7282 #endif
7283
7284 #ifdef TARGET_NR_ftruncate64
7285 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
7286                                           abi_long arg2,
7287                                           abi_long arg3,
7288                                           abi_long arg4)
7289 {
7290     if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) {
7291         arg2 = arg3;
7292         arg3 = arg4;
7293     }
7294     return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
7295 }
7296 #endif
7297
7298 #if defined(TARGET_NR_timer_settime) || \
7299     (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
7300 static inline abi_long target_to_host_itimerspec(struct itimerspec *host_its,
7301                                                  abi_ulong target_addr)
7302 {
7303     if (target_to_host_timespec(&host_its->it_interval, target_addr +
7304                                 offsetof(struct target_itimerspec,
7305                                          it_interval)) ||
7306         target_to_host_timespec(&host_its->it_value, target_addr +
7307                                 offsetof(struct target_itimerspec,
7308                                          it_value))) {
7309         return -TARGET_EFAULT;
7310     }
7311
7312     return 0;
7313 }
7314 #endif
7315
7316 #if defined(TARGET_NR_timer_settime64) || \
7317     (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD))
7318 static inline abi_long target_to_host_itimerspec64(struct itimerspec *host_its,
7319                                                    abi_ulong target_addr)
7320 {
7321     if (target_to_host_timespec64(&host_its->it_interval, target_addr +
7322                                   offsetof(struct target__kernel_itimerspec,
7323                                            it_interval)) ||
7324         target_to_host_timespec64(&host_its->it_value, target_addr +
7325                                   offsetof(struct target__kernel_itimerspec,
7326                                            it_value))) {
7327         return -TARGET_EFAULT;
7328     }
7329
7330     return 0;
7331 }
7332 #endif
7333
7334 #if ((defined(TARGET_NR_timerfd_gettime) || \
7335       defined(TARGET_NR_timerfd_settime)) && defined(CONFIG_TIMERFD)) || \
7336       defined(TARGET_NR_timer_gettime) || defined(TARGET_NR_timer_settime)
7337 static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
7338                                                  struct itimerspec *host_its)
7339 {
7340     if (host_to_target_timespec(target_addr + offsetof(struct target_itimerspec,
7341                                                        it_interval),
7342                                 &host_its->it_interval) ||
7343         host_to_target_timespec(target_addr + offsetof(struct target_itimerspec,
7344                                                        it_value),
7345                                 &host_its->it_value)) {
7346         return -TARGET_EFAULT;
7347     }
7348     return 0;
7349 }
7350 #endif
7351
7352 #if ((defined(TARGET_NR_timerfd_gettime64) || \
7353       defined(TARGET_NR_timerfd_settime64)) && defined(CONFIG_TIMERFD)) || \
7354       defined(TARGET_NR_timer_gettime64) || defined(TARGET_NR_timer_settime64)
7355 static inline abi_long host_to_target_itimerspec64(abi_ulong target_addr,
7356                                                    struct itimerspec *host_its)
7357 {
7358     if (host_to_target_timespec64(target_addr +
7359                                   offsetof(struct target__kernel_itimerspec,
7360                                            it_interval),
7361                                   &host_its->it_interval) ||
7362         host_to_target_timespec64(target_addr +
7363                                   offsetof(struct target__kernel_itimerspec,
7364                                            it_value),
7365                                   &host_its->it_value)) {
7366         return -TARGET_EFAULT;
7367     }
7368     return 0;
7369 }
7370 #endif
7371
7372 #if defined(TARGET_NR_adjtimex) || \
7373     (defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME))
7374 static inline abi_long target_to_host_timex(struct timex *host_tx,
7375                                             abi_long target_addr)
7376 {
7377     struct target_timex *target_tx;
7378
7379     if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
7380         return -TARGET_EFAULT;
7381     }
7382
7383     __get_user(host_tx->modes, &target_tx->modes);
7384     __get_user(host_tx->offset, &target_tx->offset);
7385     __get_user(host_tx->freq, &target_tx->freq);
7386     __get_user(host_tx->maxerror, &target_tx->maxerror);
7387     __get_user(host_tx->esterror, &target_tx->esterror);
7388     __get_user(host_tx->status, &target_tx->status);
7389     __get_user(host_tx->constant, &target_tx->constant);
7390     __get_user(host_tx->precision, &target_tx->precision);
7391     __get_user(host_tx->tolerance, &target_tx->tolerance);
7392     __get_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
7393     __get_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
7394     __get_user(host_tx->tick, &target_tx->tick);
7395     __get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7396     __get_user(host_tx->jitter, &target_tx->jitter);
7397     __get_user(host_tx->shift, &target_tx->shift);
7398     __get_user(host_tx->stabil, &target_tx->stabil);
7399     __get_user(host_tx->jitcnt, &target_tx->jitcnt);
7400     __get_user(host_tx->calcnt, &target_tx->calcnt);
7401     __get_user(host_tx->errcnt, &target_tx->errcnt);
7402     __get_user(host_tx->stbcnt, &target_tx->stbcnt);
7403     __get_user(host_tx->tai, &target_tx->tai);
7404
7405     unlock_user_struct(target_tx, target_addr, 0);
7406     return 0;
7407 }
7408
7409 static inline abi_long host_to_target_timex(abi_long target_addr,
7410                                             struct timex *host_tx)
7411 {
7412     struct target_timex *target_tx;
7413
7414     if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
7415         return -TARGET_EFAULT;
7416     }
7417
7418     __put_user(host_tx->modes, &target_tx->modes);
7419     __put_user(host_tx->offset, &target_tx->offset);
7420     __put_user(host_tx->freq, &target_tx->freq);
7421     __put_user(host_tx->maxerror, &target_tx->maxerror);
7422     __put_user(host_tx->esterror, &target_tx->esterror);
7423     __put_user(host_tx->status, &target_tx->status);
7424     __put_user(host_tx->constant, &target_tx->constant);
7425     __put_user(host_tx->precision, &target_tx->precision);
7426     __put_user(host_tx->tolerance, &target_tx->tolerance);
7427     __put_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
7428     __put_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
7429     __put_user(host_tx->tick, &target_tx->tick);
7430     __put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7431     __put_user(host_tx->jitter, &target_tx->jitter);
7432     __put_user(host_tx->shift, &target_tx->shift);
7433     __put_user(host_tx->stabil, &target_tx->stabil);
7434     __put_user(host_tx->jitcnt, &target_tx->jitcnt);
7435     __put_user(host_tx->calcnt, &target_tx->calcnt);
7436     __put_user(host_tx->errcnt, &target_tx->errcnt);
7437     __put_user(host_tx->stbcnt, &target_tx->stbcnt);
7438     __put_user(host_tx->tai, &target_tx->tai);
7439
7440     unlock_user_struct(target_tx, target_addr, 1);
7441     return 0;
7442 }
7443 #endif
7444
7445
7446 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
7447 static inline abi_long target_to_host_timex64(struct timex *host_tx,
7448                                               abi_long target_addr)
7449 {
7450     struct target__kernel_timex *target_tx;
7451
7452     if (copy_from_user_timeval64(&host_tx->time, target_addr +
7453                                  offsetof(struct target__kernel_timex,
7454                                           time))) {
7455         return -TARGET_EFAULT;
7456     }
7457
7458     if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
7459         return -TARGET_EFAULT;
7460     }
7461
7462     __get_user(host_tx->modes, &target_tx->modes);
7463     __get_user(host_tx->offset, &target_tx->offset);
7464     __get_user(host_tx->freq, &target_tx->freq);
7465     __get_user(host_tx->maxerror, &target_tx->maxerror);
7466     __get_user(host_tx->esterror, &target_tx->esterror);
7467     __get_user(host_tx->status, &target_tx->status);
7468     __get_user(host_tx->constant, &target_tx->constant);
7469     __get_user(host_tx->precision, &target_tx->precision);
7470     __get_user(host_tx->tolerance, &target_tx->tolerance);
7471     __get_user(host_tx->tick, &target_tx->tick);
7472     __get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7473     __get_user(host_tx->jitter, &target_tx->jitter);
7474     __get_user(host_tx->shift, &target_tx->shift);
7475     __get_user(host_tx->stabil, &target_tx->stabil);
7476     __get_user(host_tx->jitcnt, &target_tx->jitcnt);
7477     __get_user(host_tx->calcnt, &target_tx->calcnt);
7478     __get_user(host_tx->errcnt, &target_tx->errcnt);
7479     __get_user(host_tx->stbcnt, &target_tx->stbcnt);
7480     __get_user(host_tx->tai, &target_tx->tai);
7481
7482     unlock_user_struct(target_tx, target_addr, 0);
7483     return 0;
7484 }
7485
7486 static inline abi_long host_to_target_timex64(abi_long target_addr,
7487                                               struct timex *host_tx)
7488 {
7489     struct target__kernel_timex *target_tx;
7490
7491    if (copy_to_user_timeval64(target_addr +
7492                               offsetof(struct target__kernel_timex, time),
7493                               &host_tx->time)) {
7494         return -TARGET_EFAULT;
7495     }
7496
7497     if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
7498         return -TARGET_EFAULT;
7499     }
7500
7501     __put_user(host_tx->modes, &target_tx->modes);
7502     __put_user(host_tx->offset, &target_tx->offset);
7503     __put_user(host_tx->freq, &target_tx->freq);
7504     __put_user(host_tx->maxerror, &target_tx->maxerror);
7505     __put_user(host_tx->esterror, &target_tx->esterror);
7506     __put_user(host_tx->status, &target_tx->status);
7507     __put_user(host_tx->constant, &target_tx->constant);
7508     __put_user(host_tx->precision, &target_tx->precision);
7509     __put_user(host_tx->tolerance, &target_tx->tolerance);
7510     __put_user(host_tx->tick, &target_tx->tick);
7511     __put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7512     __put_user(host_tx->jitter, &target_tx->jitter);
7513     __put_user(host_tx->shift, &target_tx->shift);
7514     __put_user(host_tx->stabil, &target_tx->stabil);
7515     __put_user(host_tx->jitcnt, &target_tx->jitcnt);
7516     __put_user(host_tx->calcnt, &target_tx->calcnt);
7517     __put_user(host_tx->errcnt, &target_tx->errcnt);
7518     __put_user(host_tx->stbcnt, &target_tx->stbcnt);
7519     __put_user(host_tx->tai, &target_tx->tai);
7520
7521     unlock_user_struct(target_tx, target_addr, 1);
7522     return 0;
7523 }
7524 #endif
7525
7526 #ifndef HAVE_SIGEV_NOTIFY_THREAD_ID
7527 #define sigev_notify_thread_id _sigev_un._tid
7528 #endif
7529
7530 static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp,
7531                                                abi_ulong target_addr)
7532 {
7533     struct target_sigevent *target_sevp;
7534
7535     if (!lock_user_struct(VERIFY_READ, target_sevp, target_addr, 1)) {
7536         return -TARGET_EFAULT;
7537     }
7538
7539     /* This union is awkward on 64 bit systems because it has a 32 bit
7540      * integer and a pointer in it; we follow the conversion approach
7541      * used for handling sigval types in signal.c so the guest should get
7542      * the correct value back even if we did a 64 bit byteswap and it's
7543      * using the 32 bit integer.
7544      */
7545     host_sevp->sigev_value.sival_ptr =
7546         (void *)(uintptr_t)tswapal(target_sevp->sigev_value.sival_ptr);
7547     host_sevp->sigev_signo =
7548         target_to_host_signal(tswap32(target_sevp->sigev_signo));
7549     host_sevp->sigev_notify = tswap32(target_sevp->sigev_notify);
7550     host_sevp->sigev_notify_thread_id = tswap32(target_sevp->_sigev_un._tid);
7551
7552     unlock_user_struct(target_sevp, target_addr, 1);
7553     return 0;
7554 }
7555
7556 #if defined(TARGET_NR_mlockall)
7557 static inline int target_to_host_mlockall_arg(int arg)
7558 {
7559     int result = 0;
7560
7561     if (arg & TARGET_MCL_CURRENT) {
7562         result |= MCL_CURRENT;
7563     }
7564     if (arg & TARGET_MCL_FUTURE) {
7565         result |= MCL_FUTURE;
7566     }
7567 #ifdef MCL_ONFAULT
7568     if (arg & TARGET_MCL_ONFAULT) {
7569         result |= MCL_ONFAULT;
7570     }
7571 #endif
7572
7573     return result;
7574 }
7575 #endif
7576
7577 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) ||     \
7578      defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) ||  \
7579      defined(TARGET_NR_newfstatat))
7580 static inline abi_long host_to_target_stat64(void *cpu_env,
7581                                              abi_ulong target_addr,
7582                                              struct stat *host_st)
7583 {
7584 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
7585     if (((CPUARMState *)cpu_env)->eabi) {
7586         struct target_eabi_stat64 *target_st;
7587
7588         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7589             return -TARGET_EFAULT;
7590         memset(target_st, 0, sizeof(struct target_eabi_stat64));
7591         __put_user(host_st->st_dev, &target_st->st_dev);
7592         __put_user(host_st->st_ino, &target_st->st_ino);
7593 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7594         __put_user(host_st->st_ino, &target_st->__st_ino);
7595 #endif
7596         __put_user(host_st->st_mode, &target_st->st_mode);
7597         __put_user(host_st->st_nlink, &target_st->st_nlink);
7598         __put_user(host_st->st_uid, &target_st->st_uid);
7599         __put_user(host_st->st_gid, &target_st->st_gid);
7600         __put_user(host_st->st_rdev, &target_st->st_rdev);
7601         __put_user(host_st->st_size, &target_st->st_size);
7602         __put_user(host_st->st_blksize, &target_st->st_blksize);
7603         __put_user(host_st->st_blocks, &target_st->st_blocks);
7604         __put_user(host_st->st_atime, &target_st->target_st_atime);
7605         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7606         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7607 #ifdef HAVE_STRUCT_STAT_ST_ATIM
7608         __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec);
7609         __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec);
7610         __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec);
7611 #endif
7612         unlock_user_struct(target_st, target_addr, 1);
7613     } else
7614 #endif
7615     {
7616 #if defined(TARGET_HAS_STRUCT_STAT64)
7617         struct target_stat64 *target_st;
7618 #else
7619         struct target_stat *target_st;
7620 #endif
7621
7622         if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7623             return -TARGET_EFAULT;
7624         memset(target_st, 0, sizeof(*target_st));
7625         __put_user(host_st->st_dev, &target_st->st_dev);
7626         __put_user(host_st->st_ino, &target_st->st_ino);
7627 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7628         __put_user(host_st->st_ino, &target_st->__st_ino);
7629 #endif
7630         __put_user(host_st->st_mode, &target_st->st_mode);
7631         __put_user(host_st->st_nlink, &target_st->st_nlink);
7632         __put_user(host_st->st_uid, &target_st->st_uid);
7633         __put_user(host_st->st_gid, &target_st->st_gid);
7634         __put_user(host_st->st_rdev, &target_st->st_rdev);
7635         /* XXX: better use of kernel struct */
7636         __put_user(host_st->st_size, &target_st->st_size);
7637         __put_user(host_st->st_blksize, &target_st->st_blksize);
7638         __put_user(host_st->st_blocks, &target_st->st_blocks);
7639         __put_user(host_st->st_atime, &target_st->target_st_atime);
7640         __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7641         __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7642 #ifdef HAVE_STRUCT_STAT_ST_ATIM
7643         __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec);
7644         __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec);
7645         __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec);
7646 #endif
7647         unlock_user_struct(target_st, target_addr, 1);
7648     }
7649
7650     return 0;
7651 }
7652 #endif
7653
7654 #if defined(TARGET_NR_statx) && defined(__NR_statx)
7655 static inline abi_long host_to_target_statx(struct target_statx *host_stx,
7656                                             abi_ulong target_addr)
7657 {
7658     struct target_statx *target_stx;
7659
7660     if (!lock_user_struct(VERIFY_WRITE, target_stx, target_addr,  0)) {
7661         return -TARGET_EFAULT;
7662     }
7663     memset(target_stx, 0, sizeof(*target_stx));
7664
7665     __put_user(host_stx->stx_mask, &target_stx->stx_mask);
7666     __put_user(host_stx->stx_blksize, &target_stx->stx_blksize);
7667     __put_user(host_stx->stx_attributes, &target_stx->stx_attributes);
7668     __put_user(host_stx->stx_nlink, &target_stx->stx_nlink);
7669     __put_user(host_stx->stx_uid, &target_stx->stx_uid);
7670     __put_user(host_stx->stx_gid, &target_stx->stx_gid);
7671     __put_user(host_stx->stx_mode, &target_stx->stx_mode);
7672     __put_user(host_stx->stx_ino, &target_stx->stx_ino);
7673     __put_user(host_stx->stx_size, &target_stx->stx_size);
7674     __put_user(host_stx->stx_blocks, &target_stx->stx_blocks);
7675     __put_user(host_stx->stx_attributes_mask, &target_stx->stx_attributes_mask);
7676     __put_user(host_stx->stx_atime.tv_sec, &target_stx->stx_atime.tv_sec);
7677     __put_user(host_stx->stx_atime.tv_nsec, &target_stx->stx_atime.tv_nsec);
7678     __put_user(host_stx->stx_btime.tv_sec, &target_stx->stx_btime.tv_sec);
7679     __put_user(host_stx->stx_btime.tv_nsec, &target_stx->stx_btime.tv_nsec);
7680     __put_user(host_stx->stx_ctime.tv_sec, &target_stx->stx_ctime.tv_sec);
7681     __put_user(host_stx->stx_ctime.tv_nsec, &target_stx->stx_ctime.tv_nsec);
7682     __put_user(host_stx->stx_mtime.tv_sec, &target_stx->stx_mtime.tv_sec);
7683     __put_user(host_stx->stx_mtime.tv_nsec, &target_stx->stx_mtime.tv_nsec);
7684     __put_user(host_stx->stx_rdev_major, &target_stx->stx_rdev_major);
7685     __put_user(host_stx->stx_rdev_minor, &target_stx->stx_rdev_minor);
7686     __put_user(host_stx->stx_dev_major, &target_stx->stx_dev_major);
7687     __put_user(host_stx->stx_dev_minor, &target_stx->stx_dev_minor);
7688
7689     unlock_user_struct(target_stx, target_addr, 1);
7690
7691     return 0;
7692 }
7693 #endif
7694
7695 static int do_sys_futex(int *uaddr, int op, int val,
7696                          const struct timespec *timeout, int *uaddr2,
7697                          int val3)
7698 {
7699 #if HOST_LONG_BITS == 64
7700 #if defined(__NR_futex)
7701     /* always a 64-bit time_t, it doesn't define _time64 version  */
7702     return sys_futex(uaddr, op, val, timeout, uaddr2, val3);
7703
7704 #endif
7705 #else /* HOST_LONG_BITS == 64 */
7706 #if defined(__NR_futex_time64)
7707     if (sizeof(timeout->tv_sec) == 8) {
7708         /* _time64 function on 32bit arch */
7709         return sys_futex_time64(uaddr, op, val, timeout, uaddr2, val3);
7710     }
7711 #endif
7712 #if defined(__NR_futex)
7713     /* old function on 32bit arch */
7714     return sys_futex(uaddr, op, val, timeout, uaddr2, val3);
7715 #endif
7716 #endif /* HOST_LONG_BITS == 64 */
7717     g_assert_not_reached();
7718 }
7719
7720 static int do_safe_futex(int *uaddr, int op, int val,
7721                          const struct timespec *timeout, int *uaddr2,
7722                          int val3)
7723 {
7724 #if HOST_LONG_BITS == 64
7725 #if defined(__NR_futex)
7726     /* always a 64-bit time_t, it doesn't define _time64 version  */
7727     return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3));
7728 #endif
7729 #else /* HOST_LONG_BITS == 64 */
7730 #if defined(__NR_futex_time64)
7731     if (sizeof(timeout->tv_sec) == 8) {
7732         /* _time64 function on 32bit arch */
7733         return get_errno(safe_futex_time64(uaddr, op, val, timeout, uaddr2,
7734                                            val3));
7735     }
7736 #endif
7737 #if defined(__NR_futex)
7738     /* old function on 32bit arch */
7739     return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3));
7740 #endif
7741 #endif /* HOST_LONG_BITS == 64 */
7742     return -TARGET_ENOSYS;
7743 }
7744
7745 /* ??? Using host futex calls even when target atomic operations
7746    are not really atomic probably breaks things.  However implementing
7747    futexes locally would make futexes shared between multiple processes
7748    tricky.  However they're probably useless because guest atomic
7749    operations won't work either.  */
7750 #if defined(TARGET_NR_futex)
7751 static int do_futex(CPUState *cpu, target_ulong uaddr, int op, int val,
7752                     target_ulong timeout, target_ulong uaddr2, int val3)
7753 {
7754     struct timespec ts, *pts;
7755     int base_op;
7756
7757     /* ??? We assume FUTEX_* constants are the same on both host
7758        and target.  */
7759 #ifdef FUTEX_CMD_MASK
7760     base_op = op & FUTEX_CMD_MASK;
7761 #else
7762     base_op = op;
7763 #endif
7764     switch (base_op) {
7765     case FUTEX_WAIT:
7766     case FUTEX_WAIT_BITSET:
7767         if (timeout) {
7768             pts = &ts;
7769             target_to_host_timespec(pts, timeout);
7770         } else {
7771             pts = NULL;
7772         }
7773         return do_safe_futex(g2h(cpu, uaddr),
7774                              op, tswap32(val), pts, NULL, val3);
7775     case FUTEX_WAKE:
7776         return do_safe_futex(g2h(cpu, uaddr),
7777                              op, val, NULL, NULL, 0);
7778     case FUTEX_FD:
7779         return do_safe_futex(g2h(cpu, uaddr),
7780                              op, val, NULL, NULL, 0);
7781     case FUTEX_REQUEUE:
7782     case FUTEX_CMP_REQUEUE:
7783     case FUTEX_WAKE_OP:
7784         /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7785            TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7786            But the prototype takes a `struct timespec *'; insert casts
7787            to satisfy the compiler.  We do not need to tswap TIMEOUT
7788            since it's not compared to guest memory.  */
7789         pts = (struct timespec *)(uintptr_t) timeout;
7790         return do_safe_futex(g2h(cpu, uaddr), op, val, pts, g2h(cpu, uaddr2),
7791                              (base_op == FUTEX_CMP_REQUEUE
7792                               ? tswap32(val3) : val3));
7793     default:
7794         return -TARGET_ENOSYS;
7795     }
7796 }
7797 #endif
7798
7799 #if defined(TARGET_NR_futex_time64)
7800 static int do_futex_time64(CPUState *cpu, target_ulong uaddr, int op,
7801                            int val, target_ulong timeout,
7802                            target_ulong uaddr2, int val3)
7803 {
7804     struct timespec ts, *pts;
7805     int base_op;
7806
7807     /* ??? We assume FUTEX_* constants are the same on both host
7808        and target.  */
7809 #ifdef FUTEX_CMD_MASK
7810     base_op = op & FUTEX_CMD_MASK;
7811 #else
7812     base_op = op;
7813 #endif
7814     switch (base_op) {
7815     case FUTEX_WAIT:
7816     case FUTEX_WAIT_BITSET:
7817         if (timeout) {
7818             pts = &ts;
7819             if (target_to_host_timespec64(pts, timeout)) {
7820                 return -TARGET_EFAULT;
7821             }
7822         } else {
7823             pts = NULL;
7824         }
7825         return do_safe_futex(g2h(cpu, uaddr), op,
7826                              tswap32(val), pts, NULL, val3);
7827     case FUTEX_WAKE:
7828         return do_safe_futex(g2h(cpu, uaddr), op, val, NULL, NULL, 0);
7829     case FUTEX_FD:
7830         return do_safe_futex(g2h(cpu, uaddr), op, val, NULL, NULL, 0);
7831     case FUTEX_REQUEUE:
7832     case FUTEX_CMP_REQUEUE:
7833     case FUTEX_WAKE_OP:
7834         /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7835            TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7836            But the prototype takes a `struct timespec *'; insert casts
7837            to satisfy the compiler.  We do not need to tswap TIMEOUT
7838            since it's not compared to guest memory.  */
7839         pts = (struct timespec *)(uintptr_t) timeout;
7840         return do_safe_futex(g2h(cpu, uaddr), op, val, pts, g2h(cpu, uaddr2),
7841                              (base_op == FUTEX_CMP_REQUEUE
7842                               ? tswap32(val3) : val3));
7843     default:
7844         return -TARGET_ENOSYS;
7845     }
7846 }
7847 #endif
7848
7849 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7850 static abi_long do_name_to_handle_at(abi_long dirfd, abi_long pathname,
7851                                      abi_long handle, abi_long mount_id,
7852                                      abi_long flags)
7853 {
7854     struct file_handle *target_fh;
7855     struct file_handle *fh;
7856     int mid = 0;
7857     abi_long ret;
7858     char *name;
7859     unsigned int size, total_size;
7860
7861     if (get_user_s32(size, handle)) {
7862         return -TARGET_EFAULT;
7863     }
7864
7865     name = lock_user_string(pathname);
7866     if (!name) {
7867         return -TARGET_EFAULT;
7868     }
7869
7870     total_size = sizeof(struct file_handle) + size;
7871     target_fh = lock_user(VERIFY_WRITE, handle, total_size, 0);
7872     if (!target_fh) {
7873         unlock_user(name, pathname, 0);
7874         return -TARGET_EFAULT;
7875     }
7876
7877     fh = g_malloc0(total_size);
7878     fh->handle_bytes = size;
7879
7880     ret = get_errno(name_to_handle_at(dirfd, path(name), fh, &mid, flags));
7881     unlock_user(name, pathname, 0);
7882
7883     /* man name_to_handle_at(2):
7884      * Other than the use of the handle_bytes field, the caller should treat
7885      * the file_handle structure as an opaque data type
7886      */
7887
7888     memcpy(target_fh, fh, total_size);
7889     target_fh->handle_bytes = tswap32(fh->handle_bytes);
7890     target_fh->handle_type = tswap32(fh->handle_type);
7891     g_free(fh);
7892     unlock_user(target_fh, handle, total_size);
7893
7894     if (put_user_s32(mid, mount_id)) {
7895         return -TARGET_EFAULT;
7896     }
7897
7898     return ret;
7899
7900 }
7901 #endif
7902
7903 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7904 static abi_long do_open_by_handle_at(abi_long mount_fd, abi_long handle,
7905                                      abi_long flags)
7906 {
7907     struct file_handle *target_fh;
7908     struct file_handle *fh;
7909     unsigned int size, total_size;
7910     abi_long ret;
7911
7912     if (get_user_s32(size, handle)) {
7913         return -TARGET_EFAULT;
7914     }
7915
7916     total_size = sizeof(struct file_handle) + size;
7917     target_fh = lock_user(VERIFY_READ, handle, total_size, 1);
7918     if (!target_fh) {
7919         return -TARGET_EFAULT;
7920     }
7921
7922     fh = g_memdup(target_fh, total_size);
7923     fh->handle_bytes = size;
7924     fh->handle_type = tswap32(target_fh->handle_type);
7925
7926     ret = get_errno(open_by_handle_at(mount_fd, fh,
7927                     target_to_host_bitmask(flags, fcntl_flags_tbl)));
7928
7929     g_free(fh);
7930
7931     unlock_user(target_fh, handle, total_size);
7932
7933     return ret;
7934 }
7935 #endif
7936
7937 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7938
7939 static abi_long do_signalfd4(int fd, abi_long mask, int flags)
7940 {
7941     int host_flags;
7942     target_sigset_t *target_mask;
7943     sigset_t host_mask;
7944     abi_long ret;
7945
7946     if (flags & ~(TARGET_O_NONBLOCK_MASK | TARGET_O_CLOEXEC)) {
7947         return -TARGET_EINVAL;
7948     }
7949     if (!lock_user_struct(VERIFY_READ, target_mask, mask, 1)) {
7950         return -TARGET_EFAULT;
7951     }
7952
7953     target_to_host_sigset(&host_mask, target_mask);
7954
7955     host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
7956
7957     ret = get_errno(signalfd(fd, &host_mask, host_flags));
7958     if (ret >= 0) {
7959         fd_trans_register(ret, &target_signalfd_trans);
7960     }
7961
7962     unlock_user_struct(target_mask, mask, 0);
7963
7964     return ret;
7965 }
7966 #endif
7967
7968 /* Map host to target signal numbers for the wait family of syscalls.
7969    Assume all other status bits are the same.  */
7970 int host_to_target_waitstatus(int status)
7971 {
7972     if (WIFSIGNALED(status)) {
7973         return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
7974     }
7975     if (WIFSTOPPED(status)) {
7976         return (host_to_target_signal(WSTOPSIG(status)) << 8)
7977                | (status & 0xff);
7978     }
7979     return status;
7980 }
7981
7982 static int open_self_cmdline(void *cpu_env, int fd)
7983 {
7984     CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
7985     struct linux_binprm *bprm = ((TaskState *)cpu->opaque)->bprm;
7986     int i;
7987
7988     for (i = 0; i < bprm->argc; i++) {
7989         size_t len = strlen(bprm->argv[i]) + 1;
7990
7991         if (write(fd, bprm->argv[i], len) != len) {
7992             return -1;
7993         }
7994     }
7995
7996     return 0;
7997 }
7998
7999 static int open_self_maps(void *cpu_env, int fd)
8000 {
8001     CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
8002     TaskState *ts = cpu->opaque;
8003     GSList *map_info = read_self_maps();
8004     GSList *s;
8005     int count;
8006
8007     for (s = map_info; s; s = g_slist_next(s)) {
8008         MapInfo *e = (MapInfo *) s->data;
8009
8010         if (h2g_valid(e->start)) {
8011             unsigned long min = e->start;
8012             unsigned long max = e->end;
8013             int flags = page_get_flags(h2g(min));
8014             const char *path;
8015
8016             max = h2g_valid(max - 1) ?
8017                 max : (uintptr_t) g2h_untagged(GUEST_ADDR_MAX) + 1;
8018
8019             if (page_check_range(h2g(min), max - min, flags) == -1) {
8020                 continue;
8021             }
8022
8023             if (h2g(min) == ts->info->stack_limit) {
8024                 path = "[stack]";
8025             } else {
8026                 path = e->path;
8027             }
8028
8029             count = dprintf(fd, TARGET_ABI_FMT_ptr "-" TARGET_ABI_FMT_ptr
8030                             " %c%c%c%c %08" PRIx64 " %s %"PRId64,
8031                             h2g(min), h2g(max - 1) + 1,
8032                             (flags & PAGE_READ) ? 'r' : '-',
8033                             (flags & PAGE_WRITE_ORG) ? 'w' : '-',
8034                             (flags & PAGE_EXEC) ? 'x' : '-',
8035                             e->is_priv ? 'p' : 's',
8036                             (uint64_t) e->offset, e->dev, e->inode);
8037             if (path) {
8038                 dprintf(fd, "%*s%s\n", 73 - count, "", path);
8039             } else {
8040                 dprintf(fd, "\n");
8041             }
8042         }
8043     }
8044
8045     free_self_maps(map_info);
8046
8047 #ifdef TARGET_VSYSCALL_PAGE
8048     /*
8049      * We only support execution from the vsyscall page.
8050      * This is as if CONFIG_LEGACY_VSYSCALL_XONLY=y from v5.3.
8051      */
8052     count = dprintf(fd, TARGET_FMT_lx "-" TARGET_FMT_lx
8053                     " --xp 00000000 00:00 0",
8054                     TARGET_VSYSCALL_PAGE, TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE);
8055     dprintf(fd, "%*s%s\n", 73 - count, "",  "[vsyscall]");
8056 #endif
8057
8058     return 0;
8059 }
8060
8061 static int open_self_stat(void *cpu_env, int fd)
8062 {
8063     CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
8064     TaskState *ts = cpu->opaque;
8065     g_autoptr(GString) buf = g_string_new(NULL);
8066     int i;
8067
8068     for (i = 0; i < 44; i++) {
8069         if (i == 0) {
8070             /* pid */
8071             g_string_printf(buf, FMT_pid " ", getpid());
8072         } else if (i == 1) {
8073             /* app name */
8074             gchar *bin = g_strrstr(ts->bprm->argv[0], "/");
8075             bin = bin ? bin + 1 : ts->bprm->argv[0];
8076             g_string_printf(buf, "(%.15s) ", bin);
8077         } else if (i == 3) {
8078             /* ppid */
8079             g_string_printf(buf, FMT_pid " ", getppid());
8080         } else if (i == 27) {
8081             /* stack bottom */
8082             g_string_printf(buf, TARGET_ABI_FMT_ld " ", ts->info->start_stack);
8083         } else {
8084             /* for the rest, there is MasterCard */
8085             g_string_printf(buf, "0%c", i == 43 ? '\n' : ' ');
8086         }
8087
8088         if (write(fd, buf->str, buf->len) != buf->len) {
8089             return -1;
8090         }
8091     }
8092
8093     return 0;
8094 }
8095
8096 static int open_self_auxv(void *cpu_env, int fd)
8097 {
8098     CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
8099     TaskState *ts = cpu->opaque;
8100     abi_ulong auxv = ts->info->saved_auxv;
8101     abi_ulong len = ts->info->auxv_len;
8102     char *ptr;
8103
8104     /*
8105      * Auxiliary vector is stored in target process stack.
8106      * read in whole auxv vector and copy it to file
8107      */
8108     ptr = lock_user(VERIFY_READ, auxv, len, 0);
8109     if (ptr != NULL) {
8110         while (len > 0) {
8111             ssize_t r;
8112             r = write(fd, ptr, len);
8113             if (r <= 0) {
8114                 break;
8115             }
8116             len -= r;
8117             ptr += r;
8118         }
8119         lseek(fd, 0, SEEK_SET);
8120         unlock_user(ptr, auxv, len);
8121     }
8122
8123     return 0;
8124 }
8125
8126 static int is_proc_myself(const char *filename, const char *entry)
8127 {
8128     if (!strncmp(filename, "/proc/", strlen("/proc/"))) {
8129         filename += strlen("/proc/");
8130         if (!strncmp(filename, "self/", strlen("self/"))) {
8131             filename += strlen("self/");
8132         } else if (*filename >= '1' && *filename <= '9') {
8133             char myself[80];
8134             snprintf(myself, sizeof(myself), "%d/", getpid());
8135             if (!strncmp(filename, myself, strlen(myself))) {
8136                 filename += strlen(myself);
8137             } else {
8138                 return 0;
8139             }
8140         } else {
8141             return 0;
8142         }
8143         if (!strcmp(filename, entry)) {
8144             return 1;
8145         }
8146     }
8147     return 0;
8148 }
8149
8150 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) || \
8151     defined(TARGET_SPARC) || defined(TARGET_M68K) || defined(TARGET_HPPA)
8152 static int is_proc(const char *filename, const char *entry)
8153 {
8154     return strcmp(filename, entry) == 0;
8155 }
8156 #endif
8157
8158 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
8159 static int open_net_route(void *cpu_env, int fd)
8160 {
8161     FILE *fp;
8162     char *line = NULL;
8163     size_t len = 0;
8164     ssize_t read;
8165
8166     fp = fopen("/proc/net/route", "r");
8167     if (fp == NULL) {
8168         return -1;
8169     }
8170
8171     /* read header */
8172
8173     read = getline(&line, &len, fp);
8174     dprintf(fd, "%s", line);
8175
8176     /* read routes */
8177
8178     while ((read = getline(&line, &len, fp)) != -1) {
8179         char iface[16];
8180         uint32_t dest, gw, mask;
8181         unsigned int flags, refcnt, use, metric, mtu, window, irtt;
8182         int fields;
8183
8184         fields = sscanf(line,
8185                         "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
8186                         iface, &dest, &gw, &flags, &refcnt, &use, &metric,
8187                         &mask, &mtu, &window, &irtt);
8188         if (fields != 11) {
8189             continue;
8190         }
8191         dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
8192                 iface, tswap32(dest), tswap32(gw), flags, refcnt, use,
8193                 metric, tswap32(mask), mtu, window, irtt);
8194     }
8195
8196     free(line);
8197     fclose(fp);
8198
8199     return 0;
8200 }
8201 #endif
8202
8203 #if defined(TARGET_SPARC)
8204 static int open_cpuinfo(void *cpu_env, int fd)
8205 {
8206     dprintf(fd, "type\t\t: sun4u\n");
8207     return 0;
8208 }
8209 #endif
8210
8211 #if defined(TARGET_HPPA)
8212 static int open_cpuinfo(void *cpu_env, int fd)
8213 {
8214     dprintf(fd, "cpu family\t: PA-RISC 1.1e\n");
8215     dprintf(fd, "cpu\t\t: PA7300LC (PCX-L2)\n");
8216     dprintf(fd, "capabilities\t: os32\n");
8217     dprintf(fd, "model\t\t: 9000/778/B160L\n");
8218     dprintf(fd, "model name\t: Merlin L2 160 QEMU (9000/778/B160L)\n");
8219     return 0;
8220 }
8221 #endif
8222
8223 #if defined(TARGET_M68K)
8224 static int open_hardware(void *cpu_env, int fd)
8225 {
8226     dprintf(fd, "Model:\t\tqemu-m68k\n");
8227     return 0;
8228 }
8229 #endif
8230
8231 static int do_openat(void *cpu_env, int dirfd, const char *pathname, int flags, mode_t mode)
8232 {
8233     struct fake_open {
8234         const char *filename;
8235         int (*fill)(void *cpu_env, int fd);
8236         int (*cmp)(const char *s1, const char *s2);
8237     };
8238     const struct fake_open *fake_open;
8239     static const struct fake_open fakes[] = {
8240         { "maps", open_self_maps, is_proc_myself },
8241         { "stat", open_self_stat, is_proc_myself },
8242         { "auxv", open_self_auxv, is_proc_myself },
8243         { "cmdline", open_self_cmdline, is_proc_myself },
8244 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
8245         { "/proc/net/route", open_net_route, is_proc },
8246 #endif
8247 #if defined(TARGET_SPARC) || defined(TARGET_HPPA)
8248         { "/proc/cpuinfo", open_cpuinfo, is_proc },
8249 #endif
8250 #if defined(TARGET_M68K)
8251         { "/proc/hardware", open_hardware, is_proc },
8252 #endif
8253         { NULL, NULL, NULL }
8254     };
8255
8256     if (is_proc_myself(pathname, "exe")) {
8257         int execfd = qemu_getauxval(AT_EXECFD);
8258         return execfd ? execfd : safe_openat(dirfd, exec_path, flags, mode);
8259     }
8260
8261     for (fake_open = fakes; fake_open->filename; fake_open++) {
8262         if (fake_open->cmp(pathname, fake_open->filename)) {
8263             break;
8264         }
8265     }
8266
8267     if (fake_open->filename) {
8268         const char *tmpdir;
8269         char filename[PATH_MAX];
8270         int fd, r;
8271
8272         /* create temporary file to map stat to */
8273         tmpdir = getenv("TMPDIR");
8274         if (!tmpdir)
8275             tmpdir = "/tmp";
8276         snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir);
8277         fd = mkstemp(filename);
8278         if (fd < 0) {
8279             return fd;
8280         }
8281         unlink(filename);
8282
8283         if ((r = fake_open->fill(cpu_env, fd))) {
8284             int e = errno;
8285             close(fd);
8286             errno = e;
8287             return r;
8288         }
8289         lseek(fd, 0, SEEK_SET);
8290
8291         return fd;
8292     }
8293
8294     return safe_openat(dirfd, path(pathname), flags, mode);
8295 }
8296
8297 #define TIMER_MAGIC 0x0caf0000
8298 #define TIMER_MAGIC_MASK 0xffff0000
8299
8300 /* Convert QEMU provided timer ID back to internal 16bit index format */
8301 static target_timer_t get_timer_id(abi_long arg)
8302 {
8303     target_timer_t timerid = arg;
8304
8305     if ((timerid & TIMER_MAGIC_MASK) != TIMER_MAGIC) {
8306         return -TARGET_EINVAL;
8307     }
8308
8309     timerid &= 0xffff;
8310
8311     if (timerid >= ARRAY_SIZE(g_posix_timers)) {
8312         return -TARGET_EINVAL;
8313     }
8314
8315     return timerid;
8316 }
8317
8318 static int target_to_host_cpu_mask(unsigned long *host_mask,
8319                                    size_t host_size,
8320                                    abi_ulong target_addr,
8321                                    size_t target_size)
8322 {
8323     unsigned target_bits = sizeof(abi_ulong) * 8;
8324     unsigned host_bits = sizeof(*host_mask) * 8;
8325     abi_ulong *target_mask;
8326     unsigned i, j;
8327
8328     assert(host_size >= target_size);
8329
8330     target_mask = lock_user(VERIFY_READ, target_addr, target_size, 1);
8331     if (!target_mask) {
8332         return -TARGET_EFAULT;
8333     }
8334     memset(host_mask, 0, host_size);
8335
8336     for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) {
8337         unsigned bit = i * target_bits;
8338         abi_ulong val;
8339
8340         __get_user(val, &target_mask[i]);
8341         for (j = 0; j < target_bits; j++, bit++) {
8342             if (val & (1UL << j)) {
8343                 host_mask[bit / host_bits] |= 1UL << (bit % host_bits);
8344             }
8345         }
8346     }
8347
8348     unlock_user(target_mask, target_addr, 0);
8349     return 0;
8350 }
8351
8352 static int host_to_target_cpu_mask(const unsigned long *host_mask,
8353                                    size_t host_size,
8354                                    abi_ulong target_addr,
8355                                    size_t target_size)
8356 {
8357     unsigned target_bits = sizeof(abi_ulong) * 8;
8358     unsigned host_bits = sizeof(*host_mask) * 8;
8359     abi_ulong *target_mask;
8360     unsigned i, j;
8361
8362     assert(host_size >= target_size);
8363
8364     target_mask = lock_user(VERIFY_WRITE, target_addr, target_size, 0);
8365     if (!target_mask) {
8366         return -TARGET_EFAULT;
8367     }
8368
8369     for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) {
8370         unsigned bit = i * target_bits;
8371         abi_ulong val = 0;
8372
8373         for (j = 0; j < target_bits; j++, bit++) {
8374             if (host_mask[bit / host_bits] & (1UL << (bit % host_bits))) {
8375                 val |= 1UL << j;
8376             }
8377         }
8378         __put_user(val, &target_mask[i]);
8379     }
8380
8381     unlock_user(target_mask, target_addr, target_size);
8382     return 0;
8383 }
8384
8385 #ifdef TARGET_NR_getdents
8386 static int do_getdents(abi_long dirfd, abi_long arg2, abi_long count)
8387 {
8388     g_autofree void *hdirp = NULL;
8389     void *tdirp;
8390     int hlen, hoff, toff;
8391     int hreclen, treclen;
8392     off64_t prev_diroff = 0;
8393
8394     hdirp = g_try_malloc(count);
8395     if (!hdirp) {
8396         return -TARGET_ENOMEM;
8397     }
8398
8399 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8400     hlen = sys_getdents(dirfd, hdirp, count);
8401 #else
8402     hlen = sys_getdents64(dirfd, hdirp, count);
8403 #endif
8404
8405     hlen = get_errno(hlen);
8406     if (is_error(hlen)) {
8407         return hlen;
8408     }
8409
8410     tdirp = lock_user(VERIFY_WRITE, arg2, count, 0);
8411     if (!tdirp) {
8412         return -TARGET_EFAULT;
8413     }
8414
8415     for (hoff = toff = 0; hoff < hlen; hoff += hreclen, toff += treclen) {
8416 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8417         struct linux_dirent *hde = hdirp + hoff;
8418 #else
8419         struct linux_dirent64 *hde = hdirp + hoff;
8420 #endif
8421         struct target_dirent *tde = tdirp + toff;
8422         int namelen;
8423         uint8_t type;
8424
8425         namelen = strlen(hde->d_name);
8426         hreclen = hde->d_reclen;
8427         treclen = offsetof(struct target_dirent, d_name) + namelen + 2;
8428         treclen = QEMU_ALIGN_UP(treclen, __alignof(struct target_dirent));
8429
8430         if (toff + treclen > count) {
8431             /*
8432              * If the host struct is smaller than the target struct, or
8433              * requires less alignment and thus packs into less space,
8434              * then the host can return more entries than we can pass
8435              * on to the guest.
8436              */
8437             if (toff == 0) {
8438                 toff = -TARGET_EINVAL; /* result buffer is too small */
8439                 break;
8440             }
8441             /*
8442              * Return what we have, resetting the file pointer to the
8443              * location of the first record not returned.
8444              */
8445             lseek64(dirfd, prev_diroff, SEEK_SET);
8446             break;
8447         }
8448
8449         prev_diroff = hde->d_off;
8450         tde->d_ino = tswapal(hde->d_ino);
8451         tde->d_off = tswapal(hde->d_off);
8452         tde->d_reclen = tswap16(treclen);
8453         memcpy(tde->d_name, hde->d_name, namelen + 1);
8454
8455         /*
8456          * The getdents type is in what was formerly a padding byte at the
8457          * end of the structure.
8458          */
8459 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8460         type = *((uint8_t *)hde + hreclen - 1);
8461 #else
8462         type = hde->d_type;
8463 #endif
8464         *((uint8_t *)tde + treclen - 1) = type;
8465     }
8466
8467     unlock_user(tdirp, arg2, toff);
8468     return toff;
8469 }
8470 #endif /* TARGET_NR_getdents */
8471
8472 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
8473 static int do_getdents64(abi_long dirfd, abi_long arg2, abi_long count)
8474 {
8475     g_autofree void *hdirp = NULL;
8476     void *tdirp;
8477     int hlen, hoff, toff;
8478     int hreclen, treclen;
8479     off64_t prev_diroff = 0;
8480
8481     hdirp = g_try_malloc(count);
8482     if (!hdirp) {
8483         return -TARGET_ENOMEM;
8484     }
8485
8486     hlen = get_errno(sys_getdents64(dirfd, hdirp, count));
8487     if (is_error(hlen)) {
8488         return hlen;
8489     }
8490
8491     tdirp = lock_user(VERIFY_WRITE, arg2, count, 0);
8492     if (!tdirp) {
8493         return -TARGET_EFAULT;
8494     }
8495
8496     for (hoff = toff = 0; hoff < hlen; hoff += hreclen, toff += treclen) {
8497         struct linux_dirent64 *hde = hdirp + hoff;
8498         struct target_dirent64 *tde = tdirp + toff;
8499         int namelen;
8500
8501         namelen = strlen(hde->d_name) + 1;
8502         hreclen = hde->d_reclen;
8503         treclen = offsetof(struct target_dirent64, d_name) + namelen;
8504         treclen = QEMU_ALIGN_UP(treclen, __alignof(struct target_dirent64));
8505
8506         if (toff + treclen > count) {
8507             /*
8508              * If the host struct is smaller than the target struct, or
8509              * requires less alignment and thus packs into less space,
8510              * then the host can return more entries than we can pass
8511              * on to the guest.
8512              */
8513             if (toff == 0) {
8514                 toff = -TARGET_EINVAL; /* result buffer is too small */
8515                 break;
8516             }
8517             /*
8518              * Return what we have, resetting the file pointer to the
8519              * location of the first record not returned.
8520              */
8521             lseek64(dirfd, prev_diroff, SEEK_SET);
8522             break;
8523         }
8524
8525         prev_diroff = hde->d_off;
8526         tde->d_ino = tswap64(hde->d_ino);
8527         tde->d_off = tswap64(hde->d_off);
8528         tde->d_reclen = tswap16(treclen);
8529         tde->d_type = hde->d_type;
8530         memcpy(tde->d_name, hde->d_name, namelen);
8531     }
8532
8533     unlock_user(tdirp, arg2, toff);
8534     return toff;
8535 }
8536 #endif /* TARGET_NR_getdents64 */
8537
8538 #if defined(TARGET_NR_pivot_root) && defined(__NR_pivot_root)
8539 _syscall2(int, pivot_root, const char *, new_root, const char *, put_old)
8540 #endif
8541
8542 /* This is an internal helper for do_syscall so that it is easier
8543  * to have a single return point, so that actions, such as logging
8544  * of syscall results, can be performed.
8545  * All errnos that do_syscall() returns must be -TARGET_<errcode>.
8546  */
8547 static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
8548                             abi_long arg2, abi_long arg3, abi_long arg4,
8549                             abi_long arg5, abi_long arg6, abi_long arg7,
8550                             abi_long arg8)
8551 {
8552     CPUState *cpu = env_cpu(cpu_env);
8553     abi_long ret;
8554 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \
8555     || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \
8556     || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) \
8557     || defined(TARGET_NR_statx)
8558     struct stat st;
8559 #endif
8560 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \
8561     || defined(TARGET_NR_fstatfs)
8562     struct statfs stfs;
8563 #endif
8564     void *p;
8565
8566     switch(num) {
8567     case TARGET_NR_exit:
8568         /* In old applications this may be used to implement _exit(2).
8569            However in threaded applications it is used for thread termination,
8570            and _exit_group is used for application termination.
8571            Do thread termination if we have more then one thread.  */
8572
8573         if (block_signals()) {
8574             return -QEMU_ERESTARTSYS;
8575         }
8576
8577         pthread_mutex_lock(&clone_lock);
8578
8579         if (CPU_NEXT(first_cpu)) {
8580             TaskState *ts = cpu->opaque;
8581
8582             object_property_set_bool(OBJECT(cpu), "realized", false, NULL);
8583             object_unref(OBJECT(cpu));
8584             /*
8585              * At this point the CPU should be unrealized and removed
8586              * from cpu lists. We can clean-up the rest of the thread
8587              * data without the lock held.
8588              */
8589
8590             pthread_mutex_unlock(&clone_lock);
8591
8592             if (ts->child_tidptr) {
8593                 put_user_u32(0, ts->child_tidptr);
8594                 do_sys_futex(g2h(cpu, ts->child_tidptr),
8595                              FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
8596             }
8597             thread_cpu = NULL;
8598             g_free(ts);
8599             rcu_unregister_thread();
8600             pthread_exit(NULL);
8601         }
8602
8603         pthread_mutex_unlock(&clone_lock);
8604         preexit_cleanup(cpu_env, arg1);
8605         _exit(arg1);
8606         return 0; /* avoid warning */
8607     case TARGET_NR_read:
8608         if (arg2 == 0 && arg3 == 0) {
8609             return get_errno(safe_read(arg1, 0, 0));
8610         } else {
8611             if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
8612                 return -TARGET_EFAULT;
8613             ret = get_errno(safe_read(arg1, p, arg3));
8614             if (ret >= 0 &&
8615                 fd_trans_host_to_target_data(arg1)) {
8616                 ret = fd_trans_host_to_target_data(arg1)(p, ret);
8617             }
8618             unlock_user(p, arg2, ret);
8619         }
8620         return ret;
8621     case TARGET_NR_write:
8622         if (arg2 == 0 && arg3 == 0) {
8623             return get_errno(safe_write(arg1, 0, 0));
8624         }
8625         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
8626             return -TARGET_EFAULT;
8627         if (fd_trans_target_to_host_data(arg1)) {
8628             void *copy = g_malloc(arg3);
8629             memcpy(copy, p, arg3);
8630             ret = fd_trans_target_to_host_data(arg1)(copy, arg3);
8631             if (ret >= 0) {
8632                 ret = get_errno(safe_write(arg1, copy, ret));
8633             }
8634             g_free(copy);
8635         } else {
8636             ret = get_errno(safe_write(arg1, p, arg3));
8637         }
8638         unlock_user(p, arg2, 0);
8639         return ret;
8640
8641 #ifdef TARGET_NR_open
8642     case TARGET_NR_open:
8643         if (!(p = lock_user_string(arg1)))
8644             return -TARGET_EFAULT;
8645         ret = get_errno(do_openat(cpu_env, AT_FDCWD, p,
8646                                   target_to_host_bitmask(arg2, fcntl_flags_tbl),
8647                                   arg3));
8648         fd_trans_unregister(ret);
8649         unlock_user(p, arg1, 0);
8650         return ret;
8651 #endif
8652     case TARGET_NR_openat:
8653         if (!(p = lock_user_string(arg2)))
8654             return -TARGET_EFAULT;
8655         ret = get_errno(do_openat(cpu_env, arg1, p,
8656                                   target_to_host_bitmask(arg3, fcntl_flags_tbl),
8657                                   arg4));
8658         fd_trans_unregister(ret);
8659         unlock_user(p, arg2, 0);
8660         return ret;
8661 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8662     case TARGET_NR_name_to_handle_at:
8663         ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);
8664         return ret;
8665 #endif
8666 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8667     case TARGET_NR_open_by_handle_at:
8668         ret = do_open_by_handle_at(arg1, arg2, arg3);
8669         fd_trans_unregister(ret);
8670         return ret;
8671 #endif
8672     case TARGET_NR_close:
8673         fd_trans_unregister(arg1);
8674         return get_errno(close(arg1));
8675
8676     case TARGET_NR_brk:
8677         return do_brk(arg1);
8678 #ifdef TARGET_NR_fork
8679     case TARGET_NR_fork:
8680         return get_errno(do_fork(cpu_env, TARGET_SIGCHLD, 0, 0, 0, 0));
8681 #endif
8682 #ifdef TARGET_NR_waitpid
8683     case TARGET_NR_waitpid:
8684         {
8685             int status;
8686             ret = get_errno(safe_wait4(arg1, &status, arg3, 0));
8687             if (!is_error(ret) && arg2 && ret
8688                 && put_user_s32(host_to_target_waitstatus(status), arg2))
8689                 return -TARGET_EFAULT;
8690         }
8691         return ret;
8692 #endif
8693 #ifdef TARGET_NR_waitid
8694     case TARGET_NR_waitid:
8695         {
8696             siginfo_t info;
8697             info.si_pid = 0;
8698             ret = get_errno(safe_waitid(arg1, arg2, &info, arg4, NULL));
8699             if (!is_error(ret) && arg3 && info.si_pid != 0) {
8700                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
8701                     return -TARGET_EFAULT;
8702                 host_to_target_siginfo(p, &info);
8703                 unlock_user(p, arg3, sizeof(target_siginfo_t));
8704             }
8705         }
8706         return ret;
8707 #endif
8708 #ifdef TARGET_NR_creat /* not on alpha */
8709     case TARGET_NR_creat:
8710         if (!(p = lock_user_string(arg1)))
8711             return -TARGET_EFAULT;
8712         ret = get_errno(creat(p, arg2));
8713         fd_trans_unregister(ret);
8714         unlock_user(p, arg1, 0);
8715         return ret;
8716 #endif
8717 #ifdef TARGET_NR_link
8718     case TARGET_NR_link:
8719         {
8720             void * p2;
8721             p = lock_user_string(arg1);
8722             p2 = lock_user_string(arg2);
8723             if (!p || !p2)
8724                 ret = -TARGET_EFAULT;
8725             else
8726                 ret = get_errno(link(p, p2));
8727             unlock_user(p2, arg2, 0);
8728             unlock_user(p, arg1, 0);
8729         }
8730         return ret;
8731 #endif
8732 #if defined(TARGET_NR_linkat)
8733     case TARGET_NR_linkat:
8734         {
8735             void * p2 = NULL;
8736             if (!arg2 || !arg4)
8737                 return -TARGET_EFAULT;
8738             p  = lock_user_string(arg2);
8739             p2 = lock_user_string(arg4);
8740             if (!p || !p2)
8741                 ret = -TARGET_EFAULT;
8742             else
8743                 ret = get_errno(linkat(arg1, p, arg3, p2, arg5));
8744             unlock_user(p, arg2, 0);
8745             unlock_user(p2, arg4, 0);
8746         }
8747         return ret;
8748 #endif
8749 #ifdef TARGET_NR_unlink
8750     case TARGET_NR_unlink:
8751         if (!(p = lock_user_string(arg1)))
8752             return -TARGET_EFAULT;
8753         ret = get_errno(unlink(p));
8754         unlock_user(p, arg1, 0);
8755         return ret;
8756 #endif
8757 #if defined(TARGET_NR_unlinkat)
8758     case TARGET_NR_unlinkat:
8759         if (!(p = lock_user_string(arg2)))
8760             return -TARGET_EFAULT;
8761         ret = get_errno(unlinkat(arg1, p, arg3));
8762         unlock_user(p, arg2, 0);
8763         return ret;
8764 #endif
8765     case TARGET_NR_execve:
8766         {
8767             char **argp, **envp;
8768             int argc, envc;
8769             abi_ulong gp;
8770             abi_ulong guest_argp;
8771             abi_ulong guest_envp;
8772             abi_ulong addr;
8773             char **q;
8774
8775             argc = 0;
8776             guest_argp = arg2;
8777             for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
8778                 if (get_user_ual(addr, gp))
8779                     return -TARGET_EFAULT;
8780                 if (!addr)
8781                     break;
8782                 argc++;
8783             }
8784             envc = 0;
8785             guest_envp = arg3;
8786             for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
8787                 if (get_user_ual(addr, gp))
8788                     return -TARGET_EFAULT;
8789                 if (!addr)
8790                     break;
8791                 envc++;
8792             }
8793
8794             argp = g_new0(char *, argc + 1);
8795             envp = g_new0(char *, envc + 1);
8796
8797             for (gp = guest_argp, q = argp; gp;
8798                   gp += sizeof(abi_ulong), q++) {
8799                 if (get_user_ual(addr, gp))
8800                     goto execve_efault;
8801                 if (!addr)
8802                     break;
8803                 if (!(*q = lock_user_string(addr)))
8804                     goto execve_efault;
8805             }
8806             *q = NULL;
8807
8808             for (gp = guest_envp, q = envp; gp;
8809                   gp += sizeof(abi_ulong), q++) {
8810                 if (get_user_ual(addr, gp))
8811                     goto execve_efault;
8812                 if (!addr)
8813                     break;
8814                 if (!(*q = lock_user_string(addr)))
8815                     goto execve_efault;
8816             }
8817             *q = NULL;
8818
8819             if (!(p = lock_user_string(arg1)))
8820                 goto execve_efault;
8821             /* Although execve() is not an interruptible syscall it is
8822              * a special case where we must use the safe_syscall wrapper:
8823              * if we allow a signal to happen before we make the host
8824              * syscall then we will 'lose' it, because at the point of
8825              * execve the process leaves QEMU's control. So we use the
8826              * safe syscall wrapper to ensure that we either take the
8827              * signal as a guest signal, or else it does not happen
8828              * before the execve completes and makes it the other
8829              * program's problem.
8830              */
8831             ret = get_errno(safe_execve(p, argp, envp));
8832             unlock_user(p, arg1, 0);
8833
8834             goto execve_end;
8835
8836         execve_efault:
8837             ret = -TARGET_EFAULT;
8838
8839         execve_end:
8840             for (gp = guest_argp, q = argp; *q;
8841                   gp += sizeof(abi_ulong), q++) {
8842                 if (get_user_ual(addr, gp)
8843                     || !addr)
8844                     break;
8845                 unlock_user(*q, addr, 0);
8846             }
8847             for (gp = guest_envp, q = envp; *q;
8848                   gp += sizeof(abi_ulong), q++) {
8849                 if (get_user_ual(addr, gp)
8850                     || !addr)
8851                     break;
8852                 unlock_user(*q, addr, 0);
8853             }
8854
8855             g_free(argp);
8856             g_free(envp);
8857         }
8858         return ret;
8859     case TARGET_NR_chdir:
8860         if (!(p = lock_user_string(arg1)))
8861             return -TARGET_EFAULT;
8862         ret = get_errno(chdir(p));
8863         unlock_user(p, arg1, 0);
8864         return ret;
8865 #ifdef TARGET_NR_time
8866     case TARGET_NR_time:
8867         {
8868             time_t host_time;
8869             ret = get_errno(time(&host_time));
8870             if (!is_error(ret)
8871                 && arg1
8872                 && put_user_sal(host_time, arg1))
8873                 return -TARGET_EFAULT;
8874         }
8875         return ret;
8876 #endif
8877 #ifdef TARGET_NR_mknod
8878     case TARGET_NR_mknod:
8879         if (!(p = lock_user_string(arg1)))
8880             return -TARGET_EFAULT;
8881         ret = get_errno(mknod(p, arg2, arg3));
8882         unlock_user(p, arg1, 0);
8883         return ret;
8884 #endif
8885 #if defined(TARGET_NR_mknodat)
8886     case TARGET_NR_mknodat:
8887         if (!(p = lock_user_string(arg2)))
8888             return -TARGET_EFAULT;
8889         ret = get_errno(mknodat(arg1, p, arg3, arg4));
8890         unlock_user(p, arg2, 0);
8891         return ret;
8892 #endif
8893 #ifdef TARGET_NR_chmod
8894     case TARGET_NR_chmod:
8895         if (!(p = lock_user_string(arg1)))
8896             return -TARGET_EFAULT;
8897         ret = get_errno(chmod(p, arg2));
8898         unlock_user(p, arg1, 0);
8899         return ret;
8900 #endif
8901 #ifdef TARGET_NR_lseek
8902     case TARGET_NR_lseek:
8903         return get_errno(lseek(arg1, arg2, arg3));
8904 #endif
8905 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
8906     /* Alpha specific */
8907     case TARGET_NR_getxpid:
8908         ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
8909         return get_errno(getpid());
8910 #endif
8911 #ifdef TARGET_NR_getpid
8912     case TARGET_NR_getpid:
8913         return get_errno(getpid());
8914 #endif
8915     case TARGET_NR_mount:
8916         {
8917             /* need to look at the data field */
8918             void *p2, *p3;
8919
8920             if (arg1) {
8921                 p = lock_user_string(arg1);
8922                 if (!p) {
8923                     return -TARGET_EFAULT;
8924                 }
8925             } else {
8926                 p = NULL;
8927             }
8928
8929             p2 = lock_user_string(arg2);
8930             if (!p2) {
8931                 if (arg1) {
8932                     unlock_user(p, arg1, 0);
8933                 }
8934                 return -TARGET_EFAULT;
8935             }
8936
8937             if (arg3) {
8938                 p3 = lock_user_string(arg3);
8939                 if (!p3) {
8940                     if (arg1) {
8941                         unlock_user(p, arg1, 0);
8942                     }
8943                     unlock_user(p2, arg2, 0);
8944                     return -TARGET_EFAULT;
8945                 }
8946             } else {
8947                 p3 = NULL;
8948             }
8949
8950             /* FIXME - arg5 should be locked, but it isn't clear how to
8951              * do that since it's not guaranteed to be a NULL-terminated
8952              * string.
8953              */
8954             if (!arg5) {
8955                 ret = mount(p, p2, p3, (unsigned long)arg4, NULL);
8956             } else {
8957                 ret = mount(p, p2, p3, (unsigned long)arg4, g2h(cpu, arg5));
8958             }
8959             ret = get_errno(ret);
8960
8961             if (arg1) {
8962                 unlock_user(p, arg1, 0);
8963             }
8964             unlock_user(p2, arg2, 0);
8965             if (arg3) {
8966                 unlock_user(p3, arg3, 0);
8967             }
8968         }
8969         return ret;
8970 #if defined(TARGET_NR_umount) || defined(TARGET_NR_oldumount)
8971 #if defined(TARGET_NR_umount)
8972     case TARGET_NR_umount:
8973 #endif
8974 #if defined(TARGET_NR_oldumount)
8975     case TARGET_NR_oldumount:
8976 #endif
8977         if (!(p = lock_user_string(arg1)))
8978             return -TARGET_EFAULT;
8979         ret = get_errno(umount(p));
8980         unlock_user(p, arg1, 0);
8981         return ret;
8982 #endif
8983 #ifdef TARGET_NR_stime /* not on alpha */
8984     case TARGET_NR_stime:
8985         {
8986             struct timespec ts;
8987             ts.tv_nsec = 0;
8988             if (get_user_sal(ts.tv_sec, arg1)) {
8989                 return -TARGET_EFAULT;
8990             }
8991             return get_errno(clock_settime(CLOCK_REALTIME, &ts));
8992         }
8993 #endif
8994 #ifdef TARGET_NR_alarm /* not on alpha */
8995     case TARGET_NR_alarm:
8996         return alarm(arg1);
8997 #endif
8998 #ifdef TARGET_NR_pause /* not on alpha */
8999     case TARGET_NR_pause:
9000         if (!block_signals()) {
9001             sigsuspend(&((TaskState *)cpu->opaque)->signal_mask);
9002         }
9003         return -TARGET_EINTR;
9004 #endif
9005 #ifdef TARGET_NR_utime
9006     case TARGET_NR_utime:
9007         {
9008             struct utimbuf tbuf, *host_tbuf;
9009             struct target_utimbuf *target_tbuf;
9010             if (arg2) {
9011                 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
9012                     return -TARGET_EFAULT;
9013                 tbuf.actime = tswapal(target_tbuf->actime);
9014                 tbuf.modtime = tswapal(target_tbuf->modtime);
9015                 unlock_user_struct(target_tbuf, arg2, 0);
9016                 host_tbuf = &tbuf;
9017             } else {
9018                 host_tbuf = NULL;
9019             }
9020             if (!(p = lock_user_string(arg1)))
9021                 return -TARGET_EFAULT;
9022             ret = get_errno(utime(p, host_tbuf));
9023             unlock_user(p, arg1, 0);
9024         }
9025         return ret;
9026 #endif
9027 #ifdef TARGET_NR_utimes
9028     case TARGET_NR_utimes:
9029         {
9030             struct timeval *tvp, tv[2];
9031             if (arg2) {
9032                 if (copy_from_user_timeval(&tv[0], arg2)
9033                     || copy_from_user_timeval(&tv[1],
9034                                               arg2 + sizeof(struct target_timeval)))
9035                     return -TARGET_EFAULT;
9036                 tvp = tv;
9037             } else {
9038                 tvp = NULL;
9039             }
9040             if (!(p = lock_user_string(arg1)))
9041                 return -TARGET_EFAULT;
9042             ret = get_errno(utimes(p, tvp));
9043             unlock_user(p, arg1, 0);
9044         }
9045         return ret;
9046 #endif
9047 #if defined(TARGET_NR_futimesat)
9048     case TARGET_NR_futimesat:
9049         {
9050             struct timeval *tvp, tv[2];
9051             if (arg3) {
9052                 if (copy_from_user_timeval(&tv[0], arg3)
9053                     || copy_from_user_timeval(&tv[1],
9054                                               arg3 + sizeof(struct target_timeval)))
9055                     return -TARGET_EFAULT;
9056                 tvp = tv;
9057             } else {
9058                 tvp = NULL;
9059             }
9060             if (!(p = lock_user_string(arg2))) {
9061                 return -TARGET_EFAULT;
9062             }
9063             ret = get_errno(futimesat(arg1, path(p), tvp));
9064             unlock_user(p, arg2, 0);
9065         }
9066         return ret;
9067 #endif
9068 #ifdef TARGET_NR_access
9069     case TARGET_NR_access:
9070         if (!(p = lock_user_string(arg1))) {
9071             return -TARGET_EFAULT;
9072         }
9073         ret = get_errno(access(path(p), arg2));
9074         unlock_user(p, arg1, 0);
9075         return ret;
9076 #endif
9077 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
9078     case TARGET_NR_faccessat:
9079         if (!(p = lock_user_string(arg2))) {
9080             return -TARGET_EFAULT;
9081         }
9082         ret = get_errno(faccessat(arg1, p, arg3, 0));
9083         unlock_user(p, arg2, 0);
9084         return ret;
9085 #endif
9086 #ifdef TARGET_NR_nice /* not on alpha */
9087     case TARGET_NR_nice:
9088         return get_errno(nice(arg1));
9089 #endif
9090     case TARGET_NR_sync:
9091         sync();
9092         return 0;
9093 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
9094     case TARGET_NR_syncfs:
9095         return get_errno(syncfs(arg1));
9096 #endif
9097     case TARGET_NR_kill:
9098         return get_errno(safe_kill(arg1, target_to_host_signal(arg2)));
9099 #ifdef TARGET_NR_rename
9100     case TARGET_NR_rename:
9101         {
9102             void *p2;
9103             p = lock_user_string(arg1);
9104             p2 = lock_user_string(arg2);
9105             if (!p || !p2)
9106                 ret = -TARGET_EFAULT;
9107             else
9108                 ret = get_errno(rename(p, p2));
9109             unlock_user(p2, arg2, 0);
9110             unlock_user(p, arg1, 0);
9111         }
9112         return ret;
9113 #endif
9114 #if defined(TARGET_NR_renameat)
9115     case TARGET_NR_renameat:
9116         {
9117             void *p2;
9118             p  = lock_user_string(arg2);
9119             p2 = lock_user_string(arg4);
9120             if (!p || !p2)
9121                 ret = -TARGET_EFAULT;
9122             else
9123                 ret = get_errno(renameat(arg1, p, arg3, p2));
9124             unlock_user(p2, arg4, 0);
9125             unlock_user(p, arg2, 0);
9126         }
9127         return ret;
9128 #endif
9129 #if defined(TARGET_NR_renameat2)
9130     case TARGET_NR_renameat2:
9131         {
9132             void *p2;
9133             p  = lock_user_string(arg2);
9134             p2 = lock_user_string(arg4);
9135             if (!p || !p2) {
9136                 ret = -TARGET_EFAULT;
9137             } else {
9138                 ret = get_errno(sys_renameat2(arg1, p, arg3, p2, arg5));
9139             }
9140             unlock_user(p2, arg4, 0);
9141             unlock_user(p, arg2, 0);
9142         }
9143         return ret;
9144 #endif
9145 #ifdef TARGET_NR_mkdir
9146     case TARGET_NR_mkdir:
9147         if (!(p = lock_user_string(arg1)))
9148             return -TARGET_EFAULT;
9149         ret = get_errno(mkdir(p, arg2));
9150         unlock_user(p, arg1, 0);
9151         return ret;
9152 #endif
9153 #if defined(TARGET_NR_mkdirat)
9154     case TARGET_NR_mkdirat:
9155         if (!(p = lock_user_string(arg2)))
9156             return -TARGET_EFAULT;
9157         ret = get_errno(mkdirat(arg1, p, arg3));
9158         unlock_user(p, arg2, 0);
9159         return ret;
9160 #endif
9161 #ifdef TARGET_NR_rmdir
9162     case TARGET_NR_rmdir:
9163         if (!(p = lock_user_string(arg1)))
9164             return -TARGET_EFAULT;
9165         ret = get_errno(rmdir(p));
9166         unlock_user(p, arg1, 0);
9167         return ret;
9168 #endif
9169     case TARGET_NR_dup:
9170         ret = get_errno(dup(arg1));
9171         if (ret >= 0) {
9172             fd_trans_dup(arg1, ret);
9173         }
9174         return ret;
9175 #ifdef TARGET_NR_pipe
9176     case TARGET_NR_pipe:
9177         return do_pipe(cpu_env, arg1, 0, 0);
9178 #endif
9179 #ifdef TARGET_NR_pipe2
9180     case TARGET_NR_pipe2:
9181         return do_pipe(cpu_env, arg1,
9182                        target_to_host_bitmask(arg2, fcntl_flags_tbl), 1);
9183 #endif
9184     case TARGET_NR_times:
9185         {
9186             struct target_tms *tmsp;
9187             struct tms tms;
9188             ret = get_errno(times(&tms));
9189             if (arg1) {
9190                 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
9191                 if (!tmsp)
9192                     return -TARGET_EFAULT;
9193                 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime));
9194                 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime));
9195                 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime));
9196                 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime));
9197             }
9198             if (!is_error(ret))
9199                 ret = host_to_target_clock_t(ret);
9200         }
9201         return ret;
9202     case TARGET_NR_acct:
9203         if (arg1 == 0) {
9204             ret = get_errno(acct(NULL));
9205         } else {
9206             if (!(p = lock_user_string(arg1))) {
9207                 return -TARGET_EFAULT;
9208             }
9209             ret = get_errno(acct(path(p)));
9210             unlock_user(p, arg1, 0);
9211         }
9212         return ret;
9213 #ifdef TARGET_NR_umount2
9214     case TARGET_NR_umount2:
9215         if (!(p = lock_user_string(arg1)))
9216             return -TARGET_EFAULT;
9217         ret = get_errno(umount2(p, arg2));
9218         unlock_user(p, arg1, 0);
9219         return ret;
9220 #endif
9221     case TARGET_NR_ioctl:
9222         return do_ioctl(arg1, arg2, arg3);
9223 #ifdef TARGET_NR_fcntl
9224     case TARGET_NR_fcntl:
9225         return do_fcntl(arg1, arg2, arg3);
9226 #endif
9227     case TARGET_NR_setpgid:
9228         return get_errno(setpgid(arg1, arg2));
9229     case TARGET_NR_umask:
9230         return get_errno(umask(arg1));
9231     case TARGET_NR_chroot:
9232         if (!(p = lock_user_string(arg1)))
9233             return -TARGET_EFAULT;
9234         ret = get_errno(chroot(p));
9235         unlock_user(p, arg1, 0);
9236         return ret;
9237 #ifdef TARGET_NR_dup2
9238     case TARGET_NR_dup2:
9239         ret = get_errno(dup2(arg1, arg2));
9240         if (ret >= 0) {
9241             fd_trans_dup(arg1, arg2);
9242         }
9243         return ret;
9244 #endif
9245 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
9246     case TARGET_NR_dup3:
9247     {
9248         int host_flags;
9249
9250         if ((arg3 & ~TARGET_O_CLOEXEC) != 0) {
9251             return -EINVAL;
9252         }
9253         host_flags = target_to_host_bitmask(arg3, fcntl_flags_tbl);
9254         ret = get_errno(dup3(arg1, arg2, host_flags));
9255         if (ret >= 0) {
9256             fd_trans_dup(arg1, arg2);
9257         }
9258         return ret;
9259     }
9260 #endif
9261 #ifdef TARGET_NR_getppid /* not on alpha */
9262     case TARGET_NR_getppid:
9263         return get_errno(getppid());
9264 #endif
9265 #ifdef TARGET_NR_getpgrp
9266     case TARGET_NR_getpgrp:
9267         return get_errno(getpgrp());
9268 #endif
9269     case TARGET_NR_setsid:
9270         return get_errno(setsid());
9271 #ifdef TARGET_NR_sigaction
9272     case TARGET_NR_sigaction:
9273         {
9274 #if defined(TARGET_MIPS)
9275             struct target_sigaction act, oact, *pact, *old_act;
9276
9277             if (arg2) {
9278                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
9279                     return -TARGET_EFAULT;
9280                 act._sa_handler = old_act->_sa_handler;
9281                 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
9282                 act.sa_flags = old_act->sa_flags;
9283                 unlock_user_struct(old_act, arg2, 0);
9284                 pact = &act;
9285             } else {
9286                 pact = NULL;
9287             }
9288
9289         ret = get_errno(do_sigaction(arg1, pact, &oact, 0));
9290
9291             if (!is_error(ret) && arg3) {
9292                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
9293                     return -TARGET_EFAULT;
9294                 old_act->_sa_handler = oact._sa_handler;
9295                 old_act->sa_flags = oact.sa_flags;
9296                 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
9297                 old_act->sa_mask.sig[1] = 0;
9298                 old_act->sa_mask.sig[2] = 0;
9299                 old_act->sa_mask.sig[3] = 0;
9300                 unlock_user_struct(old_act, arg3, 1);
9301             }
9302 #else
9303             struct target_old_sigaction *old_act;
9304             struct target_sigaction act, oact, *pact;
9305             if (arg2) {
9306                 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
9307                     return -TARGET_EFAULT;
9308                 act._sa_handler = old_act->_sa_handler;
9309                 target_siginitset(&act.sa_mask, old_act->sa_mask);
9310                 act.sa_flags = old_act->sa_flags;
9311 #ifdef TARGET_ARCH_HAS_SA_RESTORER
9312                 act.sa_restorer = old_act->sa_restorer;
9313 #endif
9314                 unlock_user_struct(old_act, arg2, 0);
9315                 pact = &act;
9316             } else {
9317                 pact = NULL;
9318             }
9319             ret = get_errno(do_sigaction(arg1, pact, &oact, 0));
9320             if (!is_error(ret) && arg3) {
9321                 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
9322                     return -TARGET_EFAULT;
9323                 old_act->_sa_handler = oact._sa_handler;
9324                 old_act->sa_mask = oact.sa_mask.sig[0];
9325                 old_act->sa_flags = oact.sa_flags;
9326 #ifdef TARGET_ARCH_HAS_SA_RESTORER
9327                 old_act->sa_restorer = oact.sa_restorer;
9328 #endif
9329                 unlock_user_struct(old_act, arg3, 1);
9330             }
9331 #endif
9332         }
9333         return ret;
9334 #endif
9335     case TARGET_NR_rt_sigaction:
9336         {
9337             /*
9338              * For Alpha and SPARC this is a 5 argument syscall, with
9339              * a 'restorer' parameter which must be copied into the
9340              * sa_restorer field of the sigaction struct.
9341              * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
9342              * and arg5 is the sigsetsize.
9343              */
9344 #if defined(TARGET_ALPHA)
9345             target_ulong sigsetsize = arg4;
9346             target_ulong restorer = arg5;
9347 #elif defined(TARGET_SPARC)
9348             target_ulong restorer = arg4;
9349             target_ulong sigsetsize = arg5;
9350 #else
9351             target_ulong sigsetsize = arg4;
9352             target_ulong restorer = 0;
9353 #endif
9354             struct target_sigaction *act = NULL;
9355             struct target_sigaction *oact = NULL;
9356
9357             if (sigsetsize != sizeof(target_sigset_t)) {
9358                 return -TARGET_EINVAL;
9359             }
9360             if (arg2 && !lock_user_struct(VERIFY_READ, act, arg2, 1)) {
9361                 return -TARGET_EFAULT;
9362             }
9363             if (arg3 && !lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
9364                 ret = -TARGET_EFAULT;
9365             } else {
9366                 ret = get_errno(do_sigaction(arg1, act, oact, restorer));
9367                 if (oact) {
9368                     unlock_user_struct(oact, arg3, 1);
9369                 }
9370             }
9371             if (act) {
9372                 unlock_user_struct(act, arg2, 0);
9373             }
9374         }
9375         return ret;
9376 #ifdef TARGET_NR_sgetmask /* not on alpha */
9377     case TARGET_NR_sgetmask:
9378         {
9379             sigset_t cur_set;
9380             abi_ulong target_set;
9381             ret = do_sigprocmask(0, NULL, &cur_set);
9382             if (!ret) {
9383                 host_to_target_old_sigset(&target_set, &cur_set);
9384                 ret = target_set;
9385             }
9386         }
9387         return ret;
9388 #endif
9389 #ifdef TARGET_NR_ssetmask /* not on alpha */
9390     case TARGET_NR_ssetmask:
9391         {
9392             sigset_t set, oset;
9393             abi_ulong target_set = arg1;
9394             target_to_host_old_sigset(&set, &target_set);
9395             ret = do_sigprocmask(SIG_SETMASK, &set, &oset);
9396             if (!ret) {
9397                 host_to_target_old_sigset(&target_set, &oset);
9398                 ret = target_set;
9399             }
9400         }
9401         return ret;
9402 #endif
9403 #ifdef TARGET_NR_sigprocmask
9404     case TARGET_NR_sigprocmask:
9405         {
9406 #if defined(TARGET_ALPHA)
9407             sigset_t set, oldset;
9408             abi_ulong mask;
9409             int how;
9410
9411             switch (arg1) {
9412             case TARGET_SIG_BLOCK:
9413                 how = SIG_BLOCK;
9414                 break;
9415             case TARGET_SIG_UNBLOCK:
9416                 how = SIG_UNBLOCK;
9417                 break;
9418             case TARGET_SIG_SETMASK:
9419                 how = SIG_SETMASK;
9420                 break;
9421             default:
9422                 return -TARGET_EINVAL;
9423             }
9424             mask = arg2;
9425             target_to_host_old_sigset(&set, &mask);
9426
9427             ret = do_sigprocmask(how, &set, &oldset);
9428             if (!is_error(ret)) {
9429                 host_to_target_old_sigset(&mask, &oldset);
9430                 ret = mask;
9431                 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */
9432             }
9433 #else
9434             sigset_t set, oldset, *set_ptr;
9435             int how;
9436
9437             if (arg2) {
9438                 p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1);
9439                 if (!p) {
9440                     return -TARGET_EFAULT;
9441                 }
9442                 target_to_host_old_sigset(&set, p);
9443                 unlock_user(p, arg2, 0);
9444                 set_ptr = &set;
9445                 switch (arg1) {
9446                 case TARGET_SIG_BLOCK:
9447                     how = SIG_BLOCK;
9448                     break;
9449                 case TARGET_SIG_UNBLOCK:
9450                     how = SIG_UNBLOCK;
9451                     break;
9452                 case TARGET_SIG_SETMASK:
9453                     how = SIG_SETMASK;
9454                     break;
9455                 default:
9456                     return -TARGET_EINVAL;
9457                 }
9458             } else {
9459                 how = 0;
9460                 set_ptr = NULL;
9461             }
9462             ret = do_sigprocmask(how, set_ptr, &oldset);
9463             if (!is_error(ret) && arg3) {
9464                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
9465                     return -TARGET_EFAULT;
9466                 host_to_target_old_sigset(p, &oldset);
9467                 unlock_user(p, arg3, sizeof(target_sigset_t));
9468             }
9469 #endif
9470         }
9471         return ret;
9472 #endif
9473     case TARGET_NR_rt_sigprocmask:
9474         {
9475             int how = arg1;
9476             sigset_t set, oldset, *set_ptr;
9477
9478             if (arg4 != sizeof(target_sigset_t)) {
9479                 return -TARGET_EINVAL;
9480             }
9481
9482             if (arg2) {
9483                 p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1);
9484                 if (!p) {
9485                     return -TARGET_EFAULT;
9486                 }
9487                 target_to_host_sigset(&set, p);
9488                 unlock_user(p, arg2, 0);
9489                 set_ptr = &set;
9490                 switch(how) {
9491                 case TARGET_SIG_BLOCK:
9492                     how = SIG_BLOCK;
9493                     break;
9494                 case TARGET_SIG_UNBLOCK:
9495                     how = SIG_UNBLOCK;
9496                     break;
9497                 case TARGET_SIG_SETMASK:
9498                     how = SIG_SETMASK;
9499                     break;
9500                 default:
9501                     return -TARGET_EINVAL;
9502                 }
9503             } else {
9504                 how = 0;
9505                 set_ptr = NULL;
9506             }
9507             ret = do_sigprocmask(how, set_ptr, &oldset);
9508             if (!is_error(ret) && arg3) {
9509                 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
9510                     return -TARGET_EFAULT;
9511                 host_to_target_sigset(p, &oldset);
9512                 unlock_user(p, arg3, sizeof(target_sigset_t));
9513             }
9514         }
9515         return ret;
9516 #ifdef TARGET_NR_sigpending
9517     case TARGET_NR_sigpending:
9518         {
9519             sigset_t set;
9520             ret = get_errno(sigpending(&set));
9521             if (!is_error(ret)) {
9522                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
9523                     return -TARGET_EFAULT;
9524                 host_to_target_old_sigset(p, &set);
9525                 unlock_user(p, arg1, sizeof(target_sigset_t));
9526             }
9527         }
9528         return ret;
9529 #endif
9530     case TARGET_NR_rt_sigpending:
9531         {
9532             sigset_t set;
9533
9534             /* Yes, this check is >, not != like most. We follow the kernel's
9535              * logic and it does it like this because it implements
9536              * NR_sigpending through the same code path, and in that case
9537              * the old_sigset_t is smaller in size.
9538              */
9539             if (arg2 > sizeof(target_sigset_t)) {
9540                 return -TARGET_EINVAL;
9541             }
9542
9543             ret = get_errno(sigpending(&set));
9544             if (!is_error(ret)) {
9545                 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
9546                     return -TARGET_EFAULT;
9547                 host_to_target_sigset(p, &set);
9548                 unlock_user(p, arg1, sizeof(target_sigset_t));
9549             }
9550         }
9551         return ret;
9552 #ifdef TARGET_NR_sigsuspend
9553     case TARGET_NR_sigsuspend:
9554         {
9555             TaskState *ts = cpu->opaque;
9556 #if defined(TARGET_ALPHA)
9557             abi_ulong mask = arg1;
9558             target_to_host_old_sigset(&ts->sigsuspend_mask, &mask);
9559 #else
9560             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
9561                 return -TARGET_EFAULT;
9562             target_to_host_old_sigset(&ts->sigsuspend_mask, p);
9563             unlock_user(p, arg1, 0);
9564 #endif
9565             ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
9566                                                SIGSET_T_SIZE));
9567             if (ret != -QEMU_ERESTARTSYS) {
9568                 ts->in_sigsuspend = 1;
9569             }
9570         }
9571         return ret;
9572 #endif
9573     case TARGET_NR_rt_sigsuspend:
9574         {
9575             TaskState *ts = cpu->opaque;
9576
9577             if (arg2 != sizeof(target_sigset_t)) {
9578                 return -TARGET_EINVAL;
9579             }
9580             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
9581                 return -TARGET_EFAULT;
9582             target_to_host_sigset(&ts->sigsuspend_mask, p);
9583             unlock_user(p, arg1, 0);
9584             ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
9585                                                SIGSET_T_SIZE));
9586             if (ret != -QEMU_ERESTARTSYS) {
9587                 ts->in_sigsuspend = 1;
9588             }
9589         }
9590         return ret;
9591 #ifdef TARGET_NR_rt_sigtimedwait
9592     case TARGET_NR_rt_sigtimedwait:
9593         {
9594             sigset_t set;
9595             struct timespec uts, *puts;
9596             siginfo_t uinfo;
9597
9598             if (arg4 != sizeof(target_sigset_t)) {
9599                 return -TARGET_EINVAL;
9600             }
9601
9602             if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
9603                 return -TARGET_EFAULT;
9604             target_to_host_sigset(&set, p);
9605             unlock_user(p, arg1, 0);
9606             if (arg3) {
9607                 puts = &uts;
9608                 if (target_to_host_timespec(puts, arg3)) {
9609                     return -TARGET_EFAULT;
9610                 }
9611             } else {
9612                 puts = NULL;
9613             }
9614             ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
9615                                                  SIGSET_T_SIZE));
9616             if (!is_error(ret)) {
9617                 if (arg2) {
9618                     p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t),
9619                                   0);
9620                     if (!p) {
9621                         return -TARGET_EFAULT;
9622                     }
9623                     host_to_target_siginfo(p, &uinfo);
9624                     unlock_user(p, arg2, sizeof(target_siginfo_t));
9625                 }
9626                 ret = host_to_target_signal(ret);
9627             }
9628         }
9629         return ret;
9630 #endif
9631 #ifdef TARGET_NR_rt_sigtimedwait_time64
9632     case TARGET_NR_rt_sigtimedwait_time64:
9633         {
9634             sigset_t set;
9635             struct timespec uts, *puts;
9636             siginfo_t uinfo;
9637
9638             if (arg4 != sizeof(target_sigset_t)) {
9639                 return -TARGET_EINVAL;
9640             }
9641
9642             p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1);
9643             if (!p) {
9644                 return -TARGET_EFAULT;
9645             }
9646             target_to_host_sigset(&set, p);
9647             unlock_user(p, arg1, 0);
9648             if (arg3) {
9649                 puts = &uts;
9650                 if (target_to_host_timespec64(puts, arg3)) {
9651                     return -TARGET_EFAULT;
9652                 }
9653             } else {
9654                 puts = NULL;
9655             }
9656             ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
9657                                                  SIGSET_T_SIZE));
9658             if (!is_error(ret)) {
9659                 if (arg2) {
9660                     p = lock_user(VERIFY_WRITE, arg2,
9661                                   sizeof(target_siginfo_t), 0);
9662                     if (!p) {
9663                         return -TARGET_EFAULT;
9664                     }
9665                     host_to_target_siginfo(p, &uinfo);
9666                     unlock_user(p, arg2, sizeof(target_siginfo_t));
9667                 }
9668                 ret = host_to_target_signal(ret);
9669             }
9670         }
9671         return ret;
9672 #endif
9673     case TARGET_NR_rt_sigqueueinfo:
9674         {
9675             siginfo_t uinfo;
9676
9677             p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
9678             if (!p) {
9679                 return -TARGET_EFAULT;
9680             }
9681             target_to_host_siginfo(&uinfo, p);
9682             unlock_user(p, arg3, 0);
9683             ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
9684         }
9685         return ret;
9686     case TARGET_NR_rt_tgsigqueueinfo:
9687         {
9688             siginfo_t uinfo;
9689
9690             p = lock_user(VERIFY_READ, arg4, sizeof(target_siginfo_t), 1);
9691             if (!p) {
9692                 return -TARGET_EFAULT;
9693             }
9694             target_to_host_siginfo(&uinfo, p);
9695             unlock_user(p, arg4, 0);
9696             ret = get_errno(sys_rt_tgsigqueueinfo(arg1, arg2, arg3, &uinfo));
9697         }
9698         return ret;
9699 #ifdef TARGET_NR_sigreturn
9700     case TARGET_NR_sigreturn:
9701         if (block_signals()) {
9702             return -QEMU_ERESTARTSYS;
9703         }
9704         return do_sigreturn(cpu_env);
9705 #endif
9706     case TARGET_NR_rt_sigreturn:
9707         if (block_signals()) {
9708             return -QEMU_ERESTARTSYS;
9709         }
9710         return do_rt_sigreturn(cpu_env);
9711     case TARGET_NR_sethostname:
9712         if (!(p = lock_user_string(arg1)))
9713             return -TARGET_EFAULT;
9714         ret = get_errno(sethostname(p, arg2));
9715         unlock_user(p, arg1, 0);
9716         return ret;
9717 #ifdef TARGET_NR_setrlimit
9718     case TARGET_NR_setrlimit:
9719         {
9720             int resource = target_to_host_resource(arg1);
9721             struct target_rlimit *target_rlim;
9722             struct rlimit rlim;
9723             if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
9724                 return -TARGET_EFAULT;
9725             rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
9726             rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
9727             unlock_user_struct(target_rlim, arg2, 0);
9728             /*
9729              * If we just passed through resource limit settings for memory then
9730              * they would also apply to QEMU's own allocations, and QEMU will
9731              * crash or hang or die if its allocations fail. Ideally we would
9732              * track the guest allocations in QEMU and apply the limits ourselves.
9733              * For now, just tell the guest the call succeeded but don't actually
9734              * limit anything.
9735              */
9736             if (resource != RLIMIT_AS &&
9737                 resource != RLIMIT_DATA &&
9738                 resource != RLIMIT_STACK) {
9739                 return get_errno(setrlimit(resource, &rlim));
9740             } else {
9741                 return 0;
9742             }
9743         }
9744 #endif
9745 #ifdef TARGET_NR_getrlimit
9746     case TARGET_NR_getrlimit:
9747         {
9748             int resource = target_to_host_resource(arg1);
9749             struct target_rlimit *target_rlim;
9750             struct rlimit rlim;
9751
9752             ret = get_errno(getrlimit(resource, &rlim));
9753             if (!is_error(ret)) {
9754                 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
9755                     return -TARGET_EFAULT;
9756                 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
9757                 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
9758                 unlock_user_struct(target_rlim, arg2, 1);
9759             }
9760         }
9761         return ret;
9762 #endif
9763     case TARGET_NR_getrusage:
9764         {
9765             struct rusage rusage;
9766             ret = get_errno(getrusage(arg1, &rusage));
9767             if (!is_error(ret)) {
9768                 ret = host_to_target_rusage(arg2, &rusage);
9769             }
9770         }
9771         return ret;
9772 #if defined(TARGET_NR_gettimeofday)
9773     case TARGET_NR_gettimeofday:
9774         {
9775             struct timeval tv;
9776             struct timezone tz;
9777
9778             ret = get_errno(gettimeofday(&tv, &tz));
9779             if (!is_error(ret)) {
9780                 if (arg1 && copy_to_user_timeval(arg1, &tv)) {
9781                     return -TARGET_EFAULT;
9782                 }
9783                 if (arg2 && copy_to_user_timezone(arg2, &tz)) {
9784                     return -TARGET_EFAULT;
9785                 }
9786             }
9787         }
9788         return ret;
9789 #endif
9790 #if defined(TARGET_NR_settimeofday)
9791     case TARGET_NR_settimeofday:
9792         {
9793             struct timeval tv, *ptv = NULL;
9794             struct timezone tz, *ptz = NULL;
9795
9796             if (arg1) {
9797                 if (copy_from_user_timeval(&tv, arg1)) {
9798                     return -TARGET_EFAULT;
9799                 }
9800                 ptv = &tv;
9801             }
9802
9803             if (arg2) {
9804                 if (copy_from_user_timezone(&tz, arg2)) {
9805                     return -TARGET_EFAULT;
9806                 }
9807                 ptz = &tz;
9808             }
9809
9810             return get_errno(settimeofday(ptv, ptz));
9811         }
9812 #endif
9813 #if defined(TARGET_NR_select)
9814     case TARGET_NR_select:
9815 #if defined(TARGET_WANT_NI_OLD_SELECT)
9816         /* some architectures used to have old_select here
9817          * but now ENOSYS it.
9818          */
9819         ret = -TARGET_ENOSYS;
9820 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
9821         ret = do_old_select(arg1);
9822 #else
9823         ret = do_select(arg1, arg2, arg3, arg4, arg5);
9824 #endif
9825         return ret;
9826 #endif
9827 #ifdef TARGET_NR_pselect6
9828     case TARGET_NR_pselect6:
9829         return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
9830 #endif
9831 #ifdef TARGET_NR_pselect6_time64
9832     case TARGET_NR_pselect6_time64:
9833         return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
9834 #endif
9835 #ifdef TARGET_NR_symlink
9836     case TARGET_NR_symlink:
9837         {
9838             void *p2;
9839             p = lock_user_string(arg1);
9840             p2 = lock_user_string(arg2);
9841             if (!p || !p2)
9842                 ret = -TARGET_EFAULT;
9843             else
9844                 ret = get_errno(symlink(p, p2));
9845             unlock_user(p2, arg2, 0);
9846             unlock_user(p, arg1, 0);
9847         }
9848         return ret;
9849 #endif
9850 #if defined(TARGET_NR_symlinkat)
9851     case TARGET_NR_symlinkat:
9852         {
9853             void *p2;
9854             p  = lock_user_string(arg1);
9855             p2 = lock_user_string(arg3);
9856             if (!p || !p2)
9857                 ret = -TARGET_EFAULT;
9858             else
9859                 ret = get_errno(symlinkat(p, arg2, p2));
9860             unlock_user(p2, arg3, 0);
9861             unlock_user(p, arg1, 0);
9862         }
9863         return ret;
9864 #endif
9865 #ifdef TARGET_NR_readlink
9866     case TARGET_NR_readlink:
9867         {
9868             void *p2;
9869             p = lock_user_string(arg1);
9870             p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
9871             if (!p || !p2) {
9872                 ret = -TARGET_EFAULT;
9873             } else if (!arg3) {
9874                 /* Short circuit this for the magic exe check. */
9875                 ret = -TARGET_EINVAL;
9876             } else if (is_proc_myself((const char *)p, "exe")) {
9877                 char real[PATH_MAX], *temp;
9878                 temp = realpath(exec_path, real);
9879                 /* Return value is # of bytes that we wrote to the buffer. */
9880                 if (temp == NULL) {
9881                     ret = get_errno(-1);
9882                 } else {
9883                     /* Don't worry about sign mismatch as earlier mapping
9884                      * logic would have thrown a bad address error. */
9885                     ret = MIN(strlen(real), arg3);
9886                     /* We cannot NUL terminate the string. */
9887                     memcpy(p2, real, ret);
9888                 }
9889             } else {
9890                 ret = get_errno(readlink(path(p), p2, arg3));
9891             }
9892             unlock_user(p2, arg2, ret);
9893             unlock_user(p, arg1, 0);
9894         }
9895         return ret;
9896 #endif
9897 #if defined(TARGET_NR_readlinkat)
9898     case TARGET_NR_readlinkat:
9899         {
9900             void *p2;
9901             p  = lock_user_string(arg2);
9902             p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
9903             if (!p || !p2) {
9904                 ret = -TARGET_EFAULT;
9905             } else if (is_proc_myself((const char *)p, "exe")) {
9906                 char real[PATH_MAX], *temp;
9907                 temp = realpath(exec_path, real);
9908                 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
9909                 snprintf((char *)p2, arg4, "%s", real);
9910             } else {
9911                 ret = get_errno(readlinkat(arg1, path(p), p2, arg4));
9912             }
9913             unlock_user(p2, arg3, ret);
9914             unlock_user(p, arg2, 0);
9915         }
9916         return ret;
9917 #endif
9918 #ifdef TARGET_NR_swapon
9919     case TARGET_NR_swapon:
9920         if (!(p = lock_user_string(arg1)))
9921             return -TARGET_EFAULT;
9922         ret = get_errno(swapon(p, arg2));
9923         unlock_user(p, arg1, 0);
9924         return ret;
9925 #endif
9926     case TARGET_NR_reboot:
9927         if (arg3 == LINUX_REBOOT_CMD_RESTART2) {
9928            /* arg4 must be ignored in all other cases */
9929            p = lock_user_string(arg4);
9930            if (!p) {
9931                return -TARGET_EFAULT;
9932            }
9933            ret = get_errno(reboot(arg1, arg2, arg3, p));
9934            unlock_user(p, arg4, 0);
9935         } else {
9936            ret = get_errno(reboot(arg1, arg2, arg3, NULL));
9937         }
9938         return ret;
9939 #ifdef TARGET_NR_mmap
9940     case TARGET_NR_mmap:
9941 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
9942     (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
9943     defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
9944     || defined(TARGET_S390X)
9945         {
9946             abi_ulong *v;
9947             abi_ulong v1, v2, v3, v4, v5, v6;
9948             if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
9949                 return -TARGET_EFAULT;
9950             v1 = tswapal(v[0]);
9951             v2 = tswapal(v[1]);
9952             v3 = tswapal(v[2]);
9953             v4 = tswapal(v[3]);
9954             v5 = tswapal(v[4]);
9955             v6 = tswapal(v[5]);
9956             unlock_user(v, arg1, 0);
9957             ret = get_errno(target_mmap(v1, v2, v3,
9958                                         target_to_host_bitmask(v4, mmap_flags_tbl),
9959                                         v5, v6));
9960         }
9961 #else
9962         /* mmap pointers are always untagged */
9963         ret = get_errno(target_mmap(arg1, arg2, arg3,
9964                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
9965                                     arg5,
9966                                     arg6));
9967 #endif
9968         return ret;
9969 #endif
9970 #ifdef TARGET_NR_mmap2
9971     case TARGET_NR_mmap2:
9972 #ifndef MMAP_SHIFT
9973 #define MMAP_SHIFT 12
9974 #endif
9975         ret = target_mmap(arg1, arg2, arg3,
9976                           target_to_host_bitmask(arg4, mmap_flags_tbl),
9977                           arg5, arg6 << MMAP_SHIFT);
9978         return get_errno(ret);
9979 #endif
9980     case TARGET_NR_munmap:
9981         arg1 = cpu_untagged_addr(cpu, arg1);
9982         return get_errno(target_munmap(arg1, arg2));
9983     case TARGET_NR_mprotect:
9984         arg1 = cpu_untagged_addr(cpu, arg1);
9985         {
9986             TaskState *ts = cpu->opaque;
9987             /* Special hack to detect libc making the stack executable.  */
9988             if ((arg3 & PROT_GROWSDOWN)
9989                 && arg1 >= ts->info->stack_limit
9990                 && arg1 <= ts->info->start_stack) {
9991                 arg3 &= ~PROT_GROWSDOWN;
9992                 arg2 = arg2 + arg1 - ts->info->stack_limit;
9993                 arg1 = ts->info->stack_limit;
9994             }
9995         }
9996         return get_errno(target_mprotect(arg1, arg2, arg3));
9997 #ifdef TARGET_NR_mremap
9998     case TARGET_NR_mremap:
9999         arg1 = cpu_untagged_addr(cpu, arg1);
10000         /* mremap new_addr (arg5) is always untagged */
10001         return get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
10002 #endif
10003         /* ??? msync/mlock/munlock are broken for softmmu.  */
10004 #ifdef TARGET_NR_msync
10005     case TARGET_NR_msync:
10006         return get_errno(msync(g2h(cpu, arg1), arg2, arg3));
10007 #endif
10008 #ifdef TARGET_NR_mlock
10009     case TARGET_NR_mlock:
10010         return get_errno(mlock(g2h(cpu, arg1), arg2));
10011 #endif
10012 #ifdef TARGET_NR_munlock
10013     case TARGET_NR_munlock:
10014         return get_errno(munlock(g2h(cpu, arg1), arg2));
10015 #endif
10016 #ifdef TARGET_NR_mlockall
10017     case TARGET_NR_mlockall:
10018         return get_errno(mlockall(target_to_host_mlockall_arg(arg1)));
10019 #endif
10020 #ifdef TARGET_NR_munlockall
10021     case TARGET_NR_munlockall:
10022         return get_errno(munlockall());
10023 #endif
10024 #ifdef TARGET_NR_truncate
10025     case TARGET_NR_truncate:
10026         if (!(p = lock_user_string(arg1)))
10027             return -TARGET_EFAULT;
10028         ret = get_errno(truncate(p, arg2));
10029         unlock_user(p, arg1, 0);
10030         return ret;
10031 #endif
10032 #ifdef TARGET_NR_ftruncate
10033     case TARGET_NR_ftruncate:
10034         return get_errno(ftruncate(arg1, arg2));
10035 #endif
10036     case TARGET_NR_fchmod:
10037         return get_errno(fchmod(arg1, arg2));
10038 #if defined(TARGET_NR_fchmodat)
10039     case TARGET_NR_fchmodat:
10040         if (!(p = lock_user_string(arg2)))
10041             return -TARGET_EFAULT;
10042         ret = get_errno(fchmodat(arg1, p, arg3, 0));
10043         unlock_user(p, arg2, 0);
10044         return ret;
10045 #endif
10046     case TARGET_NR_getpriority:
10047         /* Note that negative values are valid for getpriority, so we must
10048            differentiate based on errno settings.  */
10049         errno = 0;
10050         ret = getpriority(arg1, arg2);
10051         if (ret == -1 && errno != 0) {
10052             return -host_to_target_errno(errno);
10053         }
10054 #ifdef TARGET_ALPHA
10055         /* Return value is the unbiased priority.  Signal no error.  */
10056         ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0;
10057 #else
10058         /* Return value is a biased priority to avoid negative numbers.  */
10059         ret = 20 - ret;
10060 #endif
10061         return ret;
10062     case TARGET_NR_setpriority:
10063         return get_errno(setpriority(arg1, arg2, arg3));
10064 #ifdef TARGET_NR_statfs
10065     case TARGET_NR_statfs:
10066         if (!(p = lock_user_string(arg1))) {
10067             return -TARGET_EFAULT;
10068         }
10069         ret = get_errno(statfs(path(p), &stfs));
10070         unlock_user(p, arg1, 0);
10071     convert_statfs:
10072         if (!is_error(ret)) {
10073             struct target_statfs *target_stfs;
10074
10075             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
10076                 return -TARGET_EFAULT;
10077             __put_user(stfs.f_type, &target_stfs->f_type);
10078             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
10079             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
10080             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
10081             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
10082             __put_user(stfs.f_files, &target_stfs->f_files);
10083             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
10084             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
10085             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
10086             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
10087             __put_user(stfs.f_frsize, &target_stfs->f_frsize);
10088 #ifdef _STATFS_F_FLAGS
10089             __put_user(stfs.f_flags, &target_stfs->f_flags);
10090 #else
10091             __put_user(0, &target_stfs->f_flags);
10092 #endif
10093             memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
10094             unlock_user_struct(target_stfs, arg2, 1);
10095         }
10096         return ret;
10097 #endif
10098 #ifdef TARGET_NR_fstatfs
10099     case TARGET_NR_fstatfs:
10100         ret = get_errno(fstatfs(arg1, &stfs));
10101         goto convert_statfs;
10102 #endif
10103 #ifdef TARGET_NR_statfs64
10104     case TARGET_NR_statfs64:
10105         if (!(p = lock_user_string(arg1))) {
10106             return -TARGET_EFAULT;
10107         }
10108         ret = get_errno(statfs(path(p), &stfs));
10109         unlock_user(p, arg1, 0);
10110     convert_statfs64:
10111         if (!is_error(ret)) {
10112             struct target_statfs64 *target_stfs;
10113
10114             if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
10115                 return -TARGET_EFAULT;
10116             __put_user(stfs.f_type, &target_stfs->f_type);
10117             __put_user(stfs.f_bsize, &target_stfs->f_bsize);
10118             __put_user(stfs.f_blocks, &target_stfs->f_blocks);
10119             __put_user(stfs.f_bfree, &target_stfs->f_bfree);
10120             __put_user(stfs.f_bavail, &target_stfs->f_bavail);
10121             __put_user(stfs.f_files, &target_stfs->f_files);
10122             __put_user(stfs.f_ffree, &target_stfs->f_ffree);
10123             __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
10124             __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
10125             __put_user(stfs.f_namelen, &target_stfs->f_namelen);
10126             __put_user(stfs.f_frsize, &target_stfs->f_frsize);
10127 #ifdef _STATFS_F_FLAGS
10128             __put_user(stfs.f_flags, &target_stfs->f_flags);
10129 #else
10130             __put_user(0, &target_stfs->f_flags);
10131 #endif
10132             memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
10133             unlock_user_struct(target_stfs, arg3, 1);
10134         }
10135         return ret;
10136     case TARGET_NR_fstatfs64:
10137         ret = get_errno(fstatfs(arg1, &stfs));
10138         goto convert_statfs64;
10139 #endif
10140 #ifdef TARGET_NR_socketcall
10141     case TARGET_NR_socketcall:
10142         return do_socketcall(arg1, arg2);
10143 #endif
10144 #ifdef TARGET_NR_accept
10145     case TARGET_NR_accept:
10146         return do_accept4(arg1, arg2, arg3, 0);
10147 #endif
10148 #ifdef TARGET_NR_accept4
10149     case TARGET_NR_accept4:
10150         return do_accept4(arg1, arg2, arg3, arg4);
10151 #endif
10152 #ifdef TARGET_NR_bind
10153     case TARGET_NR_bind:
10154         return do_bind(arg1, arg2, arg3);
10155 #endif
10156 #ifdef TARGET_NR_connect
10157     case TARGET_NR_connect:
10158         return do_connect(arg1, arg2, arg3);
10159 #endif
10160 #ifdef TARGET_NR_getpeername
10161     case TARGET_NR_getpeername:
10162         return do_getpeername(arg1, arg2, arg3);
10163 #endif
10164 #ifdef TARGET_NR_getsockname
10165     case TARGET_NR_getsockname:
10166         return do_getsockname(arg1, arg2, arg3);
10167 #endif
10168 #ifdef TARGET_NR_getsockopt
10169     case TARGET_NR_getsockopt:
10170         return do_getsockopt(arg1, arg2, arg3, arg4, arg5);
10171 #endif
10172 #ifdef TARGET_NR_listen
10173     case TARGET_NR_listen:
10174         return get_errno(listen(arg1, arg2));
10175 #endif
10176 #ifdef TARGET_NR_recv
10177     case TARGET_NR_recv:
10178         return do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
10179 #endif
10180 #ifdef TARGET_NR_recvfrom
10181     case TARGET_NR_recvfrom:
10182         return do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
10183 #endif
10184 #ifdef TARGET_NR_recvmsg
10185     case TARGET_NR_recvmsg:
10186         return do_sendrecvmsg(arg1, arg2, arg3, 0);
10187 #endif
10188 #ifdef TARGET_NR_send
10189     case TARGET_NR_send:
10190         return do_sendto(arg1, arg2, arg3, arg4, 0, 0);
10191 #endif
10192 #ifdef TARGET_NR_sendmsg
10193     case TARGET_NR_sendmsg:
10194         return do_sendrecvmsg(arg1, arg2, arg3, 1);
10195 #endif
10196 #ifdef TARGET_NR_sendmmsg
10197     case TARGET_NR_sendmmsg:
10198         return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1);
10199 #endif
10200 #ifdef TARGET_NR_recvmmsg
10201     case TARGET_NR_recvmmsg:
10202         return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0);
10203 #endif
10204 #ifdef TARGET_NR_sendto
10205     case TARGET_NR_sendto:
10206         return do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
10207 #endif
10208 #ifdef TARGET_NR_shutdown
10209     case TARGET_NR_shutdown:
10210         return get_errno(shutdown(arg1, arg2));
10211 #endif
10212 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
10213     case TARGET_NR_getrandom:
10214         p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
10215         if (!p) {
10216             return -TARGET_EFAULT;
10217         }
10218         ret = get_errno(getrandom(p, arg2, arg3));
10219         unlock_user(p, arg1, ret);
10220         return ret;
10221 #endif
10222 #ifdef TARGET_NR_socket
10223     case TARGET_NR_socket:
10224         return do_socket(arg1, arg2, arg3);
10225 #endif
10226 #ifdef TARGET_NR_socketpair
10227     case TARGET_NR_socketpair:
10228         return do_socketpair(arg1, arg2, arg3, arg4);
10229 #endif
10230 #ifdef TARGET_NR_setsockopt
10231     case TARGET_NR_setsockopt:
10232         return do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
10233 #endif
10234 #if defined(TARGET_NR_syslog)
10235     case TARGET_NR_syslog:
10236         {
10237             int len = arg2;
10238
10239             switch (arg1) {
10240             case TARGET_SYSLOG_ACTION_CLOSE:         /* Close log */
10241             case TARGET_SYSLOG_ACTION_OPEN:          /* Open log */
10242             case TARGET_SYSLOG_ACTION_CLEAR:         /* Clear ring buffer */
10243             case TARGET_SYSLOG_ACTION_CONSOLE_OFF:   /* Disable logging */
10244             case TARGET_SYSLOG_ACTION_CONSOLE_ON:    /* Enable logging */
10245             case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */
10246             case TARGET_SYSLOG_ACTION_SIZE_UNREAD:   /* Number of chars */
10247             case TARGET_SYSLOG_ACTION_SIZE_BUFFER:   /* Size of the buffer */
10248                 return get_errno(sys_syslog((int)arg1, NULL, (int)arg3));
10249             case TARGET_SYSLOG_ACTION_READ:          /* Read from log */
10250             case TARGET_SYSLOG_ACTION_READ_CLEAR:    /* Read/clear msgs */
10251             case TARGET_SYSLOG_ACTION_READ_ALL:      /* Read last messages */
10252                 {
10253                     if (len < 0) {
10254                         return -TARGET_EINVAL;
10255                     }
10256                     if (len == 0) {
10257                         return 0;
10258                     }
10259                     p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10260                     if (!p) {
10261                         return -TARGET_EFAULT;
10262                     }
10263                     ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
10264                     unlock_user(p, arg2, arg3);
10265                 }
10266                 return ret;
10267             default:
10268                 return -TARGET_EINVAL;
10269             }
10270         }
10271         break;
10272 #endif
10273     case TARGET_NR_setitimer:
10274         {
10275             struct itimerval value, ovalue, *pvalue;
10276
10277             if (arg2) {
10278                 pvalue = &value;
10279                 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
10280                     || copy_from_user_timeval(&pvalue->it_value,
10281                                               arg2 + sizeof(struct target_timeval)))
10282                     return -TARGET_EFAULT;
10283             } else {
10284                 pvalue = NULL;
10285             }
10286             ret = get_errno(setitimer(arg1, pvalue, &ovalue));
10287             if (!is_error(ret) && arg3) {
10288                 if (copy_to_user_timeval(arg3,
10289                                          &ovalue.it_interval)
10290                     || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
10291                                             &ovalue.it_value))
10292                     return -TARGET_EFAULT;
10293             }
10294         }
10295         return ret;
10296     case TARGET_NR_getitimer:
10297         {
10298             struct itimerval value;
10299
10300             ret = get_errno(getitimer(arg1, &value));
10301             if (!is_error(ret) && arg2) {
10302                 if (copy_to_user_timeval(arg2,
10303                                          &value.it_interval)
10304                     || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
10305                                             &value.it_value))
10306                     return -TARGET_EFAULT;
10307             }
10308         }
10309         return ret;
10310 #ifdef TARGET_NR_stat
10311     case TARGET_NR_stat:
10312         if (!(p = lock_user_string(arg1))) {
10313             return -TARGET_EFAULT;
10314         }
10315         ret = get_errno(stat(path(p), &st));
10316         unlock_user(p, arg1, 0);
10317         goto do_stat;
10318 #endif
10319 #ifdef TARGET_NR_lstat
10320     case TARGET_NR_lstat:
10321         if (!(p = lock_user_string(arg1))) {
10322             return -TARGET_EFAULT;
10323         }
10324         ret = get_errno(lstat(path(p), &st));
10325         unlock_user(p, arg1, 0);
10326         goto do_stat;
10327 #endif
10328 #ifdef TARGET_NR_fstat
10329     case TARGET_NR_fstat:
10330         {
10331             ret = get_errno(fstat(arg1, &st));
10332 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
10333         do_stat:
10334 #endif
10335             if (!is_error(ret)) {
10336                 struct target_stat *target_st;
10337
10338                 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
10339                     return -TARGET_EFAULT;
10340                 memset(target_st, 0, sizeof(*target_st));
10341                 __put_user(st.st_dev, &target_st->st_dev);
10342                 __put_user(st.st_ino, &target_st->st_ino);
10343                 __put_user(st.st_mode, &target_st->st_mode);
10344                 __put_user(st.st_uid, &target_st->st_uid);
10345                 __put_user(st.st_gid, &target_st->st_gid);
10346                 __put_user(st.st_nlink, &target_st->st_nlink);
10347                 __put_user(st.st_rdev, &target_st->st_rdev);
10348                 __put_user(st.st_size, &target_st->st_size);
10349                 __put_user(st.st_blksize, &target_st->st_blksize);
10350                 __put_user(st.st_blocks, &target_st->st_blocks);
10351                 __put_user(st.st_atime, &target_st->target_st_atime);
10352                 __put_user(st.st_mtime, &target_st->target_st_mtime);
10353                 __put_user(st.st_ctime, &target_st->target_st_ctime);
10354 #if defined(HAVE_STRUCT_STAT_ST_ATIM) && defined(TARGET_STAT_HAVE_NSEC)
10355                 __put_user(st.st_atim.tv_nsec,
10356                            &target_st->target_st_atime_nsec);
10357                 __put_user(st.st_mtim.tv_nsec,
10358                            &target_st->target_st_mtime_nsec);
10359                 __put_user(st.st_ctim.tv_nsec,
10360                            &target_st->target_st_ctime_nsec);
10361 #endif
10362                 unlock_user_struct(target_st, arg2, 1);
10363             }
10364         }
10365         return ret;
10366 #endif
10367     case TARGET_NR_vhangup:
10368         return get_errno(vhangup());
10369 #ifdef TARGET_NR_syscall
10370     case TARGET_NR_syscall:
10371         return do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5,
10372                           arg6, arg7, arg8, 0);
10373 #endif
10374 #if defined(TARGET_NR_wait4)
10375     case TARGET_NR_wait4:
10376         {
10377             int status;
10378             abi_long status_ptr = arg2;
10379             struct rusage rusage, *rusage_ptr;
10380             abi_ulong target_rusage = arg4;
10381             abi_long rusage_err;
10382             if (target_rusage)
10383                 rusage_ptr = &rusage;
10384             else
10385                 rusage_ptr = NULL;
10386             ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr));
10387             if (!is_error(ret)) {
10388                 if (status_ptr && ret) {
10389                     status = host_to_target_waitstatus(status);
10390                     if (put_user_s32(status, status_ptr))
10391                         return -TARGET_EFAULT;
10392                 }
10393                 if (target_rusage) {
10394                     rusage_err = host_to_target_rusage(target_rusage, &rusage);
10395                     if (rusage_err) {
10396                         ret = rusage_err;
10397                     }
10398                 }
10399             }
10400         }
10401         return ret;
10402 #endif
10403 #ifdef TARGET_NR_swapoff
10404     case TARGET_NR_swapoff:
10405         if (!(p = lock_user_string(arg1)))
10406             return -TARGET_EFAULT;
10407         ret = get_errno(swapoff(p));
10408         unlock_user(p, arg1, 0);
10409         return ret;
10410 #endif
10411     case TARGET_NR_sysinfo:
10412         {
10413             struct target_sysinfo *target_value;
10414             struct sysinfo value;
10415             ret = get_errno(sysinfo(&value));
10416             if (!is_error(ret) && arg1)
10417             {
10418                 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
10419                     return -TARGET_EFAULT;
10420                 __put_user(value.uptime, &target_value->uptime);
10421                 __put_user(value.loads[0], &target_value->loads[0]);
10422                 __put_user(value.loads[1], &target_value->loads[1]);
10423                 __put_user(value.loads[2], &target_value->loads[2]);
10424                 __put_user(value.totalram, &target_value->totalram);
10425                 __put_user(value.freeram, &target_value->freeram);
10426                 __put_user(value.sharedram, &target_value->sharedram);
10427                 __put_user(value.bufferram, &target_value->bufferram);
10428                 __put_user(value.totalswap, &target_value->totalswap);
10429                 __put_user(value.freeswap, &target_value->freeswap);
10430                 __put_user(value.procs, &target_value->procs);
10431                 __put_user(value.totalhigh, &target_value->totalhigh);
10432                 __put_user(value.freehigh, &target_value->freehigh);
10433                 __put_user(value.mem_unit, &target_value->mem_unit);
10434                 unlock_user_struct(target_value, arg1, 1);
10435             }
10436         }
10437         return ret;
10438 #ifdef TARGET_NR_ipc
10439     case TARGET_NR_ipc:
10440         return do_ipc(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
10441 #endif
10442 #ifdef TARGET_NR_semget
10443     case TARGET_NR_semget:
10444         return get_errno(semget(arg1, arg2, arg3));
10445 #endif
10446 #ifdef TARGET_NR_semop
10447     case TARGET_NR_semop:
10448         return do_semtimedop(arg1, arg2, arg3, 0, false);
10449 #endif
10450 #ifdef TARGET_NR_semtimedop
10451     case TARGET_NR_semtimedop:
10452         return do_semtimedop(arg1, arg2, arg3, arg4, false);
10453 #endif
10454 #ifdef TARGET_NR_semtimedop_time64
10455     case TARGET_NR_semtimedop_time64:
10456         return do_semtimedop(arg1, arg2, arg3, arg4, true);
10457 #endif
10458 #ifdef TARGET_NR_semctl
10459     case TARGET_NR_semctl:
10460         return do_semctl(arg1, arg2, arg3, arg4);
10461 #endif
10462 #ifdef TARGET_NR_msgctl
10463     case TARGET_NR_msgctl:
10464         return do_msgctl(arg1, arg2, arg3);
10465 #endif
10466 #ifdef TARGET_NR_msgget
10467     case TARGET_NR_msgget:
10468         return get_errno(msgget(arg1, arg2));
10469 #endif
10470 #ifdef TARGET_NR_msgrcv
10471     case TARGET_NR_msgrcv:
10472         return do_msgrcv(arg1, arg2, arg3, arg4, arg5);
10473 #endif
10474 #ifdef TARGET_NR_msgsnd
10475     case TARGET_NR_msgsnd:
10476         return do_msgsnd(arg1, arg2, arg3, arg4);
10477 #endif
10478 #ifdef TARGET_NR_shmget
10479     case TARGET_NR_shmget:
10480         return get_errno(shmget(arg1, arg2, arg3));
10481 #endif
10482 #ifdef TARGET_NR_shmctl
10483     case TARGET_NR_shmctl:
10484         return do_shmctl(arg1, arg2, arg3);
10485 #endif
10486 #ifdef TARGET_NR_shmat
10487     case TARGET_NR_shmat:
10488         return do_shmat(cpu_env, arg1, arg2, arg3);
10489 #endif
10490 #ifdef TARGET_NR_shmdt
10491     case TARGET_NR_shmdt:
10492         return do_shmdt(arg1);
10493 #endif
10494     case TARGET_NR_fsync:
10495         return get_errno(fsync(arg1));
10496     case TARGET_NR_clone:
10497         /* Linux manages to have three different orderings for its
10498          * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
10499          * match the kernel's CONFIG_CLONE_* settings.
10500          * Microblaze is further special in that it uses a sixth
10501          * implicit argument to clone for the TLS pointer.
10502          */
10503 #if defined(TARGET_MICROBLAZE)
10504         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5));
10505 #elif defined(TARGET_CLONE_BACKWARDS)
10506         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
10507 #elif defined(TARGET_CLONE_BACKWARDS2)
10508         ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
10509 #else
10510         ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
10511 #endif
10512         return ret;
10513 #ifdef __NR_exit_group
10514         /* new thread calls */
10515     case TARGET_NR_exit_group:
10516         preexit_cleanup(cpu_env, arg1);
10517         return get_errno(exit_group(arg1));
10518 #endif
10519     case TARGET_NR_setdomainname:
10520         if (!(p = lock_user_string(arg1)))
10521             return -TARGET_EFAULT;
10522         ret = get_errno(setdomainname(p, arg2));
10523         unlock_user(p, arg1, 0);
10524         return ret;
10525     case TARGET_NR_uname:
10526         /* no need to transcode because we use the linux syscall */
10527         {
10528             struct new_utsname * buf;
10529
10530             if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
10531                 return -TARGET_EFAULT;
10532             ret = get_errno(sys_uname(buf));
10533             if (!is_error(ret)) {
10534                 /* Overwrite the native machine name with whatever is being
10535                    emulated. */
10536                 g_strlcpy(buf->machine, cpu_to_uname_machine(cpu_env),
10537                           sizeof(buf->machine));
10538                 /* Allow the user to override the reported release.  */
10539                 if (qemu_uname_release && *qemu_uname_release) {
10540                     g_strlcpy(buf->release, qemu_uname_release,
10541                               sizeof(buf->release));
10542                 }
10543             }
10544             unlock_user_struct(buf, arg1, 1);
10545         }
10546         return ret;
10547 #ifdef TARGET_I386
10548     case TARGET_NR_modify_ldt:
10549         return do_modify_ldt(cpu_env, arg1, arg2, arg3);
10550 #if !defined(TARGET_X86_64)
10551     case TARGET_NR_vm86:
10552         return do_vm86(cpu_env, arg1, arg2);
10553 #endif
10554 #endif
10555 #if defined(TARGET_NR_adjtimex)
10556     case TARGET_NR_adjtimex:
10557         {
10558             struct timex host_buf;
10559
10560             if (target_to_host_timex(&host_buf, arg1) != 0) {
10561                 return -TARGET_EFAULT;
10562             }
10563             ret = get_errno(adjtimex(&host_buf));
10564             if (!is_error(ret)) {
10565                 if (host_to_target_timex(arg1, &host_buf) != 0) {
10566                     return -TARGET_EFAULT;
10567                 }
10568             }
10569         }
10570         return ret;
10571 #endif
10572 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
10573     case TARGET_NR_clock_adjtime:
10574         {
10575             struct timex htx, *phtx = &htx;
10576
10577             if (target_to_host_timex(phtx, arg2) != 0) {
10578                 return -TARGET_EFAULT;
10579             }
10580             ret = get_errno(clock_adjtime(arg1, phtx));
10581             if (!is_error(ret) && phtx) {
10582                 if (host_to_target_timex(arg2, phtx) != 0) {
10583                     return -TARGET_EFAULT;
10584                 }
10585             }
10586         }
10587         return ret;
10588 #endif
10589 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
10590     case TARGET_NR_clock_adjtime64:
10591         {
10592             struct timex htx;
10593
10594             if (target_to_host_timex64(&htx, arg2) != 0) {
10595                 return -TARGET_EFAULT;
10596             }
10597             ret = get_errno(clock_adjtime(arg1, &htx));
10598             if (!is_error(ret) && host_to_target_timex64(arg2, &htx)) {
10599                     return -TARGET_EFAULT;
10600             }
10601         }
10602         return ret;
10603 #endif
10604     case TARGET_NR_getpgid:
10605         return get_errno(getpgid(arg1));
10606     case TARGET_NR_fchdir:
10607         return get_errno(fchdir(arg1));
10608     case TARGET_NR_personality:
10609         return get_errno(personality(arg1));
10610 #ifdef TARGET_NR__llseek /* Not on alpha */
10611     case TARGET_NR__llseek:
10612         {
10613             int64_t res;
10614 #if !defined(__NR_llseek)
10615             res = lseek(arg1, ((uint64_t)arg2 << 32) | (abi_ulong)arg3, arg5);
10616             if (res == -1) {
10617                 ret = get_errno(res);
10618             } else {
10619                 ret = 0;
10620             }
10621 #else
10622             ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
10623 #endif
10624             if ((ret == 0) && put_user_s64(res, arg4)) {
10625                 return -TARGET_EFAULT;
10626             }
10627         }
10628         return ret;
10629 #endif
10630 #ifdef TARGET_NR_getdents
10631     case TARGET_NR_getdents:
10632         return do_getdents(arg1, arg2, arg3);
10633 #endif /* TARGET_NR_getdents */
10634 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
10635     case TARGET_NR_getdents64:
10636         return do_getdents64(arg1, arg2, arg3);
10637 #endif /* TARGET_NR_getdents64 */
10638 #if defined(TARGET_NR__newselect)
10639     case TARGET_NR__newselect:
10640         return do_select(arg1, arg2, arg3, arg4, arg5);
10641 #endif
10642 #ifdef TARGET_NR_poll
10643     case TARGET_NR_poll:
10644         return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
10645 #endif
10646 #ifdef TARGET_NR_ppoll
10647     case TARGET_NR_ppoll:
10648         return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
10649 #endif
10650 #ifdef TARGET_NR_ppoll_time64
10651     case TARGET_NR_ppoll_time64:
10652         return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
10653 #endif
10654     case TARGET_NR_flock:
10655         /* NOTE: the flock constant seems to be the same for every
10656            Linux platform */
10657         return get_errno(safe_flock(arg1, arg2));
10658     case TARGET_NR_readv:
10659         {
10660             struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10661             if (vec != NULL) {
10662                 ret = get_errno(safe_readv(arg1, vec, arg3));
10663                 unlock_iovec(vec, arg2, arg3, 1);
10664             } else {
10665                 ret = -host_to_target_errno(errno);
10666             }
10667         }
10668         return ret;
10669     case TARGET_NR_writev:
10670         {
10671             struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10672             if (vec != NULL) {
10673                 ret = get_errno(safe_writev(arg1, vec, arg3));
10674                 unlock_iovec(vec, arg2, arg3, 0);
10675             } else {
10676                 ret = -host_to_target_errno(errno);
10677             }
10678         }
10679         return ret;
10680 #if defined(TARGET_NR_preadv)
10681     case TARGET_NR_preadv:
10682         {
10683             struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10684             if (vec != NULL) {
10685                 unsigned long low, high;
10686
10687                 target_to_host_low_high(arg4, arg5, &low, &high);
10688                 ret = get_errno(safe_preadv(arg1, vec, arg3, low, high));
10689                 unlock_iovec(vec, arg2, arg3, 1);
10690             } else {
10691                 ret = -host_to_target_errno(errno);
10692            }
10693         }
10694         return ret;
10695 #endif
10696 #if defined(TARGET_NR_pwritev)
10697     case TARGET_NR_pwritev:
10698         {
10699             struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10700             if (vec != NULL) {
10701                 unsigned long low, high;
10702
10703                 target_to_host_low_high(arg4, arg5, &low, &high);
10704                 ret = get_errno(safe_pwritev(arg1, vec, arg3, low, high));
10705                 unlock_iovec(vec, arg2, arg3, 0);
10706             } else {
10707                 ret = -host_to_target_errno(errno);
10708            }
10709         }
10710         return ret;
10711 #endif
10712     case TARGET_NR_getsid:
10713         return get_errno(getsid(arg1));
10714 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
10715     case TARGET_NR_fdatasync:
10716         return get_errno(fdatasync(arg1));
10717 #endif
10718     case TARGET_NR_sched_getaffinity:
10719         {
10720             unsigned int mask_size;
10721             unsigned long *mask;
10722
10723             /*
10724              * sched_getaffinity needs multiples of ulong, so need to take
10725              * care of mismatches between target ulong and host ulong sizes.
10726              */
10727             if (arg2 & (sizeof(abi_ulong) - 1)) {
10728                 return -TARGET_EINVAL;
10729             }
10730             mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10731
10732             mask = alloca(mask_size);
10733             memset(mask, 0, mask_size);
10734             ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
10735
10736             if (!is_error(ret)) {
10737                 if (ret > arg2) {
10738                     /* More data returned than the caller's buffer will fit.
10739                      * This only happens if sizeof(abi_long) < sizeof(long)
10740                      * and the caller passed us a buffer holding an odd number
10741                      * of abi_longs. If the host kernel is actually using the
10742                      * extra 4 bytes then fail EINVAL; otherwise we can just
10743                      * ignore them and only copy the interesting part.
10744                      */
10745                     int numcpus = sysconf(_SC_NPROCESSORS_CONF);
10746                     if (numcpus > arg2 * 8) {
10747                         return -TARGET_EINVAL;
10748                     }
10749                     ret = arg2;
10750                 }
10751
10752                 if (host_to_target_cpu_mask(mask, mask_size, arg3, ret)) {
10753                     return -TARGET_EFAULT;
10754                 }
10755             }
10756         }
10757         return ret;
10758     case TARGET_NR_sched_setaffinity:
10759         {
10760             unsigned int mask_size;
10761             unsigned long *mask;
10762
10763             /*
10764              * sched_setaffinity needs multiples of ulong, so need to take
10765              * care of mismatches between target ulong and host ulong sizes.
10766              */
10767             if (arg2 & (sizeof(abi_ulong) - 1)) {
10768                 return -TARGET_EINVAL;
10769             }
10770             mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10771             mask = alloca(mask_size);
10772
10773             ret = target_to_host_cpu_mask(mask, mask_size, arg3, arg2);
10774             if (ret) {
10775                 return ret;
10776             }
10777
10778             return get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
10779         }
10780     case TARGET_NR_getcpu:
10781         {
10782             unsigned cpu, node;
10783             ret = get_errno(sys_getcpu(arg1 ? &cpu : NULL,
10784                                        arg2 ? &node : NULL,
10785                                        NULL));
10786             if (is_error(ret)) {
10787                 return ret;
10788             }
10789             if (arg1 && put_user_u32(cpu, arg1)) {
10790                 return -TARGET_EFAULT;
10791             }
10792             if (arg2 && put_user_u32(node, arg2)) {
10793                 return -TARGET_EFAULT;
10794             }
10795         }
10796         return ret;
10797     case TARGET_NR_sched_setparam:
10798         {
10799             struct target_sched_param *target_schp;
10800             struct sched_param schp;
10801
10802             if (arg2 == 0) {
10803                 return -TARGET_EINVAL;
10804             }
10805             if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) {
10806                 return -TARGET_EFAULT;
10807             }
10808             schp.sched_priority = tswap32(target_schp->sched_priority);
10809             unlock_user_struct(target_schp, arg2, 0);
10810             return get_errno(sys_sched_setparam(arg1, &schp));
10811         }
10812     case TARGET_NR_sched_getparam:
10813         {
10814             struct target_sched_param *target_schp;
10815             struct sched_param schp;
10816
10817             if (arg2 == 0) {
10818                 return -TARGET_EINVAL;
10819             }
10820             ret = get_errno(sys_sched_getparam(arg1, &schp));
10821             if (!is_error(ret)) {
10822                 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) {
10823                     return -TARGET_EFAULT;
10824                 }
10825                 target_schp->sched_priority = tswap32(schp.sched_priority);
10826                 unlock_user_struct(target_schp, arg2, 1);
10827             }
10828         }
10829         return ret;
10830     case TARGET_NR_sched_setscheduler:
10831         {
10832             struct target_sched_param *target_schp;
10833             struct sched_param schp;
10834             if (arg3 == 0) {
10835                 return -TARGET_EINVAL;
10836             }
10837             if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) {
10838                 return -TARGET_EFAULT;
10839             }
10840             schp.sched_priority = tswap32(target_schp->sched_priority);
10841             unlock_user_struct(target_schp, arg3, 0);
10842             return get_errno(sys_sched_setscheduler(arg1, arg2, &schp));
10843         }
10844     case TARGET_NR_sched_getscheduler:
10845         return get_errno(sys_sched_getscheduler(arg1));
10846     case TARGET_NR_sched_getattr:
10847         {
10848             struct target_sched_attr *target_scha;
10849             struct sched_attr scha;
10850             if (arg2 == 0) {
10851                 return -TARGET_EINVAL;
10852             }
10853             if (arg3 > sizeof(scha)) {
10854                 arg3 = sizeof(scha);
10855             }
10856             ret = get_errno(sys_sched_getattr(arg1, &scha, arg3, arg4));
10857             if (!is_error(ret)) {
10858                 target_scha = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10859                 if (!target_scha) {
10860                     return -TARGET_EFAULT;
10861                 }
10862                 target_scha->size = tswap32(scha.size);
10863                 target_scha->sched_policy = tswap32(scha.sched_policy);
10864                 target_scha->sched_flags = tswap64(scha.sched_flags);
10865                 target_scha->sched_nice = tswap32(scha.sched_nice);
10866                 target_scha->sched_priority = tswap32(scha.sched_priority);
10867                 target_scha->sched_runtime = tswap64(scha.sched_runtime);
10868                 target_scha->sched_deadline = tswap64(scha.sched_deadline);
10869                 target_scha->sched_period = tswap64(scha.sched_period);
10870                 if (scha.size > offsetof(struct sched_attr, sched_util_min)) {
10871                     target_scha->sched_util_min = tswap32(scha.sched_util_min);
10872                     target_scha->sched_util_max = tswap32(scha.sched_util_max);
10873                 }
10874                 unlock_user(target_scha, arg2, arg3);
10875             }
10876             return ret;
10877         }
10878     case TARGET_NR_sched_setattr:
10879         {
10880             struct target_sched_attr *target_scha;
10881             struct sched_attr scha;
10882             uint32_t size;
10883             int zeroed;
10884             if (arg2 == 0) {
10885                 return -TARGET_EINVAL;
10886             }
10887             if (get_user_u32(size, arg2)) {
10888                 return -TARGET_EFAULT;
10889             }
10890             if (!size) {
10891                 size = offsetof(struct target_sched_attr, sched_util_min);
10892             }
10893             if (size < offsetof(struct target_sched_attr, sched_util_min)) {
10894                 if (put_user_u32(sizeof(struct target_sched_attr), arg2)) {
10895                     return -TARGET_EFAULT;
10896                 }
10897                 return -TARGET_E2BIG;
10898             }
10899
10900             zeroed = check_zeroed_user(arg2, sizeof(struct target_sched_attr), size);
10901             if (zeroed < 0) {
10902                 return zeroed;
10903             } else if (zeroed == 0) {
10904                 if (put_user_u32(sizeof(struct target_sched_attr), arg2)) {
10905                     return -TARGET_EFAULT;
10906                 }
10907                 return -TARGET_E2BIG;
10908             }
10909             if (size > sizeof(struct target_sched_attr)) {
10910                 size = sizeof(struct target_sched_attr);
10911             }
10912
10913             target_scha = lock_user(VERIFY_READ, arg2, size, 1);
10914             if (!target_scha) {
10915                 return -TARGET_EFAULT;
10916             }
10917             scha.size = size;
10918             scha.sched_policy = tswap32(target_scha->sched_policy);
10919             scha.sched_flags = tswap64(target_scha->sched_flags);
10920             scha.sched_nice = tswap32(target_scha->sched_nice);
10921             scha.sched_priority = tswap32(target_scha->sched_priority);
10922             scha.sched_runtime = tswap64(target_scha->sched_runtime);
10923             scha.sched_deadline = tswap64(target_scha->sched_deadline);
10924             scha.sched_period = tswap64(target_scha->sched_period);
10925             if (size > offsetof(struct target_sched_attr, sched_util_min)) {
10926                 scha.sched_util_min = tswap32(target_scha->sched_util_min);
10927                 scha.sched_util_max = tswap32(target_scha->sched_util_max);
10928             }
10929             unlock_user(target_scha, arg2, 0);
10930             return get_errno(sys_sched_setattr(arg1, &scha, arg3));
10931         }
10932     case TARGET_NR_sched_yield:
10933         return get_errno(sched_yield());
10934     case TARGET_NR_sched_get_priority_max:
10935         return get_errno(sched_get_priority_max(arg1));
10936     case TARGET_NR_sched_get_priority_min:
10937         return get_errno(sched_get_priority_min(arg1));
10938 #ifdef TARGET_NR_sched_rr_get_interval
10939     case TARGET_NR_sched_rr_get_interval:
10940         {
10941             struct timespec ts;
10942             ret = get_errno(sched_rr_get_interval(arg1, &ts));
10943             if (!is_error(ret)) {
10944                 ret = host_to_target_timespec(arg2, &ts);
10945             }
10946         }
10947         return ret;
10948 #endif
10949 #ifdef TARGET_NR_sched_rr_get_interval_time64
10950     case TARGET_NR_sched_rr_get_interval_time64:
10951         {
10952             struct timespec ts;
10953             ret = get_errno(sched_rr_get_interval(arg1, &ts));
10954             if (!is_error(ret)) {
10955                 ret = host_to_target_timespec64(arg2, &ts);
10956             }
10957         }
10958         return ret;
10959 #endif
10960 #if defined(TARGET_NR_nanosleep)
10961     case TARGET_NR_nanosleep:
10962         {
10963             struct timespec req, rem;
10964             target_to_host_timespec(&req, arg1);
10965             ret = get_errno(safe_nanosleep(&req, &rem));
10966             if (is_error(ret) && arg2) {
10967                 host_to_target_timespec(arg2, &rem);
10968             }
10969         }
10970         return ret;
10971 #endif
10972     case TARGET_NR_prctl:
10973         return do_prctl(cpu_env, arg1, arg2, arg3, arg4, arg5);
10974         break;
10975 #ifdef TARGET_NR_arch_prctl
10976     case TARGET_NR_arch_prctl:
10977         return do_arch_prctl(cpu_env, arg1, arg2);
10978 #endif
10979 #ifdef TARGET_NR_pread64
10980     case TARGET_NR_pread64:
10981         if (regpairs_aligned(cpu_env, num)) {
10982             arg4 = arg5;
10983             arg5 = arg6;
10984         }
10985         if (arg2 == 0 && arg3 == 0) {
10986             /* Special-case NULL buffer and zero length, which should succeed */
10987             p = 0;
10988         } else {
10989             p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10990             if (!p) {
10991                 return -TARGET_EFAULT;
10992             }
10993         }
10994         ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
10995         unlock_user(p, arg2, ret);
10996         return ret;
10997     case TARGET_NR_pwrite64:
10998         if (regpairs_aligned(cpu_env, num)) {
10999             arg4 = arg5;
11000             arg5 = arg6;
11001         }
11002         if (arg2 == 0 && arg3 == 0) {
11003             /* Special-case NULL buffer and zero length, which should succeed */
11004             p = 0;
11005         } else {
11006             p = lock_user(VERIFY_READ, arg2, arg3, 1);
11007             if (!p) {
11008                 return -TARGET_EFAULT;
11009             }
11010         }
11011         ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
11012         unlock_user(p, arg2, 0);
11013         return ret;
11014 #endif
11015     case TARGET_NR_getcwd:
11016         if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
11017             return -TARGET_EFAULT;
11018         ret = get_errno(sys_getcwd1(p, arg2));
11019         unlock_user(p, arg1, ret);
11020         return ret;
11021     case TARGET_NR_capget:
11022     case TARGET_NR_capset:
11023     {
11024         struct target_user_cap_header *target_header;
11025         struct target_user_cap_data *target_data = NULL;
11026         struct __user_cap_header_struct header;
11027         struct __user_cap_data_struct data[2];
11028         struct __user_cap_data_struct *dataptr = NULL;
11029         int i, target_datalen;
11030         int data_items = 1;
11031
11032         if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
11033             return -TARGET_EFAULT;
11034         }
11035         header.version = tswap32(target_header->version);
11036         header.pid = tswap32(target_header->pid);
11037
11038         if (header.version != _LINUX_CAPABILITY_VERSION) {
11039             /* Version 2 and up takes pointer to two user_data structs */
11040             data_items = 2;
11041         }
11042
11043         target_datalen = sizeof(*target_data) * data_items;
11044
11045         if (arg2) {
11046             if (num == TARGET_NR_capget) {
11047                 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0);
11048             } else {
11049                 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1);
11050             }
11051             if (!target_data) {
11052                 unlock_user_struct(target_header, arg1, 0);
11053                 return -TARGET_EFAULT;
11054             }
11055
11056             if (num == TARGET_NR_capset) {
11057                 for (i = 0; i < data_items; i++) {
11058                     data[i].effective = tswap32(target_data[i].effective);
11059                     data[i].permitted = tswap32(target_data[i].permitted);
11060                     data[i].inheritable = tswap32(target_data[i].inheritable);
11061                 }
11062             }
11063
11064             dataptr = data;
11065         }
11066
11067         if (num == TARGET_NR_capget) {
11068             ret = get_errno(capget(&header, dataptr));
11069         } else {
11070             ret = get_errno(capset(&header, dataptr));
11071         }
11072
11073         /* The kernel always updates version for both capget and capset */
11074         target_header->version = tswap32(header.version);
11075         unlock_user_struct(target_header, arg1, 1);
11076
11077         if (arg2) {
11078             if (num == TARGET_NR_capget) {
11079                 for (i = 0; i < data_items; i++) {
11080                     target_data[i].effective = tswap32(data[i].effective);
11081                     target_data[i].permitted = tswap32(data[i].permitted);
11082                     target_data[i].inheritable = tswap32(data[i].inheritable);
11083                 }
11084                 unlock_user(target_data, arg2, target_datalen);
11085             } else {
11086                 unlock_user(target_data, arg2, 0);
11087             }
11088         }
11089         return ret;
11090     }
11091     case TARGET_NR_sigaltstack:
11092         return do_sigaltstack(arg1, arg2, cpu_env);
11093
11094 #ifdef CONFIG_SENDFILE
11095 #ifdef TARGET_NR_sendfile
11096     case TARGET_NR_sendfile:
11097     {
11098         off_t *offp = NULL;
11099         off_t off;
11100         if (arg3) {
11101             ret = get_user_sal(off, arg3);
11102             if (is_error(ret)) {
11103                 return ret;
11104             }
11105             offp = &off;
11106         }
11107         ret = get_errno(sendfile(arg1, arg2, offp, arg4));
11108         if (!is_error(ret) && arg3) {
11109             abi_long ret2 = put_user_sal(off, arg3);
11110             if (is_error(ret2)) {
11111                 ret = ret2;
11112             }
11113         }
11114         return ret;
11115     }
11116 #endif
11117 #ifdef TARGET_NR_sendfile64
11118     case TARGET_NR_sendfile64:
11119     {
11120         off_t *offp = NULL;
11121         off_t off;
11122         if (arg3) {
11123             ret = get_user_s64(off, arg3);
11124             if (is_error(ret)) {
11125                 return ret;
11126             }
11127             offp = &off;
11128         }
11129         ret = get_errno(sendfile(arg1, arg2, offp, arg4));
11130         if (!is_error(ret) && arg3) {
11131             abi_long ret2 = put_user_s64(off, arg3);
11132             if (is_error(ret2)) {
11133                 ret = ret2;
11134             }
11135         }
11136         return ret;
11137     }
11138 #endif
11139 #endif
11140 #ifdef TARGET_NR_vfork
11141     case TARGET_NR_vfork:
11142         return get_errno(do_fork(cpu_env,
11143                          CLONE_VFORK | CLONE_VM | TARGET_SIGCHLD,
11144                          0, 0, 0, 0));
11145 #endif
11146 #ifdef TARGET_NR_ugetrlimit
11147     case TARGET_NR_ugetrlimit:
11148     {
11149         struct rlimit rlim;
11150         int resource = target_to_host_resource(arg1);
11151         ret = get_errno(getrlimit(resource, &rlim));
11152         if (!is_error(ret)) {
11153             struct target_rlimit *target_rlim;
11154             if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
11155                 return -TARGET_EFAULT;
11156             target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
11157             target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
11158             unlock_user_struct(target_rlim, arg2, 1);
11159         }
11160         return ret;
11161     }
11162 #endif
11163 #ifdef TARGET_NR_truncate64
11164     case TARGET_NR_truncate64:
11165         if (!(p = lock_user_string(arg1)))
11166             return -TARGET_EFAULT;
11167         ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
11168         unlock_user(p, arg1, 0);
11169         return ret;
11170 #endif
11171 #ifdef TARGET_NR_ftruncate64
11172     case TARGET_NR_ftruncate64:
11173         return target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
11174 #endif
11175 #ifdef TARGET_NR_stat64
11176     case TARGET_NR_stat64:
11177         if (!(p = lock_user_string(arg1))) {
11178             return -TARGET_EFAULT;
11179         }
11180         ret = get_errno(stat(path(p), &st));
11181         unlock_user(p, arg1, 0);
11182         if (!is_error(ret))
11183             ret = host_to_target_stat64(cpu_env, arg2, &st);
11184         return ret;
11185 #endif
11186 #ifdef TARGET_NR_lstat64
11187     case TARGET_NR_lstat64:
11188         if (!(p = lock_user_string(arg1))) {
11189             return -TARGET_EFAULT;
11190         }
11191         ret = get_errno(lstat(path(p), &st));
11192         unlock_user(p, arg1, 0);
11193         if (!is_error(ret))
11194             ret = host_to_target_stat64(cpu_env, arg2, &st);
11195         return ret;
11196 #endif
11197 #ifdef TARGET_NR_fstat64
11198     case TARGET_NR_fstat64:
11199         ret = get_errno(fstat(arg1, &st));
11200         if (!is_error(ret))
11201             ret = host_to_target_stat64(cpu_env, arg2, &st);
11202         return ret;
11203 #endif
11204 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
11205 #ifdef TARGET_NR_fstatat64
11206     case TARGET_NR_fstatat64:
11207 #endif
11208 #ifdef TARGET_NR_newfstatat
11209     case TARGET_NR_newfstatat:
11210 #endif
11211         if (!(p = lock_user_string(arg2))) {
11212             return -TARGET_EFAULT;
11213         }
11214         ret = get_errno(fstatat(arg1, path(p), &st, arg4));
11215         unlock_user(p, arg2, 0);
11216         if (!is_error(ret))
11217             ret = host_to_target_stat64(cpu_env, arg3, &st);
11218         return ret;
11219 #endif
11220 #if defined(TARGET_NR_statx)
11221     case TARGET_NR_statx:
11222         {
11223             struct target_statx *target_stx;
11224             int dirfd = arg1;
11225             int flags = arg3;
11226
11227             p = lock_user_string(arg2);
11228             if (p == NULL) {
11229                 return -TARGET_EFAULT;
11230             }
11231 #if defined(__NR_statx)
11232             {
11233                 /*
11234                  * It is assumed that struct statx is architecture independent.
11235                  */
11236                 struct target_statx host_stx;
11237                 int mask = arg4;
11238
11239                 ret = get_errno(sys_statx(dirfd, p, flags, mask, &host_stx));
11240                 if (!is_error(ret)) {
11241                     if (host_to_target_statx(&host_stx, arg5) != 0) {
11242                         unlock_user(p, arg2, 0);
11243                         return -TARGET_EFAULT;
11244                     }
11245                 }
11246
11247                 if (ret != -TARGET_ENOSYS) {
11248                     unlock_user(p, arg2, 0);
11249                     return ret;
11250                 }
11251             }
11252 #endif
11253             ret = get_errno(fstatat(dirfd, path(p), &st, flags));
11254             unlock_user(p, arg2, 0);
11255
11256             if (!is_error(ret)) {
11257                 if (!lock_user_struct(VERIFY_WRITE, target_stx, arg5, 0)) {
11258                     return -TARGET_EFAULT;
11259                 }
11260                 memset(target_stx, 0, sizeof(*target_stx));
11261                 __put_user(major(st.st_dev), &target_stx->stx_dev_major);
11262                 __put_user(minor(st.st_dev), &target_stx->stx_dev_minor);
11263                 __put_user(st.st_ino, &target_stx->stx_ino);
11264                 __put_user(st.st_mode, &target_stx->stx_mode);
11265                 __put_user(st.st_uid, &target_stx->stx_uid);
11266                 __put_user(st.st_gid, &target_stx->stx_gid);
11267                 __put_user(st.st_nlink, &target_stx->stx_nlink);
11268                 __put_user(major(st.st_rdev), &target_stx->stx_rdev_major);
11269                 __put_user(minor(st.st_rdev), &target_stx->stx_rdev_minor);
11270                 __put_user(st.st_size, &target_stx->stx_size);
11271                 __put_user(st.st_blksize, &target_stx->stx_blksize);
11272                 __put_user(st.st_blocks, &target_stx->stx_blocks);
11273                 __put_user(st.st_atime, &target_stx->stx_atime.tv_sec);
11274                 __put_user(st.st_mtime, &target_stx->stx_mtime.tv_sec);
11275                 __put_user(st.st_ctime, &target_stx->stx_ctime.tv_sec);
11276                 unlock_user_struct(target_stx, arg5, 1);
11277             }
11278         }
11279         return ret;
11280 #endif
11281 #ifdef TARGET_NR_lchown
11282     case TARGET_NR_lchown:
11283         if (!(p = lock_user_string(arg1)))
11284             return -TARGET_EFAULT;
11285         ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
11286         unlock_user(p, arg1, 0);
11287         return ret;
11288 #endif
11289 #ifdef TARGET_NR_getuid
11290     case TARGET_NR_getuid:
11291         return get_errno(high2lowuid(getuid()));
11292 #endif
11293 #ifdef TARGET_NR_getgid
11294     case TARGET_NR_getgid:
11295         return get_errno(high2lowgid(getgid()));
11296 #endif
11297 #ifdef TARGET_NR_geteuid
11298     case TARGET_NR_geteuid:
11299         return get_errno(high2lowuid(geteuid()));
11300 #endif
11301 #ifdef TARGET_NR_getegid
11302     case TARGET_NR_getegid:
11303         return get_errno(high2lowgid(getegid()));
11304 #endif
11305     case TARGET_NR_setreuid:
11306         return get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
11307     case TARGET_NR_setregid:
11308         return get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
11309     case TARGET_NR_getgroups:
11310         {
11311             int gidsetsize = arg1;
11312             target_id *target_grouplist;
11313             gid_t *grouplist;
11314             int i;
11315
11316             grouplist = alloca(gidsetsize * sizeof(gid_t));
11317             ret = get_errno(getgroups(gidsetsize, grouplist));
11318             if (gidsetsize == 0)
11319                 return ret;
11320             if (!is_error(ret)) {
11321                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
11322                 if (!target_grouplist)
11323                     return -TARGET_EFAULT;
11324                 for(i = 0;i < ret; i++)
11325                     target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
11326                 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
11327             }
11328         }
11329         return ret;
11330     case TARGET_NR_setgroups:
11331         {
11332             int gidsetsize = arg1;
11333             target_id *target_grouplist;
11334             gid_t *grouplist = NULL;
11335             int i;
11336             if (gidsetsize) {
11337                 grouplist = alloca(gidsetsize * sizeof(gid_t));
11338                 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
11339                 if (!target_grouplist) {
11340                     return -TARGET_EFAULT;
11341                 }
11342                 for (i = 0; i < gidsetsize; i++) {
11343                     grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
11344                 }
11345                 unlock_user(target_grouplist, arg2, 0);
11346             }
11347             return get_errno(setgroups(gidsetsize, grouplist));
11348         }
11349     case TARGET_NR_fchown:
11350         return get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
11351 #if defined(TARGET_NR_fchownat)
11352     case TARGET_NR_fchownat:
11353         if (!(p = lock_user_string(arg2)))
11354             return -TARGET_EFAULT;
11355         ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
11356                                  low2highgid(arg4), arg5));
11357         unlock_user(p, arg2, 0);
11358         return ret;
11359 #endif
11360 #ifdef TARGET_NR_setresuid
11361     case TARGET_NR_setresuid:
11362         return get_errno(sys_setresuid(low2highuid(arg1),
11363                                        low2highuid(arg2),
11364                                        low2highuid(arg3)));
11365 #endif
11366 #ifdef TARGET_NR_getresuid
11367     case TARGET_NR_getresuid:
11368         {
11369             uid_t ruid, euid, suid;
11370             ret = get_errno(getresuid(&ruid, &euid, &suid));
11371             if (!is_error(ret)) {
11372                 if (put_user_id(high2lowuid(ruid), arg1)
11373                     || put_user_id(high2lowuid(euid), arg2)
11374                     || put_user_id(high2lowuid(suid), arg3))
11375                     return -TARGET_EFAULT;
11376             }
11377         }
11378         return ret;
11379 #endif
11380 #ifdef TARGET_NR_getresgid
11381     case TARGET_NR_setresgid:
11382         return get_errno(sys_setresgid(low2highgid(arg1),
11383                                        low2highgid(arg2),
11384                                        low2highgid(arg3)));
11385 #endif
11386 #ifdef TARGET_NR_getresgid
11387     case TARGET_NR_getresgid:
11388         {
11389             gid_t rgid, egid, sgid;
11390             ret = get_errno(getresgid(&rgid, &egid, &sgid));
11391             if (!is_error(ret)) {
11392                 if (put_user_id(high2lowgid(rgid), arg1)
11393                     || put_user_id(high2lowgid(egid), arg2)
11394                     || put_user_id(high2lowgid(sgid), arg3))
11395                     return -TARGET_EFAULT;
11396             }
11397         }
11398         return ret;
11399 #endif
11400 #ifdef TARGET_NR_chown
11401     case TARGET_NR_chown:
11402         if (!(p = lock_user_string(arg1)))
11403             return -TARGET_EFAULT;
11404         ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
11405         unlock_user(p, arg1, 0);
11406         return ret;
11407 #endif
11408     case TARGET_NR_setuid:
11409         return get_errno(sys_setuid(low2highuid(arg1)));
11410     case TARGET_NR_setgid:
11411         return get_errno(sys_setgid(low2highgid(arg1)));
11412     case TARGET_NR_setfsuid:
11413         return get_errno(setfsuid(arg1));
11414     case TARGET_NR_setfsgid:
11415         return get_errno(setfsgid(arg1));
11416
11417 #ifdef TARGET_NR_lchown32
11418     case TARGET_NR_lchown32:
11419         if (!(p = lock_user_string(arg1)))
11420             return -TARGET_EFAULT;
11421         ret = get_errno(lchown(p, arg2, arg3));
11422         unlock_user(p, arg1, 0);
11423         return ret;
11424 #endif
11425 #ifdef TARGET_NR_getuid32
11426     case TARGET_NR_getuid32:
11427         return get_errno(getuid());
11428 #endif
11429
11430 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
11431    /* Alpha specific */
11432     case TARGET_NR_getxuid:
11433          {
11434             uid_t euid;
11435             euid=geteuid();
11436             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
11437          }
11438         return get_errno(getuid());
11439 #endif
11440 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
11441    /* Alpha specific */
11442     case TARGET_NR_getxgid:
11443          {
11444             uid_t egid;
11445             egid=getegid();
11446             ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
11447          }
11448         return get_errno(getgid());
11449 #endif
11450 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
11451     /* Alpha specific */
11452     case TARGET_NR_osf_getsysinfo:
11453         ret = -TARGET_EOPNOTSUPP;
11454         switch (arg1) {
11455           case TARGET_GSI_IEEE_FP_CONTROL:
11456             {
11457                 uint64_t fpcr = cpu_alpha_load_fpcr(cpu_env);
11458                 uint64_t swcr = ((CPUAlphaState *)cpu_env)->swcr;
11459
11460                 swcr &= ~SWCR_STATUS_MASK;
11461                 swcr |= (fpcr >> 35) & SWCR_STATUS_MASK;
11462
11463                 if (put_user_u64 (swcr, arg2))
11464                         return -TARGET_EFAULT;
11465                 ret = 0;
11466             }
11467             break;
11468
11469           /* case GSI_IEEE_STATE_AT_SIGNAL:
11470              -- Not implemented in linux kernel.
11471              case GSI_UACPROC:
11472              -- Retrieves current unaligned access state; not much used.
11473              case GSI_PROC_TYPE:
11474              -- Retrieves implver information; surely not used.
11475              case GSI_GET_HWRPB:
11476              -- Grabs a copy of the HWRPB; surely not used.
11477           */
11478         }
11479         return ret;
11480 #endif
11481 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
11482     /* Alpha specific */
11483     case TARGET_NR_osf_setsysinfo:
11484         ret = -TARGET_EOPNOTSUPP;
11485         switch (arg1) {
11486           case TARGET_SSI_IEEE_FP_CONTROL:
11487             {
11488                 uint64_t swcr, fpcr;
11489
11490                 if (get_user_u64 (swcr, arg2)) {
11491                     return -TARGET_EFAULT;
11492                 }
11493
11494                 /*
11495                  * The kernel calls swcr_update_status to update the
11496                  * status bits from the fpcr at every point that it
11497                  * could be queried.  Therefore, we store the status
11498                  * bits only in FPCR.
11499                  */
11500                 ((CPUAlphaState *)cpu_env)->swcr
11501                     = swcr & (SWCR_TRAP_ENABLE_MASK | SWCR_MAP_MASK);
11502
11503                 fpcr = cpu_alpha_load_fpcr(cpu_env);
11504                 fpcr &= ((uint64_t)FPCR_DYN_MASK << 32);
11505                 fpcr |= alpha_ieee_swcr_to_fpcr(swcr);
11506                 cpu_alpha_store_fpcr(cpu_env, fpcr);
11507                 ret = 0;
11508             }
11509             break;
11510
11511           case TARGET_SSI_IEEE_RAISE_EXCEPTION:
11512             {
11513                 uint64_t exc, fpcr, fex;
11514
11515                 if (get_user_u64(exc, arg2)) {
11516                     return -TARGET_EFAULT;
11517                 }
11518                 exc &= SWCR_STATUS_MASK;
11519                 fpcr = cpu_alpha_load_fpcr(cpu_env);
11520
11521                 /* Old exceptions are not signaled.  */
11522                 fex = alpha_ieee_fpcr_to_swcr(fpcr);
11523                 fex = exc & ~fex;
11524                 fex >>= SWCR_STATUS_TO_EXCSUM_SHIFT;
11525                 fex &= ((CPUArchState *)cpu_env)->swcr;
11526
11527                 /* Update the hardware fpcr.  */
11528                 fpcr |= alpha_ieee_swcr_to_fpcr(exc);
11529                 cpu_alpha_store_fpcr(cpu_env, fpcr);
11530
11531                 if (fex) {
11532                     int si_code = TARGET_FPE_FLTUNK;
11533                     target_siginfo_t info;
11534
11535                     if (fex & SWCR_TRAP_ENABLE_DNO) {
11536                         si_code = TARGET_FPE_FLTUND;
11537                     }
11538                     if (fex & SWCR_TRAP_ENABLE_INE) {
11539                         si_code = TARGET_FPE_FLTRES;
11540                     }
11541                     if (fex & SWCR_TRAP_ENABLE_UNF) {
11542                         si_code = TARGET_FPE_FLTUND;
11543                     }
11544                     if (fex & SWCR_TRAP_ENABLE_OVF) {
11545                         si_code = TARGET_FPE_FLTOVF;
11546                     }
11547                     if (fex & SWCR_TRAP_ENABLE_DZE) {
11548                         si_code = TARGET_FPE_FLTDIV;
11549                     }
11550                     if (fex & SWCR_TRAP_ENABLE_INV) {
11551                         si_code = TARGET_FPE_FLTINV;
11552                     }
11553
11554                     info.si_signo = SIGFPE;
11555                     info.si_errno = 0;
11556                     info.si_code = si_code;
11557                     info._sifields._sigfault._addr
11558                         = ((CPUArchState *)cpu_env)->pc;
11559                     queue_signal((CPUArchState *)cpu_env, info.si_signo,
11560                                  QEMU_SI_FAULT, &info);
11561                 }
11562                 ret = 0;
11563             }
11564             break;
11565
11566           /* case SSI_NVPAIRS:
11567              -- Used with SSIN_UACPROC to enable unaligned accesses.
11568              case SSI_IEEE_STATE_AT_SIGNAL:
11569              case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
11570              -- Not implemented in linux kernel
11571           */
11572         }
11573         return ret;
11574 #endif
11575 #ifdef TARGET_NR_osf_sigprocmask
11576     /* Alpha specific.  */
11577     case TARGET_NR_osf_sigprocmask:
11578         {
11579             abi_ulong mask;
11580             int how;
11581             sigset_t set, oldset;
11582
11583             switch(arg1) {
11584             case TARGET_SIG_BLOCK:
11585                 how = SIG_BLOCK;
11586                 break;
11587             case TARGET_SIG_UNBLOCK:
11588                 how = SIG_UNBLOCK;
11589                 break;
11590             case TARGET_SIG_SETMASK:
11591                 how = SIG_SETMASK;
11592                 break;
11593             default:
11594                 return -TARGET_EINVAL;
11595             }
11596             mask = arg2;
11597             target_to_host_old_sigset(&set, &mask);
11598             ret = do_sigprocmask(how, &set, &oldset);
11599             if (!ret) {
11600                 host_to_target_old_sigset(&mask, &oldset);
11601                 ret = mask;
11602             }
11603         }
11604         return ret;
11605 #endif
11606
11607 #ifdef TARGET_NR_getgid32
11608     case TARGET_NR_getgid32:
11609         return get_errno(getgid());
11610 #endif
11611 #ifdef TARGET_NR_geteuid32
11612     case TARGET_NR_geteuid32:
11613         return get_errno(geteuid());
11614 #endif
11615 #ifdef TARGET_NR_getegid32
11616     case TARGET_NR_getegid32:
11617         return get_errno(getegid());
11618 #endif
11619 #ifdef TARGET_NR_setreuid32
11620     case TARGET_NR_setreuid32:
11621         return get_errno(setreuid(arg1, arg2));
11622 #endif
11623 #ifdef TARGET_NR_setregid32
11624     case TARGET_NR_setregid32:
11625         return get_errno(setregid(arg1, arg2));
11626 #endif
11627 #ifdef TARGET_NR_getgroups32
11628     case TARGET_NR_getgroups32:
11629         {
11630             int gidsetsize = arg1;
11631             uint32_t *target_grouplist;
11632             gid_t *grouplist;
11633             int i;
11634
11635             grouplist = alloca(gidsetsize * sizeof(gid_t));
11636             ret = get_errno(getgroups(gidsetsize, grouplist));
11637             if (gidsetsize == 0)
11638                 return ret;
11639             if (!is_error(ret)) {
11640                 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
11641                 if (!target_grouplist) {
11642                     return -TARGET_EFAULT;
11643                 }
11644                 for(i = 0;i < ret; i++)
11645                     target_grouplist[i] = tswap32(grouplist[i]);
11646                 unlock_user(target_grouplist, arg2, gidsetsize * 4);
11647             }
11648         }
11649         return ret;
11650 #endif
11651 #ifdef TARGET_NR_setgroups32
11652     case TARGET_NR_setgroups32:
11653         {
11654             int gidsetsize = arg1;
11655             uint32_t *target_grouplist;
11656             gid_t *grouplist;
11657             int i;
11658
11659             grouplist = alloca(gidsetsize * sizeof(gid_t));
11660             target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
11661             if (!target_grouplist) {
11662                 return -TARGET_EFAULT;
11663             }
11664             for(i = 0;i < gidsetsize; i++)
11665                 grouplist[i] = tswap32(target_grouplist[i]);
11666             unlock_user(target_grouplist, arg2, 0);
11667             return get_errno(setgroups(gidsetsize, grouplist));
11668         }
11669 #endif
11670 #ifdef TARGET_NR_fchown32
11671     case TARGET_NR_fchown32:
11672         return get_errno(fchown(arg1, arg2, arg3));
11673 #endif
11674 #ifdef TARGET_NR_setresuid32
11675     case TARGET_NR_setresuid32:
11676         return get_errno(sys_setresuid(arg1, arg2, arg3));
11677 #endif
11678 #ifdef TARGET_NR_getresuid32
11679     case TARGET_NR_getresuid32:
11680         {
11681             uid_t ruid, euid, suid;
11682             ret = get_errno(getresuid(&ruid, &euid, &suid));
11683             if (!is_error(ret)) {
11684                 if (put_user_u32(ruid, arg1)
11685                     || put_user_u32(euid, arg2)
11686                     || put_user_u32(suid, arg3))
11687                     return -TARGET_EFAULT;
11688             }
11689         }
11690         return ret;
11691 #endif
11692 #ifdef TARGET_NR_setresgid32
11693     case TARGET_NR_setresgid32:
11694         return get_errno(sys_setresgid(arg1, arg2, arg3));
11695 #endif
11696 #ifdef TARGET_NR_getresgid32
11697     case TARGET_NR_getresgid32:
11698         {
11699             gid_t rgid, egid, sgid;
11700             ret = get_errno(getresgid(&rgid, &egid, &sgid));
11701             if (!is_error(ret)) {
11702                 if (put_user_u32(rgid, arg1)
11703                     || put_user_u32(egid, arg2)
11704                     || put_user_u32(sgid, arg3))
11705                     return -TARGET_EFAULT;
11706             }
11707         }
11708         return ret;
11709 #endif
11710 #ifdef TARGET_NR_chown32
11711     case TARGET_NR_chown32:
11712         if (!(p = lock_user_string(arg1)))
11713             return -TARGET_EFAULT;
11714         ret = get_errno(chown(p, arg2, arg3));
11715         unlock_user(p, arg1, 0);
11716         return ret;
11717 #endif
11718 #ifdef TARGET_NR_setuid32
11719     case TARGET_NR_setuid32:
11720         return get_errno(sys_setuid(arg1));
11721 #endif
11722 #ifdef TARGET_NR_setgid32
11723     case TARGET_NR_setgid32:
11724         return get_errno(sys_setgid(arg1));
11725 #endif
11726 #ifdef TARGET_NR_setfsuid32
11727     case TARGET_NR_setfsuid32:
11728         return get_errno(setfsuid(arg1));
11729 #endif
11730 #ifdef TARGET_NR_setfsgid32
11731     case TARGET_NR_setfsgid32:
11732         return get_errno(setfsgid(arg1));
11733 #endif
11734 #ifdef TARGET_NR_mincore
11735     case TARGET_NR_mincore:
11736         {
11737             void *a = lock_user(VERIFY_READ, arg1, arg2, 0);
11738             if (!a) {
11739                 return -TARGET_ENOMEM;
11740             }
11741             p = lock_user_string(arg3);
11742             if (!p) {
11743                 ret = -TARGET_EFAULT;
11744             } else {
11745                 ret = get_errno(mincore(a, arg2, p));
11746                 unlock_user(p, arg3, ret);
11747             }
11748             unlock_user(a, arg1, 0);
11749         }
11750         return ret;
11751 #endif
11752 #ifdef TARGET_NR_arm_fadvise64_64
11753     case TARGET_NR_arm_fadvise64_64:
11754         /* arm_fadvise64_64 looks like fadvise64_64 but
11755          * with different argument order: fd, advice, offset, len
11756          * rather than the usual fd, offset, len, advice.
11757          * Note that offset and len are both 64-bit so appear as
11758          * pairs of 32-bit registers.
11759          */
11760         ret = posix_fadvise(arg1, target_offset64(arg3, arg4),
11761                             target_offset64(arg5, arg6), arg2);
11762         return -host_to_target_errno(ret);
11763 #endif
11764
11765 #if TARGET_ABI_BITS == 32
11766
11767 #ifdef TARGET_NR_fadvise64_64
11768     case TARGET_NR_fadvise64_64:
11769 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
11770         /* 6 args: fd, advice, offset (high, low), len (high, low) */
11771         ret = arg2;
11772         arg2 = arg3;
11773         arg3 = arg4;
11774         arg4 = arg5;
11775         arg5 = arg6;
11776         arg6 = ret;
11777 #else
11778         /* 6 args: fd, offset (high, low), len (high, low), advice */
11779         if (regpairs_aligned(cpu_env, num)) {
11780             /* offset is in (3,4), len in (5,6) and advice in 7 */
11781             arg2 = arg3;
11782             arg3 = arg4;
11783             arg4 = arg5;
11784             arg5 = arg6;
11785             arg6 = arg7;
11786         }
11787 #endif
11788         ret = posix_fadvise(arg1, target_offset64(arg2, arg3),
11789                             target_offset64(arg4, arg5), arg6);
11790         return -host_to_target_errno(ret);
11791 #endif
11792
11793 #ifdef TARGET_NR_fadvise64
11794     case TARGET_NR_fadvise64:
11795         /* 5 args: fd, offset (high, low), len, advice */
11796         if (regpairs_aligned(cpu_env, num)) {
11797             /* offset is in (3,4), len in 5 and advice in 6 */
11798             arg2 = arg3;
11799             arg3 = arg4;
11800             arg4 = arg5;
11801             arg5 = arg6;
11802         }
11803         ret = posix_fadvise(arg1, target_offset64(arg2, arg3), arg4, arg5);
11804         return -host_to_target_errno(ret);
11805 #endif
11806
11807 #else /* not a 32-bit ABI */
11808 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
11809 #ifdef TARGET_NR_fadvise64_64
11810     case TARGET_NR_fadvise64_64:
11811 #endif
11812 #ifdef TARGET_NR_fadvise64
11813     case TARGET_NR_fadvise64:
11814 #endif
11815 #ifdef TARGET_S390X
11816         switch (arg4) {
11817         case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
11818         case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
11819         case 6: arg4 = POSIX_FADV_DONTNEED; break;
11820         case 7: arg4 = POSIX_FADV_NOREUSE; break;
11821         default: break;
11822         }
11823 #endif
11824         return -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4));
11825 #endif
11826 #endif /* end of 64-bit ABI fadvise handling */
11827
11828 #ifdef TARGET_NR_madvise
11829     case TARGET_NR_madvise:
11830         /* A straight passthrough may not be safe because qemu sometimes
11831            turns private file-backed mappings into anonymous mappings.
11832            This will break MADV_DONTNEED.
11833            This is a hint, so ignoring and returning success is ok.  */
11834         return 0;
11835 #endif
11836 #ifdef TARGET_NR_fcntl64
11837     case TARGET_NR_fcntl64:
11838     {
11839         int cmd;
11840         struct flock64 fl;
11841         from_flock64_fn *copyfrom = copy_from_user_flock64;
11842         to_flock64_fn *copyto = copy_to_user_flock64;
11843
11844 #ifdef TARGET_ARM
11845         if (!((CPUARMState *)cpu_env)->eabi) {
11846             copyfrom = copy_from_user_oabi_flock64;
11847             copyto = copy_to_user_oabi_flock64;
11848         }
11849 #endif
11850
11851         cmd = target_to_host_fcntl_cmd(arg2);
11852         if (cmd == -TARGET_EINVAL) {
11853             return cmd;
11854         }
11855
11856         switch(arg2) {
11857         case TARGET_F_GETLK64:
11858             ret = copyfrom(&fl, arg3);
11859             if (ret) {
11860                 break;
11861             }
11862             ret = get_errno(safe_fcntl(arg1, cmd, &fl));
11863             if (ret == 0) {
11864                 ret = copyto(arg3, &fl);
11865             }
11866             break;
11867
11868         case TARGET_F_SETLK64:
11869         case TARGET_F_SETLKW64:
11870             ret = copyfrom(&fl, arg3);
11871             if (ret) {
11872                 break;
11873             }
11874             ret = get_errno(safe_fcntl(arg1, cmd, &fl));
11875             break;
11876         default:
11877             ret = do_fcntl(arg1, arg2, arg3);
11878             break;
11879         }
11880         return ret;
11881     }
11882 #endif
11883 #ifdef TARGET_NR_cacheflush
11884     case TARGET_NR_cacheflush:
11885         /* self-modifying code is handled automatically, so nothing needed */
11886         return 0;
11887 #endif
11888 #ifdef TARGET_NR_getpagesize
11889     case TARGET_NR_getpagesize:
11890         return TARGET_PAGE_SIZE;
11891 #endif
11892     case TARGET_NR_gettid:
11893         return get_errno(sys_gettid());
11894 #ifdef TARGET_NR_readahead
11895     case TARGET_NR_readahead:
11896 #if TARGET_ABI_BITS == 32
11897         if (regpairs_aligned(cpu_env, num)) {
11898             arg2 = arg3;
11899             arg3 = arg4;
11900             arg4 = arg5;
11901         }
11902         ret = get_errno(readahead(arg1, target_offset64(arg2, arg3) , arg4));
11903 #else
11904         ret = get_errno(readahead(arg1, arg2, arg3));
11905 #endif
11906         return ret;
11907 #endif
11908 #ifdef CONFIG_ATTR
11909 #ifdef TARGET_NR_setxattr
11910     case TARGET_NR_listxattr:
11911     case TARGET_NR_llistxattr:
11912     {
11913         void *p, *b = 0;
11914         if (arg2) {
11915             b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11916             if (!b) {
11917                 return -TARGET_EFAULT;
11918             }
11919         }
11920         p = lock_user_string(arg1);
11921         if (p) {
11922             if (num == TARGET_NR_listxattr) {
11923                 ret = get_errno(listxattr(p, b, arg3));
11924             } else {
11925                 ret = get_errno(llistxattr(p, b, arg3));
11926             }
11927         } else {
11928             ret = -TARGET_EFAULT;
11929         }
11930         unlock_user(p, arg1, 0);
11931         unlock_user(b, arg2, arg3);
11932         return ret;
11933     }
11934     case TARGET_NR_flistxattr:
11935     {
11936         void *b = 0;
11937         if (arg2) {
11938             b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11939             if (!b) {
11940                 return -TARGET_EFAULT;
11941             }
11942         }
11943         ret = get_errno(flistxattr(arg1, b, arg3));
11944         unlock_user(b, arg2, arg3);
11945         return ret;
11946     }
11947     case TARGET_NR_setxattr:
11948     case TARGET_NR_lsetxattr:
11949         {
11950             void *p, *n, *v = 0;
11951             if (arg3) {
11952                 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11953                 if (!v) {
11954                     return -TARGET_EFAULT;
11955                 }
11956             }
11957             p = lock_user_string(arg1);
11958             n = lock_user_string(arg2);
11959             if (p && n) {
11960                 if (num == TARGET_NR_setxattr) {
11961                     ret = get_errno(setxattr(p, n, v, arg4, arg5));
11962                 } else {
11963                     ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
11964                 }
11965             } else {
11966                 ret = -TARGET_EFAULT;
11967             }
11968             unlock_user(p, arg1, 0);
11969             unlock_user(n, arg2, 0);
11970             unlock_user(v, arg3, 0);
11971         }
11972         return ret;
11973     case TARGET_NR_fsetxattr:
11974         {
11975             void *n, *v = 0;
11976             if (arg3) {
11977                 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11978                 if (!v) {
11979                     return -TARGET_EFAULT;
11980                 }
11981             }
11982             n = lock_user_string(arg2);
11983             if (n) {
11984                 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
11985             } else {
11986                 ret = -TARGET_EFAULT;
11987             }
11988             unlock_user(n, arg2, 0);
11989             unlock_user(v, arg3, 0);
11990         }
11991         return ret;
11992     case TARGET_NR_getxattr:
11993     case TARGET_NR_lgetxattr:
11994         {
11995             void *p, *n, *v = 0;
11996             if (arg3) {
11997                 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
11998                 if (!v) {
11999                     return -TARGET_EFAULT;
12000                 }
12001             }
12002             p = lock_user_string(arg1);
12003             n = lock_user_string(arg2);
12004             if (p && n) {
12005                 if (num == TARGET_NR_getxattr) {
12006                     ret = get_errno(getxattr(p, n, v, arg4));
12007                 } else {
12008                     ret = get_errno(lgetxattr(p, n, v, arg4));
12009                 }
12010             } else {
12011                 ret = -TARGET_EFAULT;
12012             }
12013             unlock_user(p, arg1, 0);
12014             unlock_user(n, arg2, 0);
12015             unlock_user(v, arg3, arg4);
12016         }
12017         return ret;
12018     case TARGET_NR_fgetxattr:
12019         {
12020             void *n, *v = 0;
12021             if (arg3) {
12022                 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
12023                 if (!v) {
12024                     return -TARGET_EFAULT;
12025                 }
12026             }
12027             n = lock_user_string(arg2);
12028             if (n) {
12029                 ret = get_errno(fgetxattr(arg1, n, v, arg4));
12030             } else {
12031                 ret = -TARGET_EFAULT;
12032             }
12033             unlock_user(n, arg2, 0);
12034             unlock_user(v, arg3, arg4);
12035         }
12036         return ret;
12037     case TARGET_NR_removexattr:
12038     case TARGET_NR_lremovexattr:
12039         {
12040             void *p, *n;
12041             p = lock_user_string(arg1);
12042             n = lock_user_string(arg2);
12043             if (p && n) {
12044                 if (num == TARGET_NR_removexattr) {
12045                     ret = get_errno(removexattr(p, n));
12046                 } else {
12047                     ret = get_errno(lremovexattr(p, n));
12048                 }
12049             } else {
12050                 ret = -TARGET_EFAULT;
12051             }
12052             unlock_user(p, arg1, 0);
12053             unlock_user(n, arg2, 0);
12054         }
12055         return ret;
12056     case TARGET_NR_fremovexattr:
12057         {
12058             void *n;
12059             n = lock_user_string(arg2);
12060             if (n) {
12061                 ret = get_errno(fremovexattr(arg1, n));
12062             } else {
12063                 ret = -TARGET_EFAULT;
12064             }
12065             unlock_user(n, arg2, 0);
12066         }
12067         return ret;
12068 #endif
12069 #endif /* CONFIG_ATTR */
12070 #ifdef TARGET_NR_set_thread_area
12071     case TARGET_NR_set_thread_area:
12072 #if defined(TARGET_MIPS)
12073       ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1;
12074       return 0;
12075 #elif defined(TARGET_CRIS)
12076       if (arg1 & 0xff)
12077           ret = -TARGET_EINVAL;
12078       else {
12079           ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
12080           ret = 0;
12081       }
12082       return ret;
12083 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
12084       return do_set_thread_area(cpu_env, arg1);
12085 #elif defined(TARGET_M68K)
12086       {
12087           TaskState *ts = cpu->opaque;
12088           ts->tp_value = arg1;
12089           return 0;
12090       }
12091 #else
12092       return -TARGET_ENOSYS;
12093 #endif
12094 #endif
12095 #ifdef TARGET_NR_get_thread_area
12096     case TARGET_NR_get_thread_area:
12097 #if defined(TARGET_I386) && defined(TARGET_ABI32)
12098         return do_get_thread_area(cpu_env, arg1);
12099 #elif defined(TARGET_M68K)
12100         {
12101             TaskState *ts = cpu->opaque;
12102             return ts->tp_value;
12103         }
12104 #else
12105         return -TARGET_ENOSYS;
12106 #endif
12107 #endif
12108 #ifdef TARGET_NR_getdomainname
12109     case TARGET_NR_getdomainname:
12110         return -TARGET_ENOSYS;
12111 #endif
12112
12113 #ifdef TARGET_NR_clock_settime
12114     case TARGET_NR_clock_settime:
12115     {
12116         struct timespec ts;
12117
12118         ret = target_to_host_timespec(&ts, arg2);
12119         if (!is_error(ret)) {
12120             ret = get_errno(clock_settime(arg1, &ts));
12121         }
12122         return ret;
12123     }
12124 #endif
12125 #ifdef TARGET_NR_clock_settime64
12126     case TARGET_NR_clock_settime64:
12127     {
12128         struct timespec ts;
12129
12130         ret = target_to_host_timespec64(&ts, arg2);
12131         if (!is_error(ret)) {
12132             ret = get_errno(clock_settime(arg1, &ts));
12133         }
12134         return ret;
12135     }
12136 #endif
12137 #ifdef TARGET_NR_clock_gettime
12138     case TARGET_NR_clock_gettime:
12139     {
12140         struct timespec ts;
12141         ret = get_errno(clock_gettime(arg1, &ts));
12142         if (!is_error(ret)) {
12143             ret = host_to_target_timespec(arg2, &ts);
12144         }
12145         return ret;
12146     }
12147 #endif
12148 #ifdef TARGET_NR_clock_gettime64
12149     case TARGET_NR_clock_gettime64:
12150     {
12151         struct timespec ts;
12152         ret = get_errno(clock_gettime(arg1, &ts));
12153         if (!is_error(ret)) {
12154             ret = host_to_target_timespec64(arg2, &ts);
12155         }
12156         return ret;
12157     }
12158 #endif
12159 #ifdef TARGET_NR_clock_getres
12160     case TARGET_NR_clock_getres:
12161     {
12162         struct timespec ts;
12163         ret = get_errno(clock_getres(arg1, &ts));
12164         if (!is_error(ret)) {
12165             host_to_target_timespec(arg2, &ts);
12166         }
12167         return ret;
12168     }
12169 #endif
12170 #ifdef TARGET_NR_clock_getres_time64
12171     case TARGET_NR_clock_getres_time64:
12172     {
12173         struct timespec ts;
12174         ret = get_errno(clock_getres(arg1, &ts));
12175         if (!is_error(ret)) {
12176             host_to_target_timespec64(arg2, &ts);
12177         }
12178         return ret;
12179     }
12180 #endif
12181 #ifdef TARGET_NR_clock_nanosleep
12182     case TARGET_NR_clock_nanosleep:
12183     {
12184         struct timespec ts;
12185         if (target_to_host_timespec(&ts, arg3)) {
12186             return -TARGET_EFAULT;
12187         }
12188         ret = get_errno(safe_clock_nanosleep(arg1, arg2,
12189                                              &ts, arg4 ? &ts : NULL));
12190         /*
12191          * if the call is interrupted by a signal handler, it fails
12192          * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not
12193          * TIMER_ABSTIME, it returns the remaining unslept time in arg4.
12194          */
12195         if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME &&
12196             host_to_target_timespec(arg4, &ts)) {
12197               return -TARGET_EFAULT;
12198         }
12199
12200         return ret;
12201     }
12202 #endif
12203 #ifdef TARGET_NR_clock_nanosleep_time64
12204     case TARGET_NR_clock_nanosleep_time64:
12205     {
12206         struct timespec ts;
12207
12208         if (target_to_host_timespec64(&ts, arg3)) {
12209             return -TARGET_EFAULT;
12210         }
12211
12212         ret = get_errno(safe_clock_nanosleep(arg1, arg2,
12213                                              &ts, arg4 ? &ts : NULL));
12214
12215         if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME &&
12216             host_to_target_timespec64(arg4, &ts)) {
12217             return -TARGET_EFAULT;
12218         }
12219         return ret;
12220     }
12221 #endif
12222
12223 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
12224     case TARGET_NR_set_tid_address:
12225         return get_errno(set_tid_address((int *)g2h(cpu, arg1)));
12226 #endif
12227
12228     case TARGET_NR_tkill:
12229         return get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2)));
12230
12231     case TARGET_NR_tgkill:
12232         return get_errno(safe_tgkill((int)arg1, (int)arg2,
12233                          target_to_host_signal(arg3)));
12234
12235 #ifdef TARGET_NR_set_robust_list
12236     case TARGET_NR_set_robust_list:
12237     case TARGET_NR_get_robust_list:
12238         /* The ABI for supporting robust futexes has userspace pass
12239          * the kernel a pointer to a linked list which is updated by
12240          * userspace after the syscall; the list is walked by the kernel
12241          * when the thread exits. Since the linked list in QEMU guest
12242          * memory isn't a valid linked list for the host and we have
12243          * no way to reliably intercept the thread-death event, we can't
12244          * support these. Silently return ENOSYS so that guest userspace
12245          * falls back to a non-robust futex implementation (which should
12246          * be OK except in the corner case of the guest crashing while
12247          * holding a mutex that is shared with another process via
12248          * shared memory).
12249          */
12250         return -TARGET_ENOSYS;
12251 #endif
12252
12253 #if defined(TARGET_NR_utimensat)
12254     case TARGET_NR_utimensat:
12255         {
12256             struct timespec *tsp, ts[2];
12257             if (!arg3) {
12258                 tsp = NULL;
12259             } else {
12260                 if (target_to_host_timespec(ts, arg3)) {
12261                     return -TARGET_EFAULT;
12262                 }
12263                 if (target_to_host_timespec(ts + 1, arg3 +
12264                                             sizeof(struct target_timespec))) {
12265                     return -TARGET_EFAULT;
12266                 }
12267                 tsp = ts;
12268             }
12269             if (!arg2)
12270                 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
12271             else {
12272                 if (!(p = lock_user_string(arg2))) {
12273                     return -TARGET_EFAULT;
12274                 }
12275                 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
12276                 unlock_user(p, arg2, 0);
12277             }
12278         }
12279         return ret;
12280 #endif
12281 #ifdef TARGET_NR_utimensat_time64
12282     case TARGET_NR_utimensat_time64:
12283         {
12284             struct timespec *tsp, ts[2];
12285             if (!arg3) {
12286                 tsp = NULL;
12287             } else {
12288                 if (target_to_host_timespec64(ts, arg3)) {
12289                     return -TARGET_EFAULT;
12290                 }
12291                 if (target_to_host_timespec64(ts + 1, arg3 +
12292                                      sizeof(struct target__kernel_timespec))) {
12293                     return -TARGET_EFAULT;
12294                 }
12295                 tsp = ts;
12296             }
12297             if (!arg2)
12298                 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
12299             else {
12300                 p = lock_user_string(arg2);
12301                 if (!p) {
12302                     return -TARGET_EFAULT;
12303                 }
12304                 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
12305                 unlock_user(p, arg2, 0);
12306             }
12307         }
12308         return ret;
12309 #endif
12310 #ifdef TARGET_NR_futex
12311     case TARGET_NR_futex:
12312         return do_futex(cpu, arg1, arg2, arg3, arg4, arg5, arg6);
12313 #endif
12314 #ifdef TARGET_NR_futex_time64
12315     case TARGET_NR_futex_time64:
12316         return do_futex_time64(cpu, arg1, arg2, arg3, arg4, arg5, arg6);
12317 #endif
12318 #ifdef CONFIG_INOTIFY
12319 #if defined(TARGET_NR_inotify_init)
12320     case TARGET_NR_inotify_init:
12321         ret = get_errno(inotify_init());
12322         if (ret >= 0) {
12323             fd_trans_register(ret, &target_inotify_trans);
12324         }
12325         return ret;
12326 #endif
12327 #if defined(TARGET_NR_inotify_init1) && defined(CONFIG_INOTIFY1)
12328     case TARGET_NR_inotify_init1:
12329         ret = get_errno(inotify_init1(target_to_host_bitmask(arg1,
12330                                           fcntl_flags_tbl)));
12331         if (ret >= 0) {
12332             fd_trans_register(ret, &target_inotify_trans);
12333         }
12334         return ret;
12335 #endif
12336 #if defined(TARGET_NR_inotify_add_watch)
12337     case TARGET_NR_inotify_add_watch:
12338         p = lock_user_string(arg2);
12339         ret = get_errno(inotify_add_watch(arg1, path(p), arg3));
12340         unlock_user(p, arg2, 0);
12341         return ret;
12342 #endif
12343 #if defined(TARGET_NR_inotify_rm_watch)
12344     case TARGET_NR_inotify_rm_watch:
12345         return get_errno(inotify_rm_watch(arg1, arg2));
12346 #endif
12347 #endif
12348
12349 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
12350     case TARGET_NR_mq_open:
12351         {
12352             struct mq_attr posix_mq_attr;
12353             struct mq_attr *pposix_mq_attr;
12354             int host_flags;
12355
12356             host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl);
12357             pposix_mq_attr = NULL;
12358             if (arg4) {
12359                 if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) {
12360                     return -TARGET_EFAULT;
12361                 }
12362                 pposix_mq_attr = &posix_mq_attr;
12363             }
12364             p = lock_user_string(arg1 - 1);
12365             if (!p) {
12366                 return -TARGET_EFAULT;
12367             }
12368             ret = get_errno(mq_open(p, host_flags, arg3, pposix_mq_attr));
12369             unlock_user (p, arg1, 0);
12370         }
12371         return ret;
12372
12373     case TARGET_NR_mq_unlink:
12374         p = lock_user_string(arg1 - 1);
12375         if (!p) {
12376             return -TARGET_EFAULT;
12377         }
12378         ret = get_errno(mq_unlink(p));
12379         unlock_user (p, arg1, 0);
12380         return ret;
12381
12382 #ifdef TARGET_NR_mq_timedsend
12383     case TARGET_NR_mq_timedsend:
12384         {
12385             struct timespec ts;
12386
12387             p = lock_user (VERIFY_READ, arg2, arg3, 1);
12388             if (arg5 != 0) {
12389                 if (target_to_host_timespec(&ts, arg5)) {
12390                     return -TARGET_EFAULT;
12391                 }
12392                 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
12393                 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) {
12394                     return -TARGET_EFAULT;
12395                 }
12396             } else {
12397                 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
12398             }
12399             unlock_user (p, arg2, arg3);
12400         }
12401         return ret;
12402 #endif
12403 #ifdef TARGET_NR_mq_timedsend_time64
12404     case TARGET_NR_mq_timedsend_time64:
12405         {
12406             struct timespec ts;
12407
12408             p = lock_user(VERIFY_READ, arg2, arg3, 1);
12409             if (arg5 != 0) {
12410                 if (target_to_host_timespec64(&ts, arg5)) {
12411                     return -TARGET_EFAULT;
12412                 }
12413                 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
12414                 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) {
12415                     return -TARGET_EFAULT;
12416                 }
12417             } else {
12418                 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
12419             }
12420             unlock_user(p, arg2, arg3);
12421         }
12422         return ret;
12423 #endif
12424
12425 #ifdef TARGET_NR_mq_timedreceive
12426     case TARGET_NR_mq_timedreceive:
12427         {
12428             struct timespec ts;
12429             unsigned int prio;
12430
12431             p = lock_user (VERIFY_READ, arg2, arg3, 1);
12432             if (arg5 != 0) {
12433                 if (target_to_host_timespec(&ts, arg5)) {
12434                     return -TARGET_EFAULT;
12435                 }
12436                 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12437                                                      &prio, &ts));
12438                 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) {
12439                     return -TARGET_EFAULT;
12440                 }
12441             } else {
12442                 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12443                                                      &prio, NULL));
12444             }
12445             unlock_user (p, arg2, arg3);
12446             if (arg4 != 0)
12447                 put_user_u32(prio, arg4);
12448         }
12449         return ret;
12450 #endif
12451 #ifdef TARGET_NR_mq_timedreceive_time64
12452     case TARGET_NR_mq_timedreceive_time64:
12453         {
12454             struct timespec ts;
12455             unsigned int prio;
12456
12457             p = lock_user(VERIFY_READ, arg2, arg3, 1);
12458             if (arg5 != 0) {
12459                 if (target_to_host_timespec64(&ts, arg5)) {
12460                     return -TARGET_EFAULT;
12461                 }
12462                 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12463                                                      &prio, &ts));
12464                 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) {
12465                     return -TARGET_EFAULT;
12466                 }
12467             } else {
12468                 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12469                                                      &prio, NULL));
12470             }
12471             unlock_user(p, arg2, arg3);
12472             if (arg4 != 0) {
12473                 put_user_u32(prio, arg4);
12474             }
12475         }
12476         return ret;
12477 #endif
12478
12479     /* Not implemented for now... */
12480 /*     case TARGET_NR_mq_notify: */
12481 /*         break; */
12482
12483     case TARGET_NR_mq_getsetattr:
12484         {
12485             struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
12486             ret = 0;
12487             if (arg2 != 0) {
12488                 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
12489                 ret = get_errno(mq_setattr(arg1, &posix_mq_attr_in,
12490                                            &posix_mq_attr_out));
12491             } else if (arg3 != 0) {
12492                 ret = get_errno(mq_getattr(arg1, &posix_mq_attr_out));
12493             }
12494             if (ret == 0 && arg3 != 0) {
12495                 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
12496             }
12497         }
12498         return ret;
12499 #endif
12500
12501 #ifdef CONFIG_SPLICE
12502 #ifdef TARGET_NR_tee
12503     case TARGET_NR_tee:
12504         {
12505             ret = get_errno(tee(arg1,arg2,arg3,arg4));
12506         }
12507         return ret;
12508 #endif
12509 #ifdef TARGET_NR_splice
12510     case TARGET_NR_splice:
12511         {
12512             loff_t loff_in, loff_out;
12513             loff_t *ploff_in = NULL, *ploff_out = NULL;
12514             if (arg2) {
12515                 if (get_user_u64(loff_in, arg2)) {
12516                     return -TARGET_EFAULT;
12517                 }
12518                 ploff_in = &loff_in;
12519             }
12520             if (arg4) {
12521                 if (get_user_u64(loff_out, arg4)) {
12522                     return -TARGET_EFAULT;
12523                 }
12524                 ploff_out = &loff_out;
12525             }
12526             ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
12527             if (arg2) {
12528                 if (put_user_u64(loff_in, arg2)) {
12529                     return -TARGET_EFAULT;
12530                 }
12531             }
12532             if (arg4) {
12533                 if (put_user_u64(loff_out, arg4)) {
12534                     return -TARGET_EFAULT;
12535                 }
12536             }
12537         }
12538         return ret;
12539 #endif
12540 #ifdef TARGET_NR_vmsplice
12541         case TARGET_NR_vmsplice:
12542         {
12543             struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
12544             if (vec != NULL) {
12545                 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
12546                 unlock_iovec(vec, arg2, arg3, 0);
12547             } else {
12548                 ret = -host_to_target_errno(errno);
12549             }
12550         }
12551         return ret;
12552 #endif
12553 #endif /* CONFIG_SPLICE */
12554 #ifdef CONFIG_EVENTFD
12555 #if defined(TARGET_NR_eventfd)
12556     case TARGET_NR_eventfd:
12557         ret = get_errno(eventfd(arg1, 0));
12558         if (ret >= 0) {
12559             fd_trans_register(ret, &target_eventfd_trans);
12560         }
12561         return ret;
12562 #endif
12563 #if defined(TARGET_NR_eventfd2)
12564     case TARGET_NR_eventfd2:
12565     {
12566         int host_flags = arg2 & (~(TARGET_O_NONBLOCK_MASK | TARGET_O_CLOEXEC));
12567         if (arg2 & TARGET_O_NONBLOCK) {
12568             host_flags |= O_NONBLOCK;
12569         }
12570         if (arg2 & TARGET_O_CLOEXEC) {
12571             host_flags |= O_CLOEXEC;
12572         }
12573         ret = get_errno(eventfd(arg1, host_flags));
12574         if (ret >= 0) {
12575             fd_trans_register(ret, &target_eventfd_trans);
12576         }
12577         return ret;
12578     }
12579 #endif
12580 #endif /* CONFIG_EVENTFD  */
12581 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
12582     case TARGET_NR_fallocate:
12583 #if TARGET_ABI_BITS == 32
12584         ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
12585                                   target_offset64(arg5, arg6)));
12586 #else
12587         ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
12588 #endif
12589         return ret;
12590 #endif
12591 #if defined(CONFIG_SYNC_FILE_RANGE)
12592 #if defined(TARGET_NR_sync_file_range)
12593     case TARGET_NR_sync_file_range:
12594 #if TARGET_ABI_BITS == 32
12595 #if defined(TARGET_MIPS)
12596         ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
12597                                         target_offset64(arg5, arg6), arg7));
12598 #else
12599         ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
12600                                         target_offset64(arg4, arg5), arg6));
12601 #endif /* !TARGET_MIPS */
12602 #else
12603         ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
12604 #endif
12605         return ret;
12606 #endif
12607 #if defined(TARGET_NR_sync_file_range2) || \
12608     defined(TARGET_NR_arm_sync_file_range)
12609 #if defined(TARGET_NR_sync_file_range2)
12610     case TARGET_NR_sync_file_range2:
12611 #endif
12612 #if defined(TARGET_NR_arm_sync_file_range)
12613     case TARGET_NR_arm_sync_file_range:
12614 #endif
12615         /* This is like sync_file_range but the arguments are reordered */
12616 #if TARGET_ABI_BITS == 32
12617         ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
12618                                         target_offset64(arg5, arg6), arg2));
12619 #else
12620         ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
12621 #endif
12622         return ret;
12623 #endif
12624 #endif
12625 #if defined(TARGET_NR_signalfd4)
12626     case TARGET_NR_signalfd4:
12627         return do_signalfd4(arg1, arg2, arg4);
12628 #endif
12629 #if defined(TARGET_NR_signalfd)
12630     case TARGET_NR_signalfd:
12631         return do_signalfd4(arg1, arg2, 0);
12632 #endif
12633 #if defined(CONFIG_EPOLL)
12634 #if defined(TARGET_NR_epoll_create)
12635     case TARGET_NR_epoll_create:
12636         return get_errno(epoll_create(arg1));
12637 #endif
12638 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
12639     case TARGET_NR_epoll_create1:
12640         return get_errno(epoll_create1(target_to_host_bitmask(arg1, fcntl_flags_tbl)));
12641 #endif
12642 #if defined(TARGET_NR_epoll_ctl)
12643     case TARGET_NR_epoll_ctl:
12644     {
12645         struct epoll_event ep;
12646         struct epoll_event *epp = 0;
12647         if (arg4) {
12648             if (arg2 != EPOLL_CTL_DEL) {
12649                 struct target_epoll_event *target_ep;
12650                 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
12651                     return -TARGET_EFAULT;
12652                 }
12653                 ep.events = tswap32(target_ep->events);
12654                 /*
12655                  * The epoll_data_t union is just opaque data to the kernel,
12656                  * so we transfer all 64 bits across and need not worry what
12657                  * actual data type it is.
12658                  */
12659                 ep.data.u64 = tswap64(target_ep->data.u64);
12660                 unlock_user_struct(target_ep, arg4, 0);
12661             }
12662             /*
12663              * before kernel 2.6.9, EPOLL_CTL_DEL operation required a
12664              * non-null pointer, even though this argument is ignored.
12665              *
12666              */
12667             epp = &ep;
12668         }
12669         return get_errno(epoll_ctl(arg1, arg2, arg3, epp));
12670     }
12671 #endif
12672
12673 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
12674 #if defined(TARGET_NR_epoll_wait)
12675     case TARGET_NR_epoll_wait:
12676 #endif
12677 #if defined(TARGET_NR_epoll_pwait)
12678     case TARGET_NR_epoll_pwait:
12679 #endif
12680     {
12681         struct target_epoll_event *target_ep;
12682         struct epoll_event *ep;
12683         int epfd = arg1;
12684         int maxevents = arg3;
12685         int timeout = arg4;
12686
12687         if (maxevents <= 0 || maxevents > TARGET_EP_MAX_EVENTS) {
12688             return -TARGET_EINVAL;
12689         }
12690
12691         target_ep = lock_user(VERIFY_WRITE, arg2,
12692                               maxevents * sizeof(struct target_epoll_event), 1);
12693         if (!target_ep) {
12694             return -TARGET_EFAULT;
12695         }
12696
12697         ep = g_try_new(struct epoll_event, maxevents);
12698         if (!ep) {
12699             unlock_user(target_ep, arg2, 0);
12700             return -TARGET_ENOMEM;
12701         }
12702
12703         switch (num) {
12704 #if defined(TARGET_NR_epoll_pwait)
12705         case TARGET_NR_epoll_pwait:
12706         {
12707             target_sigset_t *target_set;
12708             sigset_t _set, *set = &_set;
12709
12710             if (arg5) {
12711                 if (arg6 != sizeof(target_sigset_t)) {
12712                     ret = -TARGET_EINVAL;
12713                     break;
12714                 }
12715
12716                 target_set = lock_user(VERIFY_READ, arg5,
12717                                        sizeof(target_sigset_t), 1);
12718                 if (!target_set) {
12719                     ret = -TARGET_EFAULT;
12720                     break;
12721                 }
12722                 target_to_host_sigset(set, target_set);
12723                 unlock_user(target_set, arg5, 0);
12724             } else {
12725                 set = NULL;
12726             }
12727
12728             ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12729                                              set, SIGSET_T_SIZE));
12730             break;
12731         }
12732 #endif
12733 #if defined(TARGET_NR_epoll_wait)
12734         case TARGET_NR_epoll_wait:
12735             ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12736                                              NULL, 0));
12737             break;
12738 #endif
12739         default:
12740             ret = -TARGET_ENOSYS;
12741         }
12742         if (!is_error(ret)) {
12743             int i;
12744             for (i = 0; i < ret; i++) {
12745                 target_ep[i].events = tswap32(ep[i].events);
12746                 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
12747             }
12748             unlock_user(target_ep, arg2,
12749                         ret * sizeof(struct target_epoll_event));
12750         } else {
12751             unlock_user(target_ep, arg2, 0);
12752         }
12753         g_free(ep);
12754         return ret;
12755     }
12756 #endif
12757 #endif
12758 #ifdef TARGET_NR_prlimit64
12759     case TARGET_NR_prlimit64:
12760     {
12761         /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
12762         struct target_rlimit64 *target_rnew, *target_rold;
12763         struct host_rlimit64 rnew, rold, *rnewp = 0;
12764         int resource = target_to_host_resource(arg2);
12765
12766         if (arg3 && (resource != RLIMIT_AS &&
12767                      resource != RLIMIT_DATA &&
12768                      resource != RLIMIT_STACK)) {
12769             if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
12770                 return -TARGET_EFAULT;
12771             }
12772             rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
12773             rnew.rlim_max = tswap64(target_rnew->rlim_max);
12774             unlock_user_struct(target_rnew, arg3, 0);
12775             rnewp = &rnew;
12776         }
12777
12778         ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0));
12779         if (!is_error(ret) && arg4) {
12780             if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
12781                 return -TARGET_EFAULT;
12782             }
12783             target_rold->rlim_cur = tswap64(rold.rlim_cur);
12784             target_rold->rlim_max = tswap64(rold.rlim_max);
12785             unlock_user_struct(target_rold, arg4, 1);
12786         }
12787         return ret;
12788     }
12789 #endif
12790 #ifdef TARGET_NR_gethostname
12791     case TARGET_NR_gethostname:
12792     {
12793         char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
12794         if (name) {
12795             ret = get_errno(gethostname(name, arg2));
12796             unlock_user(name, arg1, arg2);
12797         } else {
12798             ret = -TARGET_EFAULT;
12799         }
12800         return ret;
12801     }
12802 #endif
12803 #ifdef TARGET_NR_atomic_cmpxchg_32
12804     case TARGET_NR_atomic_cmpxchg_32:
12805     {
12806         /* should use start_exclusive from main.c */
12807         abi_ulong mem_value;
12808         if (get_user_u32(mem_value, arg6)) {
12809             target_siginfo_t info;
12810             info.si_signo = SIGSEGV;
12811             info.si_errno = 0;
12812             info.si_code = TARGET_SEGV_MAPERR;
12813             info._sifields._sigfault._addr = arg6;
12814             queue_signal((CPUArchState *)cpu_env, info.si_signo,
12815                          QEMU_SI_FAULT, &info);
12816             ret = 0xdeadbeef;
12817
12818         }
12819         if (mem_value == arg2)
12820             put_user_u32(arg1, arg6);
12821         return mem_value;
12822     }
12823 #endif
12824 #ifdef TARGET_NR_atomic_barrier
12825     case TARGET_NR_atomic_barrier:
12826         /* Like the kernel implementation and the
12827            qemu arm barrier, no-op this? */
12828         return 0;
12829 #endif
12830
12831 #ifdef TARGET_NR_timer_create
12832     case TARGET_NR_timer_create:
12833     {
12834         /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
12835
12836         struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
12837
12838         int clkid = arg1;
12839         int timer_index = next_free_host_timer();
12840
12841         if (timer_index < 0) {
12842             ret = -TARGET_EAGAIN;
12843         } else {
12844             timer_t *phtimer = g_posix_timers  + timer_index;
12845
12846             if (arg2) {
12847                 phost_sevp = &host_sevp;
12848                 ret = target_to_host_sigevent(phost_sevp, arg2);
12849                 if (ret != 0) {
12850                     return ret;
12851                 }
12852             }
12853
12854             ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
12855             if (ret) {
12856                 phtimer = NULL;
12857             } else {
12858                 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) {
12859                     return -TARGET_EFAULT;
12860                 }
12861             }
12862         }
12863         return ret;
12864     }
12865 #endif
12866
12867 #ifdef TARGET_NR_timer_settime
12868     case TARGET_NR_timer_settime:
12869     {
12870         /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
12871          * struct itimerspec * old_value */
12872         target_timer_t timerid = get_timer_id(arg1);
12873
12874         if (timerid < 0) {
12875             ret = timerid;
12876         } else if (arg3 == 0) {
12877             ret = -TARGET_EINVAL;
12878         } else {
12879             timer_t htimer = g_posix_timers[timerid];
12880             struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
12881
12882             if (target_to_host_itimerspec(&hspec_new, arg3)) {
12883                 return -TARGET_EFAULT;
12884             }
12885             ret = get_errno(
12886                           timer_settime(htimer, arg2, &hspec_new, &hspec_old));
12887             if (arg4 && host_to_target_itimerspec(arg4, &hspec_old)) {
12888                 return -TARGET_EFAULT;
12889             }
12890         }
12891         return ret;
12892     }
12893 #endif
12894
12895 #ifdef TARGET_NR_timer_settime64
12896     case TARGET_NR_timer_settime64:
12897     {
12898         target_timer_t timerid = get_timer_id(arg1);
12899
12900         if (timerid < 0) {
12901             ret = timerid;
12902         } else if (arg3 == 0) {
12903             ret = -TARGET_EINVAL;
12904         } else {
12905             timer_t htimer = g_posix_timers[timerid];
12906             struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
12907
12908             if (target_to_host_itimerspec64(&hspec_new, arg3)) {
12909                 return -TARGET_EFAULT;
12910             }
12911             ret = get_errno(
12912                           timer_settime(htimer, arg2, &hspec_new, &hspec_old));
12913             if (arg4 && host_to_target_itimerspec64(arg4, &hspec_old)) {
12914                 return -TARGET_EFAULT;
12915             }
12916         }
12917         return ret;
12918     }
12919 #endif
12920
12921 #ifdef TARGET_NR_timer_gettime
12922     case TARGET_NR_timer_gettime:
12923     {
12924         /* args: timer_t timerid, struct itimerspec *curr_value */
12925         target_timer_t timerid = get_timer_id(arg1);
12926
12927         if (timerid < 0) {
12928             ret = timerid;
12929         } else if (!arg2) {
12930             ret = -TARGET_EFAULT;
12931         } else {
12932             timer_t htimer = g_posix_timers[timerid];
12933             struct itimerspec hspec;
12934             ret = get_errno(timer_gettime(htimer, &hspec));
12935
12936             if (host_to_target_itimerspec(arg2, &hspec)) {
12937                 ret = -TARGET_EFAULT;
12938             }
12939         }
12940         return ret;
12941     }
12942 #endif
12943
12944 #ifdef TARGET_NR_timer_gettime64
12945     case TARGET_NR_timer_gettime64:
12946     {
12947         /* args: timer_t timerid, struct itimerspec64 *curr_value */
12948         target_timer_t timerid = get_timer_id(arg1);
12949
12950         if (timerid < 0) {
12951             ret = timerid;
12952         } else if (!arg2) {
12953             ret = -TARGET_EFAULT;
12954         } else {
12955             timer_t htimer = g_posix_timers[timerid];
12956             struct itimerspec hspec;
12957             ret = get_errno(timer_gettime(htimer, &hspec));
12958
12959             if (host_to_target_itimerspec64(arg2, &hspec)) {
12960                 ret = -TARGET_EFAULT;
12961             }
12962         }
12963         return ret;
12964     }
12965 #endif
12966
12967 #ifdef TARGET_NR_timer_getoverrun
12968     case TARGET_NR_timer_getoverrun:
12969     {
12970         /* args: timer_t timerid */
12971         target_timer_t timerid = get_timer_id(arg1);
12972
12973         if (timerid < 0) {
12974             ret = timerid;
12975         } else {
12976             timer_t htimer = g_posix_timers[timerid];
12977             ret = get_errno(timer_getoverrun(htimer));
12978         }
12979         return ret;
12980     }
12981 #endif
12982
12983 #ifdef TARGET_NR_timer_delete
12984     case TARGET_NR_timer_delete:
12985     {
12986         /* args: timer_t timerid */
12987         target_timer_t timerid = get_timer_id(arg1);
12988
12989         if (timerid < 0) {
12990             ret = timerid;
12991         } else {
12992             timer_t htimer = g_posix_timers[timerid];
12993             ret = get_errno(timer_delete(htimer));
12994             g_posix_timers[timerid] = 0;
12995         }
12996         return ret;
12997     }
12998 #endif
12999
13000 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
13001     case TARGET_NR_timerfd_create:
13002         return get_errno(timerfd_create(arg1,
13003                           target_to_host_bitmask(arg2, fcntl_flags_tbl)));
13004 #endif
13005
13006 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
13007     case TARGET_NR_timerfd_gettime:
13008         {
13009             struct itimerspec its_curr;
13010
13011             ret = get_errno(timerfd_gettime(arg1, &its_curr));
13012
13013             if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) {
13014                 return -TARGET_EFAULT;
13015             }
13016         }
13017         return ret;
13018 #endif
13019
13020 #if defined(TARGET_NR_timerfd_gettime64) && defined(CONFIG_TIMERFD)
13021     case TARGET_NR_timerfd_gettime64:
13022         {
13023             struct itimerspec its_curr;
13024
13025             ret = get_errno(timerfd_gettime(arg1, &its_curr));
13026
13027             if (arg2 && host_to_target_itimerspec64(arg2, &its_curr)) {
13028                 return -TARGET_EFAULT;
13029             }
13030         }
13031         return ret;
13032 #endif
13033
13034 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
13035     case TARGET_NR_timerfd_settime:
13036         {
13037             struct itimerspec its_new, its_old, *p_new;
13038
13039             if (arg3) {
13040                 if (target_to_host_itimerspec(&its_new, arg3)) {
13041                     return -TARGET_EFAULT;
13042                 }
13043                 p_new = &its_new;
13044             } else {
13045                 p_new = NULL;
13046             }
13047
13048             ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
13049
13050             if (arg4 && host_to_target_itimerspec(arg4, &its_old)) {
13051                 return -TARGET_EFAULT;
13052             }
13053         }
13054         return ret;
13055 #endif
13056
13057 #if defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)
13058     case TARGET_NR_timerfd_settime64:
13059         {
13060             struct itimerspec its_new, its_old, *p_new;
13061
13062             if (arg3) {
13063                 if (target_to_host_itimerspec64(&its_new, arg3)) {
13064                     return -TARGET_EFAULT;
13065                 }
13066                 p_new = &its_new;
13067             } else {
13068                 p_new = NULL;
13069             }
13070
13071             ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
13072
13073             if (arg4 && host_to_target_itimerspec64(arg4, &its_old)) {
13074                 return -TARGET_EFAULT;
13075             }
13076         }
13077         return ret;
13078 #endif
13079
13080 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
13081     case TARGET_NR_ioprio_get:
13082         return get_errno(ioprio_get(arg1, arg2));
13083 #endif
13084
13085 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
13086     case TARGET_NR_ioprio_set:
13087         return get_errno(ioprio_set(arg1, arg2, arg3));
13088 #endif
13089
13090 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
13091     case TARGET_NR_setns:
13092         return get_errno(setns(arg1, arg2));
13093 #endif
13094 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
13095     case TARGET_NR_unshare:
13096         return get_errno(unshare(arg1));
13097 #endif
13098 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
13099     case TARGET_NR_kcmp:
13100         return get_errno(kcmp(arg1, arg2, arg3, arg4, arg5));
13101 #endif
13102 #ifdef TARGET_NR_swapcontext
13103     case TARGET_NR_swapcontext:
13104         /* PowerPC specific.  */
13105         return do_swapcontext(cpu_env, arg1, arg2, arg3);
13106 #endif
13107 #ifdef TARGET_NR_memfd_create
13108     case TARGET_NR_memfd_create:
13109         p = lock_user_string(arg1);
13110         if (!p) {
13111             return -TARGET_EFAULT;
13112         }
13113         ret = get_errno(memfd_create(p, arg2));
13114         fd_trans_unregister(ret);
13115         unlock_user(p, arg1, 0);
13116         return ret;
13117 #endif
13118 #if defined TARGET_NR_membarrier && defined __NR_membarrier
13119     case TARGET_NR_membarrier:
13120         return get_errno(membarrier(arg1, arg2));
13121 #endif
13122
13123 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range)
13124     case TARGET_NR_copy_file_range:
13125         {
13126             loff_t inoff, outoff;
13127             loff_t *pinoff = NULL, *poutoff = NULL;
13128
13129             if (arg2) {
13130                 if (get_user_u64(inoff, arg2)) {
13131                     return -TARGET_EFAULT;
13132                 }
13133                 pinoff = &inoff;
13134             }
13135             if (arg4) {
13136                 if (get_user_u64(outoff, arg4)) {
13137                     return -TARGET_EFAULT;
13138                 }
13139                 poutoff = &outoff;
13140             }
13141             /* Do not sign-extend the count parameter. */
13142             ret = get_errno(safe_copy_file_range(arg1, pinoff, arg3, poutoff,
13143                                                  (abi_ulong)arg5, arg6));
13144             if (!is_error(ret) && ret > 0) {
13145                 if (arg2) {
13146                     if (put_user_u64(inoff, arg2)) {
13147                         return -TARGET_EFAULT;
13148                     }
13149                 }
13150                 if (arg4) {
13151                     if (put_user_u64(outoff, arg4)) {
13152                         return -TARGET_EFAULT;
13153                     }
13154                 }
13155             }
13156         }
13157         return ret;
13158 #endif
13159
13160 #if defined(TARGET_NR_pivot_root)
13161     case TARGET_NR_pivot_root:
13162         {
13163             void *p2;
13164             p = lock_user_string(arg1); /* new_root */
13165             p2 = lock_user_string(arg2); /* put_old */
13166             if (!p || !p2) {
13167                 ret = -TARGET_EFAULT;
13168             } else {
13169                 ret = get_errno(pivot_root(p, p2));
13170             }
13171             unlock_user(p2, arg2, 0);
13172             unlock_user(p, arg1, 0);
13173         }
13174         return ret;
13175 #endif
13176
13177     default:
13178         qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num);
13179         return -TARGET_ENOSYS;
13180     }
13181     return ret;
13182 }
13183
13184 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
13185                     abi_long arg2, abi_long arg3, abi_long arg4,
13186                     abi_long arg5, abi_long arg6, abi_long arg7,
13187                     abi_long arg8)
13188 {
13189     CPUState *cpu = env_cpu(cpu_env);
13190     abi_long ret;
13191
13192 #ifdef DEBUG_ERESTARTSYS
13193     /* Debug-only code for exercising the syscall-restart code paths
13194      * in the per-architecture cpu main loops: restart every syscall
13195      * the guest makes once before letting it through.
13196      */
13197     {
13198         static bool flag;
13199         flag = !flag;
13200         if (flag) {
13201             return -QEMU_ERESTARTSYS;
13202         }
13203     }
13204 #endif
13205
13206     record_syscall_start(cpu, num, arg1,
13207                          arg2, arg3, arg4, arg5, arg6, arg7, arg8);
13208
13209     if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
13210         print_syscall(cpu_env, num, arg1, arg2, arg3, arg4, arg5, arg6);
13211     }
13212
13213     ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4,
13214                       arg5, arg6, arg7, arg8);
13215
13216     if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
13217         print_syscall_ret(cpu_env, num, ret, arg1, arg2,
13218                           arg3, arg4, arg5, arg6);
13219     }
13220
13221     record_syscall_return(cpu, num, ret);
13222     return ret;
13223 }