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