4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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/>.
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 "exec/page-protection.h"
35 #include <sys/mount.h>
37 #include <sys/fsuid.h>
38 #include <sys/personality.h>
39 #include <sys/prctl.h>
40 #include <sys/resource.h>
42 #include <linux/capability.h>
44 #include <sys/timex.h>
45 #include <sys/socket.h>
46 #include <linux/sockios.h>
50 #include <sys/times.h>
53 #include <sys/statfs.h>
55 #include <sys/sysinfo.h>
56 #include <sys/signalfd.h>
57 //#include <sys/user.h>
58 #include <netinet/in.h>
59 #include <netinet/ip.h>
60 #include <netinet/tcp.h>
61 #include <netinet/udp.h>
62 #include <linux/wireless.h>
63 #include <linux/icmp.h>
64 #include <linux/icmpv6.h>
65 #include <linux/if_tun.h>
66 #include <linux/in6.h>
67 #include <linux/errqueue.h>
68 #include <linux/random.h>
70 #include <sys/timerfd.h>
73 #include <sys/eventfd.h>
76 #include <sys/epoll.h>
79 #include "qemu/xattr.h"
81 #ifdef CONFIG_SENDFILE
82 #include <sys/sendfile.h>
84 #ifdef HAVE_SYS_KCOV_H
88 #define termios host_termios
89 #define winsize host_winsize
90 #define termio host_termio
91 #define sgttyb host_sgttyb /* same as target */
92 #define tchars host_tchars /* same as target */
93 #define ltchars host_ltchars /* same as target */
95 #include <linux/termios.h>
96 #include <linux/unistd.h>
97 #include <linux/cdrom.h>
98 #include <linux/hdreg.h>
99 #include <linux/soundcard.h>
100 #include <linux/kd.h>
101 #include <linux/mtio.h>
102 #include <linux/fs.h>
103 #include <linux/fd.h>
104 #if defined(CONFIG_FIEMAP)
105 #include <linux/fiemap.h>
107 #include <linux/fb.h>
108 #if defined(CONFIG_USBFS)
109 #include <linux/usbdevice_fs.h>
110 #include <linux/usb/ch9.h>
112 #include <linux/vt.h>
113 #include <linux/dm-ioctl.h>
114 #include <linux/reboot.h>
115 #include <linux/route.h>
116 #include <linux/filter.h>
117 #include <linux/blkpg.h>
118 #include <netpacket/packet.h>
119 #include <linux/netlink.h>
120 #include <linux/if_alg.h>
121 #include <linux/rtc.h>
122 #include <sound/asound.h>
124 #include <linux/btrfs.h>
127 #include <libdrm/drm.h>
128 #include <libdrm/i915_drm.h>
130 #include "linux_loop.h"
134 #include "user-internals.h"
136 #include "signal-common.h"
138 #include "user-mmap.h"
139 #include "user/safe-syscall.h"
140 #include "qemu/guest-random.h"
141 #include "qemu/selfmap.h"
142 #include "user/syscall-trace.h"
143 #include "special-errno.h"
144 #include "qapi/error.h"
145 #include "fd-trans.h"
146 #include "cpu_loop-common.h"
149 #define CLONE_IO 0x80000000 /* Clone io context */
152 /* We can't directly call the host clone syscall, because this will
153 * badly confuse libc (breaking mutexes, for example). So we must
154 * divide clone flags into:
155 * * flag combinations that look like pthread_create()
156 * * flag combinations that look like fork()
157 * * flags we can implement within QEMU itself
158 * * flags we can't support and will return an error for
160 /* For thread creation, all these flags must be present; for
161 * fork, none must be present.
163 #define CLONE_THREAD_FLAGS \
164 (CLONE_VM | CLONE_FS | CLONE_FILES | \
165 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
167 /* These flags are ignored:
168 * CLONE_DETACHED is now ignored by the kernel;
169 * CLONE_IO is just an optimisation hint to the I/O scheduler
171 #define CLONE_IGNORED_FLAGS \
172 (CLONE_DETACHED | CLONE_IO)
175 # define CLONE_PIDFD 0x00001000
178 /* Flags for fork which we can implement within QEMU itself */
179 #define CLONE_OPTIONAL_FORK_FLAGS \
180 (CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_PIDFD | \
181 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
183 /* Flags for thread creation which we can implement within QEMU itself */
184 #define CLONE_OPTIONAL_THREAD_FLAGS \
185 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
186 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
188 #define CLONE_INVALID_FORK_FLAGS \
189 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
191 #define CLONE_INVALID_THREAD_FLAGS \
192 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
193 CLONE_IGNORED_FLAGS))
195 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
196 * have almost all been allocated. We cannot support any of
197 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
198 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
199 * The checks against the invalid thread masks above will catch these.
200 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
203 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
204 * once. This exercises the codepaths for restart.
206 //#define DEBUG_ERESTARTSYS
208 //#include <linux/msdos_fs.h>
209 #define VFAT_IOCTL_READDIR_BOTH \
210 _IOC(_IOC_READ, 'r', 1, (sizeof(struct linux_dirent) + 256) * 2)
211 #define VFAT_IOCTL_READDIR_SHORT \
212 _IOC(_IOC_READ, 'r', 2, (sizeof(struct linux_dirent) + 256) * 2)
222 #define _syscall0(type,name) \
223 static type name (void) \
225 return syscall(__NR_##name); \
228 #define _syscall1(type,name,type1,arg1) \
229 static type name (type1 arg1) \
231 return syscall(__NR_##name, arg1); \
234 #define _syscall2(type,name,type1,arg1,type2,arg2) \
235 static type name (type1 arg1,type2 arg2) \
237 return syscall(__NR_##name, arg1, arg2); \
240 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
241 static type name (type1 arg1,type2 arg2,type3 arg3) \
243 return syscall(__NR_##name, arg1, arg2, arg3); \
246 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
247 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
249 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
252 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
254 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
256 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
260 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
261 type5,arg5,type6,arg6) \
262 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
265 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
269 #define __NR_sys_uname __NR_uname
270 #define __NR_sys_getcwd1 __NR_getcwd
271 #define __NR_sys_getdents __NR_getdents
272 #define __NR_sys_getdents64 __NR_getdents64
273 #define __NR_sys_getpriority __NR_getpriority
274 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
275 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
276 #define __NR_sys_syslog __NR_syslog
277 #if defined(__NR_futex)
278 # define __NR_sys_futex __NR_futex
280 #if defined(__NR_futex_time64)
281 # define __NR_sys_futex_time64 __NR_futex_time64
283 #define __NR_sys_statx __NR_statx
285 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
286 #define __NR__llseek __NR_lseek
289 /* Newer kernel ports have llseek() instead of _llseek() */
290 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
291 #define TARGET_NR__llseek TARGET_NR_llseek
294 /* some platforms need to mask more bits than just TARGET_O_NONBLOCK */
295 #ifndef TARGET_O_NONBLOCK_MASK
296 #define TARGET_O_NONBLOCK_MASK TARGET_O_NONBLOCK
299 #define __NR_sys_gettid __NR_gettid
300 _syscall0(int, sys_gettid
)
302 /* For the 64-bit guest on 32-bit host case we must emulate
303 * getdents using getdents64, because otherwise the host
304 * might hand us back more dirent records than we can fit
305 * into the guest buffer after structure format conversion.
306 * Otherwise we emulate getdents with getdents if the host has it.
308 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
309 #define EMULATE_GETDENTS_WITH_GETDENTS
312 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
313 _syscall3(int, sys_getdents
, unsigned int, fd
, struct linux_dirent
*, dirp
, unsigned int, count
);
315 #if (defined(TARGET_NR_getdents) && \
316 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
317 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
318 _syscall3(int, sys_getdents64
, unsigned int, fd
, struct linux_dirent64
*, dirp
, unsigned int, count
);
320 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
321 _syscall5(int, _llseek
, unsigned int, fd
, unsigned long, hi
, unsigned long, lo
,
322 loff_t
*, res
, unsigned int, wh
);
324 _syscall3(int, sys_rt_sigqueueinfo
, pid_t
, pid
, int, sig
, siginfo_t
*, uinfo
)
325 _syscall4(int, sys_rt_tgsigqueueinfo
, pid_t
, pid
, pid_t
, tid
, int, sig
,
327 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
328 #ifdef __NR_exit_group
329 _syscall1(int,exit_group
,int,error_code
)
331 #if defined(__NR_close_range) && defined(TARGET_NR_close_range)
332 #define __NR_sys_close_range __NR_close_range
333 _syscall3(int,sys_close_range
,int,first
,int,last
,int,flags
)
334 #ifndef CLOSE_RANGE_CLOEXEC
335 #define CLOSE_RANGE_CLOEXEC (1U << 2)
338 #if defined(__NR_futex)
339 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
340 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
342 #if defined(__NR_futex_time64)
343 _syscall6(int,sys_futex_time64
,int *,uaddr
,int,op
,int,val
,
344 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
346 #if defined(__NR_pidfd_open) && defined(TARGET_NR_pidfd_open)
347 _syscall2(int, pidfd_open
, pid_t
, pid
, unsigned int, flags
);
349 #if defined(__NR_pidfd_send_signal) && defined(TARGET_NR_pidfd_send_signal)
350 _syscall4(int, pidfd_send_signal
, int, pidfd
, int, sig
, siginfo_t
*, info
,
351 unsigned int, flags
);
353 #if defined(__NR_pidfd_getfd) && defined(TARGET_NR_pidfd_getfd)
354 _syscall3(int, pidfd_getfd
, int, pidfd
, int, targetfd
, unsigned int, flags
);
356 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
357 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
358 unsigned long *, user_mask_ptr
);
359 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
360 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
361 unsigned long *, user_mask_ptr
);
362 /* sched_attr is not defined in glibc */
365 uint32_t sched_policy
;
366 uint64_t sched_flags
;
368 uint32_t sched_priority
;
369 uint64_t sched_runtime
;
370 uint64_t sched_deadline
;
371 uint64_t sched_period
;
372 uint32_t sched_util_min
;
373 uint32_t sched_util_max
;
375 #define __NR_sys_sched_getattr __NR_sched_getattr
376 _syscall4(int, sys_sched_getattr
, pid_t
, pid
, struct sched_attr
*, attr
,
377 unsigned int, size
, unsigned int, flags
);
378 #define __NR_sys_sched_setattr __NR_sched_setattr
379 _syscall3(int, sys_sched_setattr
, pid_t
, pid
, struct sched_attr
*, attr
,
380 unsigned int, flags
);
381 #define __NR_sys_sched_getscheduler __NR_sched_getscheduler
382 _syscall1(int, sys_sched_getscheduler
, pid_t
, pid
);
383 #define __NR_sys_sched_setscheduler __NR_sched_setscheduler
384 _syscall3(int, sys_sched_setscheduler
, pid_t
, pid
, int, policy
,
385 const struct sched_param
*, param
);
386 #define __NR_sys_sched_getparam __NR_sched_getparam
387 _syscall2(int, sys_sched_getparam
, pid_t
, pid
,
388 struct sched_param
*, param
);
389 #define __NR_sys_sched_setparam __NR_sched_setparam
390 _syscall2(int, sys_sched_setparam
, pid_t
, pid
,
391 const struct sched_param
*, param
);
392 #define __NR_sys_getcpu __NR_getcpu
393 _syscall3(int, sys_getcpu
, unsigned *, cpu
, unsigned *, node
, void *, tcache
);
394 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
396 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
397 struct __user_cap_data_struct
*, data
);
398 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
399 struct __user_cap_data_struct
*, data
);
400 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
401 _syscall2(int, ioprio_get
, int, which
, int, who
)
403 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
404 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
406 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
407 _syscall3(int, getrandom
, void *, buf
, size_t, buflen
, unsigned int, flags
)
410 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
411 _syscall5(int, kcmp
, pid_t
, pid1
, pid_t
, pid2
, int, type
,
412 unsigned long, idx1
, unsigned long, idx2
)
416 * It is assumed that struct statx is architecture independent.
418 #if defined(TARGET_NR_statx) && defined(__NR_statx)
419 _syscall5(int, sys_statx
, int, dirfd
, const char *, pathname
, int, flags
,
420 unsigned int, mask
, struct target_statx
*, statxbuf
)
422 #if defined(TARGET_NR_membarrier) && defined(__NR_membarrier)
423 _syscall2(int, membarrier
, int, cmd
, int, flags
)
426 static const bitmask_transtbl fcntl_flags_tbl
[] = {
427 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
428 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
429 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
430 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
431 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
432 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
433 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
434 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
435 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
436 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
437 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
438 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
439 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
440 #if defined(O_DIRECT)
441 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
443 #if defined(O_NOATIME)
444 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
446 #if defined(O_CLOEXEC)
447 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
450 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
452 #if defined(O_TMPFILE)
453 { TARGET_O_TMPFILE
, TARGET_O_TMPFILE
, O_TMPFILE
, O_TMPFILE
},
455 /* Don't terminate the list prematurely on 64-bit host+guest. */
456 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
457 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
461 _syscall2(int, sys_getcwd1
, char *, buf
, size_t, size
)
463 #if defined(TARGET_NR_utimensat) || defined(TARGET_NR_utimensat_time64)
464 #if defined(__NR_utimensat)
465 #define __NR_sys_utimensat __NR_utimensat
466 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
467 const struct timespec
*,tsp
,int,flags
)
469 static int sys_utimensat(int dirfd
, const char *pathname
,
470 const struct timespec times
[2], int flags
)
476 #endif /* TARGET_NR_utimensat */
478 #ifdef TARGET_NR_renameat2
479 #if defined(__NR_renameat2)
480 #define __NR_sys_renameat2 __NR_renameat2
481 _syscall5(int, sys_renameat2
, int, oldfd
, const char *, old
, int, newfd
,
482 const char *, new, unsigned int, flags
)
484 static int sys_renameat2(int oldfd
, const char *old
,
485 int newfd
, const char *new, int flags
)
488 return renameat(oldfd
, old
, newfd
, new);
494 #endif /* TARGET_NR_renameat2 */
496 #ifdef CONFIG_INOTIFY
497 #include <sys/inotify.h>
499 /* Userspace can usually survive runtime without inotify */
500 #undef TARGET_NR_inotify_init
501 #undef TARGET_NR_inotify_init1
502 #undef TARGET_NR_inotify_add_watch
503 #undef TARGET_NR_inotify_rm_watch
504 #endif /* CONFIG_INOTIFY */
506 #if defined(TARGET_NR_prlimit64)
507 #ifndef __NR_prlimit64
508 # define __NR_prlimit64 -1
510 #define __NR_sys_prlimit64 __NR_prlimit64
511 /* The glibc rlimit structure may not be that used by the underlying syscall */
512 struct host_rlimit64
{
516 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
517 const struct host_rlimit64
*, new_limit
,
518 struct host_rlimit64
*, old_limit
)
522 #if defined(TARGET_NR_timer_create)
523 /* Maximum of 32 active POSIX timers allowed at any one time. */
524 #define GUEST_TIMER_MAX 32
525 static timer_t g_posix_timers
[GUEST_TIMER_MAX
];
526 static int g_posix_timer_allocated
[GUEST_TIMER_MAX
];
528 static inline int next_free_host_timer(void)
531 for (k
= 0; k
< ARRAY_SIZE(g_posix_timer_allocated
); k
++) {
532 if (qatomic_xchg(g_posix_timer_allocated
+ k
, 1) == 0) {
539 static inline void free_host_timer_slot(int id
)
541 qatomic_store_release(g_posix_timer_allocated
+ id
, 0);
545 static inline int host_to_target_errno(int host_errno
)
547 switch (host_errno
) {
548 #define E(X) case X: return TARGET_##X;
549 #include "errnos.c.inc"
556 static inline int target_to_host_errno(int target_errno
)
558 switch (target_errno
) {
559 #define E(X) case TARGET_##X: return X;
560 #include "errnos.c.inc"
567 abi_long
get_errno(abi_long ret
)
570 return -host_to_target_errno(errno
);
575 const char *target_strerror(int err
)
577 if (err
== QEMU_ERESTARTSYS
) {
578 return "To be restarted";
580 if (err
== QEMU_ESIGRETURN
) {
581 return "Successful exit from sigreturn";
584 return strerror(target_to_host_errno(err
));
587 static int check_zeroed_user(abi_long addr
, size_t ksize
, size_t usize
)
591 if (usize
<= ksize
) {
594 for (i
= ksize
; i
< usize
; i
++) {
595 if (get_user_u8(b
, addr
+ i
)) {
596 return -TARGET_EFAULT
;
605 #define safe_syscall0(type, name) \
606 static type safe_##name(void) \
608 return safe_syscall(__NR_##name); \
611 #define safe_syscall1(type, name, type1, arg1) \
612 static type safe_##name(type1 arg1) \
614 return safe_syscall(__NR_##name, arg1); \
617 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
618 static type safe_##name(type1 arg1, type2 arg2) \
620 return safe_syscall(__NR_##name, arg1, arg2); \
623 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
624 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
626 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
629 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
631 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
633 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
636 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
637 type4, arg4, type5, arg5) \
638 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
641 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
644 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
645 type4, arg4, type5, arg5, type6, arg6) \
646 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
647 type5 arg5, type6 arg6) \
649 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
652 safe_syscall3(ssize_t
, read
, int, fd
, void *, buff
, size_t, count
)
653 safe_syscall3(ssize_t
, write
, int, fd
, const void *, buff
, size_t, count
)
654 safe_syscall4(int, openat
, int, dirfd
, const char *, pathname
, \
655 int, flags
, mode_t
, mode
)
656 #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid)
657 safe_syscall4(pid_t
, wait4
, pid_t
, pid
, int *, status
, int, options
, \
658 struct rusage
*, rusage
)
660 safe_syscall5(int, waitid
, idtype_t
, idtype
, id_t
, id
, siginfo_t
*, infop
, \
661 int, options
, struct rusage
*, rusage
)
662 safe_syscall3(int, execve
, const char *, filename
, char **, argv
, char **, envp
)
663 safe_syscall5(int, execveat
, int, dirfd
, const char *, filename
,
664 char **, argv
, char **, envp
, int, flags
)
665 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
666 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
667 safe_syscall6(int, pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
, \
668 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
)
670 #if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
671 safe_syscall5(int, ppoll
, struct pollfd
*, ufds
, unsigned int, nfds
,
672 struct timespec
*, tsp
, const sigset_t
*, sigmask
,
675 safe_syscall6(int, epoll_pwait
, int, epfd
, struct epoll_event
*, events
,
676 int, maxevents
, int, timeout
, const sigset_t
*, sigmask
,
678 #if defined(__NR_futex)
679 safe_syscall6(int,futex
,int *,uaddr
,int,op
,int,val
, \
680 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
682 #if defined(__NR_futex_time64)
683 safe_syscall6(int,futex_time64
,int *,uaddr
,int,op
,int,val
, \
684 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
686 safe_syscall2(int, rt_sigsuspend
, sigset_t
*, newset
, size_t, sigsetsize
)
687 safe_syscall2(int, kill
, pid_t
, pid
, int, sig
)
688 safe_syscall2(int, tkill
, int, tid
, int, sig
)
689 safe_syscall3(int, tgkill
, int, tgid
, int, pid
, int, sig
)
690 safe_syscall3(ssize_t
, readv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
691 safe_syscall3(ssize_t
, writev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
692 safe_syscall5(ssize_t
, preadv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
693 unsigned long, pos_l
, unsigned long, pos_h
)
694 safe_syscall5(ssize_t
, pwritev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
695 unsigned long, pos_l
, unsigned long, pos_h
)
696 safe_syscall3(int, connect
, int, fd
, const struct sockaddr
*, addr
,
698 safe_syscall6(ssize_t
, sendto
, int, fd
, const void *, buf
, size_t, len
,
699 int, flags
, const struct sockaddr
*, addr
, socklen_t
, addrlen
)
700 safe_syscall6(ssize_t
, recvfrom
, int, fd
, void *, buf
, size_t, len
,
701 int, flags
, struct sockaddr
*, addr
, socklen_t
*, addrlen
)
702 safe_syscall3(ssize_t
, sendmsg
, int, fd
, const struct msghdr
*, msg
, int, flags
)
703 safe_syscall3(ssize_t
, recvmsg
, int, fd
, struct msghdr
*, msg
, int, flags
)
704 safe_syscall2(int, flock
, int, fd
, int, operation
)
705 #if defined(TARGET_NR_rt_sigtimedwait) || defined(TARGET_NR_rt_sigtimedwait_time64)
706 safe_syscall4(int, rt_sigtimedwait
, const sigset_t
*, these
, siginfo_t
*, uinfo
,
707 const struct timespec
*, uts
, size_t, sigsetsize
)
709 safe_syscall4(int, accept4
, int, fd
, struct sockaddr
*, addr
, socklen_t
*, len
,
711 #if defined(TARGET_NR_nanosleep)
712 safe_syscall2(int, nanosleep
, const struct timespec
*, req
,
713 struct timespec
*, rem
)
715 #if defined(TARGET_NR_clock_nanosleep) || \
716 defined(TARGET_NR_clock_nanosleep_time64)
717 safe_syscall4(int, clock_nanosleep
, const clockid_t
, clock
, int, flags
,
718 const struct timespec
*, req
, struct timespec
*, rem
)
722 safe_syscall5(int, ipc
, int, call
, long, first
, long, second
, long, third
,
725 safe_syscall6(int, ipc
, int, call
, long, first
, long, second
, long, third
,
726 void *, ptr
, long, fifth
)
730 safe_syscall4(int, msgsnd
, int, msgid
, const void *, msgp
, size_t, sz
,
734 safe_syscall5(int, msgrcv
, int, msgid
, void *, msgp
, size_t, sz
,
735 long, msgtype
, int, flags
)
737 #ifdef __NR_semtimedop
738 safe_syscall4(int, semtimedop
, int, semid
, struct sembuf
*, tsops
,
739 unsigned, nsops
, const struct timespec
*, timeout
)
741 #if defined(TARGET_NR_mq_timedsend) || \
742 defined(TARGET_NR_mq_timedsend_time64)
743 safe_syscall5(int, mq_timedsend
, int, mqdes
, const char *, msg_ptr
,
744 size_t, len
, unsigned, prio
, const struct timespec
*, timeout
)
746 #if defined(TARGET_NR_mq_timedreceive) || \
747 defined(TARGET_NR_mq_timedreceive_time64)
748 safe_syscall5(int, mq_timedreceive
, int, mqdes
, char *, msg_ptr
,
749 size_t, len
, unsigned *, prio
, const struct timespec
*, timeout
)
751 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range)
752 safe_syscall6(ssize_t
, copy_file_range
, int, infd
, loff_t
*, pinoff
,
753 int, outfd
, loff_t
*, poutoff
, size_t, length
,
757 /* We do ioctl like this rather than via safe_syscall3 to preserve the
758 * "third argument might be integer or pointer or not present" behaviour of
761 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
762 /* Similarly for fcntl. Note that callers must always:
763 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
764 * use the flock64 struct rather than unsuffixed flock
765 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
768 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
770 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
773 static inline int host_to_target_sock_type(int host_type
)
777 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
779 target_type
= TARGET_SOCK_DGRAM
;
782 target_type
= TARGET_SOCK_STREAM
;
785 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
789 #if defined(SOCK_CLOEXEC)
790 if (host_type
& SOCK_CLOEXEC
) {
791 target_type
|= TARGET_SOCK_CLOEXEC
;
795 #if defined(SOCK_NONBLOCK)
796 if (host_type
& SOCK_NONBLOCK
) {
797 target_type
|= TARGET_SOCK_NONBLOCK
;
804 static abi_ulong target_brk
, initial_target_brk
;
806 void target_set_brk(abi_ulong new_brk
)
808 target_brk
= TARGET_PAGE_ALIGN(new_brk
);
809 initial_target_brk
= target_brk
;
812 /* do_brk() must return target values and target errnos. */
813 abi_long
do_brk(abi_ulong brk_val
)
815 abi_long mapped_addr
;
819 /* brk pointers are always untagged */
821 /* do not allow to shrink below initial brk value */
822 if (brk_val
< initial_target_brk
) {
826 new_brk
= TARGET_PAGE_ALIGN(brk_val
);
827 old_brk
= TARGET_PAGE_ALIGN(target_brk
);
829 /* new and old target_brk might be on the same page */
830 if (new_brk
== old_brk
) {
831 target_brk
= brk_val
;
835 /* Release heap if necessary */
836 if (new_brk
< old_brk
) {
837 target_munmap(new_brk
, old_brk
- new_brk
);
839 target_brk
= brk_val
;
843 mapped_addr
= target_mmap(old_brk
, new_brk
- old_brk
,
844 PROT_READ
| PROT_WRITE
,
845 MAP_FIXED_NOREPLACE
| MAP_ANON
| MAP_PRIVATE
,
848 if (mapped_addr
== old_brk
) {
849 target_brk
= brk_val
;
853 #if defined(TARGET_ALPHA)
854 /* We (partially) emulate OSF/1 on Alpha, which requires we
855 return a proper errno, not an unchanged brk value. */
856 return -TARGET_ENOMEM
;
858 /* For everything else, return the previous break. */
862 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
863 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
864 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
865 abi_ulong target_fds_addr
,
869 abi_ulong b
, *target_fds
;
871 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
872 if (!(target_fds
= lock_user(VERIFY_READ
,
874 sizeof(abi_ulong
) * nw
,
876 return -TARGET_EFAULT
;
880 for (i
= 0; i
< nw
; i
++) {
881 /* grab the abi_ulong */
882 __get_user(b
, &target_fds
[i
]);
883 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
884 /* check the bit inside the abi_ulong */
891 unlock_user(target_fds
, target_fds_addr
, 0);
896 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
897 abi_ulong target_fds_addr
,
900 if (target_fds_addr
) {
901 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
902 return -TARGET_EFAULT
;
910 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
916 abi_ulong
*target_fds
;
918 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
919 if (!(target_fds
= lock_user(VERIFY_WRITE
,
921 sizeof(abi_ulong
) * nw
,
923 return -TARGET_EFAULT
;
926 for (i
= 0; i
< nw
; i
++) {
928 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
929 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
932 __put_user(v
, &target_fds
[i
]);
935 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
941 #if defined(__alpha__)
947 static inline abi_long
host_to_target_clock_t(long ticks
)
949 #if HOST_HZ == TARGET_HZ
952 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
956 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
957 const struct rusage
*rusage
)
959 struct target_rusage
*target_rusage
;
961 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
962 return -TARGET_EFAULT
;
963 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
964 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
965 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
966 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
967 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
968 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
969 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
970 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
971 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
972 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
973 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
974 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
975 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
976 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
977 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
978 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
979 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
980 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
981 unlock_user_struct(target_rusage
, target_addr
, 1);
986 #ifdef TARGET_NR_setrlimit
987 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
989 abi_ulong target_rlim_swap
;
992 target_rlim_swap
= tswapal(target_rlim
);
993 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
994 return RLIM_INFINITY
;
996 result
= target_rlim_swap
;
997 if (target_rlim_swap
!= (rlim_t
)result
)
998 return RLIM_INFINITY
;
1004 #if defined(TARGET_NR_getrlimit) || defined(TARGET_NR_ugetrlimit)
1005 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
1007 abi_ulong target_rlim_swap
;
1010 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
1011 target_rlim_swap
= TARGET_RLIM_INFINITY
;
1013 target_rlim_swap
= rlim
;
1014 result
= tswapal(target_rlim_swap
);
1020 static inline int target_to_host_resource(int code
)
1023 case TARGET_RLIMIT_AS
:
1025 case TARGET_RLIMIT_CORE
:
1027 case TARGET_RLIMIT_CPU
:
1029 case TARGET_RLIMIT_DATA
:
1031 case TARGET_RLIMIT_FSIZE
:
1032 return RLIMIT_FSIZE
;
1033 case TARGET_RLIMIT_LOCKS
:
1034 return RLIMIT_LOCKS
;
1035 case TARGET_RLIMIT_MEMLOCK
:
1036 return RLIMIT_MEMLOCK
;
1037 case TARGET_RLIMIT_MSGQUEUE
:
1038 return RLIMIT_MSGQUEUE
;
1039 case TARGET_RLIMIT_NICE
:
1041 case TARGET_RLIMIT_NOFILE
:
1042 return RLIMIT_NOFILE
;
1043 case TARGET_RLIMIT_NPROC
:
1044 return RLIMIT_NPROC
;
1045 case TARGET_RLIMIT_RSS
:
1047 case TARGET_RLIMIT_RTPRIO
:
1048 return RLIMIT_RTPRIO
;
1049 #ifdef RLIMIT_RTTIME
1050 case TARGET_RLIMIT_RTTIME
:
1051 return RLIMIT_RTTIME
;
1053 case TARGET_RLIMIT_SIGPENDING
:
1054 return RLIMIT_SIGPENDING
;
1055 case TARGET_RLIMIT_STACK
:
1056 return RLIMIT_STACK
;
1062 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
1063 abi_ulong target_tv_addr
)
1065 struct target_timeval
*target_tv
;
1067 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1)) {
1068 return -TARGET_EFAULT
;
1071 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1072 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1074 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1079 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
1080 const struct timeval
*tv
)
1082 struct target_timeval
*target_tv
;
1084 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0)) {
1085 return -TARGET_EFAULT
;
1088 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1089 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1091 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1096 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
1097 static inline abi_long
copy_from_user_timeval64(struct timeval
*tv
,
1098 abi_ulong target_tv_addr
)
1100 struct target__kernel_sock_timeval
*target_tv
;
1102 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1)) {
1103 return -TARGET_EFAULT
;
1106 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1107 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1109 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1115 static inline abi_long
copy_to_user_timeval64(abi_ulong target_tv_addr
,
1116 const struct timeval
*tv
)
1118 struct target__kernel_sock_timeval
*target_tv
;
1120 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0)) {
1121 return -TARGET_EFAULT
;
1124 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1125 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1127 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1132 #if defined(TARGET_NR_futex) || \
1133 defined(TARGET_NR_rt_sigtimedwait) || \
1134 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6) || \
1135 defined(TARGET_NR_nanosleep) || defined(TARGET_NR_clock_settime) || \
1136 defined(TARGET_NR_utimensat) || defined(TARGET_NR_mq_timedsend) || \
1137 defined(TARGET_NR_mq_timedreceive) || defined(TARGET_NR_ipc) || \
1138 defined(TARGET_NR_semop) || defined(TARGET_NR_semtimedop) || \
1139 defined(TARGET_NR_timer_settime) || \
1140 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
1141 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
1142 abi_ulong target_addr
)
1144 struct target_timespec
*target_ts
;
1146 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1)) {
1147 return -TARGET_EFAULT
;
1149 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1150 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1151 unlock_user_struct(target_ts
, target_addr
, 0);
1156 #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
1157 defined(TARGET_NR_timer_settime64) || \
1158 defined(TARGET_NR_mq_timedsend_time64) || \
1159 defined(TARGET_NR_mq_timedreceive_time64) || \
1160 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)) || \
1161 defined(TARGET_NR_clock_nanosleep_time64) || \
1162 defined(TARGET_NR_rt_sigtimedwait_time64) || \
1163 defined(TARGET_NR_utimensat) || \
1164 defined(TARGET_NR_utimensat_time64) || \
1165 defined(TARGET_NR_semtimedop_time64) || \
1166 defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
1167 static inline abi_long
target_to_host_timespec64(struct timespec
*host_ts
,
1168 abi_ulong target_addr
)
1170 struct target__kernel_timespec
*target_ts
;
1172 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1)) {
1173 return -TARGET_EFAULT
;
1175 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1176 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1177 /* in 32bit mode, this drops the padding */
1178 host_ts
->tv_nsec
= (long)(abi_long
)host_ts
->tv_nsec
;
1179 unlock_user_struct(target_ts
, target_addr
, 0);
1184 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
1185 struct timespec
*host_ts
)
1187 struct target_timespec
*target_ts
;
1189 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0)) {
1190 return -TARGET_EFAULT
;
1192 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1193 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1194 unlock_user_struct(target_ts
, target_addr
, 1);
1198 static inline abi_long
host_to_target_timespec64(abi_ulong target_addr
,
1199 struct timespec
*host_ts
)
1201 struct target__kernel_timespec
*target_ts
;
1203 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0)) {
1204 return -TARGET_EFAULT
;
1206 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1207 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1208 unlock_user_struct(target_ts
, target_addr
, 1);
1212 #if defined(TARGET_NR_gettimeofday)
1213 static inline abi_long
copy_to_user_timezone(abi_ulong target_tz_addr
,
1214 struct timezone
*tz
)
1216 struct target_timezone
*target_tz
;
1218 if (!lock_user_struct(VERIFY_WRITE
, target_tz
, target_tz_addr
, 1)) {
1219 return -TARGET_EFAULT
;
1222 __put_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1223 __put_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1225 unlock_user_struct(target_tz
, target_tz_addr
, 1);
1231 #if defined(TARGET_NR_settimeofday)
1232 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
1233 abi_ulong target_tz_addr
)
1235 struct target_timezone
*target_tz
;
1237 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
1238 return -TARGET_EFAULT
;
1241 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1242 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1244 unlock_user_struct(target_tz
, target_tz_addr
, 0);
1250 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1253 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
1254 abi_ulong target_mq_attr_addr
)
1256 struct target_mq_attr
*target_mq_attr
;
1258 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
1259 target_mq_attr_addr
, 1))
1260 return -TARGET_EFAULT
;
1262 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1263 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1264 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1265 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1267 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
1272 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
1273 const struct mq_attr
*attr
)
1275 struct target_mq_attr
*target_mq_attr
;
1277 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
1278 target_mq_attr_addr
, 0))
1279 return -TARGET_EFAULT
;
1281 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1282 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1283 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1284 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1286 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1292 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1293 /* do_select() must return target values and target errnos. */
1294 static abi_long
do_select(int n
,
1295 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1296 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1298 fd_set rfds
, wfds
, efds
;
1299 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1301 struct timespec ts
, *ts_ptr
;
1304 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1308 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1312 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1317 if (target_tv_addr
) {
1318 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1319 return -TARGET_EFAULT
;
1320 ts
.tv_sec
= tv
.tv_sec
;
1321 ts
.tv_nsec
= tv
.tv_usec
* 1000;
1327 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1330 if (!is_error(ret
)) {
1331 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1332 return -TARGET_EFAULT
;
1333 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1334 return -TARGET_EFAULT
;
1335 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1336 return -TARGET_EFAULT
;
1338 if (target_tv_addr
) {
1339 tv
.tv_sec
= ts
.tv_sec
;
1340 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
1341 if (copy_to_user_timeval(target_tv_addr
, &tv
)) {
1342 return -TARGET_EFAULT
;
1350 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1351 static abi_long
do_old_select(abi_ulong arg1
)
1353 struct target_sel_arg_struct
*sel
;
1354 abi_ulong inp
, outp
, exp
, tvp
;
1357 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1)) {
1358 return -TARGET_EFAULT
;
1361 nsel
= tswapal(sel
->n
);
1362 inp
= tswapal(sel
->inp
);
1363 outp
= tswapal(sel
->outp
);
1364 exp
= tswapal(sel
->exp
);
1365 tvp
= tswapal(sel
->tvp
);
1367 unlock_user_struct(sel
, arg1
, 0);
1369 return do_select(nsel
, inp
, outp
, exp
, tvp
);
1374 #if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
1375 static abi_long
do_pselect6(abi_long arg1
, abi_long arg2
, abi_long arg3
,
1376 abi_long arg4
, abi_long arg5
, abi_long arg6
,
1379 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
1380 fd_set rfds
, wfds
, efds
;
1381 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1382 struct timespec ts
, *ts_ptr
;
1386 * The 6th arg is actually two args smashed together,
1387 * so we cannot use the C library.
1394 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
1402 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1406 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1410 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1416 * This takes a timespec, and not a timeval, so we cannot
1417 * use the do_select() helper ...
1421 if (target_to_host_timespec64(&ts
, ts_addr
)) {
1422 return -TARGET_EFAULT
;
1425 if (target_to_host_timespec(&ts
, ts_addr
)) {
1426 return -TARGET_EFAULT
;
1434 /* Extract the two packed args for the sigset */
1437 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
1439 return -TARGET_EFAULT
;
1441 arg_sigset
= tswapal(arg7
[0]);
1442 arg_sigsize
= tswapal(arg7
[1]);
1443 unlock_user(arg7
, arg6
, 0);
1446 ret
= process_sigsuspend_mask(&sig
.set
, arg_sigset
, arg_sigsize
);
1451 sig
.size
= SIGSET_T_SIZE
;
1455 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1459 finish_sigsuspend_mask(ret
);
1462 if (!is_error(ret
)) {
1463 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
)) {
1464 return -TARGET_EFAULT
;
1466 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
)) {
1467 return -TARGET_EFAULT
;
1469 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
)) {
1470 return -TARGET_EFAULT
;
1473 if (ts_addr
&& host_to_target_timespec64(ts_addr
, &ts
)) {
1474 return -TARGET_EFAULT
;
1477 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
)) {
1478 return -TARGET_EFAULT
;
1486 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
1487 defined(TARGET_NR_ppoll_time64)
1488 static abi_long
do_ppoll(abi_long arg1
, abi_long arg2
, abi_long arg3
,
1489 abi_long arg4
, abi_long arg5
, bool ppoll
, bool time64
)
1491 struct target_pollfd
*target_pfd
;
1492 unsigned int nfds
= arg2
;
1500 if (nfds
> (INT_MAX
/ sizeof(struct target_pollfd
))) {
1501 return -TARGET_EINVAL
;
1503 target_pfd
= lock_user(VERIFY_WRITE
, arg1
,
1504 sizeof(struct target_pollfd
) * nfds
, 1);
1506 return -TARGET_EFAULT
;
1509 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
1510 for (i
= 0; i
< nfds
; i
++) {
1511 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
1512 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
1516 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
1517 sigset_t
*set
= NULL
;
1521 if (target_to_host_timespec64(timeout_ts
, arg3
)) {
1522 unlock_user(target_pfd
, arg1
, 0);
1523 return -TARGET_EFAULT
;
1526 if (target_to_host_timespec(timeout_ts
, arg3
)) {
1527 unlock_user(target_pfd
, arg1
, 0);
1528 return -TARGET_EFAULT
;
1536 ret
= process_sigsuspend_mask(&set
, arg4
, arg5
);
1538 unlock_user(target_pfd
, arg1
, 0);
1543 ret
= get_errno(safe_ppoll(pfd
, nfds
, timeout_ts
,
1544 set
, SIGSET_T_SIZE
));
1547 finish_sigsuspend_mask(ret
);
1549 if (!is_error(ret
) && arg3
) {
1551 if (host_to_target_timespec64(arg3
, timeout_ts
)) {
1552 return -TARGET_EFAULT
;
1555 if (host_to_target_timespec(arg3
, timeout_ts
)) {
1556 return -TARGET_EFAULT
;
1561 struct timespec ts
, *pts
;
1564 /* Convert ms to secs, ns */
1565 ts
.tv_sec
= arg3
/ 1000;
1566 ts
.tv_nsec
= (arg3
% 1000) * 1000000LL;
1569 /* -ve poll() timeout means "infinite" */
1572 ret
= get_errno(safe_ppoll(pfd
, nfds
, pts
, NULL
, 0));
1575 if (!is_error(ret
)) {
1576 for (i
= 0; i
< nfds
; i
++) {
1577 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
1580 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
1585 static abi_long
do_pipe(CPUArchState
*cpu_env
, abi_ulong pipedes
,
1586 int flags
, int is_pipe2
)
1590 ret
= pipe2(host_pipe
, flags
);
1593 return get_errno(ret
);
1595 /* Several targets have special calling conventions for the original
1596 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1598 #if defined(TARGET_ALPHA)
1599 cpu_env
->ir
[IR_A4
] = host_pipe
[1];
1600 return host_pipe
[0];
1601 #elif defined(TARGET_MIPS)
1602 cpu_env
->active_tc
.gpr
[3] = host_pipe
[1];
1603 return host_pipe
[0];
1604 #elif defined(TARGET_SH4)
1605 cpu_env
->gregs
[1] = host_pipe
[1];
1606 return host_pipe
[0];
1607 #elif defined(TARGET_SPARC)
1608 cpu_env
->regwptr
[1] = host_pipe
[1];
1609 return host_pipe
[0];
1613 if (put_user_s32(host_pipe
[0], pipedes
)
1614 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(abi_int
)))
1615 return -TARGET_EFAULT
;
1616 return get_errno(ret
);
1619 static inline abi_long
target_to_host_sockaddr(int fd
, struct sockaddr
*addr
,
1620 abi_ulong target_addr
,
1623 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1624 sa_family_t sa_family
;
1625 struct target_sockaddr
*target_saddr
;
1627 if (fd_trans_target_to_host_addr(fd
)) {
1628 return fd_trans_target_to_host_addr(fd
)(addr
, target_addr
, len
);
1631 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1633 return -TARGET_EFAULT
;
1635 sa_family
= tswap16(target_saddr
->sa_family
);
1637 /* Oops. The caller might send a incomplete sun_path; sun_path
1638 * must be terminated by \0 (see the manual page), but
1639 * unfortunately it is quite common to specify sockaddr_un
1640 * length as "strlen(x->sun_path)" while it should be
1641 * "strlen(...) + 1". We'll fix that here if needed.
1642 * Linux kernel has a similar feature.
1645 if (sa_family
== AF_UNIX
) {
1646 if (len
< unix_maxlen
&& len
> 0) {
1647 char *cp
= (char*)target_saddr
;
1649 if ( cp
[len
-1] && !cp
[len
] )
1652 if (len
> unix_maxlen
)
1656 memcpy(addr
, target_saddr
, len
);
1657 addr
->sa_family
= sa_family
;
1658 if (sa_family
== AF_NETLINK
) {
1659 struct sockaddr_nl
*nladdr
;
1661 nladdr
= (struct sockaddr_nl
*)addr
;
1662 nladdr
->nl_pid
= tswap32(nladdr
->nl_pid
);
1663 nladdr
->nl_groups
= tswap32(nladdr
->nl_groups
);
1664 } else if (sa_family
== AF_PACKET
) {
1665 struct target_sockaddr_ll
*lladdr
;
1667 lladdr
= (struct target_sockaddr_ll
*)addr
;
1668 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1669 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1670 } else if (sa_family
== AF_INET6
) {
1671 struct sockaddr_in6
*in6addr
;
1673 in6addr
= (struct sockaddr_in6
*)addr
;
1674 in6addr
->sin6_scope_id
= tswap32(in6addr
->sin6_scope_id
);
1676 unlock_user(target_saddr
, target_addr
, 0);
1681 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1682 struct sockaddr
*addr
,
1685 struct target_sockaddr
*target_saddr
;
1692 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1694 return -TARGET_EFAULT
;
1695 memcpy(target_saddr
, addr
, len
);
1696 if (len
>= offsetof(struct target_sockaddr
, sa_family
) +
1697 sizeof(target_saddr
->sa_family
)) {
1698 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1700 if (addr
->sa_family
== AF_NETLINK
&&
1701 len
>= sizeof(struct target_sockaddr_nl
)) {
1702 struct target_sockaddr_nl
*target_nl
=
1703 (struct target_sockaddr_nl
*)target_saddr
;
1704 target_nl
->nl_pid
= tswap32(target_nl
->nl_pid
);
1705 target_nl
->nl_groups
= tswap32(target_nl
->nl_groups
);
1706 } else if (addr
->sa_family
== AF_PACKET
) {
1707 struct sockaddr_ll
*target_ll
= (struct sockaddr_ll
*)target_saddr
;
1708 target_ll
->sll_ifindex
= tswap32(target_ll
->sll_ifindex
);
1709 target_ll
->sll_hatype
= tswap16(target_ll
->sll_hatype
);
1710 } else if (addr
->sa_family
== AF_INET6
&&
1711 len
>= sizeof(struct target_sockaddr_in6
)) {
1712 struct target_sockaddr_in6
*target_in6
=
1713 (struct target_sockaddr_in6
*)target_saddr
;
1714 target_in6
->sin6_scope_id
= tswap16(target_in6
->sin6_scope_id
);
1716 unlock_user(target_saddr
, target_addr
, len
);
1721 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1722 struct target_msghdr
*target_msgh
)
1724 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1725 abi_long msg_controllen
;
1726 abi_ulong target_cmsg_addr
;
1727 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1728 socklen_t space
= 0;
1730 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1731 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1733 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1734 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1735 target_cmsg_start
= target_cmsg
;
1737 return -TARGET_EFAULT
;
1739 while (cmsg
&& target_cmsg
) {
1740 void *data
= CMSG_DATA(cmsg
);
1741 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1743 int len
= tswapal(target_cmsg
->cmsg_len
)
1744 - sizeof(struct target_cmsghdr
);
1746 space
+= CMSG_SPACE(len
);
1747 if (space
> msgh
->msg_controllen
) {
1748 space
-= CMSG_SPACE(len
);
1749 /* This is a QEMU bug, since we allocated the payload
1750 * area ourselves (unlike overflow in host-to-target
1751 * conversion, which is just the guest giving us a buffer
1752 * that's too small). It can't happen for the payload types
1753 * we currently support; if it becomes an issue in future
1754 * we would need to improve our allocation strategy to
1755 * something more intelligent than "twice the size of the
1756 * target buffer we're reading from".
1758 qemu_log_mask(LOG_UNIMP
,
1759 ("Unsupported ancillary data %d/%d: "
1760 "unhandled msg size\n"),
1761 tswap32(target_cmsg
->cmsg_level
),
1762 tswap32(target_cmsg
->cmsg_type
));
1766 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1767 cmsg
->cmsg_level
= SOL_SOCKET
;
1769 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1771 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1772 cmsg
->cmsg_len
= CMSG_LEN(len
);
1774 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1775 int *fd
= (int *)data
;
1776 int *target_fd
= (int *)target_data
;
1777 int i
, numfds
= len
/ sizeof(int);
1779 for (i
= 0; i
< numfds
; i
++) {
1780 __get_user(fd
[i
], target_fd
+ i
);
1782 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1783 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1784 struct ucred
*cred
= (struct ucred
*)data
;
1785 struct target_ucred
*target_cred
=
1786 (struct target_ucred
*)target_data
;
1788 __get_user(cred
->pid
, &target_cred
->pid
);
1789 __get_user(cred
->uid
, &target_cred
->uid
);
1790 __get_user(cred
->gid
, &target_cred
->gid
);
1791 } else if (cmsg
->cmsg_level
== SOL_ALG
) {
1792 uint32_t *dst
= (uint32_t *)data
;
1794 memcpy(dst
, target_data
, len
);
1795 /* fix endianness of first 32-bit word */
1796 if (len
>= sizeof(uint32_t)) {
1797 *dst
= tswap32(*dst
);
1800 qemu_log_mask(LOG_UNIMP
, "Unsupported ancillary data: %d/%d\n",
1801 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1802 memcpy(data
, target_data
, len
);
1805 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1806 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1809 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1811 msgh
->msg_controllen
= space
;
1815 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1816 struct msghdr
*msgh
)
1818 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1819 abi_long msg_controllen
;
1820 abi_ulong target_cmsg_addr
;
1821 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1822 socklen_t space
= 0;
1824 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1825 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1827 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1828 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1829 target_cmsg_start
= target_cmsg
;
1831 return -TARGET_EFAULT
;
1833 while (cmsg
&& target_cmsg
) {
1834 void *data
= CMSG_DATA(cmsg
);
1835 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1837 int len
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1838 int tgt_len
, tgt_space
;
1840 /* We never copy a half-header but may copy half-data;
1841 * this is Linux's behaviour in put_cmsg(). Note that
1842 * truncation here is a guest problem (which we report
1843 * to the guest via the CTRUNC bit), unlike truncation
1844 * in target_to_host_cmsg, which is a QEMU bug.
1846 if (msg_controllen
< sizeof(struct target_cmsghdr
)) {
1847 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1851 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1852 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1854 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1856 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1858 /* Payload types which need a different size of payload on
1859 * the target must adjust tgt_len here.
1862 switch (cmsg
->cmsg_level
) {
1864 switch (cmsg
->cmsg_type
) {
1866 tgt_len
= sizeof(struct target_timeval
);
1876 if (msg_controllen
< TARGET_CMSG_LEN(tgt_len
)) {
1877 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1878 tgt_len
= msg_controllen
- sizeof(struct target_cmsghdr
);
1881 /* We must now copy-and-convert len bytes of payload
1882 * into tgt_len bytes of destination space. Bear in mind
1883 * that in both source and destination we may be dealing
1884 * with a truncated value!
1886 switch (cmsg
->cmsg_level
) {
1888 switch (cmsg
->cmsg_type
) {
1891 int *fd
= (int *)data
;
1892 int *target_fd
= (int *)target_data
;
1893 int i
, numfds
= tgt_len
/ sizeof(int);
1895 for (i
= 0; i
< numfds
; i
++) {
1896 __put_user(fd
[i
], target_fd
+ i
);
1902 struct timeval
*tv
= (struct timeval
*)data
;
1903 struct target_timeval
*target_tv
=
1904 (struct target_timeval
*)target_data
;
1906 if (len
!= sizeof(struct timeval
) ||
1907 tgt_len
!= sizeof(struct target_timeval
)) {
1911 /* copy struct timeval to target */
1912 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1913 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1916 case SCM_CREDENTIALS
:
1918 struct ucred
*cred
= (struct ucred
*)data
;
1919 struct target_ucred
*target_cred
=
1920 (struct target_ucred
*)target_data
;
1922 __put_user(cred
->pid
, &target_cred
->pid
);
1923 __put_user(cred
->uid
, &target_cred
->uid
);
1924 __put_user(cred
->gid
, &target_cred
->gid
);
1933 switch (cmsg
->cmsg_type
) {
1936 uint32_t *v
= (uint32_t *)data
;
1937 uint32_t *t_int
= (uint32_t *)target_data
;
1939 if (len
!= sizeof(uint32_t) ||
1940 tgt_len
!= sizeof(uint32_t)) {
1943 __put_user(*v
, t_int
);
1949 struct sock_extended_err ee
;
1950 struct sockaddr_in offender
;
1952 struct errhdr_t
*errh
= (struct errhdr_t
*)data
;
1953 struct errhdr_t
*target_errh
=
1954 (struct errhdr_t
*)target_data
;
1956 if (len
!= sizeof(struct errhdr_t
) ||
1957 tgt_len
!= sizeof(struct errhdr_t
)) {
1960 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1961 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1962 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1963 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1964 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1965 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1966 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1967 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1968 (void *) &errh
->offender
, sizeof(errh
->offender
));
1977 switch (cmsg
->cmsg_type
) {
1980 uint32_t *v
= (uint32_t *)data
;
1981 uint32_t *t_int
= (uint32_t *)target_data
;
1983 if (len
!= sizeof(uint32_t) ||
1984 tgt_len
!= sizeof(uint32_t)) {
1987 __put_user(*v
, t_int
);
1993 struct sock_extended_err ee
;
1994 struct sockaddr_in6 offender
;
1996 struct errhdr6_t
*errh
= (struct errhdr6_t
*)data
;
1997 struct errhdr6_t
*target_errh
=
1998 (struct errhdr6_t
*)target_data
;
2000 if (len
!= sizeof(struct errhdr6_t
) ||
2001 tgt_len
!= sizeof(struct errhdr6_t
)) {
2004 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
2005 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
2006 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
2007 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
2008 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
2009 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
2010 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
2011 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
2012 (void *) &errh
->offender
, sizeof(errh
->offender
));
2022 qemu_log_mask(LOG_UNIMP
, "Unsupported ancillary data: %d/%d\n",
2023 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
2024 memcpy(target_data
, data
, MIN(len
, tgt_len
));
2025 if (tgt_len
> len
) {
2026 memset(target_data
+ len
, 0, tgt_len
- len
);
2030 target_cmsg
->cmsg_len
= tswapal(TARGET_CMSG_LEN(tgt_len
));
2031 tgt_space
= TARGET_CMSG_SPACE(tgt_len
);
2032 if (msg_controllen
< tgt_space
) {
2033 tgt_space
= msg_controllen
;
2035 msg_controllen
-= tgt_space
;
2037 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
2038 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
2041 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
2043 target_msgh
->msg_controllen
= tswapal(space
);
2047 /* do_setsockopt() Must return target values and target errnos. */
2048 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
2049 abi_ulong optval_addr
, socklen_t optlen
)
2057 /* TCP and UDP options all take an 'int' value. */
2058 if (optlen
< sizeof(uint32_t))
2059 return -TARGET_EINVAL
;
2061 if (get_user_u32(val
, optval_addr
))
2062 return -TARGET_EFAULT
;
2063 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2070 case IP_ROUTER_ALERT
:
2074 case IP_MTU_DISCOVER
:
2081 case IP_MULTICAST_TTL
:
2082 case IP_MULTICAST_LOOP
:
2084 if (optlen
>= sizeof(uint32_t)) {
2085 if (get_user_u32(val
, optval_addr
))
2086 return -TARGET_EFAULT
;
2087 } else if (optlen
>= 1) {
2088 if (get_user_u8(val
, optval_addr
))
2089 return -TARGET_EFAULT
;
2091 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2093 case IP_ADD_MEMBERSHIP
:
2094 case IP_DROP_MEMBERSHIP
:
2096 struct ip_mreqn ip_mreq
;
2097 struct target_ip_mreqn
*target_smreqn
;
2099 QEMU_BUILD_BUG_ON(sizeof(struct ip_mreq
) !=
2100 sizeof(struct target_ip_mreq
));
2102 if (optlen
< sizeof (struct target_ip_mreq
) ||
2103 optlen
> sizeof (struct target_ip_mreqn
)) {
2104 return -TARGET_EINVAL
;
2107 target_smreqn
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2108 if (!target_smreqn
) {
2109 return -TARGET_EFAULT
;
2111 ip_mreq
.imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
2112 ip_mreq
.imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
2113 if (optlen
== sizeof(struct target_ip_mreqn
)) {
2114 ip_mreq
.imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
2115 optlen
= sizeof(struct ip_mreqn
);
2117 unlock_user(target_smreqn
, optval_addr
, 0);
2119 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &ip_mreq
, optlen
));
2122 case IP_BLOCK_SOURCE
:
2123 case IP_UNBLOCK_SOURCE
:
2124 case IP_ADD_SOURCE_MEMBERSHIP
:
2125 case IP_DROP_SOURCE_MEMBERSHIP
:
2127 struct ip_mreq_source
*ip_mreq_source
;
2129 if (optlen
!= sizeof (struct target_ip_mreq_source
))
2130 return -TARGET_EINVAL
;
2132 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2133 if (!ip_mreq_source
) {
2134 return -TARGET_EFAULT
;
2136 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
2137 unlock_user (ip_mreq_source
, optval_addr
, 0);
2146 case IPV6_MTU_DISCOVER
:
2149 case IPV6_RECVPKTINFO
:
2150 case IPV6_UNICAST_HOPS
:
2151 case IPV6_MULTICAST_HOPS
:
2152 case IPV6_MULTICAST_LOOP
:
2154 case IPV6_RECVHOPLIMIT
:
2155 case IPV6_2292HOPLIMIT
:
2158 case IPV6_2292PKTINFO
:
2159 case IPV6_RECVTCLASS
:
2160 case IPV6_RECVRTHDR
:
2161 case IPV6_2292RTHDR
:
2162 case IPV6_RECVHOPOPTS
:
2163 case IPV6_2292HOPOPTS
:
2164 case IPV6_RECVDSTOPTS
:
2165 case IPV6_2292DSTOPTS
:
2167 case IPV6_ADDR_PREFERENCES
:
2168 #ifdef IPV6_RECVPATHMTU
2169 case IPV6_RECVPATHMTU
:
2171 #ifdef IPV6_TRANSPARENT
2172 case IPV6_TRANSPARENT
:
2174 #ifdef IPV6_FREEBIND
2177 #ifdef IPV6_RECVORIGDSTADDR
2178 case IPV6_RECVORIGDSTADDR
:
2181 if (optlen
< sizeof(uint32_t)) {
2182 return -TARGET_EINVAL
;
2184 if (get_user_u32(val
, optval_addr
)) {
2185 return -TARGET_EFAULT
;
2187 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2188 &val
, sizeof(val
)));
2192 struct in6_pktinfo pki
;
2194 if (optlen
< sizeof(pki
)) {
2195 return -TARGET_EINVAL
;
2198 if (copy_from_user(&pki
, optval_addr
, sizeof(pki
))) {
2199 return -TARGET_EFAULT
;
2202 pki
.ipi6_ifindex
= tswap32(pki
.ipi6_ifindex
);
2204 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2205 &pki
, sizeof(pki
)));
2208 case IPV6_ADD_MEMBERSHIP
:
2209 case IPV6_DROP_MEMBERSHIP
:
2211 struct ipv6_mreq ipv6mreq
;
2213 if (optlen
< sizeof(ipv6mreq
)) {
2214 return -TARGET_EINVAL
;
2217 if (copy_from_user(&ipv6mreq
, optval_addr
, sizeof(ipv6mreq
))) {
2218 return -TARGET_EFAULT
;
2221 ipv6mreq
.ipv6mr_interface
= tswap32(ipv6mreq
.ipv6mr_interface
);
2223 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2224 &ipv6mreq
, sizeof(ipv6mreq
)));
2235 struct icmp6_filter icmp6f
;
2237 if (optlen
> sizeof(icmp6f
)) {
2238 optlen
= sizeof(icmp6f
);
2241 if (copy_from_user(&icmp6f
, optval_addr
, optlen
)) {
2242 return -TARGET_EFAULT
;
2245 for (val
= 0; val
< 8; val
++) {
2246 icmp6f
.data
[val
] = tswap32(icmp6f
.data
[val
]);
2249 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2261 /* those take an u32 value */
2262 if (optlen
< sizeof(uint32_t)) {
2263 return -TARGET_EINVAL
;
2266 if (get_user_u32(val
, optval_addr
)) {
2267 return -TARGET_EFAULT
;
2269 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2270 &val
, sizeof(val
)));
2277 #if defined(SOL_ALG) && defined(ALG_SET_KEY) && defined(ALG_SET_AEAD_AUTHSIZE)
2282 char *alg_key
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2284 return -TARGET_EFAULT
;
2286 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2288 unlock_user(alg_key
, optval_addr
, optlen
);
2291 case ALG_SET_AEAD_AUTHSIZE
:
2293 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2302 case TARGET_SOL_SOCKET
:
2304 case TARGET_SO_RCVTIMEO
:
2305 case TARGET_SO_SNDTIMEO
:
2309 if (optlen
!= sizeof(struct target_timeval
)) {
2310 return -TARGET_EINVAL
;
2313 if (copy_from_user_timeval(&tv
, optval_addr
)) {
2314 return -TARGET_EFAULT
;
2317 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
2318 optname
== TARGET_SO_RCVTIMEO
?
2319 SO_RCVTIMEO
: SO_SNDTIMEO
,
2323 case TARGET_SO_ATTACH_FILTER
:
2325 struct target_sock_fprog
*tfprog
;
2326 struct target_sock_filter
*tfilter
;
2327 struct sock_fprog fprog
;
2328 struct sock_filter
*filter
;
2331 if (optlen
!= sizeof(*tfprog
)) {
2332 return -TARGET_EINVAL
;
2334 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
2335 return -TARGET_EFAULT
;
2337 if (!lock_user_struct(VERIFY_READ
, tfilter
,
2338 tswapal(tfprog
->filter
), 0)) {
2339 unlock_user_struct(tfprog
, optval_addr
, 1);
2340 return -TARGET_EFAULT
;
2343 fprog
.len
= tswap16(tfprog
->len
);
2344 filter
= g_try_new(struct sock_filter
, fprog
.len
);
2345 if (filter
== NULL
) {
2346 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2347 unlock_user_struct(tfprog
, optval_addr
, 1);
2348 return -TARGET_ENOMEM
;
2350 for (i
= 0; i
< fprog
.len
; i
++) {
2351 filter
[i
].code
= tswap16(tfilter
[i
].code
);
2352 filter
[i
].jt
= tfilter
[i
].jt
;
2353 filter
[i
].jf
= tfilter
[i
].jf
;
2354 filter
[i
].k
= tswap32(tfilter
[i
].k
);
2356 fprog
.filter
= filter
;
2358 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
2359 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
2362 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2363 unlock_user_struct(tfprog
, optval_addr
, 1);
2366 case TARGET_SO_BINDTODEVICE
:
2368 char *dev_ifname
, *addr_ifname
;
2370 if (optlen
> IFNAMSIZ
- 1) {
2371 optlen
= IFNAMSIZ
- 1;
2373 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2375 return -TARGET_EFAULT
;
2377 optname
= SO_BINDTODEVICE
;
2378 addr_ifname
= alloca(IFNAMSIZ
);
2379 memcpy(addr_ifname
, dev_ifname
, optlen
);
2380 addr_ifname
[optlen
] = 0;
2381 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
2382 addr_ifname
, optlen
));
2383 unlock_user (dev_ifname
, optval_addr
, 0);
2386 case TARGET_SO_LINGER
:
2389 struct target_linger
*tlg
;
2391 if (optlen
!= sizeof(struct target_linger
)) {
2392 return -TARGET_EINVAL
;
2394 if (!lock_user_struct(VERIFY_READ
, tlg
, optval_addr
, 1)) {
2395 return -TARGET_EFAULT
;
2397 __get_user(lg
.l_onoff
, &tlg
->l_onoff
);
2398 __get_user(lg
.l_linger
, &tlg
->l_linger
);
2399 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, SO_LINGER
,
2401 unlock_user_struct(tlg
, optval_addr
, 0);
2404 /* Options with 'int' argument. */
2405 case TARGET_SO_DEBUG
:
2408 case TARGET_SO_REUSEADDR
:
2409 optname
= SO_REUSEADDR
;
2412 case TARGET_SO_REUSEPORT
:
2413 optname
= SO_REUSEPORT
;
2416 case TARGET_SO_TYPE
:
2419 case TARGET_SO_ERROR
:
2422 case TARGET_SO_DONTROUTE
:
2423 optname
= SO_DONTROUTE
;
2425 case TARGET_SO_BROADCAST
:
2426 optname
= SO_BROADCAST
;
2428 case TARGET_SO_SNDBUF
:
2429 optname
= SO_SNDBUF
;
2431 case TARGET_SO_SNDBUFFORCE
:
2432 optname
= SO_SNDBUFFORCE
;
2434 case TARGET_SO_RCVBUF
:
2435 optname
= SO_RCVBUF
;
2437 case TARGET_SO_RCVBUFFORCE
:
2438 optname
= SO_RCVBUFFORCE
;
2440 case TARGET_SO_KEEPALIVE
:
2441 optname
= SO_KEEPALIVE
;
2443 case TARGET_SO_OOBINLINE
:
2444 optname
= SO_OOBINLINE
;
2446 case TARGET_SO_NO_CHECK
:
2447 optname
= SO_NO_CHECK
;
2449 case TARGET_SO_PRIORITY
:
2450 optname
= SO_PRIORITY
;
2453 case TARGET_SO_BSDCOMPAT
:
2454 optname
= SO_BSDCOMPAT
;
2457 case TARGET_SO_PASSCRED
:
2458 optname
= SO_PASSCRED
;
2460 case TARGET_SO_PASSSEC
:
2461 optname
= SO_PASSSEC
;
2463 case TARGET_SO_TIMESTAMP
:
2464 optname
= SO_TIMESTAMP
;
2466 case TARGET_SO_RCVLOWAT
:
2467 optname
= SO_RCVLOWAT
;
2472 if (optlen
< sizeof(uint32_t))
2473 return -TARGET_EINVAL
;
2475 if (get_user_u32(val
, optval_addr
))
2476 return -TARGET_EFAULT
;
2477 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
2482 case NETLINK_PKTINFO
:
2483 case NETLINK_ADD_MEMBERSHIP
:
2484 case NETLINK_DROP_MEMBERSHIP
:
2485 case NETLINK_BROADCAST_ERROR
:
2486 case NETLINK_NO_ENOBUFS
:
2487 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2488 case NETLINK_LISTEN_ALL_NSID
:
2489 case NETLINK_CAP_ACK
:
2490 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2491 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2492 case NETLINK_EXT_ACK
:
2493 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2494 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2495 case NETLINK_GET_STRICT_CHK
:
2496 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2502 if (optlen
< sizeof(uint32_t)) {
2503 return -TARGET_EINVAL
;
2505 if (get_user_u32(val
, optval_addr
)) {
2506 return -TARGET_EFAULT
;
2508 ret
= get_errno(setsockopt(sockfd
, SOL_NETLINK
, optname
, &val
,
2511 #endif /* SOL_NETLINK */
2514 qemu_log_mask(LOG_UNIMP
, "Unsupported setsockopt level=%d optname=%d\n",
2516 ret
= -TARGET_ENOPROTOOPT
;
2521 /* do_getsockopt() Must return target values and target errnos. */
2522 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
2523 abi_ulong optval_addr
, abi_ulong optlen
)
2530 case TARGET_SOL_SOCKET
:
2533 /* These don't just return a single integer */
2534 case TARGET_SO_PEERNAME
:
2536 case TARGET_SO_RCVTIMEO
: {
2540 optname
= SO_RCVTIMEO
;
2543 if (get_user_u32(len
, optlen
)) {
2544 return -TARGET_EFAULT
;
2547 return -TARGET_EINVAL
;
2551 ret
= get_errno(getsockopt(sockfd
, level
, optname
,
2556 if (len
> sizeof(struct target_timeval
)) {
2557 len
= sizeof(struct target_timeval
);
2559 if (copy_to_user_timeval(optval_addr
, &tv
)) {
2560 return -TARGET_EFAULT
;
2562 if (put_user_u32(len
, optlen
)) {
2563 return -TARGET_EFAULT
;
2567 case TARGET_SO_SNDTIMEO
:
2568 optname
= SO_SNDTIMEO
;
2570 case TARGET_SO_PEERCRED
: {
2573 struct target_ucred
*tcr
;
2575 if (get_user_u32(len
, optlen
)) {
2576 return -TARGET_EFAULT
;
2579 return -TARGET_EINVAL
;
2583 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
2591 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
2592 return -TARGET_EFAULT
;
2594 __put_user(cr
.pid
, &tcr
->pid
);
2595 __put_user(cr
.uid
, &tcr
->uid
);
2596 __put_user(cr
.gid
, &tcr
->gid
);
2597 unlock_user_struct(tcr
, optval_addr
, 1);
2598 if (put_user_u32(len
, optlen
)) {
2599 return -TARGET_EFAULT
;
2603 case TARGET_SO_PEERSEC
: {
2606 if (get_user_u32(len
, optlen
)) {
2607 return -TARGET_EFAULT
;
2610 return -TARGET_EINVAL
;
2612 name
= lock_user(VERIFY_WRITE
, optval_addr
, len
, 0);
2614 return -TARGET_EFAULT
;
2617 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERSEC
,
2619 if (put_user_u32(lv
, optlen
)) {
2620 ret
= -TARGET_EFAULT
;
2622 unlock_user(name
, optval_addr
, lv
);
2625 case TARGET_SO_LINGER
:
2629 struct target_linger
*tlg
;
2631 if (get_user_u32(len
, optlen
)) {
2632 return -TARGET_EFAULT
;
2635 return -TARGET_EINVAL
;
2639 ret
= get_errno(getsockopt(sockfd
, level
, SO_LINGER
,
2647 if (!lock_user_struct(VERIFY_WRITE
, tlg
, optval_addr
, 0)) {
2648 return -TARGET_EFAULT
;
2650 __put_user(lg
.l_onoff
, &tlg
->l_onoff
);
2651 __put_user(lg
.l_linger
, &tlg
->l_linger
);
2652 unlock_user_struct(tlg
, optval_addr
, 1);
2653 if (put_user_u32(len
, optlen
)) {
2654 return -TARGET_EFAULT
;
2658 /* Options with 'int' argument. */
2659 case TARGET_SO_DEBUG
:
2662 case TARGET_SO_REUSEADDR
:
2663 optname
= SO_REUSEADDR
;
2666 case TARGET_SO_REUSEPORT
:
2667 optname
= SO_REUSEPORT
;
2670 case TARGET_SO_TYPE
:
2673 case TARGET_SO_ERROR
:
2676 case TARGET_SO_DONTROUTE
:
2677 optname
= SO_DONTROUTE
;
2679 case TARGET_SO_BROADCAST
:
2680 optname
= SO_BROADCAST
;
2682 case TARGET_SO_SNDBUF
:
2683 optname
= SO_SNDBUF
;
2685 case TARGET_SO_RCVBUF
:
2686 optname
= SO_RCVBUF
;
2688 case TARGET_SO_KEEPALIVE
:
2689 optname
= SO_KEEPALIVE
;
2691 case TARGET_SO_OOBINLINE
:
2692 optname
= SO_OOBINLINE
;
2694 case TARGET_SO_NO_CHECK
:
2695 optname
= SO_NO_CHECK
;
2697 case TARGET_SO_PRIORITY
:
2698 optname
= SO_PRIORITY
;
2701 case TARGET_SO_BSDCOMPAT
:
2702 optname
= SO_BSDCOMPAT
;
2705 case TARGET_SO_PASSCRED
:
2706 optname
= SO_PASSCRED
;
2708 case TARGET_SO_TIMESTAMP
:
2709 optname
= SO_TIMESTAMP
;
2711 case TARGET_SO_RCVLOWAT
:
2712 optname
= SO_RCVLOWAT
;
2714 case TARGET_SO_ACCEPTCONN
:
2715 optname
= SO_ACCEPTCONN
;
2717 case TARGET_SO_PROTOCOL
:
2718 optname
= SO_PROTOCOL
;
2720 case TARGET_SO_DOMAIN
:
2721 optname
= SO_DOMAIN
;
2729 /* TCP and UDP options all take an 'int' value. */
2731 if (get_user_u32(len
, optlen
))
2732 return -TARGET_EFAULT
;
2734 return -TARGET_EINVAL
;
2736 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2741 val
= host_to_target_sock_type(val
);
2744 val
= host_to_target_errno(val
);
2750 if (put_user_u32(val
, optval_addr
))
2751 return -TARGET_EFAULT
;
2753 if (put_user_u8(val
, optval_addr
))
2754 return -TARGET_EFAULT
;
2756 if (put_user_u32(len
, optlen
))
2757 return -TARGET_EFAULT
;
2764 case IP_ROUTER_ALERT
:
2768 case IP_MTU_DISCOVER
:
2774 case IP_MULTICAST_TTL
:
2775 case IP_MULTICAST_LOOP
:
2776 if (get_user_u32(len
, optlen
))
2777 return -TARGET_EFAULT
;
2779 return -TARGET_EINVAL
;
2781 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2784 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2786 if (put_user_u32(len
, optlen
)
2787 || put_user_u8(val
, optval_addr
))
2788 return -TARGET_EFAULT
;
2790 if (len
> sizeof(int))
2792 if (put_user_u32(len
, optlen
)
2793 || put_user_u32(val
, optval_addr
))
2794 return -TARGET_EFAULT
;
2798 ret
= -TARGET_ENOPROTOOPT
;
2804 case IPV6_MTU_DISCOVER
:
2807 case IPV6_RECVPKTINFO
:
2808 case IPV6_UNICAST_HOPS
:
2809 case IPV6_MULTICAST_HOPS
:
2810 case IPV6_MULTICAST_LOOP
:
2812 case IPV6_RECVHOPLIMIT
:
2813 case IPV6_2292HOPLIMIT
:
2816 case IPV6_2292PKTINFO
:
2817 case IPV6_RECVTCLASS
:
2818 case IPV6_RECVRTHDR
:
2819 case IPV6_2292RTHDR
:
2820 case IPV6_RECVHOPOPTS
:
2821 case IPV6_2292HOPOPTS
:
2822 case IPV6_RECVDSTOPTS
:
2823 case IPV6_2292DSTOPTS
:
2825 case IPV6_ADDR_PREFERENCES
:
2826 #ifdef IPV6_RECVPATHMTU
2827 case IPV6_RECVPATHMTU
:
2829 #ifdef IPV6_TRANSPARENT
2830 case IPV6_TRANSPARENT
:
2832 #ifdef IPV6_FREEBIND
2835 #ifdef IPV6_RECVORIGDSTADDR
2836 case IPV6_RECVORIGDSTADDR
:
2838 if (get_user_u32(len
, optlen
))
2839 return -TARGET_EFAULT
;
2841 return -TARGET_EINVAL
;
2843 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2846 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2848 if (put_user_u32(len
, optlen
)
2849 || put_user_u8(val
, optval_addr
))
2850 return -TARGET_EFAULT
;
2852 if (len
> sizeof(int))
2854 if (put_user_u32(len
, optlen
)
2855 || put_user_u32(val
, optval_addr
))
2856 return -TARGET_EFAULT
;
2860 ret
= -TARGET_ENOPROTOOPT
;
2867 case NETLINK_PKTINFO
:
2868 case NETLINK_BROADCAST_ERROR
:
2869 case NETLINK_NO_ENOBUFS
:
2870 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2871 case NETLINK_LISTEN_ALL_NSID
:
2872 case NETLINK_CAP_ACK
:
2873 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2874 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2875 case NETLINK_EXT_ACK
:
2876 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2877 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2878 case NETLINK_GET_STRICT_CHK
:
2879 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2880 if (get_user_u32(len
, optlen
)) {
2881 return -TARGET_EFAULT
;
2883 if (len
!= sizeof(val
)) {
2884 return -TARGET_EINVAL
;
2887 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2891 if (put_user_u32(lv
, optlen
)
2892 || put_user_u32(val
, optval_addr
)) {
2893 return -TARGET_EFAULT
;
2896 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2897 case NETLINK_LIST_MEMBERSHIPS
:
2901 if (get_user_u32(len
, optlen
)) {
2902 return -TARGET_EFAULT
;
2905 return -TARGET_EINVAL
;
2907 results
= lock_user(VERIFY_WRITE
, optval_addr
, len
, 1);
2908 if (!results
&& len
> 0) {
2909 return -TARGET_EFAULT
;
2912 ret
= get_errno(getsockopt(sockfd
, level
, optname
, results
, &lv
));
2914 unlock_user(results
, optval_addr
, 0);
2917 /* swap host endianness to target endianness. */
2918 for (i
= 0; i
< (len
/ sizeof(uint32_t)); i
++) {
2919 results
[i
] = tswap32(results
[i
]);
2921 if (put_user_u32(lv
, optlen
)) {
2922 return -TARGET_EFAULT
;
2924 unlock_user(results
, optval_addr
, 0);
2927 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2932 #endif /* SOL_NETLINK */
2935 qemu_log_mask(LOG_UNIMP
,
2936 "getsockopt level=%d optname=%d not yet supported\n",
2938 ret
= -TARGET_EOPNOTSUPP
;
2944 /* Convert target low/high pair representing file offset into the host
2945 * low/high pair. This function doesn't handle offsets bigger than 64 bits
2946 * as the kernel doesn't handle them either.
2948 static void target_to_host_low_high(abi_ulong tlow
,
2950 unsigned long *hlow
,
2951 unsigned long *hhigh
)
2953 uint64_t off
= tlow
|
2954 ((unsigned long long)thigh
<< TARGET_LONG_BITS
/ 2) <<
2955 TARGET_LONG_BITS
/ 2;
2958 *hhigh
= (off
>> HOST_LONG_BITS
/ 2) >> HOST_LONG_BITS
/ 2;
2961 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
2962 abi_ulong count
, int copy
)
2964 struct target_iovec
*target_vec
;
2966 abi_ulong total_len
, max_len
;
2969 bool bad_address
= false;
2975 if (count
> IOV_MAX
) {
2980 vec
= g_try_new0(struct iovec
, count
);
2986 target_vec
= lock_user(VERIFY_READ
, target_addr
,
2987 count
* sizeof(struct target_iovec
), 1);
2988 if (target_vec
== NULL
) {
2993 /* ??? If host page size > target page size, this will result in a
2994 value larger than what we can actually support. */
2995 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
2998 for (i
= 0; i
< count
; i
++) {
2999 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3000 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3005 } else if (len
== 0) {
3006 /* Zero length pointer is ignored. */
3007 vec
[i
].iov_base
= 0;
3009 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
3010 /* If the first buffer pointer is bad, this is a fault. But
3011 * subsequent bad buffers will result in a partial write; this
3012 * is realized by filling the vector with null pointers and
3014 if (!vec
[i
].iov_base
) {
3025 if (len
> max_len
- total_len
) {
3026 len
= max_len
- total_len
;
3029 vec
[i
].iov_len
= len
;
3033 unlock_user(target_vec
, target_addr
, 0);
3038 if (tswapal(target_vec
[i
].iov_len
) > 0) {
3039 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
3042 unlock_user(target_vec
, target_addr
, 0);
3049 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
3050 abi_ulong count
, int copy
)
3052 struct target_iovec
*target_vec
;
3055 target_vec
= lock_user(VERIFY_READ
, target_addr
,
3056 count
* sizeof(struct target_iovec
), 1);
3058 for (i
= 0; i
< count
; i
++) {
3059 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3060 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3064 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
3066 unlock_user(target_vec
, target_addr
, 0);
3072 static inline int target_to_host_sock_type(int *type
)
3075 int target_type
= *type
;
3077 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
3078 case TARGET_SOCK_DGRAM
:
3079 host_type
= SOCK_DGRAM
;
3081 case TARGET_SOCK_STREAM
:
3082 host_type
= SOCK_STREAM
;
3085 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
3088 if (target_type
& TARGET_SOCK_CLOEXEC
) {
3089 #if defined(SOCK_CLOEXEC)
3090 host_type
|= SOCK_CLOEXEC
;
3092 return -TARGET_EINVAL
;
3095 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3096 #if defined(SOCK_NONBLOCK)
3097 host_type
|= SOCK_NONBLOCK
;
3098 #elif !defined(O_NONBLOCK)
3099 return -TARGET_EINVAL
;
3106 /* Try to emulate socket type flags after socket creation. */
3107 static int sock_flags_fixup(int fd
, int target_type
)
3109 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3110 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3111 int flags
= fcntl(fd
, F_GETFL
);
3112 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
3114 return -TARGET_EINVAL
;
3121 /* do_socket() Must return target values and target errnos. */
3122 static abi_long
do_socket(int domain
, int type
, int protocol
)
3124 int target_type
= type
;
3127 ret
= target_to_host_sock_type(&type
);
3132 if (domain
== PF_NETLINK
&& !(
3133 #ifdef CONFIG_RTNETLINK
3134 protocol
== NETLINK_ROUTE
||
3136 protocol
== NETLINK_KOBJECT_UEVENT
||
3137 protocol
== NETLINK_AUDIT
)) {
3138 return -TARGET_EPROTONOSUPPORT
;
3141 if (domain
== AF_PACKET
||
3142 (domain
== AF_INET
&& type
== SOCK_PACKET
)) {
3143 protocol
= tswap16(protocol
);
3146 ret
= get_errno(socket(domain
, type
, protocol
));
3148 ret
= sock_flags_fixup(ret
, target_type
);
3149 if (type
== SOCK_PACKET
) {
3150 /* Manage an obsolete case :
3151 * if socket type is SOCK_PACKET, bind by name
3153 fd_trans_register(ret
, &target_packet_trans
);
3154 } else if (domain
== PF_NETLINK
) {
3156 #ifdef CONFIG_RTNETLINK
3158 fd_trans_register(ret
, &target_netlink_route_trans
);
3161 case NETLINK_KOBJECT_UEVENT
:
3162 /* nothing to do: messages are strings */
3165 fd_trans_register(ret
, &target_netlink_audit_trans
);
3168 g_assert_not_reached();
3175 /* do_bind() Must return target values and target errnos. */
3176 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
3182 if ((int)addrlen
< 0) {
3183 return -TARGET_EINVAL
;
3186 addr
= alloca(addrlen
+1);
3188 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3192 return get_errno(bind(sockfd
, addr
, addrlen
));
3195 /* do_connect() Must return target values and target errnos. */
3196 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
3202 if ((int)addrlen
< 0) {
3203 return -TARGET_EINVAL
;
3206 addr
= alloca(addrlen
+1);
3208 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3212 return get_errno(safe_connect(sockfd
, addr
, addrlen
));
3215 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
3216 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
3217 int flags
, int send
)
3223 abi_ulong target_vec
;
3225 if (msgp
->msg_name
) {
3226 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
3227 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
3228 ret
= target_to_host_sockaddr(fd
, msg
.msg_name
,
3229 tswapal(msgp
->msg_name
),
3231 if (ret
== -TARGET_EFAULT
) {
3232 /* For connected sockets msg_name and msg_namelen must
3233 * be ignored, so returning EFAULT immediately is wrong.
3234 * Instead, pass a bad msg_name to the host kernel, and
3235 * let it decide whether to return EFAULT or not.
3237 msg
.msg_name
= (void *)-1;
3242 msg
.msg_name
= NULL
;
3243 msg
.msg_namelen
= 0;
3245 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
3246 msg
.msg_control
= alloca(msg
.msg_controllen
);
3247 memset(msg
.msg_control
, 0, msg
.msg_controllen
);
3249 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
3251 count
= tswapal(msgp
->msg_iovlen
);
3252 target_vec
= tswapal(msgp
->msg_iov
);
3254 if (count
> IOV_MAX
) {
3255 /* sendrcvmsg returns a different errno for this condition than
3256 * readv/writev, so we must catch it here before lock_iovec() does.
3258 ret
= -TARGET_EMSGSIZE
;
3262 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
3263 target_vec
, count
, send
);
3265 ret
= -host_to_target_errno(errno
);
3266 /* allow sending packet without any iov, e.g. with MSG_MORE flag */
3271 msg
.msg_iovlen
= count
;
3275 if (fd_trans_target_to_host_data(fd
)) {
3278 host_msg
= g_malloc(msg
.msg_iov
->iov_len
);
3279 memcpy(host_msg
, msg
.msg_iov
->iov_base
, msg
.msg_iov
->iov_len
);
3280 ret
= fd_trans_target_to_host_data(fd
)(host_msg
,
3281 msg
.msg_iov
->iov_len
);
3283 msg
.msg_iov
->iov_base
= host_msg
;
3284 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3288 ret
= target_to_host_cmsg(&msg
, msgp
);
3290 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3294 ret
= get_errno(safe_recvmsg(fd
, &msg
, flags
));
3295 if (!is_error(ret
)) {
3297 if (fd_trans_host_to_target_data(fd
)) {
3298 ret
= fd_trans_host_to_target_data(fd
)(msg
.msg_iov
->iov_base
,
3299 MIN(msg
.msg_iov
->iov_len
, len
));
3301 if (!is_error(ret
)) {
3302 ret
= host_to_target_cmsg(msgp
, &msg
);
3304 if (!is_error(ret
)) {
3305 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
3306 msgp
->msg_flags
= tswap32(msg
.msg_flags
);
3307 if (msg
.msg_name
!= NULL
&& msg
.msg_name
!= (void *)-1) {
3308 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
3309 msg
.msg_name
, msg
.msg_namelen
);
3322 unlock_iovec(vec
, target_vec
, count
, !send
);
3328 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
3329 int flags
, int send
)
3332 struct target_msghdr
*msgp
;
3334 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
3338 return -TARGET_EFAULT
;
3340 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
3341 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
3345 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
3346 * so it might not have this *mmsg-specific flag either.
3348 #ifndef MSG_WAITFORONE
3349 #define MSG_WAITFORONE 0x10000
3352 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
3353 unsigned int vlen
, unsigned int flags
,
3356 struct target_mmsghdr
*mmsgp
;
3360 if (vlen
> UIO_MAXIOV
) {
3364 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
3366 return -TARGET_EFAULT
;
3369 for (i
= 0; i
< vlen
; i
++) {
3370 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
3371 if (is_error(ret
)) {
3374 mmsgp
[i
].msg_len
= tswap32(ret
);
3375 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3376 if (flags
& MSG_WAITFORONE
) {
3377 flags
|= MSG_DONTWAIT
;
3381 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
3383 /* Return number of datagrams sent if we sent any at all;
3384 * otherwise return the error.
3392 /* do_accept4() Must return target values and target errnos. */
3393 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
3394 abi_ulong target_addrlen_addr
, int flags
)
3396 socklen_t addrlen
, ret_addrlen
;
3401 if (flags
& ~(TARGET_SOCK_CLOEXEC
| TARGET_SOCK_NONBLOCK
)) {
3402 return -TARGET_EINVAL
;
3406 if (flags
& TARGET_SOCK_NONBLOCK
) {
3407 host_flags
|= SOCK_NONBLOCK
;
3409 if (flags
& TARGET_SOCK_CLOEXEC
) {
3410 host_flags
|= SOCK_CLOEXEC
;
3413 if (target_addr
== 0) {
3414 return get_errno(safe_accept4(fd
, NULL
, NULL
, host_flags
));
3417 /* linux returns EFAULT if addrlen pointer is invalid */
3418 if (get_user_u32(addrlen
, target_addrlen_addr
))
3419 return -TARGET_EFAULT
;
3421 if ((int)addrlen
< 0) {
3422 return -TARGET_EINVAL
;
3425 if (!access_ok(thread_cpu
, VERIFY_WRITE
, target_addr
, addrlen
)) {
3426 return -TARGET_EFAULT
;
3429 addr
= alloca(addrlen
);
3431 ret_addrlen
= addrlen
;
3432 ret
= get_errno(safe_accept4(fd
, addr
, &ret_addrlen
, host_flags
));
3433 if (!is_error(ret
)) {
3434 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3435 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3436 ret
= -TARGET_EFAULT
;
3442 /* do_getpeername() Must return target values and target errnos. */
3443 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
3444 abi_ulong target_addrlen_addr
)
3446 socklen_t addrlen
, ret_addrlen
;
3450 if (get_user_u32(addrlen
, target_addrlen_addr
))
3451 return -TARGET_EFAULT
;
3453 if ((int)addrlen
< 0) {
3454 return -TARGET_EINVAL
;
3457 if (!access_ok(thread_cpu
, VERIFY_WRITE
, target_addr
, addrlen
)) {
3458 return -TARGET_EFAULT
;
3461 addr
= alloca(addrlen
);
3463 ret_addrlen
= addrlen
;
3464 ret
= get_errno(getpeername(fd
, addr
, &ret_addrlen
));
3465 if (!is_error(ret
)) {
3466 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3467 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3468 ret
= -TARGET_EFAULT
;
3474 /* do_getsockname() Must return target values and target errnos. */
3475 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
3476 abi_ulong target_addrlen_addr
)
3478 socklen_t addrlen
, ret_addrlen
;
3482 if (get_user_u32(addrlen
, target_addrlen_addr
))
3483 return -TARGET_EFAULT
;
3485 if ((int)addrlen
< 0) {
3486 return -TARGET_EINVAL
;
3489 if (!access_ok(thread_cpu
, VERIFY_WRITE
, target_addr
, addrlen
)) {
3490 return -TARGET_EFAULT
;
3493 addr
= alloca(addrlen
);
3495 ret_addrlen
= addrlen
;
3496 ret
= get_errno(getsockname(fd
, addr
, &ret_addrlen
));
3497 if (!is_error(ret
)) {
3498 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3499 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3500 ret
= -TARGET_EFAULT
;
3506 /* do_socketpair() Must return target values and target errnos. */
3507 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
3508 abi_ulong target_tab_addr
)
3513 target_to_host_sock_type(&type
);
3515 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
3516 if (!is_error(ret
)) {
3517 if (put_user_s32(tab
[0], target_tab_addr
)
3518 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
3519 ret
= -TARGET_EFAULT
;
3524 /* do_sendto() Must return target values and target errnos. */
3525 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
3526 abi_ulong target_addr
, socklen_t addrlen
)
3530 void *copy_msg
= NULL
;
3533 if ((int)addrlen
< 0) {
3534 return -TARGET_EINVAL
;
3537 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
3539 return -TARGET_EFAULT
;
3540 if (fd_trans_target_to_host_data(fd
)) {
3541 copy_msg
= host_msg
;
3542 host_msg
= g_malloc(len
);
3543 memcpy(host_msg
, copy_msg
, len
);
3544 ret
= fd_trans_target_to_host_data(fd
)(host_msg
, len
);
3550 addr
= alloca(addrlen
+1);
3551 ret
= target_to_host_sockaddr(fd
, addr
, target_addr
, addrlen
);
3555 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
3557 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, NULL
, 0));
3562 host_msg
= copy_msg
;
3564 unlock_user(host_msg
, msg
, 0);
3568 /* do_recvfrom() Must return target values and target errnos. */
3569 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
3570 abi_ulong target_addr
,
3571 abi_ulong target_addrlen
)
3573 socklen_t addrlen
, ret_addrlen
;
3581 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
3583 return -TARGET_EFAULT
;
3587 if (get_user_u32(addrlen
, target_addrlen
)) {
3588 ret
= -TARGET_EFAULT
;
3591 if ((int)addrlen
< 0) {
3592 ret
= -TARGET_EINVAL
;
3595 addr
= alloca(addrlen
);
3596 ret_addrlen
= addrlen
;
3597 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
,
3598 addr
, &ret_addrlen
));
3600 addr
= NULL
; /* To keep compiler quiet. */
3601 addrlen
= 0; /* To keep compiler quiet. */
3602 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
, NULL
, 0));
3604 if (!is_error(ret
)) {
3605 if (fd_trans_host_to_target_data(fd
)) {
3607 trans
= fd_trans_host_to_target_data(fd
)(host_msg
, MIN(ret
, len
));
3608 if (is_error(trans
)) {
3614 host_to_target_sockaddr(target_addr
, addr
,
3615 MIN(addrlen
, ret_addrlen
));
3616 if (put_user_u32(ret_addrlen
, target_addrlen
)) {
3617 ret
= -TARGET_EFAULT
;
3621 unlock_user(host_msg
, msg
, len
);
3624 unlock_user(host_msg
, msg
, 0);
3629 #ifdef TARGET_NR_socketcall
3630 /* do_socketcall() must return target values and target errnos. */
3631 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
3633 static const unsigned nargs
[] = { /* number of arguments per operation */
3634 [TARGET_SYS_SOCKET
] = 3, /* domain, type, protocol */
3635 [TARGET_SYS_BIND
] = 3, /* fd, addr, addrlen */
3636 [TARGET_SYS_CONNECT
] = 3, /* fd, addr, addrlen */
3637 [TARGET_SYS_LISTEN
] = 2, /* fd, backlog */
3638 [TARGET_SYS_ACCEPT
] = 3, /* fd, addr, addrlen */
3639 [TARGET_SYS_GETSOCKNAME
] = 3, /* fd, addr, addrlen */
3640 [TARGET_SYS_GETPEERNAME
] = 3, /* fd, addr, addrlen */
3641 [TARGET_SYS_SOCKETPAIR
] = 4, /* domain, type, protocol, tab */
3642 [TARGET_SYS_SEND
] = 4, /* fd, msg, len, flags */
3643 [TARGET_SYS_RECV
] = 4, /* fd, msg, len, flags */
3644 [TARGET_SYS_SENDTO
] = 6, /* fd, msg, len, flags, addr, addrlen */
3645 [TARGET_SYS_RECVFROM
] = 6, /* fd, msg, len, flags, addr, addrlen */
3646 [TARGET_SYS_SHUTDOWN
] = 2, /* fd, how */
3647 [TARGET_SYS_SETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3648 [TARGET_SYS_GETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3649 [TARGET_SYS_SENDMSG
] = 3, /* fd, msg, flags */
3650 [TARGET_SYS_RECVMSG
] = 3, /* fd, msg, flags */
3651 [TARGET_SYS_ACCEPT4
] = 4, /* fd, addr, addrlen, flags */
3652 [TARGET_SYS_RECVMMSG
] = 4, /* fd, msgvec, vlen, flags */
3653 [TARGET_SYS_SENDMMSG
] = 4, /* fd, msgvec, vlen, flags */
3655 abi_long a
[6]; /* max 6 args */
3658 /* check the range of the first argument num */
3659 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
3660 if (num
< 1 || num
> TARGET_SYS_SENDMMSG
) {
3661 return -TARGET_EINVAL
;
3663 /* ensure we have space for args */
3664 if (nargs
[num
] > ARRAY_SIZE(a
)) {
3665 return -TARGET_EINVAL
;
3667 /* collect the arguments in a[] according to nargs[] */
3668 for (i
= 0; i
< nargs
[num
]; ++i
) {
3669 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
3670 return -TARGET_EFAULT
;
3673 /* now when we have the args, invoke the appropriate underlying function */
3675 case TARGET_SYS_SOCKET
: /* domain, type, protocol */
3676 return do_socket(a
[0], a
[1], a
[2]);
3677 case TARGET_SYS_BIND
: /* sockfd, addr, addrlen */
3678 return do_bind(a
[0], a
[1], a
[2]);
3679 case TARGET_SYS_CONNECT
: /* sockfd, addr, addrlen */
3680 return do_connect(a
[0], a
[1], a
[2]);
3681 case TARGET_SYS_LISTEN
: /* sockfd, backlog */
3682 return get_errno(listen(a
[0], a
[1]));
3683 case TARGET_SYS_ACCEPT
: /* sockfd, addr, addrlen */
3684 return do_accept4(a
[0], a
[1], a
[2], 0);
3685 case TARGET_SYS_GETSOCKNAME
: /* sockfd, addr, addrlen */
3686 return do_getsockname(a
[0], a
[1], a
[2]);
3687 case TARGET_SYS_GETPEERNAME
: /* sockfd, addr, addrlen */
3688 return do_getpeername(a
[0], a
[1], a
[2]);
3689 case TARGET_SYS_SOCKETPAIR
: /* domain, type, protocol, tab */
3690 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
3691 case TARGET_SYS_SEND
: /* sockfd, msg, len, flags */
3692 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
3693 case TARGET_SYS_RECV
: /* sockfd, msg, len, flags */
3694 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
3695 case TARGET_SYS_SENDTO
: /* sockfd, msg, len, flags, addr, addrlen */
3696 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3697 case TARGET_SYS_RECVFROM
: /* sockfd, msg, len, flags, addr, addrlen */
3698 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3699 case TARGET_SYS_SHUTDOWN
: /* sockfd, how */
3700 return get_errno(shutdown(a
[0], a
[1]));
3701 case TARGET_SYS_SETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3702 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3703 case TARGET_SYS_GETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3704 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3705 case TARGET_SYS_SENDMSG
: /* sockfd, msg, flags */
3706 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
3707 case TARGET_SYS_RECVMSG
: /* sockfd, msg, flags */
3708 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
3709 case TARGET_SYS_ACCEPT4
: /* sockfd, addr, addrlen, flags */
3710 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
3711 case TARGET_SYS_RECVMMSG
: /* sockfd, msgvec, vlen, flags */
3712 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 0);
3713 case TARGET_SYS_SENDMMSG
: /* sockfd, msgvec, vlen, flags */
3714 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 1);
3716 qemu_log_mask(LOG_UNIMP
, "Unsupported socketcall: %d\n", num
);
3717 return -TARGET_EINVAL
;
3722 #ifndef TARGET_SEMID64_DS
3723 /* asm-generic version of this struct */
3724 struct target_semid64_ds
3726 struct target_ipc_perm sem_perm
;
3727 abi_ulong sem_otime
;
3728 #if TARGET_ABI_BITS == 32
3729 abi_ulong __unused1
;
3731 abi_ulong sem_ctime
;
3732 #if TARGET_ABI_BITS == 32
3733 abi_ulong __unused2
;
3735 abi_ulong sem_nsems
;
3736 abi_ulong __unused3
;
3737 abi_ulong __unused4
;
3741 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
3742 abi_ulong target_addr
)
3744 struct target_ipc_perm
*target_ip
;
3745 struct target_semid64_ds
*target_sd
;
3747 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3748 return -TARGET_EFAULT
;
3749 target_ip
= &(target_sd
->sem_perm
);
3750 host_ip
->__key
= tswap32(target_ip
->__key
);
3751 host_ip
->uid
= tswap32(target_ip
->uid
);
3752 host_ip
->gid
= tswap32(target_ip
->gid
);
3753 host_ip
->cuid
= tswap32(target_ip
->cuid
);
3754 host_ip
->cgid
= tswap32(target_ip
->cgid
);
3755 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3756 host_ip
->mode
= tswap32(target_ip
->mode
);
3758 host_ip
->mode
= tswap16(target_ip
->mode
);
3760 #if defined(TARGET_PPC)
3761 host_ip
->__seq
= tswap32(target_ip
->__seq
);
3763 host_ip
->__seq
= tswap16(target_ip
->__seq
);
3765 unlock_user_struct(target_sd
, target_addr
, 0);
3769 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
3770 struct ipc_perm
*host_ip
)
3772 struct target_ipc_perm
*target_ip
;
3773 struct target_semid64_ds
*target_sd
;
3775 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3776 return -TARGET_EFAULT
;
3777 target_ip
= &(target_sd
->sem_perm
);
3778 target_ip
->__key
= tswap32(host_ip
->__key
);
3779 target_ip
->uid
= tswap32(host_ip
->uid
);
3780 target_ip
->gid
= tswap32(host_ip
->gid
);
3781 target_ip
->cuid
= tswap32(host_ip
->cuid
);
3782 target_ip
->cgid
= tswap32(host_ip
->cgid
);
3783 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3784 target_ip
->mode
= tswap32(host_ip
->mode
);
3786 target_ip
->mode
= tswap16(host_ip
->mode
);
3788 #if defined(TARGET_PPC)
3789 target_ip
->__seq
= tswap32(host_ip
->__seq
);
3791 target_ip
->__seq
= tswap16(host_ip
->__seq
);
3793 unlock_user_struct(target_sd
, target_addr
, 1);
3797 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
3798 abi_ulong target_addr
)
3800 struct target_semid64_ds
*target_sd
;
3802 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3803 return -TARGET_EFAULT
;
3804 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
3805 return -TARGET_EFAULT
;
3806 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
3807 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
3808 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
3809 unlock_user_struct(target_sd
, target_addr
, 0);
3813 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
3814 struct semid_ds
*host_sd
)
3816 struct target_semid64_ds
*target_sd
;
3818 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3819 return -TARGET_EFAULT
;
3820 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
3821 return -TARGET_EFAULT
;
3822 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
3823 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
3824 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
3825 unlock_user_struct(target_sd
, target_addr
, 1);
3829 struct target_seminfo
{
3842 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
3843 struct seminfo
*host_seminfo
)
3845 struct target_seminfo
*target_seminfo
;
3846 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
3847 return -TARGET_EFAULT
;
3848 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
3849 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
3850 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
3851 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
3852 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
3853 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
3854 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
3855 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
3856 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
3857 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
3858 unlock_user_struct(target_seminfo
, target_addr
, 1);
3864 struct semid_ds
*buf
;
3865 unsigned short *array
;
3866 struct seminfo
*__buf
;
3869 union target_semun
{
3876 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
3877 abi_ulong target_addr
)
3880 unsigned short *array
;
3882 struct semid_ds semid_ds
;
3885 semun
.buf
= &semid_ds
;
3887 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3889 return get_errno(ret
);
3891 nsems
= semid_ds
.sem_nsems
;
3893 *host_array
= g_try_new(unsigned short, nsems
);
3895 return -TARGET_ENOMEM
;
3897 array
= lock_user(VERIFY_READ
, target_addr
,
3898 nsems
*sizeof(unsigned short), 1);
3900 g_free(*host_array
);
3901 return -TARGET_EFAULT
;
3904 for(i
=0; i
<nsems
; i
++) {
3905 __get_user((*host_array
)[i
], &array
[i
]);
3907 unlock_user(array
, target_addr
, 0);
3912 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
3913 unsigned short **host_array
)
3916 unsigned short *array
;
3918 struct semid_ds semid_ds
;
3921 semun
.buf
= &semid_ds
;
3923 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3925 return get_errno(ret
);
3927 nsems
= semid_ds
.sem_nsems
;
3929 array
= lock_user(VERIFY_WRITE
, target_addr
,
3930 nsems
*sizeof(unsigned short), 0);
3932 return -TARGET_EFAULT
;
3934 for(i
=0; i
<nsems
; i
++) {
3935 __put_user((*host_array
)[i
], &array
[i
]);
3937 g_free(*host_array
);
3938 unlock_user(array
, target_addr
, 1);
3943 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
3944 abi_ulong target_arg
)
3946 union target_semun target_su
= { .buf
= target_arg
};
3948 struct semid_ds dsarg
;
3949 unsigned short *array
= NULL
;
3950 struct seminfo seminfo
;
3951 abi_long ret
= -TARGET_EINVAL
;
3958 /* In 64 bit cross-endian situations, we will erroneously pick up
3959 * the wrong half of the union for the "val" element. To rectify
3960 * this, the entire 8-byte structure is byteswapped, followed by
3961 * a swap of the 4 byte val field. In other cases, the data is
3962 * already in proper host byte order. */
3963 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
3964 target_su
.buf
= tswapal(target_su
.buf
);
3965 arg
.val
= tswap32(target_su
.val
);
3967 arg
.val
= target_su
.val
;
3969 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3973 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
3977 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3978 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
3985 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
3989 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3990 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
3996 arg
.__buf
= &seminfo
;
3997 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3998 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
4006 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
4013 struct target_sembuf
{
4014 unsigned short sem_num
;
4019 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
4020 abi_ulong target_addr
,
4023 struct target_sembuf
*target_sembuf
;
4026 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
4027 nsops
*sizeof(struct target_sembuf
), 1);
4029 return -TARGET_EFAULT
;
4031 for(i
=0; i
<nsops
; i
++) {
4032 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
4033 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
4034 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
4037 unlock_user(target_sembuf
, target_addr
, 0);
4042 #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
4043 defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
4046 * This macro is required to handle the s390 variants, which passes the
4047 * arguments in a different order than default.
4050 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
4051 (__nsops), (__timeout), (__sops)
4053 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
4054 (__nsops), 0, (__sops), (__timeout)
4057 static inline abi_long
do_semtimedop(int semid
,
4060 abi_long timeout
, bool time64
)
4062 struct sembuf
*sops
;
4063 struct timespec ts
, *pts
= NULL
;
4069 if (target_to_host_timespec64(pts
, timeout
)) {
4070 return -TARGET_EFAULT
;
4073 if (target_to_host_timespec(pts
, timeout
)) {
4074 return -TARGET_EFAULT
;
4079 if (nsops
> TARGET_SEMOPM
) {
4080 return -TARGET_E2BIG
;
4083 sops
= g_new(struct sembuf
, nsops
);
4085 if (target_to_host_sembuf(sops
, ptr
, nsops
)) {
4087 return -TARGET_EFAULT
;
4090 ret
= -TARGET_ENOSYS
;
4091 #ifdef __NR_semtimedop
4092 ret
= get_errno(safe_semtimedop(semid
, sops
, nsops
, pts
));
4095 if (ret
== -TARGET_ENOSYS
) {
4096 ret
= get_errno(safe_ipc(IPCOP_semtimedop
, semid
,
4097 SEMTIMEDOP_IPC_ARGS(nsops
, sops
, (long)pts
)));
4105 struct target_msqid_ds
4107 struct target_ipc_perm msg_perm
;
4108 abi_ulong msg_stime
;
4109 #if TARGET_ABI_BITS == 32
4110 abi_ulong __unused1
;
4112 abi_ulong msg_rtime
;
4113 #if TARGET_ABI_BITS == 32
4114 abi_ulong __unused2
;
4116 abi_ulong msg_ctime
;
4117 #if TARGET_ABI_BITS == 32
4118 abi_ulong __unused3
;
4120 abi_ulong __msg_cbytes
;
4122 abi_ulong msg_qbytes
;
4123 abi_ulong msg_lspid
;
4124 abi_ulong msg_lrpid
;
4125 abi_ulong __unused4
;
4126 abi_ulong __unused5
;
4129 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
4130 abi_ulong target_addr
)
4132 struct target_msqid_ds
*target_md
;
4134 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
4135 return -TARGET_EFAULT
;
4136 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
4137 return -TARGET_EFAULT
;
4138 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
4139 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
4140 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
4141 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
4142 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
4143 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
4144 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
4145 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
4146 unlock_user_struct(target_md
, target_addr
, 0);
4150 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
4151 struct msqid_ds
*host_md
)
4153 struct target_msqid_ds
*target_md
;
4155 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
4156 return -TARGET_EFAULT
;
4157 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
4158 return -TARGET_EFAULT
;
4159 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
4160 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
4161 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
4162 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
4163 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
4164 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
4165 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
4166 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
4167 unlock_user_struct(target_md
, target_addr
, 1);
4171 struct target_msginfo
{
4179 unsigned short int msgseg
;
4182 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
4183 struct msginfo
*host_msginfo
)
4185 struct target_msginfo
*target_msginfo
;
4186 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
4187 return -TARGET_EFAULT
;
4188 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
4189 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
4190 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
4191 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
4192 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
4193 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
4194 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
4195 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
4196 unlock_user_struct(target_msginfo
, target_addr
, 1);
4200 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
4202 struct msqid_ds dsarg
;
4203 struct msginfo msginfo
;
4204 abi_long ret
= -TARGET_EINVAL
;
4212 if (target_to_host_msqid_ds(&dsarg
,ptr
))
4213 return -TARGET_EFAULT
;
4214 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
4215 if (host_to_target_msqid_ds(ptr
,&dsarg
))
4216 return -TARGET_EFAULT
;
4219 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
4223 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
4224 if (host_to_target_msginfo(ptr
, &msginfo
))
4225 return -TARGET_EFAULT
;
4232 struct target_msgbuf
{
4237 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
4238 ssize_t msgsz
, int msgflg
)
4240 struct target_msgbuf
*target_mb
;
4241 struct msgbuf
*host_mb
;
4245 return -TARGET_EINVAL
;
4248 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
4249 return -TARGET_EFAULT
;
4250 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4252 unlock_user_struct(target_mb
, msgp
, 0);
4253 return -TARGET_ENOMEM
;
4255 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
4256 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
4257 ret
= -TARGET_ENOSYS
;
4259 ret
= get_errno(safe_msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
4262 if (ret
== -TARGET_ENOSYS
) {
4264 ret
= get_errno(safe_ipc(IPCOP_msgsnd
, msqid
, msgsz
, msgflg
,
4267 ret
= get_errno(safe_ipc(IPCOP_msgsnd
, msqid
, msgsz
, msgflg
,
4273 unlock_user_struct(target_mb
, msgp
, 0);
4279 #if defined(__sparc__)
4280 /* SPARC for msgrcv it does not use the kludge on final 2 arguments. */
4281 #define MSGRCV_ARGS(__msgp, __msgtyp) __msgp, __msgtyp
4282 #elif defined(__s390x__)
4283 /* The s390 sys_ipc variant has only five parameters. */
4284 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4285 ((long int[]){(long int)__msgp, __msgtyp})
4287 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4288 ((long int[]){(long int)__msgp, __msgtyp}), 0
4292 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
4293 ssize_t msgsz
, abi_long msgtyp
,
4296 struct target_msgbuf
*target_mb
;
4298 struct msgbuf
*host_mb
;
4302 return -TARGET_EINVAL
;
4305 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
4306 return -TARGET_EFAULT
;
4308 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4310 ret
= -TARGET_ENOMEM
;
4313 ret
= -TARGET_ENOSYS
;
4315 ret
= get_errno(safe_msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
4318 if (ret
== -TARGET_ENOSYS
) {
4319 ret
= get_errno(safe_ipc(IPCOP_CALL(1, IPCOP_msgrcv
), msqid
, msgsz
,
4320 msgflg
, MSGRCV_ARGS(host_mb
, msgtyp
)));
4325 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
4326 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
4327 if (!target_mtext
) {
4328 ret
= -TARGET_EFAULT
;
4331 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
4332 unlock_user(target_mtext
, target_mtext_addr
, ret
);
4335 target_mb
->mtype
= tswapal(host_mb
->mtype
);
4339 unlock_user_struct(target_mb
, msgp
, 1);
4344 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
4345 abi_ulong target_addr
)
4347 struct target_shmid_ds
*target_sd
;
4349 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4350 return -TARGET_EFAULT
;
4351 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
4352 return -TARGET_EFAULT
;
4353 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4354 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4355 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4356 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4357 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4358 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4359 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4360 unlock_user_struct(target_sd
, target_addr
, 0);
4364 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
4365 struct shmid_ds
*host_sd
)
4367 struct target_shmid_ds
*target_sd
;
4369 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4370 return -TARGET_EFAULT
;
4371 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
4372 return -TARGET_EFAULT
;
4373 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4374 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4375 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4376 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4377 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4378 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4379 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4380 unlock_user_struct(target_sd
, target_addr
, 1);
4384 struct target_shminfo
{
4392 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
4393 struct shminfo
*host_shminfo
)
4395 struct target_shminfo
*target_shminfo
;
4396 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
4397 return -TARGET_EFAULT
;
4398 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
4399 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
4400 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
4401 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
4402 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
4403 unlock_user_struct(target_shminfo
, target_addr
, 1);
4407 struct target_shm_info
{
4412 abi_ulong swap_attempts
;
4413 abi_ulong swap_successes
;
4416 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
4417 struct shm_info
*host_shm_info
)
4419 struct target_shm_info
*target_shm_info
;
4420 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
4421 return -TARGET_EFAULT
;
4422 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
4423 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
4424 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
4425 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
4426 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
4427 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
4428 unlock_user_struct(target_shm_info
, target_addr
, 1);
4432 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
4434 struct shmid_ds dsarg
;
4435 struct shminfo shminfo
;
4436 struct shm_info shm_info
;
4437 abi_long ret
= -TARGET_EINVAL
;
4445 if (target_to_host_shmid_ds(&dsarg
, buf
))
4446 return -TARGET_EFAULT
;
4447 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
4448 if (host_to_target_shmid_ds(buf
, &dsarg
))
4449 return -TARGET_EFAULT
;
4452 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
4453 if (host_to_target_shminfo(buf
, &shminfo
))
4454 return -TARGET_EFAULT
;
4457 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
4458 if (host_to_target_shm_info(buf
, &shm_info
))
4459 return -TARGET_EFAULT
;
4464 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
4471 #ifdef TARGET_NR_ipc
4472 /* ??? This only works with linear mappings. */
4473 /* do_ipc() must return target values and target errnos. */
4474 static abi_long
do_ipc(CPUArchState
*cpu_env
,
4475 unsigned int call
, abi_long first
,
4476 abi_long second
, abi_long third
,
4477 abi_long ptr
, abi_long fifth
)
4482 version
= call
>> 16;
4487 ret
= do_semtimedop(first
, ptr
, second
, 0, false);
4489 case IPCOP_semtimedop
:
4491 * The s390 sys_ipc variant has only five parameters instead of six
4492 * (as for default variant) and the only difference is the handling of
4493 * SEMTIMEDOP where on s390 the third parameter is used as a pointer
4494 * to a struct timespec where the generic variant uses fifth parameter.
4496 #if defined(TARGET_S390X)
4497 ret
= do_semtimedop(first
, ptr
, second
, third
, TARGET_ABI_BITS
== 64);
4499 ret
= do_semtimedop(first
, ptr
, second
, fifth
, TARGET_ABI_BITS
== 64);
4504 ret
= get_errno(semget(first
, second
, third
));
4507 case IPCOP_semctl
: {
4508 /* The semun argument to semctl is passed by value, so dereference the
4511 get_user_ual(atptr
, ptr
);
4512 ret
= do_semctl(first
, second
, third
, atptr
);
4517 ret
= get_errno(msgget(first
, second
));
4521 ret
= do_msgsnd(first
, ptr
, second
, third
);
4525 ret
= do_msgctl(first
, second
, ptr
);
4532 struct target_ipc_kludge
{
4537 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
4538 ret
= -TARGET_EFAULT
;
4542 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
4544 unlock_user_struct(tmp
, ptr
, 0);
4548 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
4557 raddr
= target_shmat(cpu_env
, first
, ptr
, second
);
4558 if (is_error(raddr
))
4559 return get_errno(raddr
);
4560 if (put_user_ual(raddr
, third
))
4561 return -TARGET_EFAULT
;
4565 ret
= -TARGET_EINVAL
;
4570 ret
= target_shmdt(ptr
);
4574 /* IPC_* flag values are the same on all linux platforms */
4575 ret
= get_errno(shmget(first
, second
, third
));
4578 /* IPC_* and SHM_* command values are the same on all linux platforms */
4580 ret
= do_shmctl(first
, second
, ptr
);
4583 qemu_log_mask(LOG_UNIMP
, "Unsupported ipc call: %d (version %d)\n",
4585 ret
= -TARGET_ENOSYS
;
4592 /* kernel structure types definitions */
4594 #define STRUCT(name, ...) STRUCT_ ## name,
4595 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
4597 #include "syscall_types.h"
4601 #undef STRUCT_SPECIAL
4603 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
4604 #define STRUCT_SPECIAL(name)
4605 #include "syscall_types.h"
4607 #undef STRUCT_SPECIAL
4609 #define MAX_STRUCT_SIZE 4096
4611 #ifdef CONFIG_FIEMAP
4612 /* So fiemap access checks don't overflow on 32 bit systems.
4613 * This is very slightly smaller than the limit imposed by
4614 * the underlying kernel.
4616 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
4617 / sizeof(struct fiemap_extent))
4619 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4620 int fd
, int cmd
, abi_long arg
)
4622 /* The parameter for this ioctl is a struct fiemap followed
4623 * by an array of struct fiemap_extent whose size is set
4624 * in fiemap->fm_extent_count. The array is filled in by the
4627 int target_size_in
, target_size_out
;
4629 const argtype
*arg_type
= ie
->arg_type
;
4630 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
4633 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
4637 assert(arg_type
[0] == TYPE_PTR
);
4638 assert(ie
->access
== IOC_RW
);
4640 target_size_in
= thunk_type_size(arg_type
, 0);
4641 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
4643 return -TARGET_EFAULT
;
4645 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4646 unlock_user(argptr
, arg
, 0);
4647 fm
= (struct fiemap
*)buf_temp
;
4648 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
4649 return -TARGET_EINVAL
;
4652 outbufsz
= sizeof (*fm
) +
4653 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
4655 if (outbufsz
> MAX_STRUCT_SIZE
) {
4656 /* We can't fit all the extents into the fixed size buffer.
4657 * Allocate one that is large enough and use it instead.
4659 fm
= g_try_malloc(outbufsz
);
4661 return -TARGET_ENOMEM
;
4663 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
4666 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, fm
));
4667 if (!is_error(ret
)) {
4668 target_size_out
= target_size_in
;
4669 /* An extent_count of 0 means we were only counting the extents
4670 * so there are no structs to copy
4672 if (fm
->fm_extent_count
!= 0) {
4673 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
4675 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
4677 ret
= -TARGET_EFAULT
;
4679 /* Convert the struct fiemap */
4680 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
4681 if (fm
->fm_extent_count
!= 0) {
4682 p
= argptr
+ target_size_in
;
4683 /* ...and then all the struct fiemap_extents */
4684 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
4685 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
4690 unlock_user(argptr
, arg
, target_size_out
);
4700 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4701 int fd
, int cmd
, abi_long arg
)
4703 const argtype
*arg_type
= ie
->arg_type
;
4707 struct ifconf
*host_ifconf
;
4709 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
4710 const argtype ifreq_max_type
[] = { MK_STRUCT(STRUCT_ifmap_ifreq
) };
4711 int target_ifreq_size
;
4716 abi_long target_ifc_buf
;
4720 assert(arg_type
[0] == TYPE_PTR
);
4721 assert(ie
->access
== IOC_RW
);
4724 target_size
= thunk_type_size(arg_type
, 0);
4726 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4728 return -TARGET_EFAULT
;
4729 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4730 unlock_user(argptr
, arg
, 0);
4732 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
4733 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
4734 target_ifreq_size
= thunk_type_size(ifreq_max_type
, 0);
4736 if (target_ifc_buf
!= 0) {
4737 target_ifc_len
= host_ifconf
->ifc_len
;
4738 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
4739 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
4741 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
4742 if (outbufsz
> MAX_STRUCT_SIZE
) {
4744 * We can't fit all the extents into the fixed size buffer.
4745 * Allocate one that is large enough and use it instead.
4747 host_ifconf
= g_try_malloc(outbufsz
);
4749 return -TARGET_ENOMEM
;
4751 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
4754 host_ifc_buf
= (char *)host_ifconf
+ sizeof(*host_ifconf
);
4756 host_ifconf
->ifc_len
= host_ifc_len
;
4758 host_ifc_buf
= NULL
;
4760 host_ifconf
->ifc_buf
= host_ifc_buf
;
4762 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_ifconf
));
4763 if (!is_error(ret
)) {
4764 /* convert host ifc_len to target ifc_len */
4766 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
4767 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
4768 host_ifconf
->ifc_len
= target_ifc_len
;
4770 /* restore target ifc_buf */
4772 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
4774 /* copy struct ifconf to target user */
4776 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4778 return -TARGET_EFAULT
;
4779 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
4780 unlock_user(argptr
, arg
, target_size
);
4782 if (target_ifc_buf
!= 0) {
4783 /* copy ifreq[] to target user */
4784 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
4785 for (i
= 0; i
< nb_ifreq
; i
++) {
4786 thunk_convert(argptr
+ i
* target_ifreq_size
,
4787 host_ifc_buf
+ i
* sizeof(struct ifreq
),
4788 ifreq_arg_type
, THUNK_TARGET
);
4790 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
4795 g_free(host_ifconf
);
4801 #if defined(CONFIG_USBFS)
4802 #if HOST_LONG_BITS > 64
4803 #error USBDEVFS thunks do not support >64 bit hosts yet.
4806 uint64_t target_urb_adr
;
4807 uint64_t target_buf_adr
;
4808 char *target_buf_ptr
;
4809 struct usbdevfs_urb host_urb
;
4812 static GHashTable
*usbdevfs_urb_hashtable(void)
4814 static GHashTable
*urb_hashtable
;
4816 if (!urb_hashtable
) {
4817 urb_hashtable
= g_hash_table_new(g_int64_hash
, g_int64_equal
);
4819 return urb_hashtable
;
4822 static void urb_hashtable_insert(struct live_urb
*urb
)
4824 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4825 g_hash_table_insert(urb_hashtable
, urb
, urb
);
4828 static struct live_urb
*urb_hashtable_lookup(uint64_t target_urb_adr
)
4830 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4831 return g_hash_table_lookup(urb_hashtable
, &target_urb_adr
);
4834 static void urb_hashtable_remove(struct live_urb
*urb
)
4836 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4837 g_hash_table_remove(urb_hashtable
, urb
);
4841 do_ioctl_usbdevfs_reapurb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4842 int fd
, int cmd
, abi_long arg
)
4844 const argtype usbfsurb_arg_type
[] = { MK_STRUCT(STRUCT_usbdevfs_urb
) };
4845 const argtype ptrvoid_arg_type
[] = { TYPE_PTRVOID
, 0, 0 };
4846 struct live_urb
*lurb
;
4850 uintptr_t target_urb_adr
;
4853 target_size
= thunk_type_size(usbfsurb_arg_type
, THUNK_TARGET
);
4855 memset(buf_temp
, 0, sizeof(uint64_t));
4856 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4857 if (is_error(ret
)) {
4861 memcpy(&hurb
, buf_temp
, sizeof(uint64_t));
4862 lurb
= (void *)((uintptr_t)hurb
- offsetof(struct live_urb
, host_urb
));
4863 if (!lurb
->target_urb_adr
) {
4864 return -TARGET_EFAULT
;
4866 urb_hashtable_remove(lurb
);
4867 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
,
4868 lurb
->host_urb
.buffer_length
);
4869 lurb
->target_buf_ptr
= NULL
;
4871 /* restore the guest buffer pointer */
4872 lurb
->host_urb
.buffer
= (void *)(uintptr_t)lurb
->target_buf_adr
;
4874 /* update the guest urb struct */
4875 argptr
= lock_user(VERIFY_WRITE
, lurb
->target_urb_adr
, target_size
, 0);
4878 return -TARGET_EFAULT
;
4880 thunk_convert(argptr
, &lurb
->host_urb
, usbfsurb_arg_type
, THUNK_TARGET
);
4881 unlock_user(argptr
, lurb
->target_urb_adr
, target_size
);
4883 target_size
= thunk_type_size(ptrvoid_arg_type
, THUNK_TARGET
);
4884 /* write back the urb handle */
4885 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4888 return -TARGET_EFAULT
;
4891 /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */
4892 target_urb_adr
= lurb
->target_urb_adr
;
4893 thunk_convert(argptr
, &target_urb_adr
, ptrvoid_arg_type
, THUNK_TARGET
);
4894 unlock_user(argptr
, arg
, target_size
);
4901 do_ioctl_usbdevfs_discardurb(const IOCTLEntry
*ie
,
4902 uint8_t *buf_temp
__attribute__((unused
)),
4903 int fd
, int cmd
, abi_long arg
)
4905 struct live_urb
*lurb
;
4907 /* map target address back to host URB with metadata. */
4908 lurb
= urb_hashtable_lookup(arg
);
4910 return -TARGET_EFAULT
;
4912 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4916 do_ioctl_usbdevfs_submiturb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4917 int fd
, int cmd
, abi_long arg
)
4919 const argtype
*arg_type
= ie
->arg_type
;
4924 struct live_urb
*lurb
;
4927 * each submitted URB needs to map to a unique ID for the
4928 * kernel, and that unique ID needs to be a pointer to
4929 * host memory. hence, we need to malloc for each URB.
4930 * isochronous transfers have a variable length struct.
4933 target_size
= thunk_type_size(arg_type
, THUNK_TARGET
);
4935 /* construct host copy of urb and metadata */
4936 lurb
= g_try_new0(struct live_urb
, 1);
4938 return -TARGET_ENOMEM
;
4941 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4944 return -TARGET_EFAULT
;
4946 thunk_convert(&lurb
->host_urb
, argptr
, arg_type
, THUNK_HOST
);
4947 unlock_user(argptr
, arg
, 0);
4949 lurb
->target_urb_adr
= arg
;
4950 lurb
->target_buf_adr
= (uintptr_t)lurb
->host_urb
.buffer
;
4952 /* buffer space used depends on endpoint type so lock the entire buffer */
4953 /* control type urbs should check the buffer contents for true direction */
4954 rw_dir
= lurb
->host_urb
.endpoint
& USB_DIR_IN
? VERIFY_WRITE
: VERIFY_READ
;
4955 lurb
->target_buf_ptr
= lock_user(rw_dir
, lurb
->target_buf_adr
,
4956 lurb
->host_urb
.buffer_length
, 1);
4957 if (lurb
->target_buf_ptr
== NULL
) {
4959 return -TARGET_EFAULT
;
4962 /* update buffer pointer in host copy */
4963 lurb
->host_urb
.buffer
= lurb
->target_buf_ptr
;
4965 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4966 if (is_error(ret
)) {
4967 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
, 0);
4970 urb_hashtable_insert(lurb
);
4975 #endif /* CONFIG_USBFS */
4977 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
4978 int cmd
, abi_long arg
)
4981 struct dm_ioctl
*host_dm
;
4982 abi_long guest_data
;
4983 uint32_t guest_data_size
;
4985 const argtype
*arg_type
= ie
->arg_type
;
4987 void *big_buf
= NULL
;
4991 target_size
= thunk_type_size(arg_type
, 0);
4992 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4994 ret
= -TARGET_EFAULT
;
4997 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4998 unlock_user(argptr
, arg
, 0);
5000 /* buf_temp is too small, so fetch things into a bigger buffer */
5001 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
5002 memcpy(big_buf
, buf_temp
, target_size
);
5006 guest_data
= arg
+ host_dm
->data_start
;
5007 if ((guest_data
- arg
) < 0) {
5008 ret
= -TARGET_EINVAL
;
5011 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5012 host_data
= (char*)host_dm
+ host_dm
->data_start
;
5014 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
5016 ret
= -TARGET_EFAULT
;
5020 switch (ie
->host_cmd
) {
5022 case DM_LIST_DEVICES
:
5025 case DM_DEV_SUSPEND
:
5028 case DM_TABLE_STATUS
:
5029 case DM_TABLE_CLEAR
:
5031 case DM_LIST_VERSIONS
:
5035 case DM_DEV_SET_GEOMETRY
:
5036 /* data contains only strings */
5037 memcpy(host_data
, argptr
, guest_data_size
);
5040 memcpy(host_data
, argptr
, guest_data_size
);
5041 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
5045 void *gspec
= argptr
;
5046 void *cur_data
= host_data
;
5047 const argtype dm_arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5048 int spec_size
= thunk_type_size(dm_arg_type
, 0);
5051 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5052 struct dm_target_spec
*spec
= cur_data
;
5056 thunk_convert(spec
, gspec
, dm_arg_type
, THUNK_HOST
);
5057 slen
= strlen((char*)gspec
+ spec_size
) + 1;
5059 spec
->next
= sizeof(*spec
) + slen
;
5060 strcpy((char*)&spec
[1], gspec
+ spec_size
);
5062 cur_data
+= spec
->next
;
5067 ret
= -TARGET_EINVAL
;
5068 unlock_user(argptr
, guest_data
, 0);
5071 unlock_user(argptr
, guest_data
, 0);
5073 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5074 if (!is_error(ret
)) {
5075 guest_data
= arg
+ host_dm
->data_start
;
5076 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5077 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
5078 switch (ie
->host_cmd
) {
5083 case DM_DEV_SUSPEND
:
5086 case DM_TABLE_CLEAR
:
5088 case DM_DEV_SET_GEOMETRY
:
5089 /* no return data */
5091 case DM_LIST_DEVICES
:
5093 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
5094 uint32_t remaining_data
= guest_data_size
;
5095 void *cur_data
= argptr
;
5096 const argtype dm_arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
5097 int nl_size
= 12; /* can't use thunk_size due to alignment */
5100 uint32_t next
= nl
->next
;
5102 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
5104 if (remaining_data
< nl
->next
) {
5105 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5108 thunk_convert(cur_data
, nl
, dm_arg_type
, THUNK_TARGET
);
5109 strcpy(cur_data
+ nl_size
, nl
->name
);
5110 cur_data
+= nl
->next
;
5111 remaining_data
-= nl
->next
;
5115 nl
= (void*)nl
+ next
;
5120 case DM_TABLE_STATUS
:
5122 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
5123 void *cur_data
= argptr
;
5124 const argtype dm_arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5125 int spec_size
= thunk_type_size(dm_arg_type
, 0);
5128 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5129 uint32_t next
= spec
->next
;
5130 int slen
= strlen((char*)&spec
[1]) + 1;
5131 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
5132 if (guest_data_size
< spec
->next
) {
5133 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5136 thunk_convert(cur_data
, spec
, dm_arg_type
, THUNK_TARGET
);
5137 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
5138 cur_data
= argptr
+ spec
->next
;
5139 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
5145 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
5146 int count
= *(uint32_t*)hdata
;
5147 uint64_t *hdev
= hdata
+ 8;
5148 uint64_t *gdev
= argptr
+ 8;
5151 *(uint32_t*)argptr
= tswap32(count
);
5152 for (i
= 0; i
< count
; i
++) {
5153 *gdev
= tswap64(*hdev
);
5159 case DM_LIST_VERSIONS
:
5161 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
5162 uint32_t remaining_data
= guest_data_size
;
5163 void *cur_data
= argptr
;
5164 const argtype dm_arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
5165 int vers_size
= thunk_type_size(dm_arg_type
, 0);
5168 uint32_t next
= vers
->next
;
5170 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
5172 if (remaining_data
< vers
->next
) {
5173 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5176 thunk_convert(cur_data
, vers
, dm_arg_type
, THUNK_TARGET
);
5177 strcpy(cur_data
+ vers_size
, vers
->name
);
5178 cur_data
+= vers
->next
;
5179 remaining_data
-= vers
->next
;
5183 vers
= (void*)vers
+ next
;
5188 unlock_user(argptr
, guest_data
, 0);
5189 ret
= -TARGET_EINVAL
;
5192 unlock_user(argptr
, guest_data
, guest_data_size
);
5194 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5196 ret
= -TARGET_EFAULT
;
5199 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5200 unlock_user(argptr
, arg
, target_size
);
5207 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
5208 int cmd
, abi_long arg
)
5212 const argtype
*arg_type
= ie
->arg_type
;
5213 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
5216 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
5217 struct blkpg_partition host_part
;
5219 /* Read and convert blkpg */
5221 target_size
= thunk_type_size(arg_type
, 0);
5222 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5224 ret
= -TARGET_EFAULT
;
5227 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5228 unlock_user(argptr
, arg
, 0);
5230 switch (host_blkpg
->op
) {
5231 case BLKPG_ADD_PARTITION
:
5232 case BLKPG_DEL_PARTITION
:
5233 /* payload is struct blkpg_partition */
5236 /* Unknown opcode */
5237 ret
= -TARGET_EINVAL
;
5241 /* Read and convert blkpg->data */
5242 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
5243 target_size
= thunk_type_size(part_arg_type
, 0);
5244 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5246 ret
= -TARGET_EFAULT
;
5249 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
5250 unlock_user(argptr
, arg
, 0);
5252 /* Swizzle the data pointer to our local copy and call! */
5253 host_blkpg
->data
= &host_part
;
5254 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_blkpg
));
5260 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5261 int fd
, int cmd
, abi_long arg
)
5263 const argtype
*arg_type
= ie
->arg_type
;
5264 const StructEntry
*se
;
5265 const argtype
*field_types
;
5266 const int *dst_offsets
, *src_offsets
;
5269 abi_ulong
*target_rt_dev_ptr
= NULL
;
5270 unsigned long *host_rt_dev_ptr
= NULL
;
5274 assert(ie
->access
== IOC_W
);
5275 assert(*arg_type
== TYPE_PTR
);
5277 assert(*arg_type
== TYPE_STRUCT
);
5278 target_size
= thunk_type_size(arg_type
, 0);
5279 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5281 return -TARGET_EFAULT
;
5284 assert(*arg_type
== (int)STRUCT_rtentry
);
5285 se
= struct_entries
+ *arg_type
++;
5286 assert(se
->convert
[0] == NULL
);
5287 /* convert struct here to be able to catch rt_dev string */
5288 field_types
= se
->field_types
;
5289 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
5290 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
5291 for (i
= 0; i
< se
->nb_fields
; i
++) {
5292 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
5293 assert(*field_types
== TYPE_PTRVOID
);
5294 target_rt_dev_ptr
= argptr
+ src_offsets
[i
];
5295 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
5296 if (*target_rt_dev_ptr
!= 0) {
5297 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
5298 tswapal(*target_rt_dev_ptr
));
5299 if (!*host_rt_dev_ptr
) {
5300 unlock_user(argptr
, arg
, 0);
5301 return -TARGET_EFAULT
;
5304 *host_rt_dev_ptr
= 0;
5309 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
5310 argptr
+ src_offsets
[i
],
5311 field_types
, THUNK_HOST
);
5313 unlock_user(argptr
, arg
, 0);
5315 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5317 assert(host_rt_dev_ptr
!= NULL
);
5318 assert(target_rt_dev_ptr
!= NULL
);
5319 if (*host_rt_dev_ptr
!= 0) {
5320 unlock_user((void *)*host_rt_dev_ptr
,
5321 *target_rt_dev_ptr
, 0);
5326 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5327 int fd
, int cmd
, abi_long arg
)
5329 int sig
= target_to_host_signal(arg
);
5330 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, sig
));
5333 static abi_long
do_ioctl_SIOCGSTAMP(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5334 int fd
, int cmd
, abi_long arg
)
5339 ret
= get_errno(safe_ioctl(fd
, SIOCGSTAMP
, &tv
));
5340 if (is_error(ret
)) {
5344 if (cmd
== (int)TARGET_SIOCGSTAMP_OLD
) {
5345 if (copy_to_user_timeval(arg
, &tv
)) {
5346 return -TARGET_EFAULT
;
5349 if (copy_to_user_timeval64(arg
, &tv
)) {
5350 return -TARGET_EFAULT
;
5357 static abi_long
do_ioctl_SIOCGSTAMPNS(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5358 int fd
, int cmd
, abi_long arg
)
5363 ret
= get_errno(safe_ioctl(fd
, SIOCGSTAMPNS
, &ts
));
5364 if (is_error(ret
)) {
5368 if (cmd
== (int)TARGET_SIOCGSTAMPNS_OLD
) {
5369 if (host_to_target_timespec(arg
, &ts
)) {
5370 return -TARGET_EFAULT
;
5373 if (host_to_target_timespec64(arg
, &ts
)) {
5374 return -TARGET_EFAULT
;
5382 static abi_long
do_ioctl_tiocgptpeer(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5383 int fd
, int cmd
, abi_long arg
)
5385 int flags
= target_to_host_bitmask(arg
, fcntl_flags_tbl
);
5386 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, flags
));
5392 static void unlock_drm_version(struct drm_version
*host_ver
,
5393 struct target_drm_version
*target_ver
,
5396 unlock_user(host_ver
->name
, target_ver
->name
,
5397 copy
? host_ver
->name_len
: 0);
5398 unlock_user(host_ver
->date
, target_ver
->date
,
5399 copy
? host_ver
->date_len
: 0);
5400 unlock_user(host_ver
->desc
, target_ver
->desc
,
5401 copy
? host_ver
->desc_len
: 0);
5404 static inline abi_long
target_to_host_drmversion(struct drm_version
*host_ver
,
5405 struct target_drm_version
*target_ver
)
5407 memset(host_ver
, 0, sizeof(*host_ver
));
5409 __get_user(host_ver
->name_len
, &target_ver
->name_len
);
5410 if (host_ver
->name_len
) {
5411 host_ver
->name
= lock_user(VERIFY_WRITE
, target_ver
->name
,
5412 target_ver
->name_len
, 0);
5413 if (!host_ver
->name
) {
5418 __get_user(host_ver
->date_len
, &target_ver
->date_len
);
5419 if (host_ver
->date_len
) {
5420 host_ver
->date
= lock_user(VERIFY_WRITE
, target_ver
->date
,
5421 target_ver
->date_len
, 0);
5422 if (!host_ver
->date
) {
5427 __get_user(host_ver
->desc_len
, &target_ver
->desc_len
);
5428 if (host_ver
->desc_len
) {
5429 host_ver
->desc
= lock_user(VERIFY_WRITE
, target_ver
->desc
,
5430 target_ver
->desc_len
, 0);
5431 if (!host_ver
->desc
) {
5438 unlock_drm_version(host_ver
, target_ver
, false);
5442 static inline void host_to_target_drmversion(
5443 struct target_drm_version
*target_ver
,
5444 struct drm_version
*host_ver
)
5446 __put_user(host_ver
->version_major
, &target_ver
->version_major
);
5447 __put_user(host_ver
->version_minor
, &target_ver
->version_minor
);
5448 __put_user(host_ver
->version_patchlevel
, &target_ver
->version_patchlevel
);
5449 __put_user(host_ver
->name_len
, &target_ver
->name_len
);
5450 __put_user(host_ver
->date_len
, &target_ver
->date_len
);
5451 __put_user(host_ver
->desc_len
, &target_ver
->desc_len
);
5452 unlock_drm_version(host_ver
, target_ver
, true);
5455 static abi_long
do_ioctl_drm(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5456 int fd
, int cmd
, abi_long arg
)
5458 struct drm_version
*ver
;
5459 struct target_drm_version
*target_ver
;
5462 switch (ie
->host_cmd
) {
5463 case DRM_IOCTL_VERSION
:
5464 if (!lock_user_struct(VERIFY_WRITE
, target_ver
, arg
, 0)) {
5465 return -TARGET_EFAULT
;
5467 ver
= (struct drm_version
*)buf_temp
;
5468 ret
= target_to_host_drmversion(ver
, target_ver
);
5469 if (!is_error(ret
)) {
5470 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, ver
));
5471 if (is_error(ret
)) {
5472 unlock_drm_version(ver
, target_ver
, false);
5474 host_to_target_drmversion(target_ver
, ver
);
5477 unlock_user_struct(target_ver
, arg
, 0);
5480 return -TARGET_ENOSYS
;
5483 static abi_long
do_ioctl_drm_i915_getparam(const IOCTLEntry
*ie
,
5484 struct drm_i915_getparam
*gparam
,
5485 int fd
, abi_long arg
)
5489 struct target_drm_i915_getparam
*target_gparam
;
5491 if (!lock_user_struct(VERIFY_READ
, target_gparam
, arg
, 0)) {
5492 return -TARGET_EFAULT
;
5495 __get_user(gparam
->param
, &target_gparam
->param
);
5496 gparam
->value
= &value
;
5497 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, gparam
));
5498 put_user_s32(value
, target_gparam
->value
);
5500 unlock_user_struct(target_gparam
, arg
, 0);
5504 static abi_long
do_ioctl_drm_i915(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5505 int fd
, int cmd
, abi_long arg
)
5507 switch (ie
->host_cmd
) {
5508 case DRM_IOCTL_I915_GETPARAM
:
5509 return do_ioctl_drm_i915_getparam(ie
,
5510 (struct drm_i915_getparam
*)buf_temp
,
5513 return -TARGET_ENOSYS
;
5519 static abi_long
do_ioctl_TUNSETTXFILTER(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5520 int fd
, int cmd
, abi_long arg
)
5522 struct tun_filter
*filter
= (struct tun_filter
*)buf_temp
;
5523 struct tun_filter
*target_filter
;
5526 assert(ie
->access
== IOC_W
);
5528 target_filter
= lock_user(VERIFY_READ
, arg
, sizeof(*target_filter
), 1);
5529 if (!target_filter
) {
5530 return -TARGET_EFAULT
;
5532 filter
->flags
= tswap16(target_filter
->flags
);
5533 filter
->count
= tswap16(target_filter
->count
);
5534 unlock_user(target_filter
, arg
, 0);
5536 if (filter
->count
) {
5537 if (offsetof(struct tun_filter
, addr
) + filter
->count
* ETH_ALEN
>
5539 return -TARGET_EFAULT
;
5542 target_addr
= lock_user(VERIFY_READ
,
5543 arg
+ offsetof(struct tun_filter
, addr
),
5544 filter
->count
* ETH_ALEN
, 1);
5546 return -TARGET_EFAULT
;
5548 memcpy(filter
->addr
, target_addr
, filter
->count
* ETH_ALEN
);
5549 unlock_user(target_addr
, arg
+ offsetof(struct tun_filter
, addr
), 0);
5552 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, filter
));
5555 IOCTLEntry ioctl_entries
[] = {
5556 #define IOCTL(cmd, access, ...) \
5557 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5558 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5559 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
5560 #define IOCTL_IGNORE(cmd) \
5561 { TARGET_ ## cmd, 0, #cmd },
5566 /* ??? Implement proper locking for ioctls. */
5567 /* do_ioctl() Must return target values and target errnos. */
5568 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
5570 const IOCTLEntry
*ie
;
5571 const argtype
*arg_type
;
5573 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
5579 if (ie
->target_cmd
== 0) {
5581 LOG_UNIMP
, "Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
5582 return -TARGET_ENOTTY
;
5584 if (ie
->target_cmd
== cmd
)
5588 arg_type
= ie
->arg_type
;
5590 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
5591 } else if (!ie
->host_cmd
) {
5592 /* Some architectures define BSD ioctls in their headers
5593 that are not implemented in Linux. */
5594 return -TARGET_ENOTTY
;
5597 switch(arg_type
[0]) {
5600 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
));
5606 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, arg
));
5610 target_size
= thunk_type_size(arg_type
, 0);
5611 switch(ie
->access
) {
5613 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5614 if (!is_error(ret
)) {
5615 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5617 return -TARGET_EFAULT
;
5618 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5619 unlock_user(argptr
, arg
, target_size
);
5623 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5625 return -TARGET_EFAULT
;
5626 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5627 unlock_user(argptr
, arg
, 0);
5628 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5632 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5634 return -TARGET_EFAULT
;
5635 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5636 unlock_user(argptr
, arg
, 0);
5637 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5638 if (!is_error(ret
)) {
5639 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5641 return -TARGET_EFAULT
;
5642 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5643 unlock_user(argptr
, arg
, target_size
);
5649 qemu_log_mask(LOG_UNIMP
,
5650 "Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5651 (long)cmd
, arg_type
[0]);
5652 ret
= -TARGET_ENOTTY
;
5658 static const bitmask_transtbl iflag_tbl
[] = {
5659 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
5660 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
5661 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
5662 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
5663 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
5664 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
5665 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
5666 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
5667 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
5668 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
5669 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
5670 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
5671 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
5672 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
5673 { TARGET_IUTF8
, TARGET_IUTF8
, IUTF8
, IUTF8
},
5676 static const bitmask_transtbl oflag_tbl
[] = {
5677 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
5678 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
5679 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
5680 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
5681 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
5682 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
5683 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
5684 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
5685 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
5686 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
5687 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
5688 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
5689 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
5690 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
5691 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
5692 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
5693 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
5694 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
5695 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
5696 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
5697 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
5698 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
5699 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
5700 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
5703 static const bitmask_transtbl cflag_tbl
[] = {
5704 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
5705 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
5706 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
5707 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
5708 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
5709 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
5710 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
5711 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
5712 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
5713 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
5714 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
5715 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
5716 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
5717 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
5718 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
5719 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
5720 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
5721 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
5722 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
5723 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
5724 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
5725 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
5726 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
5727 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
5728 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
5729 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
5730 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
5731 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
5732 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
5733 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
5734 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
5737 static const bitmask_transtbl lflag_tbl
[] = {
5738 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
5739 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
5740 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
5741 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
5742 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
5743 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
5744 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
5745 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
5746 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
5747 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
5748 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
5749 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
5750 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
5751 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
5752 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
5753 { TARGET_EXTPROC
, TARGET_EXTPROC
, EXTPROC
, EXTPROC
},
5756 static void target_to_host_termios (void *dst
, const void *src
)
5758 struct host_termios
*host
= dst
;
5759 const struct target_termios
*target
= src
;
5762 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
5764 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
5766 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
5768 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
5769 host
->c_line
= target
->c_line
;
5771 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
5772 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
5773 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
5774 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
5775 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
5776 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
5777 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
5778 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
5779 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
5780 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
5781 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
5782 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
5783 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
5784 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
5785 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
5786 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
5787 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
5788 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
5791 static void host_to_target_termios (void *dst
, const void *src
)
5793 struct target_termios
*target
= dst
;
5794 const struct host_termios
*host
= src
;
5797 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
5799 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
5801 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
5803 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
5804 target
->c_line
= host
->c_line
;
5806 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
5807 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
5808 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
5809 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
5810 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
5811 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
5812 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
5813 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
5814 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
5815 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
5816 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
5817 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
5818 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
5819 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
5820 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
5821 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
5822 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
5823 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
5826 static const StructEntry struct_termios_def
= {
5827 .convert
= { host_to_target_termios
, target_to_host_termios
},
5828 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
5829 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
5830 .print
= print_termios
,
5833 /* If the host does not provide these bits, they may be safely discarded. */
5837 #ifndef MAP_UNINITIALIZED
5838 #define MAP_UNINITIALIZED 0
5841 static const bitmask_transtbl mmap_flags_tbl
[] = {
5842 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
5843 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
,
5844 MAP_ANONYMOUS
, MAP_ANONYMOUS
},
5845 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
,
5846 MAP_GROWSDOWN
, MAP_GROWSDOWN
},
5847 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
,
5848 MAP_DENYWRITE
, MAP_DENYWRITE
},
5849 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
,
5850 MAP_EXECUTABLE
, MAP_EXECUTABLE
},
5851 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
5852 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
,
5853 MAP_NORESERVE
, MAP_NORESERVE
},
5854 { TARGET_MAP_HUGETLB
, TARGET_MAP_HUGETLB
, MAP_HUGETLB
, MAP_HUGETLB
},
5855 /* MAP_STACK had been ignored by the kernel for quite some time.
5856 Recognize it for the target insofar as we do not want to pass
5857 it through to the host. */
5858 { TARGET_MAP_STACK
, TARGET_MAP_STACK
, 0, 0 },
5859 { TARGET_MAP_NONBLOCK
, TARGET_MAP_NONBLOCK
, MAP_NONBLOCK
, MAP_NONBLOCK
},
5860 { TARGET_MAP_POPULATE
, TARGET_MAP_POPULATE
, MAP_POPULATE
, MAP_POPULATE
},
5861 { TARGET_MAP_FIXED_NOREPLACE
, TARGET_MAP_FIXED_NOREPLACE
,
5862 MAP_FIXED_NOREPLACE
, MAP_FIXED_NOREPLACE
},
5863 { TARGET_MAP_UNINITIALIZED
, TARGET_MAP_UNINITIALIZED
,
5864 MAP_UNINITIALIZED
, MAP_UNINITIALIZED
},
5868 * Arrange for legacy / undefined architecture specific flags to be
5869 * ignored by mmap handling code.
5871 #ifndef TARGET_MAP_32BIT
5872 #define TARGET_MAP_32BIT 0
5874 #ifndef TARGET_MAP_HUGE_2MB
5875 #define TARGET_MAP_HUGE_2MB 0
5877 #ifndef TARGET_MAP_HUGE_1GB
5878 #define TARGET_MAP_HUGE_1GB 0
5881 static abi_long
do_mmap(abi_ulong addr
, abi_ulong len
, int prot
,
5882 int target_flags
, int fd
, off_t offset
)
5885 * The historical set of flags that all mmap types implicitly support.
5888 TARGET_LEGACY_MAP_MASK
= TARGET_MAP_SHARED
5889 | TARGET_MAP_PRIVATE
5891 | TARGET_MAP_ANONYMOUS
5892 | TARGET_MAP_DENYWRITE
5893 | TARGET_MAP_EXECUTABLE
5894 | TARGET_MAP_UNINITIALIZED
5895 | TARGET_MAP_GROWSDOWN
5897 | TARGET_MAP_NORESERVE
5898 | TARGET_MAP_POPULATE
5899 | TARGET_MAP_NONBLOCK
5901 | TARGET_MAP_HUGETLB
5903 | TARGET_MAP_HUGE_2MB
5904 | TARGET_MAP_HUGE_1GB
5908 switch (target_flags
& TARGET_MAP_TYPE
) {
5909 case TARGET_MAP_PRIVATE
:
5910 host_flags
= MAP_PRIVATE
;
5912 case TARGET_MAP_SHARED
:
5913 host_flags
= MAP_SHARED
;
5915 case TARGET_MAP_SHARED_VALIDATE
:
5917 * MAP_SYNC is only supported for MAP_SHARED_VALIDATE, and is
5918 * therefore omitted from mmap_flags_tbl and TARGET_LEGACY_MAP_MASK.
5920 if (target_flags
& ~(TARGET_LEGACY_MAP_MASK
| TARGET_MAP_SYNC
)) {
5921 return -TARGET_EOPNOTSUPP
;
5923 host_flags
= MAP_SHARED_VALIDATE
;
5924 if (target_flags
& TARGET_MAP_SYNC
) {
5925 host_flags
|= MAP_SYNC
;
5929 return -TARGET_EINVAL
;
5931 host_flags
|= target_to_host_bitmask(target_flags
, mmap_flags_tbl
);
5933 return get_errno(target_mmap(addr
, len
, prot
, host_flags
, fd
, offset
));
5937 * NOTE: TARGET_ABI32 is defined for TARGET_I386 (but not for TARGET_X86_64)
5938 * TARGET_I386 is defined if TARGET_X86_64 is defined
5940 #if defined(TARGET_I386)
5942 /* NOTE: there is really one LDT for all the threads */
5943 static uint8_t *ldt_table
;
5945 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
5952 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
5953 if (size
> bytecount
)
5955 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
5957 return -TARGET_EFAULT
;
5958 /* ??? Should this by byteswapped? */
5959 memcpy(p
, ldt_table
, size
);
5960 unlock_user(p
, ptr
, size
);
5964 /* XXX: add locking support */
5965 static abi_long
write_ldt(CPUX86State
*env
,
5966 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
5968 struct target_modify_ldt_ldt_s ldt_info
;
5969 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5970 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5971 int seg_not_present
, useable
, lm
;
5972 uint32_t *lp
, entry_1
, entry_2
;
5974 if (bytecount
!= sizeof(ldt_info
))
5975 return -TARGET_EINVAL
;
5976 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
5977 return -TARGET_EFAULT
;
5978 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5979 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5980 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5981 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5982 unlock_user_struct(target_ldt_info
, ptr
, 0);
5984 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
5985 return -TARGET_EINVAL
;
5986 seg_32bit
= ldt_info
.flags
& 1;
5987 contents
= (ldt_info
.flags
>> 1) & 3;
5988 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5989 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5990 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5991 useable
= (ldt_info
.flags
>> 6) & 1;
5995 lm
= (ldt_info
.flags
>> 7) & 1;
5997 if (contents
== 3) {
5999 return -TARGET_EINVAL
;
6000 if (seg_not_present
== 0)
6001 return -TARGET_EINVAL
;
6003 /* allocate the LDT */
6005 env
->ldt
.base
= target_mmap(0,
6006 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
6007 PROT_READ
|PROT_WRITE
,
6008 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
6009 if (env
->ldt
.base
== -1)
6010 return -TARGET_ENOMEM
;
6011 memset(g2h_untagged(env
->ldt
.base
), 0,
6012 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
6013 env
->ldt
.limit
= 0xffff;
6014 ldt_table
= g2h_untagged(env
->ldt
.base
);
6017 /* NOTE: same code as Linux kernel */
6018 /* Allow LDTs to be cleared by the user. */
6019 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6022 read_exec_only
== 1 &&
6024 limit_in_pages
== 0 &&
6025 seg_not_present
== 1 &&
6033 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6034 (ldt_info
.limit
& 0x0ffff);
6035 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6036 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6037 (ldt_info
.limit
& 0xf0000) |
6038 ((read_exec_only
^ 1) << 9) |
6040 ((seg_not_present
^ 1) << 15) |
6042 (limit_in_pages
<< 23) |
6046 entry_2
|= (useable
<< 20);
6048 /* Install the new entry ... */
6050 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
6051 lp
[0] = tswap32(entry_1
);
6052 lp
[1] = tswap32(entry_2
);
6056 /* specific and weird i386 syscalls */
6057 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
6058 unsigned long bytecount
)
6064 ret
= read_ldt(ptr
, bytecount
);
6067 ret
= write_ldt(env
, ptr
, bytecount
, 1);
6070 ret
= write_ldt(env
, ptr
, bytecount
, 0);
6073 ret
= -TARGET_ENOSYS
;
6079 #if defined(TARGET_ABI32)
6080 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6082 uint64_t *gdt_table
= g2h_untagged(env
->gdt
.base
);
6083 struct target_modify_ldt_ldt_s ldt_info
;
6084 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6085 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
6086 int seg_not_present
, useable
, lm
;
6087 uint32_t *lp
, entry_1
, entry_2
;
6090 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6091 if (!target_ldt_info
)
6092 return -TARGET_EFAULT
;
6093 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
6094 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
6095 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
6096 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
6097 if (ldt_info
.entry_number
== -1) {
6098 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
6099 if (gdt_table
[i
] == 0) {
6100 ldt_info
.entry_number
= i
;
6101 target_ldt_info
->entry_number
= tswap32(i
);
6106 unlock_user_struct(target_ldt_info
, ptr
, 1);
6108 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
6109 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
6110 return -TARGET_EINVAL
;
6111 seg_32bit
= ldt_info
.flags
& 1;
6112 contents
= (ldt_info
.flags
>> 1) & 3;
6113 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
6114 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
6115 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
6116 useable
= (ldt_info
.flags
>> 6) & 1;
6120 lm
= (ldt_info
.flags
>> 7) & 1;
6123 if (contents
== 3) {
6124 if (seg_not_present
== 0)
6125 return -TARGET_EINVAL
;
6128 /* NOTE: same code as Linux kernel */
6129 /* Allow LDTs to be cleared by the user. */
6130 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6131 if ((contents
== 0 &&
6132 read_exec_only
== 1 &&
6134 limit_in_pages
== 0 &&
6135 seg_not_present
== 1 &&
6143 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6144 (ldt_info
.limit
& 0x0ffff);
6145 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6146 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6147 (ldt_info
.limit
& 0xf0000) |
6148 ((read_exec_only
^ 1) << 9) |
6150 ((seg_not_present
^ 1) << 15) |
6152 (limit_in_pages
<< 23) |
6157 /* Install the new entry ... */
6159 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
6160 lp
[0] = tswap32(entry_1
);
6161 lp
[1] = tswap32(entry_2
);
6165 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6167 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6168 uint64_t *gdt_table
= g2h_untagged(env
->gdt
.base
);
6169 uint32_t base_addr
, limit
, flags
;
6170 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
6171 int seg_not_present
, useable
, lm
;
6172 uint32_t *lp
, entry_1
, entry_2
;
6174 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6175 if (!target_ldt_info
)
6176 return -TARGET_EFAULT
;
6177 idx
= tswap32(target_ldt_info
->entry_number
);
6178 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
6179 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
6180 unlock_user_struct(target_ldt_info
, ptr
, 1);
6181 return -TARGET_EINVAL
;
6183 lp
= (uint32_t *)(gdt_table
+ idx
);
6184 entry_1
= tswap32(lp
[0]);
6185 entry_2
= tswap32(lp
[1]);
6187 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
6188 contents
= (entry_2
>> 10) & 3;
6189 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
6190 seg_32bit
= (entry_2
>> 22) & 1;
6191 limit_in_pages
= (entry_2
>> 23) & 1;
6192 useable
= (entry_2
>> 20) & 1;
6196 lm
= (entry_2
>> 21) & 1;
6198 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
6199 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
6200 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
6201 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
6202 base_addr
= (entry_1
>> 16) |
6203 (entry_2
& 0xff000000) |
6204 ((entry_2
& 0xff) << 16);
6205 target_ldt_info
->base_addr
= tswapal(base_addr
);
6206 target_ldt_info
->limit
= tswap32(limit
);
6207 target_ldt_info
->flags
= tswap32(flags
);
6208 unlock_user_struct(target_ldt_info
, ptr
, 1);
6212 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
6214 return -TARGET_ENOSYS
;
6217 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
6224 case TARGET_ARCH_SET_GS
:
6225 case TARGET_ARCH_SET_FS
:
6226 if (code
== TARGET_ARCH_SET_GS
)
6230 cpu_x86_load_seg(env
, idx
, 0);
6231 env
->segs
[idx
].base
= addr
;
6233 case TARGET_ARCH_GET_GS
:
6234 case TARGET_ARCH_GET_FS
:
6235 if (code
== TARGET_ARCH_GET_GS
)
6239 val
= env
->segs
[idx
].base
;
6240 if (put_user(val
, addr
, abi_ulong
))
6241 ret
= -TARGET_EFAULT
;
6244 ret
= -TARGET_EINVAL
;
6249 #endif /* defined(TARGET_ABI32 */
6250 #endif /* defined(TARGET_I386) */
6253 * These constants are generic. Supply any that are missing from the host.
6256 # define PR_SET_NAME 15
6257 # define PR_GET_NAME 16
6259 #ifndef PR_SET_FP_MODE
6260 # define PR_SET_FP_MODE 45
6261 # define PR_GET_FP_MODE 46
6262 # define PR_FP_MODE_FR (1 << 0)
6263 # define PR_FP_MODE_FRE (1 << 1)
6265 #ifndef PR_SVE_SET_VL
6266 # define PR_SVE_SET_VL 50
6267 # define PR_SVE_GET_VL 51
6268 # define PR_SVE_VL_LEN_MASK 0xffff
6269 # define PR_SVE_VL_INHERIT (1 << 17)
6271 #ifndef PR_PAC_RESET_KEYS
6272 # define PR_PAC_RESET_KEYS 54
6273 # define PR_PAC_APIAKEY (1 << 0)
6274 # define PR_PAC_APIBKEY (1 << 1)
6275 # define PR_PAC_APDAKEY (1 << 2)
6276 # define PR_PAC_APDBKEY (1 << 3)
6277 # define PR_PAC_APGAKEY (1 << 4)
6279 #ifndef PR_SET_TAGGED_ADDR_CTRL
6280 # define PR_SET_TAGGED_ADDR_CTRL 55
6281 # define PR_GET_TAGGED_ADDR_CTRL 56
6282 # define PR_TAGGED_ADDR_ENABLE (1UL << 0)
6284 #ifndef PR_SET_IO_FLUSHER
6285 # define PR_SET_IO_FLUSHER 57
6286 # define PR_GET_IO_FLUSHER 58
6288 #ifndef PR_SET_SYSCALL_USER_DISPATCH
6289 # define PR_SET_SYSCALL_USER_DISPATCH 59
6291 #ifndef PR_SME_SET_VL
6292 # define PR_SME_SET_VL 63
6293 # define PR_SME_GET_VL 64
6294 # define PR_SME_VL_LEN_MASK 0xffff
6295 # define PR_SME_VL_INHERIT (1 << 17)
6298 #include "target_prctl.h"
6300 static abi_long
do_prctl_inval0(CPUArchState
*env
)
6302 return -TARGET_EINVAL
;
6305 static abi_long
do_prctl_inval1(CPUArchState
*env
, abi_long arg2
)
6307 return -TARGET_EINVAL
;
6310 #ifndef do_prctl_get_fp_mode
6311 #define do_prctl_get_fp_mode do_prctl_inval0
6313 #ifndef do_prctl_set_fp_mode
6314 #define do_prctl_set_fp_mode do_prctl_inval1
6316 #ifndef do_prctl_sve_get_vl
6317 #define do_prctl_sve_get_vl do_prctl_inval0
6319 #ifndef do_prctl_sve_set_vl
6320 #define do_prctl_sve_set_vl do_prctl_inval1
6322 #ifndef do_prctl_reset_keys
6323 #define do_prctl_reset_keys do_prctl_inval1
6325 #ifndef do_prctl_set_tagged_addr_ctrl
6326 #define do_prctl_set_tagged_addr_ctrl do_prctl_inval1
6328 #ifndef do_prctl_get_tagged_addr_ctrl
6329 #define do_prctl_get_tagged_addr_ctrl do_prctl_inval0
6331 #ifndef do_prctl_get_unalign
6332 #define do_prctl_get_unalign do_prctl_inval1
6334 #ifndef do_prctl_set_unalign
6335 #define do_prctl_set_unalign do_prctl_inval1
6337 #ifndef do_prctl_sme_get_vl
6338 #define do_prctl_sme_get_vl do_prctl_inval0
6340 #ifndef do_prctl_sme_set_vl
6341 #define do_prctl_sme_set_vl do_prctl_inval1
6344 static abi_long
do_prctl(CPUArchState
*env
, abi_long option
, abi_long arg2
,
6345 abi_long arg3
, abi_long arg4
, abi_long arg5
)
6350 case PR_GET_PDEATHSIG
:
6353 ret
= get_errno(prctl(PR_GET_PDEATHSIG
, &deathsig
,
6355 if (!is_error(ret
) &&
6356 put_user_s32(host_to_target_signal(deathsig
), arg2
)) {
6357 return -TARGET_EFAULT
;
6361 case PR_SET_PDEATHSIG
:
6362 return get_errno(prctl(PR_SET_PDEATHSIG
, target_to_host_signal(arg2
),
6366 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
6368 return -TARGET_EFAULT
;
6370 ret
= get_errno(prctl(PR_GET_NAME
, (uintptr_t)name
,
6372 unlock_user(name
, arg2
, 16);
6377 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
6379 return -TARGET_EFAULT
;
6381 ret
= get_errno(prctl(PR_SET_NAME
, (uintptr_t)name
,
6383 unlock_user(name
, arg2
, 0);
6386 case PR_GET_FP_MODE
:
6387 return do_prctl_get_fp_mode(env
);
6388 case PR_SET_FP_MODE
:
6389 return do_prctl_set_fp_mode(env
, arg2
);
6391 return do_prctl_sve_get_vl(env
);
6393 return do_prctl_sve_set_vl(env
, arg2
);
6395 return do_prctl_sme_get_vl(env
);
6397 return do_prctl_sme_set_vl(env
, arg2
);
6398 case PR_PAC_RESET_KEYS
:
6399 if (arg3
|| arg4
|| arg5
) {
6400 return -TARGET_EINVAL
;
6402 return do_prctl_reset_keys(env
, arg2
);
6403 case PR_SET_TAGGED_ADDR_CTRL
:
6404 if (arg3
|| arg4
|| arg5
) {
6405 return -TARGET_EINVAL
;
6407 return do_prctl_set_tagged_addr_ctrl(env
, arg2
);
6408 case PR_GET_TAGGED_ADDR_CTRL
:
6409 if (arg2
|| arg3
|| arg4
|| arg5
) {
6410 return -TARGET_EINVAL
;
6412 return do_prctl_get_tagged_addr_ctrl(env
);
6414 case PR_GET_UNALIGN
:
6415 return do_prctl_get_unalign(env
, arg2
);
6416 case PR_SET_UNALIGN
:
6417 return do_prctl_set_unalign(env
, arg2
);
6419 case PR_CAP_AMBIENT
:
6420 case PR_CAPBSET_READ
:
6421 case PR_CAPBSET_DROP
:
6422 case PR_GET_DUMPABLE
:
6423 case PR_SET_DUMPABLE
:
6424 case PR_GET_KEEPCAPS
:
6425 case PR_SET_KEEPCAPS
:
6426 case PR_GET_SECUREBITS
:
6427 case PR_SET_SECUREBITS
:
6430 case PR_GET_TIMERSLACK
:
6431 case PR_SET_TIMERSLACK
:
6433 case PR_MCE_KILL_GET
:
6434 case PR_GET_NO_NEW_PRIVS
:
6435 case PR_SET_NO_NEW_PRIVS
:
6436 case PR_GET_IO_FLUSHER
:
6437 case PR_SET_IO_FLUSHER
:
6438 case PR_SET_CHILD_SUBREAPER
:
6439 case PR_GET_SPECULATION_CTRL
:
6440 case PR_SET_SPECULATION_CTRL
:
6441 /* Some prctl options have no pointer arguments and we can pass on. */
6442 return get_errno(prctl(option
, arg2
, arg3
, arg4
, arg5
));
6444 case PR_GET_CHILD_SUBREAPER
:
6447 ret
= get_errno(prctl(PR_GET_CHILD_SUBREAPER
, &val
,
6449 if (!is_error(ret
) && put_user_s32(val
, arg2
)) {
6450 return -TARGET_EFAULT
;
6455 case PR_GET_TID_ADDRESS
:
6457 TaskState
*ts
= get_task_state(env_cpu(env
));
6458 return put_user_ual(ts
->child_tidptr
, arg2
);
6463 /* Was used for SPE on PowerPC. */
6464 return -TARGET_EINVAL
;
6471 case PR_GET_SECCOMP
:
6472 case PR_SET_SECCOMP
:
6473 case PR_SET_SYSCALL_USER_DISPATCH
:
6474 case PR_GET_THP_DISABLE
:
6475 case PR_SET_THP_DISABLE
:
6478 /* Disable to prevent the target disabling stuff we need. */
6479 return -TARGET_EINVAL
;
6482 qemu_log_mask(LOG_UNIMP
, "Unsupported prctl: " TARGET_ABI_FMT_ld
"\n",
6484 return -TARGET_EINVAL
;
6488 #define NEW_STACK_SIZE 0x40000
6491 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
6494 pthread_mutex_t mutex
;
6495 pthread_cond_t cond
;
6498 abi_ulong child_tidptr
;
6499 abi_ulong parent_tidptr
;
6503 static void * G_NORETURN
clone_func(void *arg
)
6505 new_thread_info
*info
= arg
;
6510 rcu_register_thread();
6511 tcg_register_thread();
6515 ts
= get_task_state(cpu
);
6516 info
->tid
= sys_gettid();
6518 if (info
->child_tidptr
)
6519 put_user_u32(info
->tid
, info
->child_tidptr
);
6520 if (info
->parent_tidptr
)
6521 put_user_u32(info
->tid
, info
->parent_tidptr
);
6522 qemu_guest_random_seed_thread_part2(cpu
->random_seed
);
6523 /* Enable signals. */
6524 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
6525 /* Signal to the parent that we're ready. */
6526 pthread_mutex_lock(&info
->mutex
);
6527 pthread_cond_broadcast(&info
->cond
);
6528 pthread_mutex_unlock(&info
->mutex
);
6529 /* Wait until the parent has finished initializing the tls state. */
6530 pthread_mutex_lock(&clone_lock
);
6531 pthread_mutex_unlock(&clone_lock
);
6536 /* do_fork() Must return host values and target errnos (unlike most
6537 do_*() functions). */
6538 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
6539 abi_ulong parent_tidptr
, target_ulong newtls
,
6540 abi_ulong child_tidptr
)
6542 CPUState
*cpu
= env_cpu(env
);
6546 CPUArchState
*new_env
;
6549 flags
&= ~CLONE_IGNORED_FLAGS
;
6551 /* Emulate vfork() with fork() */
6552 if (flags
& CLONE_VFORK
)
6553 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
6555 if (flags
& CLONE_VM
) {
6556 TaskState
*parent_ts
= get_task_state(cpu
);
6557 new_thread_info info
;
6558 pthread_attr_t attr
;
6560 if (((flags
& CLONE_THREAD_FLAGS
) != CLONE_THREAD_FLAGS
) ||
6561 (flags
& CLONE_INVALID_THREAD_FLAGS
)) {
6562 return -TARGET_EINVAL
;
6565 ts
= g_new0(TaskState
, 1);
6566 init_task_state(ts
);
6568 /* Grab a mutex so that thread setup appears atomic. */
6569 pthread_mutex_lock(&clone_lock
);
6572 * If this is our first additional thread, we need to ensure we
6573 * generate code for parallel execution and flush old translations.
6574 * Do this now so that the copy gets CF_PARALLEL too.
6576 if (!tcg_cflags_has(cpu
, CF_PARALLEL
)) {
6577 tcg_cflags_set(cpu
, CF_PARALLEL
);
6581 /* we create a new CPU instance. */
6582 new_env
= cpu_copy(env
);
6583 /* Init regs that differ from the parent. */
6584 cpu_clone_regs_child(new_env
, newsp
, flags
);
6585 cpu_clone_regs_parent(env
, flags
);
6586 new_cpu
= env_cpu(new_env
);
6587 new_cpu
->opaque
= ts
;
6588 ts
->bprm
= parent_ts
->bprm
;
6589 ts
->info
= parent_ts
->info
;
6590 ts
->signal_mask
= parent_ts
->signal_mask
;
6592 if (flags
& CLONE_CHILD_CLEARTID
) {
6593 ts
->child_tidptr
= child_tidptr
;
6596 if (flags
& CLONE_SETTLS
) {
6597 cpu_set_tls (new_env
, newtls
);
6600 memset(&info
, 0, sizeof(info
));
6601 pthread_mutex_init(&info
.mutex
, NULL
);
6602 pthread_mutex_lock(&info
.mutex
);
6603 pthread_cond_init(&info
.cond
, NULL
);
6605 if (flags
& CLONE_CHILD_SETTID
) {
6606 info
.child_tidptr
= child_tidptr
;
6608 if (flags
& CLONE_PARENT_SETTID
) {
6609 info
.parent_tidptr
= parent_tidptr
;
6612 ret
= pthread_attr_init(&attr
);
6613 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
6614 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
6615 /* It is not safe to deliver signals until the child has finished
6616 initializing, so temporarily block all signals. */
6617 sigfillset(&sigmask
);
6618 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
6619 cpu
->random_seed
= qemu_guest_random_seed_thread_part1();
6621 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
6622 /* TODO: Free new CPU state if thread creation failed. */
6624 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
6625 pthread_attr_destroy(&attr
);
6627 /* Wait for the child to initialize. */
6628 pthread_cond_wait(&info
.cond
, &info
.mutex
);
6633 pthread_mutex_unlock(&info
.mutex
);
6634 pthread_cond_destroy(&info
.cond
);
6635 pthread_mutex_destroy(&info
.mutex
);
6636 pthread_mutex_unlock(&clone_lock
);
6638 /* if no CLONE_VM, we consider it is a fork */
6639 if (flags
& CLONE_INVALID_FORK_FLAGS
) {
6640 return -TARGET_EINVAL
;
6643 /* We can't support custom termination signals */
6644 if ((flags
& CSIGNAL
) != TARGET_SIGCHLD
) {
6645 return -TARGET_EINVAL
;
6648 #if !defined(__NR_pidfd_open) || !defined(TARGET_NR_pidfd_open)
6649 if (flags
& CLONE_PIDFD
) {
6650 return -TARGET_EINVAL
;
6654 /* Can not allow CLONE_PIDFD with CLONE_PARENT_SETTID */
6655 if ((flags
& CLONE_PIDFD
) && (flags
& CLONE_PARENT_SETTID
)) {
6656 return -TARGET_EINVAL
;
6659 if (block_signals()) {
6660 return -QEMU_ERESTARTSYS
;
6666 /* Child Process. */
6667 cpu_clone_regs_child(env
, newsp
, flags
);
6669 /* There is a race condition here. The parent process could
6670 theoretically read the TID in the child process before the child
6671 tid is set. This would require using either ptrace
6672 (not implemented) or having *_tidptr to point at a shared memory
6673 mapping. We can't repeat the spinlock hack used above because
6674 the child process gets its own copy of the lock. */
6675 if (flags
& CLONE_CHILD_SETTID
)
6676 put_user_u32(sys_gettid(), child_tidptr
);
6677 if (flags
& CLONE_PARENT_SETTID
)
6678 put_user_u32(sys_gettid(), parent_tidptr
);
6679 ts
= get_task_state(cpu
);
6680 if (flags
& CLONE_SETTLS
)
6681 cpu_set_tls (env
, newtls
);
6682 if (flags
& CLONE_CHILD_CLEARTID
)
6683 ts
->child_tidptr
= child_tidptr
;
6685 cpu_clone_regs_parent(env
, flags
);
6686 if (flags
& CLONE_PIDFD
) {
6688 #if defined(__NR_pidfd_open) && defined(TARGET_NR_pidfd_open)
6689 int pid_child
= ret
;
6690 pid_fd
= pidfd_open(pid_child
, 0);
6692 fcntl(pid_fd
, F_SETFD
, fcntl(pid_fd
, F_GETFL
)
6698 put_user_u32(pid_fd
, parent_tidptr
);
6702 g_assert(!cpu_in_exclusive_context(cpu
));
6707 /* warning : doesn't handle linux specific flags... */
6708 static int target_to_host_fcntl_cmd(int cmd
)
6713 case TARGET_F_DUPFD
:
6714 case TARGET_F_GETFD
:
6715 case TARGET_F_SETFD
:
6716 case TARGET_F_GETFL
:
6717 case TARGET_F_SETFL
:
6718 case TARGET_F_OFD_GETLK
:
6719 case TARGET_F_OFD_SETLK
:
6720 case TARGET_F_OFD_SETLKW
:
6723 case TARGET_F_GETLK
:
6726 case TARGET_F_SETLK
:
6729 case TARGET_F_SETLKW
:
6732 case TARGET_F_GETOWN
:
6735 case TARGET_F_SETOWN
:
6738 case TARGET_F_GETSIG
:
6741 case TARGET_F_SETSIG
:
6744 #if TARGET_ABI_BITS == 32
6745 case TARGET_F_GETLK64
:
6748 case TARGET_F_SETLK64
:
6751 case TARGET_F_SETLKW64
:
6755 case TARGET_F_SETLEASE
:
6758 case TARGET_F_GETLEASE
:
6761 #ifdef F_DUPFD_CLOEXEC
6762 case TARGET_F_DUPFD_CLOEXEC
:
6763 ret
= F_DUPFD_CLOEXEC
;
6766 case TARGET_F_NOTIFY
:
6770 case TARGET_F_GETOWN_EX
:
6775 case TARGET_F_SETOWN_EX
:
6780 case TARGET_F_SETPIPE_SZ
:
6783 case TARGET_F_GETPIPE_SZ
:
6788 case TARGET_F_ADD_SEALS
:
6791 case TARGET_F_GET_SEALS
:
6796 ret
= -TARGET_EINVAL
;
6800 #if defined(__powerpc64__)
6801 /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and
6802 * is not supported by kernel. The glibc fcntl call actually adjusts
6803 * them to 5, 6 and 7 before making the syscall(). Since we make the
6804 * syscall directly, adjust to what is supported by the kernel.
6806 if (ret
>= F_GETLK64
&& ret
<= F_SETLKW64
) {
6807 ret
-= F_GETLK64
- 5;
6814 #define FLOCK_TRANSTBL \
6816 TRANSTBL_CONVERT(F_RDLCK); \
6817 TRANSTBL_CONVERT(F_WRLCK); \
6818 TRANSTBL_CONVERT(F_UNLCK); \
6821 static int target_to_host_flock(int type
)
6823 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
6825 #undef TRANSTBL_CONVERT
6826 return -TARGET_EINVAL
;
6829 static int host_to_target_flock(int type
)
6831 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
6833 #undef TRANSTBL_CONVERT
6834 /* if we don't know how to convert the value coming
6835 * from the host we copy to the target field as-is
6840 static inline abi_long
copy_from_user_flock(struct flock64
*fl
,
6841 abi_ulong target_flock_addr
)
6843 struct target_flock
*target_fl
;
6846 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6847 return -TARGET_EFAULT
;
6850 __get_user(l_type
, &target_fl
->l_type
);
6851 l_type
= target_to_host_flock(l_type
);
6855 fl
->l_type
= l_type
;
6856 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6857 __get_user(fl
->l_start
, &target_fl
->l_start
);
6858 __get_user(fl
->l_len
, &target_fl
->l_len
);
6859 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6860 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6864 static inline abi_long
copy_to_user_flock(abi_ulong target_flock_addr
,
6865 const struct flock64
*fl
)
6867 struct target_flock
*target_fl
;
6870 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6871 return -TARGET_EFAULT
;
6874 l_type
= host_to_target_flock(fl
->l_type
);
6875 __put_user(l_type
, &target_fl
->l_type
);
6876 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6877 __put_user(fl
->l_start
, &target_fl
->l_start
);
6878 __put_user(fl
->l_len
, &target_fl
->l_len
);
6879 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6880 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6884 typedef abi_long
from_flock64_fn(struct flock64
*fl
, abi_ulong target_addr
);
6885 typedef abi_long
to_flock64_fn(abi_ulong target_addr
, const struct flock64
*fl
);
6887 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6888 struct target_oabi_flock64
{
6896 static inline abi_long
copy_from_user_oabi_flock64(struct flock64
*fl
,
6897 abi_ulong target_flock_addr
)
6899 struct target_oabi_flock64
*target_fl
;
6902 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6903 return -TARGET_EFAULT
;
6906 __get_user(l_type
, &target_fl
->l_type
);
6907 l_type
= target_to_host_flock(l_type
);
6911 fl
->l_type
= l_type
;
6912 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6913 __get_user(fl
->l_start
, &target_fl
->l_start
);
6914 __get_user(fl
->l_len
, &target_fl
->l_len
);
6915 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6916 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6920 static inline abi_long
copy_to_user_oabi_flock64(abi_ulong target_flock_addr
,
6921 const struct flock64
*fl
)
6923 struct target_oabi_flock64
*target_fl
;
6926 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6927 return -TARGET_EFAULT
;
6930 l_type
= host_to_target_flock(fl
->l_type
);
6931 __put_user(l_type
, &target_fl
->l_type
);
6932 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6933 __put_user(fl
->l_start
, &target_fl
->l_start
);
6934 __put_user(fl
->l_len
, &target_fl
->l_len
);
6935 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6936 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6941 static inline abi_long
copy_from_user_flock64(struct flock64
*fl
,
6942 abi_ulong target_flock_addr
)
6944 struct target_flock64
*target_fl
;
6947 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6948 return -TARGET_EFAULT
;
6951 __get_user(l_type
, &target_fl
->l_type
);
6952 l_type
= target_to_host_flock(l_type
);
6956 fl
->l_type
= l_type
;
6957 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6958 __get_user(fl
->l_start
, &target_fl
->l_start
);
6959 __get_user(fl
->l_len
, &target_fl
->l_len
);
6960 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6961 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6965 static inline abi_long
copy_to_user_flock64(abi_ulong target_flock_addr
,
6966 const struct flock64
*fl
)
6968 struct target_flock64
*target_fl
;
6971 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6972 return -TARGET_EFAULT
;
6975 l_type
= host_to_target_flock(fl
->l_type
);
6976 __put_user(l_type
, &target_fl
->l_type
);
6977 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6978 __put_user(fl
->l_start
, &target_fl
->l_start
);
6979 __put_user(fl
->l_len
, &target_fl
->l_len
);
6980 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6981 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6985 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
6987 struct flock64 fl64
;
6989 struct f_owner_ex fox
;
6990 struct target_f_owner_ex
*target_fox
;
6993 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
6995 if (host_cmd
== -TARGET_EINVAL
)
6999 case TARGET_F_GETLK
:
7000 ret
= copy_from_user_flock(&fl64
, arg
);
7004 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
7006 ret
= copy_to_user_flock(arg
, &fl64
);
7010 case TARGET_F_SETLK
:
7011 case TARGET_F_SETLKW
:
7012 ret
= copy_from_user_flock(&fl64
, arg
);
7016 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
7019 case TARGET_F_GETLK64
:
7020 case TARGET_F_OFD_GETLK
:
7021 ret
= copy_from_user_flock64(&fl64
, arg
);
7025 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
7027 ret
= copy_to_user_flock64(arg
, &fl64
);
7030 case TARGET_F_SETLK64
:
7031 case TARGET_F_SETLKW64
:
7032 case TARGET_F_OFD_SETLK
:
7033 case TARGET_F_OFD_SETLKW
:
7034 ret
= copy_from_user_flock64(&fl64
, arg
);
7038 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
7041 case TARGET_F_GETFL
:
7042 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
7044 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
7045 /* tell 32-bit guests it uses largefile on 64-bit hosts: */
7046 if (O_LARGEFILE
== 0 && HOST_LONG_BITS
== 64) {
7047 ret
|= TARGET_O_LARGEFILE
;
7052 case TARGET_F_SETFL
:
7053 ret
= get_errno(safe_fcntl(fd
, host_cmd
,
7054 target_to_host_bitmask(arg
,
7059 case TARGET_F_GETOWN_EX
:
7060 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
7062 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
7063 return -TARGET_EFAULT
;
7064 target_fox
->type
= tswap32(fox
.type
);
7065 target_fox
->pid
= tswap32(fox
.pid
);
7066 unlock_user_struct(target_fox
, arg
, 1);
7072 case TARGET_F_SETOWN_EX
:
7073 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
7074 return -TARGET_EFAULT
;
7075 fox
.type
= tswap32(target_fox
->type
);
7076 fox
.pid
= tswap32(target_fox
->pid
);
7077 unlock_user_struct(target_fox
, arg
, 0);
7078 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
7082 case TARGET_F_SETSIG
:
7083 ret
= get_errno(safe_fcntl(fd
, host_cmd
, target_to_host_signal(arg
)));
7086 case TARGET_F_GETSIG
:
7087 ret
= host_to_target_signal(get_errno(safe_fcntl(fd
, host_cmd
, arg
)));
7090 case TARGET_F_SETOWN
:
7091 case TARGET_F_GETOWN
:
7092 case TARGET_F_SETLEASE
:
7093 case TARGET_F_GETLEASE
:
7094 case TARGET_F_SETPIPE_SZ
:
7095 case TARGET_F_GETPIPE_SZ
:
7096 case TARGET_F_ADD_SEALS
:
7097 case TARGET_F_GET_SEALS
:
7098 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
7102 ret
= get_errno(safe_fcntl(fd
, cmd
, arg
));
7110 static inline int high2lowuid(int uid
)
7118 static inline int high2lowgid(int gid
)
7126 static inline int low2highuid(int uid
)
7128 if ((int16_t)uid
== -1)
7134 static inline int low2highgid(int gid
)
7136 if ((int16_t)gid
== -1)
7141 static inline int tswapid(int id
)
7146 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
7148 #else /* !USE_UID16 */
7149 static inline int high2lowuid(int uid
)
7153 static inline int high2lowgid(int gid
)
7157 static inline int low2highuid(int uid
)
7161 static inline int low2highgid(int gid
)
7165 static inline int tswapid(int id
)
7170 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
7172 #endif /* USE_UID16 */
7174 /* We must do direct syscalls for setting UID/GID, because we want to
7175 * implement the Linux system call semantics of "change only for this thread",
7176 * not the libc/POSIX semantics of "change for all threads in process".
7177 * (See http://ewontfix.com/17/ for more details.)
7178 * We use the 32-bit version of the syscalls if present; if it is not
7179 * then either the host architecture supports 32-bit UIDs natively with
7180 * the standard syscall, or the 16-bit UID is the best we can do.
7182 #ifdef __NR_setuid32
7183 #define __NR_sys_setuid __NR_setuid32
7185 #define __NR_sys_setuid __NR_setuid
7187 #ifdef __NR_setgid32
7188 #define __NR_sys_setgid __NR_setgid32
7190 #define __NR_sys_setgid __NR_setgid
7192 #ifdef __NR_setresuid32
7193 #define __NR_sys_setresuid __NR_setresuid32
7195 #define __NR_sys_setresuid __NR_setresuid
7197 #ifdef __NR_setresgid32
7198 #define __NR_sys_setresgid __NR_setresgid32
7200 #define __NR_sys_setresgid __NR_setresgid
7202 #ifdef __NR_setgroups32
7203 #define __NR_sys_setgroups __NR_setgroups32
7205 #define __NR_sys_setgroups __NR_setgroups
7208 _syscall1(int, sys_setuid
, uid_t
, uid
)
7209 _syscall1(int, sys_setgid
, gid_t
, gid
)
7210 _syscall3(int, sys_setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
7211 _syscall3(int, sys_setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
7212 _syscall2(int, sys_setgroups
, int, size
, gid_t
*, grouplist
)
7214 void syscall_init(void)
7217 const argtype
*arg_type
;
7220 thunk_init(STRUCT_MAX
);
7222 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
7223 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
7224 #include "syscall_types.h"
7226 #undef STRUCT_SPECIAL
7228 /* we patch the ioctl size if necessary. We rely on the fact that
7229 no ioctl has all the bits at '1' in the size field */
7231 while (ie
->target_cmd
!= 0) {
7232 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
7233 TARGET_IOC_SIZEMASK
) {
7234 arg_type
= ie
->arg_type
;
7235 if (arg_type
[0] != TYPE_PTR
) {
7236 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
7241 size
= thunk_type_size(arg_type
, 0);
7242 ie
->target_cmd
= (ie
->target_cmd
&
7243 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
7244 (size
<< TARGET_IOC_SIZESHIFT
);
7247 /* automatic consistency check if same arch */
7248 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
7249 (defined(__x86_64__) && defined(TARGET_X86_64))
7250 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
7251 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
7252 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
7259 #ifdef TARGET_NR_truncate64
7260 static inline abi_long
target_truncate64(CPUArchState
*cpu_env
, const char *arg1
,
7265 if (regpairs_aligned(cpu_env
, TARGET_NR_truncate64
)) {
7269 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
7273 #ifdef TARGET_NR_ftruncate64
7274 static inline abi_long
target_ftruncate64(CPUArchState
*cpu_env
, abi_long arg1
,
7279 if (regpairs_aligned(cpu_env
, TARGET_NR_ftruncate64
)) {
7283 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
7287 #if defined(TARGET_NR_timer_settime) || \
7288 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
7289 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_its
,
7290 abi_ulong target_addr
)
7292 if (target_to_host_timespec(&host_its
->it_interval
, target_addr
+
7293 offsetof(struct target_itimerspec
,
7295 target_to_host_timespec(&host_its
->it_value
, target_addr
+
7296 offsetof(struct target_itimerspec
,
7298 return -TARGET_EFAULT
;
7305 #if defined(TARGET_NR_timer_settime64) || \
7306 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD))
7307 static inline abi_long
target_to_host_itimerspec64(struct itimerspec
*host_its
,
7308 abi_ulong target_addr
)
7310 if (target_to_host_timespec64(&host_its
->it_interval
, target_addr
+
7311 offsetof(struct target__kernel_itimerspec
,
7313 target_to_host_timespec64(&host_its
->it_value
, target_addr
+
7314 offsetof(struct target__kernel_itimerspec
,
7316 return -TARGET_EFAULT
;
7323 #if ((defined(TARGET_NR_timerfd_gettime) || \
7324 defined(TARGET_NR_timerfd_settime)) && defined(CONFIG_TIMERFD)) || \
7325 defined(TARGET_NR_timer_gettime) || defined(TARGET_NR_timer_settime)
7326 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
7327 struct itimerspec
*host_its
)
7329 if (host_to_target_timespec(target_addr
+ offsetof(struct target_itimerspec
,
7331 &host_its
->it_interval
) ||
7332 host_to_target_timespec(target_addr
+ offsetof(struct target_itimerspec
,
7334 &host_its
->it_value
)) {
7335 return -TARGET_EFAULT
;
7341 #if ((defined(TARGET_NR_timerfd_gettime64) || \
7342 defined(TARGET_NR_timerfd_settime64)) && defined(CONFIG_TIMERFD)) || \
7343 defined(TARGET_NR_timer_gettime64) || defined(TARGET_NR_timer_settime64)
7344 static inline abi_long
host_to_target_itimerspec64(abi_ulong target_addr
,
7345 struct itimerspec
*host_its
)
7347 if (host_to_target_timespec64(target_addr
+
7348 offsetof(struct target__kernel_itimerspec
,
7350 &host_its
->it_interval
) ||
7351 host_to_target_timespec64(target_addr
+
7352 offsetof(struct target__kernel_itimerspec
,
7354 &host_its
->it_value
)) {
7355 return -TARGET_EFAULT
;
7361 #if defined(TARGET_NR_adjtimex) || \
7362 (defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME))
7363 static inline abi_long
target_to_host_timex(struct timex
*host_tx
,
7364 abi_long target_addr
)
7366 struct target_timex
*target_tx
;
7368 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
7369 return -TARGET_EFAULT
;
7372 __get_user(host_tx
->modes
, &target_tx
->modes
);
7373 __get_user(host_tx
->offset
, &target_tx
->offset
);
7374 __get_user(host_tx
->freq
, &target_tx
->freq
);
7375 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7376 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
7377 __get_user(host_tx
->status
, &target_tx
->status
);
7378 __get_user(host_tx
->constant
, &target_tx
->constant
);
7379 __get_user(host_tx
->precision
, &target_tx
->precision
);
7380 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7381 __get_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7382 __get_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7383 __get_user(host_tx
->tick
, &target_tx
->tick
);
7384 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7385 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
7386 __get_user(host_tx
->shift
, &target_tx
->shift
);
7387 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
7388 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7389 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7390 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7391 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7392 __get_user(host_tx
->tai
, &target_tx
->tai
);
7394 unlock_user_struct(target_tx
, target_addr
, 0);
7398 static inline abi_long
host_to_target_timex(abi_long target_addr
,
7399 struct timex
*host_tx
)
7401 struct target_timex
*target_tx
;
7403 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
7404 return -TARGET_EFAULT
;
7407 __put_user(host_tx
->modes
, &target_tx
->modes
);
7408 __put_user(host_tx
->offset
, &target_tx
->offset
);
7409 __put_user(host_tx
->freq
, &target_tx
->freq
);
7410 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7411 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
7412 __put_user(host_tx
->status
, &target_tx
->status
);
7413 __put_user(host_tx
->constant
, &target_tx
->constant
);
7414 __put_user(host_tx
->precision
, &target_tx
->precision
);
7415 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7416 __put_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7417 __put_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7418 __put_user(host_tx
->tick
, &target_tx
->tick
);
7419 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7420 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
7421 __put_user(host_tx
->shift
, &target_tx
->shift
);
7422 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
7423 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7424 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7425 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7426 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7427 __put_user(host_tx
->tai
, &target_tx
->tai
);
7429 unlock_user_struct(target_tx
, target_addr
, 1);
7435 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
7436 static inline abi_long
target_to_host_timex64(struct timex
*host_tx
,
7437 abi_long target_addr
)
7439 struct target__kernel_timex
*target_tx
;
7441 if (copy_from_user_timeval64(&host_tx
->time
, target_addr
+
7442 offsetof(struct target__kernel_timex
,
7444 return -TARGET_EFAULT
;
7447 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
7448 return -TARGET_EFAULT
;
7451 __get_user(host_tx
->modes
, &target_tx
->modes
);
7452 __get_user(host_tx
->offset
, &target_tx
->offset
);
7453 __get_user(host_tx
->freq
, &target_tx
->freq
);
7454 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7455 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
7456 __get_user(host_tx
->status
, &target_tx
->status
);
7457 __get_user(host_tx
->constant
, &target_tx
->constant
);
7458 __get_user(host_tx
->precision
, &target_tx
->precision
);
7459 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7460 __get_user(host_tx
->tick
, &target_tx
->tick
);
7461 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7462 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
7463 __get_user(host_tx
->shift
, &target_tx
->shift
);
7464 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
7465 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7466 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7467 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7468 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7469 __get_user(host_tx
->tai
, &target_tx
->tai
);
7471 unlock_user_struct(target_tx
, target_addr
, 0);
7475 static inline abi_long
host_to_target_timex64(abi_long target_addr
,
7476 struct timex
*host_tx
)
7478 struct target__kernel_timex
*target_tx
;
7480 if (copy_to_user_timeval64(target_addr
+
7481 offsetof(struct target__kernel_timex
, time
),
7483 return -TARGET_EFAULT
;
7486 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
7487 return -TARGET_EFAULT
;
7490 __put_user(host_tx
->modes
, &target_tx
->modes
);
7491 __put_user(host_tx
->offset
, &target_tx
->offset
);
7492 __put_user(host_tx
->freq
, &target_tx
->freq
);
7493 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7494 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
7495 __put_user(host_tx
->status
, &target_tx
->status
);
7496 __put_user(host_tx
->constant
, &target_tx
->constant
);
7497 __put_user(host_tx
->precision
, &target_tx
->precision
);
7498 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7499 __put_user(host_tx
->tick
, &target_tx
->tick
);
7500 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7501 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
7502 __put_user(host_tx
->shift
, &target_tx
->shift
);
7503 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
7504 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7505 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7506 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7507 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7508 __put_user(host_tx
->tai
, &target_tx
->tai
);
7510 unlock_user_struct(target_tx
, target_addr
, 1);
7515 #ifndef HAVE_SIGEV_NOTIFY_THREAD_ID
7516 #define sigev_notify_thread_id _sigev_un._tid
7519 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
7520 abi_ulong target_addr
)
7522 struct target_sigevent
*target_sevp
;
7524 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
7525 return -TARGET_EFAULT
;
7528 /* This union is awkward on 64 bit systems because it has a 32 bit
7529 * integer and a pointer in it; we follow the conversion approach
7530 * used for handling sigval types in signal.c so the guest should get
7531 * the correct value back even if we did a 64 bit byteswap and it's
7532 * using the 32 bit integer.
7534 host_sevp
->sigev_value
.sival_ptr
=
7535 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
7536 host_sevp
->sigev_signo
=
7537 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
7538 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
7539 host_sevp
->sigev_notify_thread_id
= tswap32(target_sevp
->_sigev_un
._tid
);
7541 unlock_user_struct(target_sevp
, target_addr
, 1);
7545 #if defined(TARGET_NR_mlockall)
7546 static inline int target_to_host_mlockall_arg(int arg
)
7550 if (arg
& TARGET_MCL_CURRENT
) {
7551 result
|= MCL_CURRENT
;
7553 if (arg
& TARGET_MCL_FUTURE
) {
7554 result
|= MCL_FUTURE
;
7557 if (arg
& TARGET_MCL_ONFAULT
) {
7558 result
|= MCL_ONFAULT
;
7566 static inline int target_to_host_msync_arg(abi_long arg
)
7568 return ((arg
& TARGET_MS_ASYNC
) ? MS_ASYNC
: 0) |
7569 ((arg
& TARGET_MS_INVALIDATE
) ? MS_INVALIDATE
: 0) |
7570 ((arg
& TARGET_MS_SYNC
) ? MS_SYNC
: 0) |
7571 (arg
& ~(TARGET_MS_ASYNC
| TARGET_MS_INVALIDATE
| TARGET_MS_SYNC
));
7574 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) || \
7575 defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) || \
7576 defined(TARGET_NR_newfstatat))
7577 static inline abi_long
host_to_target_stat64(CPUArchState
*cpu_env
,
7578 abi_ulong target_addr
,
7579 struct stat
*host_st
)
7581 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
7582 if (cpu_env
->eabi
) {
7583 struct target_eabi_stat64
*target_st
;
7585 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7586 return -TARGET_EFAULT
;
7587 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
7588 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7589 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7590 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7591 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7593 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7594 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7595 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7596 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7597 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7598 __put_user(host_st
->st_size
, &target_st
->st_size
);
7599 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7600 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7601 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7602 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7603 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7604 #ifdef HAVE_STRUCT_STAT_ST_ATIM
7605 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
7606 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
7607 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
7609 unlock_user_struct(target_st
, target_addr
, 1);
7613 #if defined(TARGET_HAS_STRUCT_STAT64)
7614 struct target_stat64
*target_st
;
7616 struct target_stat
*target_st
;
7619 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7620 return -TARGET_EFAULT
;
7621 memset(target_st
, 0, sizeof(*target_st
));
7622 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7623 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7624 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7625 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7627 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7628 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7629 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7630 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7631 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7632 /* XXX: better use of kernel struct */
7633 __put_user(host_st
->st_size
, &target_st
->st_size
);
7634 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7635 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7636 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7637 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7638 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7639 #ifdef HAVE_STRUCT_STAT_ST_ATIM
7640 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
7641 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
7642 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
7644 unlock_user_struct(target_st
, target_addr
, 1);
7651 #if defined(TARGET_NR_statx) && defined(__NR_statx)
7652 static inline abi_long
host_to_target_statx(struct target_statx
*host_stx
,
7653 abi_ulong target_addr
)
7655 struct target_statx
*target_stx
;
7657 if (!lock_user_struct(VERIFY_WRITE
, target_stx
, target_addr
, 0)) {
7658 return -TARGET_EFAULT
;
7660 memset(target_stx
, 0, sizeof(*target_stx
));
7662 __put_user(host_stx
->stx_mask
, &target_stx
->stx_mask
);
7663 __put_user(host_stx
->stx_blksize
, &target_stx
->stx_blksize
);
7664 __put_user(host_stx
->stx_attributes
, &target_stx
->stx_attributes
);
7665 __put_user(host_stx
->stx_nlink
, &target_stx
->stx_nlink
);
7666 __put_user(host_stx
->stx_uid
, &target_stx
->stx_uid
);
7667 __put_user(host_stx
->stx_gid
, &target_stx
->stx_gid
);
7668 __put_user(host_stx
->stx_mode
, &target_stx
->stx_mode
);
7669 __put_user(host_stx
->stx_ino
, &target_stx
->stx_ino
);
7670 __put_user(host_stx
->stx_size
, &target_stx
->stx_size
);
7671 __put_user(host_stx
->stx_blocks
, &target_stx
->stx_blocks
);
7672 __put_user(host_stx
->stx_attributes_mask
, &target_stx
->stx_attributes_mask
);
7673 __put_user(host_stx
->stx_atime
.tv_sec
, &target_stx
->stx_atime
.tv_sec
);
7674 __put_user(host_stx
->stx_atime
.tv_nsec
, &target_stx
->stx_atime
.tv_nsec
);
7675 __put_user(host_stx
->stx_btime
.tv_sec
, &target_stx
->stx_btime
.tv_sec
);
7676 __put_user(host_stx
->stx_btime
.tv_nsec
, &target_stx
->stx_btime
.tv_nsec
);
7677 __put_user(host_stx
->stx_ctime
.tv_sec
, &target_stx
->stx_ctime
.tv_sec
);
7678 __put_user(host_stx
->stx_ctime
.tv_nsec
, &target_stx
->stx_ctime
.tv_nsec
);
7679 __put_user(host_stx
->stx_mtime
.tv_sec
, &target_stx
->stx_mtime
.tv_sec
);
7680 __put_user(host_stx
->stx_mtime
.tv_nsec
, &target_stx
->stx_mtime
.tv_nsec
);
7681 __put_user(host_stx
->stx_rdev_major
, &target_stx
->stx_rdev_major
);
7682 __put_user(host_stx
->stx_rdev_minor
, &target_stx
->stx_rdev_minor
);
7683 __put_user(host_stx
->stx_dev_major
, &target_stx
->stx_dev_major
);
7684 __put_user(host_stx
->stx_dev_minor
, &target_stx
->stx_dev_minor
);
7686 unlock_user_struct(target_stx
, target_addr
, 1);
7692 static int do_sys_futex(int *uaddr
, int op
, int val
,
7693 const struct timespec
*timeout
, int *uaddr2
,
7696 #if HOST_LONG_BITS == 64
7697 #if defined(__NR_futex)
7698 /* always a 64-bit time_t, it doesn't define _time64 version */
7699 return sys_futex(uaddr
, op
, val
, timeout
, uaddr2
, val3
);
7702 #else /* HOST_LONG_BITS == 64 */
7703 #if defined(__NR_futex_time64)
7704 if (sizeof(timeout
->tv_sec
) == 8) {
7705 /* _time64 function on 32bit arch */
7706 return sys_futex_time64(uaddr
, op
, val
, timeout
, uaddr2
, val3
);
7709 #if defined(__NR_futex)
7710 /* old function on 32bit arch */
7711 return sys_futex(uaddr
, op
, val
, timeout
, uaddr2
, val3
);
7713 #endif /* HOST_LONG_BITS == 64 */
7714 g_assert_not_reached();
7717 static int do_safe_futex(int *uaddr
, int op
, int val
,
7718 const struct timespec
*timeout
, int *uaddr2
,
7721 #if HOST_LONG_BITS == 64
7722 #if defined(__NR_futex)
7723 /* always a 64-bit time_t, it doesn't define _time64 version */
7724 return get_errno(safe_futex(uaddr
, op
, val
, timeout
, uaddr2
, val3
));
7726 #else /* HOST_LONG_BITS == 64 */
7727 #if defined(__NR_futex_time64)
7728 if (sizeof(timeout
->tv_sec
) == 8) {
7729 /* _time64 function on 32bit arch */
7730 return get_errno(safe_futex_time64(uaddr
, op
, val
, timeout
, uaddr2
,
7734 #if defined(__NR_futex)
7735 /* old function on 32bit arch */
7736 return get_errno(safe_futex(uaddr
, op
, val
, timeout
, uaddr2
, val3
));
7738 #endif /* HOST_LONG_BITS == 64 */
7739 return -TARGET_ENOSYS
;
7742 /* ??? Using host futex calls even when target atomic operations
7743 are not really atomic probably breaks things. However implementing
7744 futexes locally would make futexes shared between multiple processes
7745 tricky. However they're probably useless because guest atomic
7746 operations won't work either. */
7747 #if defined(TARGET_NR_futex) || defined(TARGET_NR_futex_time64)
7748 static int do_futex(CPUState
*cpu
, bool time64
, target_ulong uaddr
,
7749 int op
, int val
, target_ulong timeout
,
7750 target_ulong uaddr2
, int val3
)
7752 struct timespec ts
, *pts
= NULL
;
7753 void *haddr2
= NULL
;
7756 /* We assume FUTEX_* constants are the same on both host and target. */
7757 #ifdef FUTEX_CMD_MASK
7758 base_op
= op
& FUTEX_CMD_MASK
;
7764 case FUTEX_WAIT_BITSET
:
7767 case FUTEX_WAIT_REQUEUE_PI
:
7769 haddr2
= g2h(cpu
, uaddr2
);
7772 case FUTEX_LOCK_PI2
:
7775 case FUTEX_WAKE_BITSET
:
7776 case FUTEX_TRYLOCK_PI
:
7777 case FUTEX_UNLOCK_PI
:
7781 val
= target_to_host_signal(val
);
7784 case FUTEX_CMP_REQUEUE
:
7785 case FUTEX_CMP_REQUEUE_PI
:
7786 val3
= tswap32(val3
);
7791 * For these, the 4th argument is not TIMEOUT, but VAL2.
7792 * But the prototype of do_safe_futex takes a pointer, so
7793 * insert casts to satisfy the compiler. We do not need
7794 * to tswap VAL2 since it's not compared to guest memory.
7796 pts
= (struct timespec
*)(uintptr_t)timeout
;
7798 haddr2
= g2h(cpu
, uaddr2
);
7801 return -TARGET_ENOSYS
;
7806 ? target_to_host_timespec64(pts
, timeout
)
7807 : target_to_host_timespec(pts
, timeout
)) {
7808 return -TARGET_EFAULT
;
7811 return do_safe_futex(g2h(cpu
, uaddr
), op
, val
, pts
, haddr2
, val3
);
7815 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7816 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
7817 abi_long handle
, abi_long mount_id
,
7820 struct file_handle
*target_fh
;
7821 struct file_handle
*fh
;
7825 unsigned int size
, total_size
;
7827 if (get_user_s32(size
, handle
)) {
7828 return -TARGET_EFAULT
;
7831 name
= lock_user_string(pathname
);
7833 return -TARGET_EFAULT
;
7836 total_size
= sizeof(struct file_handle
) + size
;
7837 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
7839 unlock_user(name
, pathname
, 0);
7840 return -TARGET_EFAULT
;
7843 fh
= g_malloc0(total_size
);
7844 fh
->handle_bytes
= size
;
7846 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
7847 unlock_user(name
, pathname
, 0);
7849 /* man name_to_handle_at(2):
7850 * Other than the use of the handle_bytes field, the caller should treat
7851 * the file_handle structure as an opaque data type
7854 memcpy(target_fh
, fh
, total_size
);
7855 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
7856 target_fh
->handle_type
= tswap32(fh
->handle_type
);
7858 unlock_user(target_fh
, handle
, total_size
);
7860 if (put_user_s32(mid
, mount_id
)) {
7861 return -TARGET_EFAULT
;
7869 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7870 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
7873 struct file_handle
*target_fh
;
7874 struct file_handle
*fh
;
7875 unsigned int size
, total_size
;
7878 if (get_user_s32(size
, handle
)) {
7879 return -TARGET_EFAULT
;
7882 total_size
= sizeof(struct file_handle
) + size
;
7883 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
7885 return -TARGET_EFAULT
;
7888 fh
= g_memdup(target_fh
, total_size
);
7889 fh
->handle_bytes
= size
;
7890 fh
->handle_type
= tswap32(target_fh
->handle_type
);
7892 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
7893 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
7897 unlock_user(target_fh
, handle
, total_size
);
7903 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7905 static abi_long
do_signalfd4(int fd
, abi_long mask
, int flags
)
7908 target_sigset_t
*target_mask
;
7912 if (flags
& ~(TARGET_O_NONBLOCK_MASK
| TARGET_O_CLOEXEC
)) {
7913 return -TARGET_EINVAL
;
7915 if (!lock_user_struct(VERIFY_READ
, target_mask
, mask
, 1)) {
7916 return -TARGET_EFAULT
;
7919 target_to_host_sigset(&host_mask
, target_mask
);
7921 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
7923 ret
= get_errno(signalfd(fd
, &host_mask
, host_flags
));
7925 fd_trans_register(ret
, &target_signalfd_trans
);
7928 unlock_user_struct(target_mask
, mask
, 0);
7934 /* Map host to target signal numbers for the wait family of syscalls.
7935 Assume all other status bits are the same. */
7936 int host_to_target_waitstatus(int status
)
7938 if (WIFSIGNALED(status
)) {
7939 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
7941 if (WIFSTOPPED(status
)) {
7942 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
7948 static int open_self_cmdline(CPUArchState
*cpu_env
, int fd
)
7950 CPUState
*cpu
= env_cpu(cpu_env
);
7951 struct linux_binprm
*bprm
= get_task_state(cpu
)->bprm
;
7954 for (i
= 0; i
< bprm
->argc
; i
++) {
7955 size_t len
= strlen(bprm
->argv
[i
]) + 1;
7957 if (write(fd
, bprm
->argv
[i
], len
) != len
) {
7965 struct open_self_maps_data
{
7967 IntervalTreeRoot
*host_maps
;
7973 * Subroutine to output one line of /proc/self/maps,
7974 * or one region of /proc/self/smaps.
7978 # define test_stack(S, E, L) (E == L)
7980 # define test_stack(S, E, L) (S == L)
7983 static void open_self_maps_4(const struct open_self_maps_data
*d
,
7984 const MapInfo
*mi
, abi_ptr start
,
7985 abi_ptr end
, unsigned flags
)
7987 const struct image_info
*info
= d
->ts
->info
;
7988 const char *path
= mi
->path
;
7993 if (test_stack(start
, end
, info
->stack_limit
)) {
7995 } else if (start
== info
->brk
) {
7997 } else if (start
== info
->vdso
) {
7999 #ifdef TARGET_X86_64
8000 } else if (start
== TARGET_VSYSCALL_PAGE
) {
8001 path
= "[vsyscall]";
8005 /* Except null device (MAP_ANON), adjust offset for this fragment. */
8006 offset
= mi
->offset
;
8008 uintptr_t hstart
= (uintptr_t)g2h_untagged(start
);
8009 offset
+= hstart
- mi
->itree
.start
;
8012 count
= dprintf(fd
, TARGET_ABI_FMT_ptr
"-" TARGET_ABI_FMT_ptr
8013 " %c%c%c%c %08" PRIx64
" %02x:%02x %"PRId64
,
8015 (flags
& PAGE_READ
) ? 'r' : '-',
8016 (flags
& PAGE_WRITE_ORG
) ? 'w' : '-',
8017 (flags
& PAGE_EXEC
) ? 'x' : '-',
8018 mi
->is_priv
? 'p' : 's',
8019 offset
, major(mi
->dev
), minor(mi
->dev
),
8020 (uint64_t)mi
->inode
);
8022 dprintf(fd
, "%*s%s\n", 73 - count
, "", path
);
8028 unsigned long size
= end
- start
;
8029 unsigned long page_size_kb
= TARGET_PAGE_SIZE
>> 10;
8030 unsigned long size_kb
= size
>> 10;
8032 dprintf(fd
, "Size: %lu kB\n"
8033 "KernelPageSize: %lu kB\n"
8034 "MMUPageSize: %lu kB\n"
8038 "Shared_Clean: 0 kB\n"
8039 "Shared_Dirty: 0 kB\n"
8040 "Private_Clean: 0 kB\n"
8041 "Private_Dirty: 0 kB\n"
8042 "Referenced: 0 kB\n"
8043 "Anonymous: %lu kB\n"
8045 "AnonHugePages: 0 kB\n"
8046 "ShmemPmdMapped: 0 kB\n"
8047 "FilePmdMapped: 0 kB\n"
8048 "Shared_Hugetlb: 0 kB\n"
8049 "Private_Hugetlb: 0 kB\n"
8054 "VmFlags:%s%s%s%s%s%s%s%s\n",
8055 size_kb
, page_size_kb
, page_size_kb
,
8056 (flags
& PAGE_ANON
? size_kb
: 0),
8057 (flags
& PAGE_READ
) ? " rd" : "",
8058 (flags
& PAGE_WRITE_ORG
) ? " wr" : "",
8059 (flags
& PAGE_EXEC
) ? " ex" : "",
8060 mi
->is_priv
? "" : " sh",
8061 (flags
& PAGE_READ
) ? " mr" : "",
8062 (flags
& PAGE_WRITE_ORG
) ? " mw" : "",
8063 (flags
& PAGE_EXEC
) ? " me" : "",
8064 mi
->is_priv
? "" : " ms");
8069 * Callback for walk_memory_regions, when read_self_maps() fails.
8070 * Proceed without the benefit of host /proc/self/maps cross-check.
8072 static int open_self_maps_3(void *opaque
, target_ulong guest_start
,
8073 target_ulong guest_end
, unsigned long flags
)
8075 static const MapInfo mi
= { .is_priv
= true };
8077 open_self_maps_4(opaque
, &mi
, guest_start
, guest_end
, flags
);
8082 * Callback for walk_memory_regions, when read_self_maps() succeeds.
8084 static int open_self_maps_2(void *opaque
, target_ulong guest_start
,
8085 target_ulong guest_end
, unsigned long flags
)
8087 const struct open_self_maps_data
*d
= opaque
;
8088 uintptr_t host_start
= (uintptr_t)g2h_untagged(guest_start
);
8089 uintptr_t host_last
= (uintptr_t)g2h_untagged(guest_end
- 1);
8091 #ifdef TARGET_X86_64
8093 * Because of the extremely high position of the page within the guest
8094 * virtual address space, this is not backed by host memory at all.
8095 * Therefore the loop below would fail. This is the only instance
8096 * of not having host backing memory.
8098 if (guest_start
== TARGET_VSYSCALL_PAGE
) {
8099 return open_self_maps_3(opaque
, guest_start
, guest_end
, flags
);
8104 IntervalTreeNode
*n
=
8105 interval_tree_iter_first(d
->host_maps
, host_start
, host_start
);
8106 MapInfo
*mi
= container_of(n
, MapInfo
, itree
);
8107 uintptr_t this_hlast
= MIN(host_last
, n
->last
);
8108 target_ulong this_gend
= h2g(this_hlast
) + 1;
8110 open_self_maps_4(d
, mi
, guest_start
, this_gend
, flags
);
8112 if (this_hlast
== host_last
) {
8115 host_start
= this_hlast
+ 1;
8116 guest_start
= h2g(host_start
);
8120 static int open_self_maps_1(CPUArchState
*env
, int fd
, bool smaps
)
8122 struct open_self_maps_data d
= {
8123 .ts
= get_task_state(env_cpu(env
)),
8124 .host_maps
= read_self_maps(),
8130 walk_memory_regions(&d
, open_self_maps_2
);
8131 free_self_maps(d
.host_maps
);
8133 walk_memory_regions(&d
, open_self_maps_3
);
8138 static int open_self_maps(CPUArchState
*cpu_env
, int fd
)
8140 return open_self_maps_1(cpu_env
, fd
, false);
8143 static int open_self_smaps(CPUArchState
*cpu_env
, int fd
)
8145 return open_self_maps_1(cpu_env
, fd
, true);
8148 static int open_self_stat(CPUArchState
*cpu_env
, int fd
)
8150 CPUState
*cpu
= env_cpu(cpu_env
);
8151 TaskState
*ts
= get_task_state(cpu
);
8152 g_autoptr(GString
) buf
= g_string_new(NULL
);
8155 for (i
= 0; i
< 44; i
++) {
8158 g_string_printf(buf
, FMT_pid
" ", getpid());
8159 } else if (i
== 1) {
8161 gchar
*bin
= g_strrstr(ts
->bprm
->argv
[0], "/");
8162 bin
= bin
? bin
+ 1 : ts
->bprm
->argv
[0];
8163 g_string_printf(buf
, "(%.15s) ", bin
);
8164 } else if (i
== 2) {
8166 g_string_assign(buf
, "R "); /* we are running right now */
8167 } else if (i
== 3) {
8169 g_string_printf(buf
, FMT_pid
" ", getppid());
8170 } else if (i
== 21) {
8172 g_string_printf(buf
, "%" PRIu64
" ", ts
->start_boottime
);
8173 } else if (i
== 27) {
8175 g_string_printf(buf
, TARGET_ABI_FMT_ld
" ", ts
->info
->start_stack
);
8177 /* for the rest, there is MasterCard */
8178 g_string_printf(buf
, "0%c", i
== 43 ? '\n' : ' ');
8181 if (write(fd
, buf
->str
, buf
->len
) != buf
->len
) {
8189 static int open_self_auxv(CPUArchState
*cpu_env
, int fd
)
8191 CPUState
*cpu
= env_cpu(cpu_env
);
8192 TaskState
*ts
= get_task_state(cpu
);
8193 abi_ulong auxv
= ts
->info
->saved_auxv
;
8194 abi_ulong len
= ts
->info
->auxv_len
;
8198 * Auxiliary vector is stored in target process stack.
8199 * read in whole auxv vector and copy it to file
8201 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
8205 r
= write(fd
, ptr
, len
);
8212 lseek(fd
, 0, SEEK_SET
);
8213 unlock_user(ptr
, auxv
, len
);
8219 static int is_proc_myself(const char *filename
, const char *entry
)
8221 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
8222 filename
+= strlen("/proc/");
8223 if (!strncmp(filename
, "self/", strlen("self/"))) {
8224 filename
+= strlen("self/");
8225 } else if (*filename
>= '1' && *filename
<= '9') {
8227 snprintf(myself
, sizeof(myself
), "%d/", getpid());
8228 if (!strncmp(filename
, myself
, strlen(myself
))) {
8229 filename
+= strlen(myself
);
8236 if (!strcmp(filename
, entry
)) {
8243 static void excp_dump_file(FILE *logfile
, CPUArchState
*env
,
8244 const char *fmt
, int code
)
8247 CPUState
*cs
= env_cpu(env
);
8249 fprintf(logfile
, fmt
, code
);
8250 fprintf(logfile
, "Failing executable: %s\n", exec_path
);
8251 cpu_dump_state(cs
, logfile
, 0);
8252 open_self_maps(env
, fileno(logfile
));
8256 void target_exception_dump(CPUArchState
*env
, const char *fmt
, int code
)
8258 /* dump to console */
8259 excp_dump_file(stderr
, env
, fmt
, code
);
8261 /* dump to log file */
8262 if (qemu_log_separate()) {
8263 FILE *logfile
= qemu_log_trylock();
8265 excp_dump_file(logfile
, env
, fmt
, code
);
8266 qemu_log_unlock(logfile
);
8270 #include "target_proc.h"
8272 #if HOST_BIG_ENDIAN != TARGET_BIG_ENDIAN || \
8273 defined(HAVE_ARCH_PROC_CPUINFO) || \
8274 defined(HAVE_ARCH_PROC_HARDWARE)
8275 static int is_proc(const char *filename
, const char *entry
)
8277 return strcmp(filename
, entry
) == 0;
8281 #if HOST_BIG_ENDIAN != TARGET_BIG_ENDIAN
8282 static int open_net_route(CPUArchState
*cpu_env
, int fd
)
8289 fp
= fopen("/proc/net/route", "r");
8296 read
= getline(&line
, &len
, fp
);
8297 dprintf(fd
, "%s", line
);
8301 while ((read
= getline(&line
, &len
, fp
)) != -1) {
8303 uint32_t dest
, gw
, mask
;
8304 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
8307 fields
= sscanf(line
,
8308 "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
8309 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
8310 &mask
, &mtu
, &window
, &irtt
);
8314 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
8315 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
8316 metric
, tswap32(mask
), mtu
, window
, irtt
);
8326 int do_guest_openat(CPUArchState
*cpu_env
, int dirfd
, const char *fname
,
8327 int flags
, mode_t mode
, bool safe
)
8329 g_autofree
char *proc_name
= NULL
;
8330 const char *pathname
;
8332 const char *filename
;
8333 int (*fill
)(CPUArchState
*cpu_env
, int fd
);
8334 int (*cmp
)(const char *s1
, const char *s2
);
8336 const struct fake_open
*fake_open
;
8337 static const struct fake_open fakes
[] = {
8338 { "maps", open_self_maps
, is_proc_myself
},
8339 { "smaps", open_self_smaps
, is_proc_myself
},
8340 { "stat", open_self_stat
, is_proc_myself
},
8341 { "auxv", open_self_auxv
, is_proc_myself
},
8342 { "cmdline", open_self_cmdline
, is_proc_myself
},
8343 #if HOST_BIG_ENDIAN != TARGET_BIG_ENDIAN
8344 { "/proc/net/route", open_net_route
, is_proc
},
8346 #if defined(HAVE_ARCH_PROC_CPUINFO)
8347 { "/proc/cpuinfo", open_cpuinfo
, is_proc
},
8349 #if defined(HAVE_ARCH_PROC_HARDWARE)
8350 { "/proc/hardware", open_hardware
, is_proc
},
8352 { NULL
, NULL
, NULL
}
8355 /* if this is a file from /proc/ filesystem, expand full name */
8356 proc_name
= realpath(fname
, NULL
);
8357 if (proc_name
&& strncmp(proc_name
, "/proc/", 6) == 0) {
8358 pathname
= proc_name
;
8363 if (is_proc_myself(pathname
, "exe")) {
8365 return safe_openat(dirfd
, exec_path
, flags
, mode
);
8367 return openat(dirfd
, exec_path
, flags
, mode
);
8371 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
8372 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
8377 if (fake_open
->filename
) {
8379 char filename
[PATH_MAX
];
8382 fd
= memfd_create("qemu-open", 0);
8384 if (errno
!= ENOSYS
) {
8387 /* create temporary file to map stat to */
8388 tmpdir
= getenv("TMPDIR");
8391 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
8392 fd
= mkstemp(filename
);
8399 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
8405 lseek(fd
, 0, SEEK_SET
);
8411 return safe_openat(dirfd
, path(pathname
), flags
, mode
);
8413 return openat(dirfd
, path(pathname
), flags
, mode
);
8417 ssize_t
do_guest_readlink(const char *pathname
, char *buf
, size_t bufsiz
)
8421 if (!pathname
|| !buf
) {
8427 /* Short circuit this for the magic exe check. */
8432 if (is_proc_myself((const char *)pathname
, "exe")) {
8434 * Don't worry about sign mismatch as earlier mapping
8435 * logic would have thrown a bad address error.
8437 ret
= MIN(strlen(exec_path
), bufsiz
);
8438 /* We cannot NUL terminate the string. */
8439 memcpy(buf
, exec_path
, ret
);
8441 ret
= readlink(path(pathname
), buf
, bufsiz
);
8447 static int do_execv(CPUArchState
*cpu_env
, int dirfd
,
8448 abi_long pathname
, abi_long guest_argp
,
8449 abi_long guest_envp
, int flags
, bool is_execveat
)
8452 char **argp
, **envp
;
8461 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
8462 if (get_user_ual(addr
, gp
)) {
8463 return -TARGET_EFAULT
;
8471 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
8472 if (get_user_ual(addr
, gp
)) {
8473 return -TARGET_EFAULT
;
8481 argp
= g_new0(char *, argc
+ 1);
8482 envp
= g_new0(char *, envc
+ 1);
8484 for (gp
= guest_argp
, q
= argp
; gp
; gp
+= sizeof(abi_ulong
), q
++) {
8485 if (get_user_ual(addr
, gp
)) {
8491 *q
= lock_user_string(addr
);
8498 for (gp
= guest_envp
, q
= envp
; gp
; gp
+= sizeof(abi_ulong
), q
++) {
8499 if (get_user_ual(addr
, gp
)) {
8505 *q
= lock_user_string(addr
);
8513 * Although execve() is not an interruptible syscall it is
8514 * a special case where we must use the safe_syscall wrapper:
8515 * if we allow a signal to happen before we make the host
8516 * syscall then we will 'lose' it, because at the point of
8517 * execve the process leaves QEMU's control. So we use the
8518 * safe syscall wrapper to ensure that we either take the
8519 * signal as a guest signal, or else it does not happen
8520 * before the execve completes and makes it the other
8521 * program's problem.
8523 p
= lock_user_string(pathname
);
8528 const char *exe
= p
;
8529 if (is_proc_myself(p
, "exe")) {
8533 ? safe_execveat(dirfd
, exe
, argp
, envp
, flags
)
8534 : safe_execve(exe
, argp
, envp
);
8535 ret
= get_errno(ret
);
8537 unlock_user(p
, pathname
, 0);
8542 ret
= -TARGET_EFAULT
;
8545 for (gp
= guest_argp
, q
= argp
; *q
; gp
+= sizeof(abi_ulong
), q
++) {
8546 if (get_user_ual(addr
, gp
) || !addr
) {
8549 unlock_user(*q
, addr
, 0);
8551 for (gp
= guest_envp
, q
= envp
; *q
; gp
+= sizeof(abi_ulong
), q
++) {
8552 if (get_user_ual(addr
, gp
) || !addr
) {
8555 unlock_user(*q
, addr
, 0);
8563 #define TIMER_MAGIC 0x0caf0000
8564 #define TIMER_MAGIC_MASK 0xffff0000
8566 /* Convert QEMU provided timer ID back to internal 16bit index format */
8567 static target_timer_t
get_timer_id(abi_long arg
)
8569 target_timer_t timerid
= arg
;
8571 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
8572 return -TARGET_EINVAL
;
8577 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
8578 return -TARGET_EINVAL
;
8584 static int target_to_host_cpu_mask(unsigned long *host_mask
,
8586 abi_ulong target_addr
,
8589 unsigned target_bits
= sizeof(abi_ulong
) * 8;
8590 unsigned host_bits
= sizeof(*host_mask
) * 8;
8591 abi_ulong
*target_mask
;
8594 assert(host_size
>= target_size
);
8596 target_mask
= lock_user(VERIFY_READ
, target_addr
, target_size
, 1);
8598 return -TARGET_EFAULT
;
8600 memset(host_mask
, 0, host_size
);
8602 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
8603 unsigned bit
= i
* target_bits
;
8606 __get_user(val
, &target_mask
[i
]);
8607 for (j
= 0; j
< target_bits
; j
++, bit
++) {
8608 if (val
& (1UL << j
)) {
8609 host_mask
[bit
/ host_bits
] |= 1UL << (bit
% host_bits
);
8614 unlock_user(target_mask
, target_addr
, 0);
8618 static int host_to_target_cpu_mask(const unsigned long *host_mask
,
8620 abi_ulong target_addr
,
8623 unsigned target_bits
= sizeof(abi_ulong
) * 8;
8624 unsigned host_bits
= sizeof(*host_mask
) * 8;
8625 abi_ulong
*target_mask
;
8628 assert(host_size
>= target_size
);
8630 target_mask
= lock_user(VERIFY_WRITE
, target_addr
, target_size
, 0);
8632 return -TARGET_EFAULT
;
8635 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
8636 unsigned bit
= i
* target_bits
;
8639 for (j
= 0; j
< target_bits
; j
++, bit
++) {
8640 if (host_mask
[bit
/ host_bits
] & (1UL << (bit
% host_bits
))) {
8644 __put_user(val
, &target_mask
[i
]);
8647 unlock_user(target_mask
, target_addr
, target_size
);
8651 #ifdef TARGET_NR_getdents
8652 static int do_getdents(abi_long dirfd
, abi_long arg2
, abi_long count
)
8654 g_autofree
void *hdirp
= NULL
;
8656 int hlen
, hoff
, toff
;
8657 int hreclen
, treclen
;
8658 off64_t prev_diroff
= 0;
8660 hdirp
= g_try_malloc(count
);
8662 return -TARGET_ENOMEM
;
8665 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8666 hlen
= sys_getdents(dirfd
, hdirp
, count
);
8668 hlen
= sys_getdents64(dirfd
, hdirp
, count
);
8671 hlen
= get_errno(hlen
);
8672 if (is_error(hlen
)) {
8676 tdirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
8678 return -TARGET_EFAULT
;
8681 for (hoff
= toff
= 0; hoff
< hlen
; hoff
+= hreclen
, toff
+= treclen
) {
8682 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8683 struct linux_dirent
*hde
= hdirp
+ hoff
;
8685 struct linux_dirent64
*hde
= hdirp
+ hoff
;
8687 struct target_dirent
*tde
= tdirp
+ toff
;
8691 namelen
= strlen(hde
->d_name
);
8692 hreclen
= hde
->d_reclen
;
8693 treclen
= offsetof(struct target_dirent
, d_name
) + namelen
+ 2;
8694 treclen
= QEMU_ALIGN_UP(treclen
, __alignof(struct target_dirent
));
8696 if (toff
+ treclen
> count
) {
8698 * If the host struct is smaller than the target struct, or
8699 * requires less alignment and thus packs into less space,
8700 * then the host can return more entries than we can pass
8704 toff
= -TARGET_EINVAL
; /* result buffer is too small */
8708 * Return what we have, resetting the file pointer to the
8709 * location of the first record not returned.
8711 lseek64(dirfd
, prev_diroff
, SEEK_SET
);
8715 prev_diroff
= hde
->d_off
;
8716 tde
->d_ino
= tswapal(hde
->d_ino
);
8717 tde
->d_off
= tswapal(hde
->d_off
);
8718 tde
->d_reclen
= tswap16(treclen
);
8719 memcpy(tde
->d_name
, hde
->d_name
, namelen
+ 1);
8722 * The getdents type is in what was formerly a padding byte at the
8723 * end of the structure.
8725 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
8726 type
= *((uint8_t *)hde
+ hreclen
- 1);
8730 *((uint8_t *)tde
+ treclen
- 1) = type
;
8733 unlock_user(tdirp
, arg2
, toff
);
8736 #endif /* TARGET_NR_getdents */
8738 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
8739 static int do_getdents64(abi_long dirfd
, abi_long arg2
, abi_long count
)
8741 g_autofree
void *hdirp
= NULL
;
8743 int hlen
, hoff
, toff
;
8744 int hreclen
, treclen
;
8745 off64_t prev_diroff
= 0;
8747 hdirp
= g_try_malloc(count
);
8749 return -TARGET_ENOMEM
;
8752 hlen
= get_errno(sys_getdents64(dirfd
, hdirp
, count
));
8753 if (is_error(hlen
)) {
8757 tdirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
8759 return -TARGET_EFAULT
;
8762 for (hoff
= toff
= 0; hoff
< hlen
; hoff
+= hreclen
, toff
+= treclen
) {
8763 struct linux_dirent64
*hde
= hdirp
+ hoff
;
8764 struct target_dirent64
*tde
= tdirp
+ toff
;
8767 namelen
= strlen(hde
->d_name
) + 1;
8768 hreclen
= hde
->d_reclen
;
8769 treclen
= offsetof(struct target_dirent64
, d_name
) + namelen
;
8770 treclen
= QEMU_ALIGN_UP(treclen
, __alignof(struct target_dirent64
));
8772 if (toff
+ treclen
> count
) {
8774 * If the host struct is smaller than the target struct, or
8775 * requires less alignment and thus packs into less space,
8776 * then the host can return more entries than we can pass
8780 toff
= -TARGET_EINVAL
; /* result buffer is too small */
8784 * Return what we have, resetting the file pointer to the
8785 * location of the first record not returned.
8787 lseek64(dirfd
, prev_diroff
, SEEK_SET
);
8791 prev_diroff
= hde
->d_off
;
8792 tde
->d_ino
= tswap64(hde
->d_ino
);
8793 tde
->d_off
= tswap64(hde
->d_off
);
8794 tde
->d_reclen
= tswap16(treclen
);
8795 tde
->d_type
= hde
->d_type
;
8796 memcpy(tde
->d_name
, hde
->d_name
, namelen
);
8799 unlock_user(tdirp
, arg2
, toff
);
8802 #endif /* TARGET_NR_getdents64 */
8804 #if defined(TARGET_NR_riscv_hwprobe)
8806 #define RISCV_HWPROBE_KEY_MVENDORID 0
8807 #define RISCV_HWPROBE_KEY_MARCHID 1
8808 #define RISCV_HWPROBE_KEY_MIMPID 2
8810 #define RISCV_HWPROBE_KEY_BASE_BEHAVIOR 3
8811 #define RISCV_HWPROBE_BASE_BEHAVIOR_IMA (1 << 0)
8813 #define RISCV_HWPROBE_KEY_IMA_EXT_0 4
8814 #define RISCV_HWPROBE_IMA_FD (1 << 0)
8815 #define RISCV_HWPROBE_IMA_C (1 << 1)
8816 #define RISCV_HWPROBE_IMA_V (1 << 2)
8817 #define RISCV_HWPROBE_EXT_ZBA (1 << 3)
8818 #define RISCV_HWPROBE_EXT_ZBB (1 << 4)
8819 #define RISCV_HWPROBE_EXT_ZBS (1 << 5)
8820 #define RISCV_HWPROBE_EXT_ZICBOZ (1 << 6)
8821 #define RISCV_HWPROBE_EXT_ZBC (1 << 7)
8822 #define RISCV_HWPROBE_EXT_ZBKB (1 << 8)
8823 #define RISCV_HWPROBE_EXT_ZBKC (1 << 9)
8824 #define RISCV_HWPROBE_EXT_ZBKX (1 << 10)
8825 #define RISCV_HWPROBE_EXT_ZKND (1 << 11)
8826 #define RISCV_HWPROBE_EXT_ZKNE (1 << 12)
8827 #define RISCV_HWPROBE_EXT_ZKNH (1 << 13)
8828 #define RISCV_HWPROBE_EXT_ZKSED (1 << 14)
8829 #define RISCV_HWPROBE_EXT_ZKSH (1 << 15)
8830 #define RISCV_HWPROBE_EXT_ZKT (1 << 16)
8831 #define RISCV_HWPROBE_EXT_ZVBB (1 << 17)
8832 #define RISCV_HWPROBE_EXT_ZVBC (1 << 18)
8833 #define RISCV_HWPROBE_EXT_ZVKB (1 << 19)
8834 #define RISCV_HWPROBE_EXT_ZVKG (1 << 20)
8835 #define RISCV_HWPROBE_EXT_ZVKNED (1 << 21)
8836 #define RISCV_HWPROBE_EXT_ZVKNHA (1 << 22)
8837 #define RISCV_HWPROBE_EXT_ZVKNHB (1 << 23)
8838 #define RISCV_HWPROBE_EXT_ZVKSED (1 << 24)
8839 #define RISCV_HWPROBE_EXT_ZVKSH (1 << 25)
8840 #define RISCV_HWPROBE_EXT_ZVKT (1 << 26)
8841 #define RISCV_HWPROBE_EXT_ZFH (1 << 27)
8842 #define RISCV_HWPROBE_EXT_ZFHMIN (1 << 28)
8843 #define RISCV_HWPROBE_EXT_ZIHINTNTL (1 << 29)
8844 #define RISCV_HWPROBE_EXT_ZVFH (1 << 30)
8845 #define RISCV_HWPROBE_EXT_ZVFHMIN (1 << 31)
8846 #define RISCV_HWPROBE_EXT_ZFA (1ULL << 32)
8847 #define RISCV_HWPROBE_EXT_ZTSO (1ULL << 33)
8848 #define RISCV_HWPROBE_EXT_ZACAS (1ULL << 34)
8849 #define RISCV_HWPROBE_EXT_ZICOND (1ULL << 35)
8851 #define RISCV_HWPROBE_KEY_CPUPERF_0 5
8852 #define RISCV_HWPROBE_MISALIGNED_UNKNOWN (0 << 0)
8853 #define RISCV_HWPROBE_MISALIGNED_EMULATED (1 << 0)
8854 #define RISCV_HWPROBE_MISALIGNED_SLOW (2 << 0)
8855 #define RISCV_HWPROBE_MISALIGNED_FAST (3 << 0)
8856 #define RISCV_HWPROBE_MISALIGNED_UNSUPPORTED (4 << 0)
8857 #define RISCV_HWPROBE_MISALIGNED_MASK (7 << 0)
8859 #define RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE 6
8861 struct riscv_hwprobe
{
8866 static void risc_hwprobe_fill_pairs(CPURISCVState
*env
,
8867 struct riscv_hwprobe
*pair
,
8870 const RISCVCPUConfig
*cfg
= riscv_cpu_cfg(env
);
8872 for (; pair_count
> 0; pair_count
--, pair
++) {
8875 __put_user(0, &pair
->value
);
8876 __get_user(key
, &pair
->key
);
8878 case RISCV_HWPROBE_KEY_MVENDORID
:
8879 __put_user(cfg
->mvendorid
, &pair
->value
);
8881 case RISCV_HWPROBE_KEY_MARCHID
:
8882 __put_user(cfg
->marchid
, &pair
->value
);
8884 case RISCV_HWPROBE_KEY_MIMPID
:
8885 __put_user(cfg
->mimpid
, &pair
->value
);
8887 case RISCV_HWPROBE_KEY_BASE_BEHAVIOR
:
8888 value
= riscv_has_ext(env
, RVI
) &&
8889 riscv_has_ext(env
, RVM
) &&
8890 riscv_has_ext(env
, RVA
) ?
8891 RISCV_HWPROBE_BASE_BEHAVIOR_IMA
: 0;
8892 __put_user(value
, &pair
->value
);
8894 case RISCV_HWPROBE_KEY_IMA_EXT_0
:
8895 value
= riscv_has_ext(env
, RVF
) &&
8896 riscv_has_ext(env
, RVD
) ?
8897 RISCV_HWPROBE_IMA_FD
: 0;
8898 value
|= riscv_has_ext(env
, RVC
) ?
8899 RISCV_HWPROBE_IMA_C
: 0;
8900 value
|= riscv_has_ext(env
, RVV
) ?
8901 RISCV_HWPROBE_IMA_V
: 0;
8902 value
|= cfg
->ext_zba
?
8903 RISCV_HWPROBE_EXT_ZBA
: 0;
8904 value
|= cfg
->ext_zbb
?
8905 RISCV_HWPROBE_EXT_ZBB
: 0;
8906 value
|= cfg
->ext_zbs
?
8907 RISCV_HWPROBE_EXT_ZBS
: 0;
8908 value
|= cfg
->ext_zicboz
?
8909 RISCV_HWPROBE_EXT_ZICBOZ
: 0;
8910 value
|= cfg
->ext_zbc
?
8911 RISCV_HWPROBE_EXT_ZBC
: 0;
8912 value
|= cfg
->ext_zbkb
?
8913 RISCV_HWPROBE_EXT_ZBKB
: 0;
8914 value
|= cfg
->ext_zbkc
?
8915 RISCV_HWPROBE_EXT_ZBKC
: 0;
8916 value
|= cfg
->ext_zbkx
?
8917 RISCV_HWPROBE_EXT_ZBKX
: 0;
8918 value
|= cfg
->ext_zknd
?
8919 RISCV_HWPROBE_EXT_ZKND
: 0;
8920 value
|= cfg
->ext_zkne
?
8921 RISCV_HWPROBE_EXT_ZKNE
: 0;
8922 value
|= cfg
->ext_zknh
?
8923 RISCV_HWPROBE_EXT_ZKNH
: 0;
8924 value
|= cfg
->ext_zksed
?
8925 RISCV_HWPROBE_EXT_ZKSED
: 0;
8926 value
|= cfg
->ext_zksh
?
8927 RISCV_HWPROBE_EXT_ZKSH
: 0;
8928 value
|= cfg
->ext_zkt
?
8929 RISCV_HWPROBE_EXT_ZKT
: 0;
8930 value
|= cfg
->ext_zvbb
?
8931 RISCV_HWPROBE_EXT_ZVBB
: 0;
8932 value
|= cfg
->ext_zvbc
?
8933 RISCV_HWPROBE_EXT_ZVBC
: 0;
8934 value
|= cfg
->ext_zvkb
?
8935 RISCV_HWPROBE_EXT_ZVKB
: 0;
8936 value
|= cfg
->ext_zvkg
?
8937 RISCV_HWPROBE_EXT_ZVKG
: 0;
8938 value
|= cfg
->ext_zvkned
?
8939 RISCV_HWPROBE_EXT_ZVKNED
: 0;
8940 value
|= cfg
->ext_zvknha
?
8941 RISCV_HWPROBE_EXT_ZVKNHA
: 0;
8942 value
|= cfg
->ext_zvknhb
?
8943 RISCV_HWPROBE_EXT_ZVKNHB
: 0;
8944 value
|= cfg
->ext_zvksed
?
8945 RISCV_HWPROBE_EXT_ZVKSED
: 0;
8946 value
|= cfg
->ext_zvksh
?
8947 RISCV_HWPROBE_EXT_ZVKSH
: 0;
8948 value
|= cfg
->ext_zvkt
?
8949 RISCV_HWPROBE_EXT_ZVKT
: 0;
8950 value
|= cfg
->ext_zfh
?
8951 RISCV_HWPROBE_EXT_ZFH
: 0;
8952 value
|= cfg
->ext_zfhmin
?
8953 RISCV_HWPROBE_EXT_ZFHMIN
: 0;
8954 value
|= cfg
->ext_zihintntl
?
8955 RISCV_HWPROBE_EXT_ZIHINTNTL
: 0;
8956 value
|= cfg
->ext_zvfh
?
8957 RISCV_HWPROBE_EXT_ZVFH
: 0;
8958 value
|= cfg
->ext_zvfhmin
?
8959 RISCV_HWPROBE_EXT_ZVFHMIN
: 0;
8960 value
|= cfg
->ext_zfa
?
8961 RISCV_HWPROBE_EXT_ZFA
: 0;
8962 value
|= cfg
->ext_ztso
?
8963 RISCV_HWPROBE_EXT_ZTSO
: 0;
8964 value
|= cfg
->ext_zacas
?
8965 RISCV_HWPROBE_EXT_ZACAS
: 0;
8966 value
|= cfg
->ext_zicond
?
8967 RISCV_HWPROBE_EXT_ZICOND
: 0;
8968 __put_user(value
, &pair
->value
);
8970 case RISCV_HWPROBE_KEY_CPUPERF_0
:
8971 __put_user(RISCV_HWPROBE_MISALIGNED_FAST
, &pair
->value
);
8973 case RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE
:
8974 value
= cfg
->ext_zicboz
? cfg
->cboz_blocksize
: 0;
8975 __put_user(value
, &pair
->value
);
8978 __put_user(-1, &pair
->key
);
8984 static int cpu_set_valid(abi_long arg3
, abi_long arg4
)
8987 size_t host_mask_size
, target_mask_size
;
8988 unsigned long *host_mask
;
8991 * cpu_set_t represent CPU masks as bit masks of type unsigned long *.
8992 * arg3 contains the cpu count.
8994 tmp
= (8 * sizeof(abi_ulong
));
8995 target_mask_size
= ((arg3
+ tmp
- 1) / tmp
) * sizeof(abi_ulong
);
8996 host_mask_size
= (target_mask_size
+ (sizeof(*host_mask
) - 1)) &
8997 ~(sizeof(*host_mask
) - 1);
8999 host_mask
= alloca(host_mask_size
);
9001 ret
= target_to_host_cpu_mask(host_mask
, host_mask_size
,
9002 arg4
, target_mask_size
);
9007 for (i
= 0 ; i
< host_mask_size
/ sizeof(*host_mask
); i
++) {
9008 if (host_mask
[i
] != 0) {
9012 return -TARGET_EINVAL
;
9015 static abi_long
do_riscv_hwprobe(CPUArchState
*cpu_env
, abi_long arg1
,
9016 abi_long arg2
, abi_long arg3
,
9017 abi_long arg4
, abi_long arg5
)
9020 struct riscv_hwprobe
*host_pairs
;
9022 /* flags must be 0 */
9024 return -TARGET_EINVAL
;
9029 ret
= cpu_set_valid(arg3
, arg4
);
9033 } else if (arg4
!= 0) {
9034 return -TARGET_EINVAL
;
9042 host_pairs
= lock_user(VERIFY_WRITE
, arg1
,
9043 sizeof(*host_pairs
) * (size_t)arg2
, 0);
9044 if (host_pairs
== NULL
) {
9045 return -TARGET_EFAULT
;
9047 risc_hwprobe_fill_pairs(cpu_env
, host_pairs
, arg2
);
9048 unlock_user(host_pairs
, arg1
, sizeof(*host_pairs
) * (size_t)arg2
);
9051 #endif /* TARGET_NR_riscv_hwprobe */
9053 #if defined(TARGET_NR_pivot_root) && defined(__NR_pivot_root)
9054 _syscall2(int, pivot_root
, const char *, new_root
, const char *, put_old
)
9057 #if defined(TARGET_NR_open_tree) && defined(__NR_open_tree)
9058 #define __NR_sys_open_tree __NR_open_tree
9059 _syscall3(int, sys_open_tree
, int, __dfd
, const char *, __filename
,
9060 unsigned int, __flags
)
9063 #if defined(TARGET_NR_move_mount) && defined(__NR_move_mount)
9064 #define __NR_sys_move_mount __NR_move_mount
9065 _syscall5(int, sys_move_mount
, int, __from_dfd
, const char *, __from_pathname
,
9066 int, __to_dfd
, const char *, __to_pathname
, unsigned int, flag
)
9069 /* This is an internal helper for do_syscall so that it is easier
9070 * to have a single return point, so that actions, such as logging
9071 * of syscall results, can be performed.
9072 * All errnos that do_syscall() returns must be -TARGET_<errcode>.
9074 static abi_long
do_syscall1(CPUArchState
*cpu_env
, int num
, abi_long arg1
,
9075 abi_long arg2
, abi_long arg3
, abi_long arg4
,
9076 abi_long arg5
, abi_long arg6
, abi_long arg7
,
9079 CPUState
*cpu
= env_cpu(cpu_env
);
9081 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \
9082 || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \
9083 || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) \
9084 || defined(TARGET_NR_statx)
9087 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \
9088 || defined(TARGET_NR_fstatfs)
9094 case TARGET_NR_exit
:
9095 /* In old applications this may be used to implement _exit(2).
9096 However in threaded applications it is used for thread termination,
9097 and _exit_group is used for application termination.
9098 Do thread termination if we have more then one thread. */
9100 if (block_signals()) {
9101 return -QEMU_ERESTARTSYS
;
9104 pthread_mutex_lock(&clone_lock
);
9106 if (CPU_NEXT(first_cpu
)) {
9107 TaskState
*ts
= get_task_state(cpu
);
9109 if (ts
->child_tidptr
) {
9110 put_user_u32(0, ts
->child_tidptr
);
9111 do_sys_futex(g2h(cpu
, ts
->child_tidptr
),
9112 FUTEX_WAKE
, INT_MAX
, NULL
, NULL
, 0);
9115 object_unparent(OBJECT(cpu
));
9116 object_unref(OBJECT(cpu
));
9118 * At this point the CPU should be unrealized and removed
9119 * from cpu lists. We can clean-up the rest of the thread
9120 * data without the lock held.
9123 pthread_mutex_unlock(&clone_lock
);
9127 rcu_unregister_thread();
9131 pthread_mutex_unlock(&clone_lock
);
9132 preexit_cleanup(cpu_env
, arg1
);
9134 return 0; /* avoid warning */
9135 case TARGET_NR_read
:
9136 if (arg2
== 0 && arg3
== 0) {
9137 return get_errno(safe_read(arg1
, 0, 0));
9139 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
9140 return -TARGET_EFAULT
;
9141 ret
= get_errno(safe_read(arg1
, p
, arg3
));
9143 fd_trans_host_to_target_data(arg1
)) {
9144 ret
= fd_trans_host_to_target_data(arg1
)(p
, ret
);
9146 unlock_user(p
, arg2
, ret
);
9149 case TARGET_NR_write
:
9150 if (arg2
== 0 && arg3
== 0) {
9151 return get_errno(safe_write(arg1
, 0, 0));
9153 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
9154 return -TARGET_EFAULT
;
9155 if (fd_trans_target_to_host_data(arg1
)) {
9156 void *copy
= g_malloc(arg3
);
9157 memcpy(copy
, p
, arg3
);
9158 ret
= fd_trans_target_to_host_data(arg1
)(copy
, arg3
);
9160 ret
= get_errno(safe_write(arg1
, copy
, ret
));
9164 ret
= get_errno(safe_write(arg1
, p
, arg3
));
9166 unlock_user(p
, arg2
, 0);
9169 #ifdef TARGET_NR_open
9170 case TARGET_NR_open
:
9171 if (!(p
= lock_user_string(arg1
)))
9172 return -TARGET_EFAULT
;
9173 ret
= get_errno(do_guest_openat(cpu_env
, AT_FDCWD
, p
,
9174 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
9176 fd_trans_unregister(ret
);
9177 unlock_user(p
, arg1
, 0);
9180 case TARGET_NR_openat
:
9181 if (!(p
= lock_user_string(arg2
)))
9182 return -TARGET_EFAULT
;
9183 ret
= get_errno(do_guest_openat(cpu_env
, arg1
, p
,
9184 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
9186 fd_trans_unregister(ret
);
9187 unlock_user(p
, arg2
, 0);
9189 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
9190 case TARGET_NR_name_to_handle_at
:
9191 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
9194 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
9195 case TARGET_NR_open_by_handle_at
:
9196 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
9197 fd_trans_unregister(ret
);
9200 #if defined(__NR_pidfd_open) && defined(TARGET_NR_pidfd_open)
9201 case TARGET_NR_pidfd_open
:
9202 return get_errno(pidfd_open(arg1
, arg2
));
9204 #if defined(__NR_pidfd_send_signal) && defined(TARGET_NR_pidfd_send_signal)
9205 case TARGET_NR_pidfd_send_signal
:
9207 siginfo_t uinfo
, *puinfo
;
9210 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
9212 return -TARGET_EFAULT
;
9214 target_to_host_siginfo(&uinfo
, p
);
9215 unlock_user(p
, arg3
, 0);
9220 ret
= get_errno(pidfd_send_signal(arg1
, target_to_host_signal(arg2
),
9225 #if defined(__NR_pidfd_getfd) && defined(TARGET_NR_pidfd_getfd)
9226 case TARGET_NR_pidfd_getfd
:
9227 return get_errno(pidfd_getfd(arg1
, arg2
, arg3
));
9229 case TARGET_NR_close
:
9230 fd_trans_unregister(arg1
);
9231 return get_errno(close(arg1
));
9232 #if defined(__NR_close_range) && defined(TARGET_NR_close_range)
9233 case TARGET_NR_close_range
:
9234 ret
= get_errno(sys_close_range(arg1
, arg2
, arg3
));
9235 if (ret
== 0 && !(arg3
& CLOSE_RANGE_CLOEXEC
)) {
9237 maxfd
= MIN(arg2
, target_fd_max
);
9238 for (fd
= arg1
; fd
< maxfd
; fd
++) {
9239 fd_trans_unregister(fd
);
9246 return do_brk(arg1
);
9247 #ifdef TARGET_NR_fork
9248 case TARGET_NR_fork
:
9249 return get_errno(do_fork(cpu_env
, TARGET_SIGCHLD
, 0, 0, 0, 0));
9251 #ifdef TARGET_NR_waitpid
9252 case TARGET_NR_waitpid
:
9255 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, 0));
9256 if (!is_error(ret
) && arg2
&& ret
9257 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
9258 return -TARGET_EFAULT
;
9262 #ifdef TARGET_NR_waitid
9263 case TARGET_NR_waitid
:
9268 ret
= get_errno(safe_waitid(arg1
, arg2
, (arg3
? &info
: NULL
),
9269 arg4
, (arg5
? &ru
: NULL
)));
9270 if (!is_error(ret
)) {
9272 p
= lock_user(VERIFY_WRITE
, arg3
,
9273 sizeof(target_siginfo_t
), 0);
9275 return -TARGET_EFAULT
;
9277 host_to_target_siginfo(p
, &info
);
9278 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
9280 if (arg5
&& host_to_target_rusage(arg5
, &ru
)) {
9281 return -TARGET_EFAULT
;
9287 #ifdef TARGET_NR_creat /* not on alpha */
9288 case TARGET_NR_creat
:
9289 if (!(p
= lock_user_string(arg1
)))
9290 return -TARGET_EFAULT
;
9291 ret
= get_errno(creat(p
, arg2
));
9292 fd_trans_unregister(ret
);
9293 unlock_user(p
, arg1
, 0);
9296 #ifdef TARGET_NR_link
9297 case TARGET_NR_link
:
9300 p
= lock_user_string(arg1
);
9301 p2
= lock_user_string(arg2
);
9303 ret
= -TARGET_EFAULT
;
9305 ret
= get_errno(link(p
, p2
));
9306 unlock_user(p2
, arg2
, 0);
9307 unlock_user(p
, arg1
, 0);
9311 #if defined(TARGET_NR_linkat)
9312 case TARGET_NR_linkat
:
9316 return -TARGET_EFAULT
;
9317 p
= lock_user_string(arg2
);
9318 p2
= lock_user_string(arg4
);
9320 ret
= -TARGET_EFAULT
;
9322 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
9323 unlock_user(p
, arg2
, 0);
9324 unlock_user(p2
, arg4
, 0);
9328 #ifdef TARGET_NR_unlink
9329 case TARGET_NR_unlink
:
9330 if (!(p
= lock_user_string(arg1
)))
9331 return -TARGET_EFAULT
;
9332 ret
= get_errno(unlink(p
));
9333 unlock_user(p
, arg1
, 0);
9336 #if defined(TARGET_NR_unlinkat)
9337 case TARGET_NR_unlinkat
:
9338 if (!(p
= lock_user_string(arg2
)))
9339 return -TARGET_EFAULT
;
9340 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
9341 unlock_user(p
, arg2
, 0);
9344 case TARGET_NR_execveat
:
9345 return do_execv(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, true);
9346 case TARGET_NR_execve
:
9347 return do_execv(cpu_env
, AT_FDCWD
, arg1
, arg2
, arg3
, 0, false);
9348 case TARGET_NR_chdir
:
9349 if (!(p
= lock_user_string(arg1
)))
9350 return -TARGET_EFAULT
;
9351 ret
= get_errno(chdir(p
));
9352 unlock_user(p
, arg1
, 0);
9354 #ifdef TARGET_NR_time
9355 case TARGET_NR_time
:
9358 ret
= get_errno(time(&host_time
));
9361 && put_user_sal(host_time
, arg1
))
9362 return -TARGET_EFAULT
;
9366 #ifdef TARGET_NR_mknod
9367 case TARGET_NR_mknod
:
9368 if (!(p
= lock_user_string(arg1
)))
9369 return -TARGET_EFAULT
;
9370 ret
= get_errno(mknod(p
, arg2
, arg3
));
9371 unlock_user(p
, arg1
, 0);
9374 #if defined(TARGET_NR_mknodat)
9375 case TARGET_NR_mknodat
:
9376 if (!(p
= lock_user_string(arg2
)))
9377 return -TARGET_EFAULT
;
9378 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
9379 unlock_user(p
, arg2
, 0);
9382 #ifdef TARGET_NR_chmod
9383 case TARGET_NR_chmod
:
9384 if (!(p
= lock_user_string(arg1
)))
9385 return -TARGET_EFAULT
;
9386 ret
= get_errno(chmod(p
, arg2
));
9387 unlock_user(p
, arg1
, 0);
9390 #ifdef TARGET_NR_lseek
9391 case TARGET_NR_lseek
:
9392 return get_errno(lseek(arg1
, arg2
, arg3
));
9394 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
9395 /* Alpha specific */
9396 case TARGET_NR_getxpid
:
9397 cpu_env
->ir
[IR_A4
] = getppid();
9398 return get_errno(getpid());
9400 #ifdef TARGET_NR_getpid
9401 case TARGET_NR_getpid
:
9402 return get_errno(getpid());
9404 case TARGET_NR_mount
:
9406 /* need to look at the data field */
9410 p
= lock_user_string(arg1
);
9412 return -TARGET_EFAULT
;
9418 p2
= lock_user_string(arg2
);
9421 unlock_user(p
, arg1
, 0);
9423 return -TARGET_EFAULT
;
9427 p3
= lock_user_string(arg3
);
9430 unlock_user(p
, arg1
, 0);
9432 unlock_user(p2
, arg2
, 0);
9433 return -TARGET_EFAULT
;
9439 /* FIXME - arg5 should be locked, but it isn't clear how to
9440 * do that since it's not guaranteed to be a NULL-terminated
9444 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
9446 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(cpu
, arg5
));
9448 ret
= get_errno(ret
);
9451 unlock_user(p
, arg1
, 0);
9453 unlock_user(p2
, arg2
, 0);
9455 unlock_user(p3
, arg3
, 0);
9459 #if defined(TARGET_NR_umount) || defined(TARGET_NR_oldumount)
9460 #if defined(TARGET_NR_umount)
9461 case TARGET_NR_umount
:
9463 #if defined(TARGET_NR_oldumount)
9464 case TARGET_NR_oldumount
:
9466 if (!(p
= lock_user_string(arg1
)))
9467 return -TARGET_EFAULT
;
9468 ret
= get_errno(umount(p
));
9469 unlock_user(p
, arg1
, 0);
9472 #if defined(TARGET_NR_move_mount) && defined(__NR_move_mount)
9473 case TARGET_NR_move_mount
:
9477 if (!arg2
|| !arg4
) {
9478 return -TARGET_EFAULT
;
9481 p2
= lock_user_string(arg2
);
9483 return -TARGET_EFAULT
;
9486 p4
= lock_user_string(arg4
);
9488 unlock_user(p2
, arg2
, 0);
9489 return -TARGET_EFAULT
;
9491 ret
= get_errno(sys_move_mount(arg1
, p2
, arg3
, p4
, arg5
));
9493 unlock_user(p2
, arg2
, 0);
9494 unlock_user(p4
, arg4
, 0);
9499 #if defined(TARGET_NR_open_tree) && defined(__NR_open_tree)
9500 case TARGET_NR_open_tree
:
9506 return -TARGET_EFAULT
;
9509 p2
= lock_user_string(arg2
);
9511 return -TARGET_EFAULT
;
9514 host_flags
= arg3
& ~TARGET_O_CLOEXEC
;
9515 if (arg3
& TARGET_O_CLOEXEC
) {
9516 host_flags
|= O_CLOEXEC
;
9519 ret
= get_errno(sys_open_tree(arg1
, p2
, host_flags
));
9521 unlock_user(p2
, arg2
, 0);
9526 #ifdef TARGET_NR_stime /* not on alpha */
9527 case TARGET_NR_stime
:
9531 if (get_user_sal(ts
.tv_sec
, arg1
)) {
9532 return -TARGET_EFAULT
;
9534 return get_errno(clock_settime(CLOCK_REALTIME
, &ts
));
9537 #ifdef TARGET_NR_alarm /* not on alpha */
9538 case TARGET_NR_alarm
:
9541 #ifdef TARGET_NR_pause /* not on alpha */
9542 case TARGET_NR_pause
:
9543 if (!block_signals()) {
9544 sigsuspend(&get_task_state(cpu
)->signal_mask
);
9546 return -TARGET_EINTR
;
9548 #ifdef TARGET_NR_utime
9549 case TARGET_NR_utime
:
9551 struct utimbuf tbuf
, *host_tbuf
;
9552 struct target_utimbuf
*target_tbuf
;
9554 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
9555 return -TARGET_EFAULT
;
9556 tbuf
.actime
= tswapal(target_tbuf
->actime
);
9557 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
9558 unlock_user_struct(target_tbuf
, arg2
, 0);
9563 if (!(p
= lock_user_string(arg1
)))
9564 return -TARGET_EFAULT
;
9565 ret
= get_errno(utime(p
, host_tbuf
));
9566 unlock_user(p
, arg1
, 0);
9570 #ifdef TARGET_NR_utimes
9571 case TARGET_NR_utimes
:
9573 struct timeval
*tvp
, tv
[2];
9575 if (copy_from_user_timeval(&tv
[0], arg2
)
9576 || copy_from_user_timeval(&tv
[1],
9577 arg2
+ sizeof(struct target_timeval
)))
9578 return -TARGET_EFAULT
;
9583 if (!(p
= lock_user_string(arg1
)))
9584 return -TARGET_EFAULT
;
9585 ret
= get_errno(utimes(p
, tvp
));
9586 unlock_user(p
, arg1
, 0);
9590 #if defined(TARGET_NR_futimesat)
9591 case TARGET_NR_futimesat
:
9593 struct timeval
*tvp
, tv
[2];
9595 if (copy_from_user_timeval(&tv
[0], arg3
)
9596 || copy_from_user_timeval(&tv
[1],
9597 arg3
+ sizeof(struct target_timeval
)))
9598 return -TARGET_EFAULT
;
9603 if (!(p
= lock_user_string(arg2
))) {
9604 return -TARGET_EFAULT
;
9606 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
9607 unlock_user(p
, arg2
, 0);
9611 #ifdef TARGET_NR_access
9612 case TARGET_NR_access
:
9613 if (!(p
= lock_user_string(arg1
))) {
9614 return -TARGET_EFAULT
;
9616 ret
= get_errno(access(path(p
), arg2
));
9617 unlock_user(p
, arg1
, 0);
9620 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
9621 case TARGET_NR_faccessat
:
9622 if (!(p
= lock_user_string(arg2
))) {
9623 return -TARGET_EFAULT
;
9625 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
9626 unlock_user(p
, arg2
, 0);
9629 #if defined(TARGET_NR_faccessat2)
9630 case TARGET_NR_faccessat2
:
9631 if (!(p
= lock_user_string(arg2
))) {
9632 return -TARGET_EFAULT
;
9634 ret
= get_errno(faccessat(arg1
, p
, arg3
, arg4
));
9635 unlock_user(p
, arg2
, 0);
9638 #ifdef TARGET_NR_nice /* not on alpha */
9639 case TARGET_NR_nice
:
9640 return get_errno(nice(arg1
));
9642 case TARGET_NR_sync
:
9645 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
9646 case TARGET_NR_syncfs
:
9647 return get_errno(syncfs(arg1
));
9649 case TARGET_NR_kill
:
9650 return get_errno(safe_kill(arg1
, target_to_host_signal(arg2
)));
9651 #ifdef TARGET_NR_rename
9652 case TARGET_NR_rename
:
9655 p
= lock_user_string(arg1
);
9656 p2
= lock_user_string(arg2
);
9658 ret
= -TARGET_EFAULT
;
9660 ret
= get_errno(rename(p
, p2
));
9661 unlock_user(p2
, arg2
, 0);
9662 unlock_user(p
, arg1
, 0);
9666 #if defined(TARGET_NR_renameat)
9667 case TARGET_NR_renameat
:
9670 p
= lock_user_string(arg2
);
9671 p2
= lock_user_string(arg4
);
9673 ret
= -TARGET_EFAULT
;
9675 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
9676 unlock_user(p2
, arg4
, 0);
9677 unlock_user(p
, arg2
, 0);
9681 #if defined(TARGET_NR_renameat2)
9682 case TARGET_NR_renameat2
:
9685 p
= lock_user_string(arg2
);
9686 p2
= lock_user_string(arg4
);
9688 ret
= -TARGET_EFAULT
;
9690 ret
= get_errno(sys_renameat2(arg1
, p
, arg3
, p2
, arg5
));
9692 unlock_user(p2
, arg4
, 0);
9693 unlock_user(p
, arg2
, 0);
9697 #ifdef TARGET_NR_mkdir
9698 case TARGET_NR_mkdir
:
9699 if (!(p
= lock_user_string(arg1
)))
9700 return -TARGET_EFAULT
;
9701 ret
= get_errno(mkdir(p
, arg2
));
9702 unlock_user(p
, arg1
, 0);
9705 #if defined(TARGET_NR_mkdirat)
9706 case TARGET_NR_mkdirat
:
9707 if (!(p
= lock_user_string(arg2
)))
9708 return -TARGET_EFAULT
;
9709 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
9710 unlock_user(p
, arg2
, 0);
9713 #ifdef TARGET_NR_rmdir
9714 case TARGET_NR_rmdir
:
9715 if (!(p
= lock_user_string(arg1
)))
9716 return -TARGET_EFAULT
;
9717 ret
= get_errno(rmdir(p
));
9718 unlock_user(p
, arg1
, 0);
9722 ret
= get_errno(dup(arg1
));
9724 fd_trans_dup(arg1
, ret
);
9727 #ifdef TARGET_NR_pipe
9728 case TARGET_NR_pipe
:
9729 return do_pipe(cpu_env
, arg1
, 0, 0);
9731 #ifdef TARGET_NR_pipe2
9732 case TARGET_NR_pipe2
:
9733 return do_pipe(cpu_env
, arg1
,
9734 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
9736 case TARGET_NR_times
:
9738 struct target_tms
*tmsp
;
9740 ret
= get_errno(times(&tms
));
9742 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
9744 return -TARGET_EFAULT
;
9745 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
9746 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
9747 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
9748 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
9751 ret
= host_to_target_clock_t(ret
);
9754 case TARGET_NR_acct
:
9756 ret
= get_errno(acct(NULL
));
9758 if (!(p
= lock_user_string(arg1
))) {
9759 return -TARGET_EFAULT
;
9761 ret
= get_errno(acct(path(p
)));
9762 unlock_user(p
, arg1
, 0);
9765 #ifdef TARGET_NR_umount2
9766 case TARGET_NR_umount2
:
9767 if (!(p
= lock_user_string(arg1
)))
9768 return -TARGET_EFAULT
;
9769 ret
= get_errno(umount2(p
, arg2
));
9770 unlock_user(p
, arg1
, 0);
9773 case TARGET_NR_ioctl
:
9774 return do_ioctl(arg1
, arg2
, arg3
);
9775 #ifdef TARGET_NR_fcntl
9776 case TARGET_NR_fcntl
:
9777 return do_fcntl(arg1
, arg2
, arg3
);
9779 case TARGET_NR_setpgid
:
9780 return get_errno(setpgid(arg1
, arg2
));
9781 case TARGET_NR_umask
:
9782 return get_errno(umask(arg1
));
9783 case TARGET_NR_chroot
:
9784 if (!(p
= lock_user_string(arg1
)))
9785 return -TARGET_EFAULT
;
9786 ret
= get_errno(chroot(p
));
9787 unlock_user(p
, arg1
, 0);
9789 #ifdef TARGET_NR_dup2
9790 case TARGET_NR_dup2
:
9791 ret
= get_errno(dup2(arg1
, arg2
));
9793 fd_trans_dup(arg1
, arg2
);
9797 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
9798 case TARGET_NR_dup3
:
9802 if ((arg3
& ~TARGET_O_CLOEXEC
) != 0) {
9805 host_flags
= target_to_host_bitmask(arg3
, fcntl_flags_tbl
);
9806 ret
= get_errno(dup3(arg1
, arg2
, host_flags
));
9808 fd_trans_dup(arg1
, arg2
);
9813 #ifdef TARGET_NR_getppid /* not on alpha */
9814 case TARGET_NR_getppid
:
9815 return get_errno(getppid());
9817 #ifdef TARGET_NR_getpgrp
9818 case TARGET_NR_getpgrp
:
9819 return get_errno(getpgrp());
9821 case TARGET_NR_setsid
:
9822 return get_errno(setsid());
9823 #ifdef TARGET_NR_sigaction
9824 case TARGET_NR_sigaction
:
9826 #if defined(TARGET_MIPS)
9827 struct target_sigaction act
, oact
, *pact
, *old_act
;
9830 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
9831 return -TARGET_EFAULT
;
9832 act
._sa_handler
= old_act
->_sa_handler
;
9833 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
9834 act
.sa_flags
= old_act
->sa_flags
;
9835 unlock_user_struct(old_act
, arg2
, 0);
9841 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
, 0));
9843 if (!is_error(ret
) && arg3
) {
9844 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
9845 return -TARGET_EFAULT
;
9846 old_act
->_sa_handler
= oact
._sa_handler
;
9847 old_act
->sa_flags
= oact
.sa_flags
;
9848 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
9849 old_act
->sa_mask
.sig
[1] = 0;
9850 old_act
->sa_mask
.sig
[2] = 0;
9851 old_act
->sa_mask
.sig
[3] = 0;
9852 unlock_user_struct(old_act
, arg3
, 1);
9855 struct target_old_sigaction
*old_act
;
9856 struct target_sigaction act
, oact
, *pact
;
9858 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
9859 return -TARGET_EFAULT
;
9860 act
._sa_handler
= old_act
->_sa_handler
;
9861 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
9862 act
.sa_flags
= old_act
->sa_flags
;
9863 #ifdef TARGET_ARCH_HAS_SA_RESTORER
9864 act
.sa_restorer
= old_act
->sa_restorer
;
9866 unlock_user_struct(old_act
, arg2
, 0);
9871 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
, 0));
9872 if (!is_error(ret
) && arg3
) {
9873 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
9874 return -TARGET_EFAULT
;
9875 old_act
->_sa_handler
= oact
._sa_handler
;
9876 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
9877 old_act
->sa_flags
= oact
.sa_flags
;
9878 #ifdef TARGET_ARCH_HAS_SA_RESTORER
9879 old_act
->sa_restorer
= oact
.sa_restorer
;
9881 unlock_user_struct(old_act
, arg3
, 1);
9887 case TARGET_NR_rt_sigaction
:
9890 * For Alpha and SPARC this is a 5 argument syscall, with
9891 * a 'restorer' parameter which must be copied into the
9892 * sa_restorer field of the sigaction struct.
9893 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
9894 * and arg5 is the sigsetsize.
9896 #if defined(TARGET_ALPHA)
9897 target_ulong sigsetsize
= arg4
;
9898 target_ulong restorer
= arg5
;
9899 #elif defined(TARGET_SPARC)
9900 target_ulong restorer
= arg4
;
9901 target_ulong sigsetsize
= arg5
;
9903 target_ulong sigsetsize
= arg4
;
9904 target_ulong restorer
= 0;
9906 struct target_sigaction
*act
= NULL
;
9907 struct target_sigaction
*oact
= NULL
;
9909 if (sigsetsize
!= sizeof(target_sigset_t
)) {
9910 return -TARGET_EINVAL
;
9912 if (arg2
&& !lock_user_struct(VERIFY_READ
, act
, arg2
, 1)) {
9913 return -TARGET_EFAULT
;
9915 if (arg3
&& !lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
9916 ret
= -TARGET_EFAULT
;
9918 ret
= get_errno(do_sigaction(arg1
, act
, oact
, restorer
));
9920 unlock_user_struct(oact
, arg3
, 1);
9924 unlock_user_struct(act
, arg2
, 0);
9928 #ifdef TARGET_NR_sgetmask /* not on alpha */
9929 case TARGET_NR_sgetmask
:
9932 abi_ulong target_set
;
9933 ret
= do_sigprocmask(0, NULL
, &cur_set
);
9935 host_to_target_old_sigset(&target_set
, &cur_set
);
9941 #ifdef TARGET_NR_ssetmask /* not on alpha */
9942 case TARGET_NR_ssetmask
:
9945 abi_ulong target_set
= arg1
;
9946 target_to_host_old_sigset(&set
, &target_set
);
9947 ret
= do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
9949 host_to_target_old_sigset(&target_set
, &oset
);
9955 #ifdef TARGET_NR_sigprocmask
9956 case TARGET_NR_sigprocmask
:
9958 #if defined(TARGET_ALPHA)
9959 sigset_t set
, oldset
;
9964 case TARGET_SIG_BLOCK
:
9967 case TARGET_SIG_UNBLOCK
:
9970 case TARGET_SIG_SETMASK
:
9974 return -TARGET_EINVAL
;
9977 target_to_host_old_sigset(&set
, &mask
);
9979 ret
= do_sigprocmask(how
, &set
, &oldset
);
9980 if (!is_error(ret
)) {
9981 host_to_target_old_sigset(&mask
, &oldset
);
9983 cpu_env
->ir
[IR_V0
] = 0; /* force no error */
9986 sigset_t set
, oldset
, *set_ptr
;
9990 p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1);
9992 return -TARGET_EFAULT
;
9994 target_to_host_old_sigset(&set
, p
);
9995 unlock_user(p
, arg2
, 0);
9998 case TARGET_SIG_BLOCK
:
10001 case TARGET_SIG_UNBLOCK
:
10004 case TARGET_SIG_SETMASK
:
10008 return -TARGET_EINVAL
;
10014 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
10015 if (!is_error(ret
) && arg3
) {
10016 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
10017 return -TARGET_EFAULT
;
10018 host_to_target_old_sigset(p
, &oldset
);
10019 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
10025 case TARGET_NR_rt_sigprocmask
:
10028 sigset_t set
, oldset
, *set_ptr
;
10030 if (arg4
!= sizeof(target_sigset_t
)) {
10031 return -TARGET_EINVAL
;
10035 p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1);
10037 return -TARGET_EFAULT
;
10039 target_to_host_sigset(&set
, p
);
10040 unlock_user(p
, arg2
, 0);
10043 case TARGET_SIG_BLOCK
:
10046 case TARGET_SIG_UNBLOCK
:
10049 case TARGET_SIG_SETMASK
:
10053 return -TARGET_EINVAL
;
10059 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
10060 if (!is_error(ret
) && arg3
) {
10061 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
10062 return -TARGET_EFAULT
;
10063 host_to_target_sigset(p
, &oldset
);
10064 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
10068 #ifdef TARGET_NR_sigpending
10069 case TARGET_NR_sigpending
:
10072 ret
= get_errno(sigpending(&set
));
10073 if (!is_error(ret
)) {
10074 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
10075 return -TARGET_EFAULT
;
10076 host_to_target_old_sigset(p
, &set
);
10077 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
10082 case TARGET_NR_rt_sigpending
:
10086 /* Yes, this check is >, not != like most. We follow the kernel's
10087 * logic and it does it like this because it implements
10088 * NR_sigpending through the same code path, and in that case
10089 * the old_sigset_t is smaller in size.
10091 if (arg2
> sizeof(target_sigset_t
)) {
10092 return -TARGET_EINVAL
;
10095 ret
= get_errno(sigpending(&set
));
10096 if (!is_error(ret
)) {
10097 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
10098 return -TARGET_EFAULT
;
10099 host_to_target_sigset(p
, &set
);
10100 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
10104 #ifdef TARGET_NR_sigsuspend
10105 case TARGET_NR_sigsuspend
:
10109 #if defined(TARGET_ALPHA)
10110 TaskState
*ts
= get_task_state(cpu
);
10111 /* target_to_host_old_sigset will bswap back */
10112 abi_ulong mask
= tswapal(arg1
);
10113 set
= &ts
->sigsuspend_mask
;
10114 target_to_host_old_sigset(set
, &mask
);
10116 ret
= process_sigsuspend_mask(&set
, arg1
, sizeof(target_sigset_t
));
10121 ret
= get_errno(safe_rt_sigsuspend(set
, SIGSET_T_SIZE
));
10122 finish_sigsuspend_mask(ret
);
10126 case TARGET_NR_rt_sigsuspend
:
10130 ret
= process_sigsuspend_mask(&set
, arg1
, arg2
);
10134 ret
= get_errno(safe_rt_sigsuspend(set
, SIGSET_T_SIZE
));
10135 finish_sigsuspend_mask(ret
);
10138 #ifdef TARGET_NR_rt_sigtimedwait
10139 case TARGET_NR_rt_sigtimedwait
:
10142 struct timespec uts
, *puts
;
10145 if (arg4
!= sizeof(target_sigset_t
)) {
10146 return -TARGET_EINVAL
;
10149 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
10150 return -TARGET_EFAULT
;
10151 target_to_host_sigset(&set
, p
);
10152 unlock_user(p
, arg1
, 0);
10155 if (target_to_host_timespec(puts
, arg3
)) {
10156 return -TARGET_EFAULT
;
10161 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
10163 if (!is_error(ret
)) {
10165 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
10168 return -TARGET_EFAULT
;
10170 host_to_target_siginfo(p
, &uinfo
);
10171 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
10173 ret
= host_to_target_signal(ret
);
10178 #ifdef TARGET_NR_rt_sigtimedwait_time64
10179 case TARGET_NR_rt_sigtimedwait_time64
:
10182 struct timespec uts
, *puts
;
10185 if (arg4
!= sizeof(target_sigset_t
)) {
10186 return -TARGET_EINVAL
;
10189 p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1);
10191 return -TARGET_EFAULT
;
10193 target_to_host_sigset(&set
, p
);
10194 unlock_user(p
, arg1
, 0);
10197 if (target_to_host_timespec64(puts
, arg3
)) {
10198 return -TARGET_EFAULT
;
10203 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
10205 if (!is_error(ret
)) {
10207 p
= lock_user(VERIFY_WRITE
, arg2
,
10208 sizeof(target_siginfo_t
), 0);
10210 return -TARGET_EFAULT
;
10212 host_to_target_siginfo(p
, &uinfo
);
10213 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
10215 ret
= host_to_target_signal(ret
);
10220 case TARGET_NR_rt_sigqueueinfo
:
10224 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
10226 return -TARGET_EFAULT
;
10228 target_to_host_siginfo(&uinfo
, p
);
10229 unlock_user(p
, arg3
, 0);
10230 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, target_to_host_signal(arg2
), &uinfo
));
10233 case TARGET_NR_rt_tgsigqueueinfo
:
10237 p
= lock_user(VERIFY_READ
, arg4
, sizeof(target_siginfo_t
), 1);
10239 return -TARGET_EFAULT
;
10241 target_to_host_siginfo(&uinfo
, p
);
10242 unlock_user(p
, arg4
, 0);
10243 ret
= get_errno(sys_rt_tgsigqueueinfo(arg1
, arg2
, target_to_host_signal(arg3
), &uinfo
));
10246 #ifdef TARGET_NR_sigreturn
10247 case TARGET_NR_sigreturn
:
10248 if (block_signals()) {
10249 return -QEMU_ERESTARTSYS
;
10251 return do_sigreturn(cpu_env
);
10253 case TARGET_NR_rt_sigreturn
:
10254 if (block_signals()) {
10255 return -QEMU_ERESTARTSYS
;
10257 return do_rt_sigreturn(cpu_env
);
10258 case TARGET_NR_sethostname
:
10259 if (!(p
= lock_user_string(arg1
)))
10260 return -TARGET_EFAULT
;
10261 ret
= get_errno(sethostname(p
, arg2
));
10262 unlock_user(p
, arg1
, 0);
10264 #ifdef TARGET_NR_setrlimit
10265 case TARGET_NR_setrlimit
:
10267 int resource
= target_to_host_resource(arg1
);
10268 struct target_rlimit
*target_rlim
;
10269 struct rlimit rlim
;
10270 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
10271 return -TARGET_EFAULT
;
10272 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
10273 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
10274 unlock_user_struct(target_rlim
, arg2
, 0);
10276 * If we just passed through resource limit settings for memory then
10277 * they would also apply to QEMU's own allocations, and QEMU will
10278 * crash or hang or die if its allocations fail. Ideally we would
10279 * track the guest allocations in QEMU and apply the limits ourselves.
10280 * For now, just tell the guest the call succeeded but don't actually
10283 if (resource
!= RLIMIT_AS
&&
10284 resource
!= RLIMIT_DATA
&&
10285 resource
!= RLIMIT_STACK
) {
10286 return get_errno(setrlimit(resource
, &rlim
));
10292 #ifdef TARGET_NR_getrlimit
10293 case TARGET_NR_getrlimit
:
10295 int resource
= target_to_host_resource(arg1
);
10296 struct target_rlimit
*target_rlim
;
10297 struct rlimit rlim
;
10299 ret
= get_errno(getrlimit(resource
, &rlim
));
10300 if (!is_error(ret
)) {
10301 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
10302 return -TARGET_EFAULT
;
10303 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
10304 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
10305 unlock_user_struct(target_rlim
, arg2
, 1);
10310 case TARGET_NR_getrusage
:
10312 struct rusage rusage
;
10313 ret
= get_errno(getrusage(arg1
, &rusage
));
10314 if (!is_error(ret
)) {
10315 ret
= host_to_target_rusage(arg2
, &rusage
);
10319 #if defined(TARGET_NR_gettimeofday)
10320 case TARGET_NR_gettimeofday
:
10323 struct timezone tz
;
10325 ret
= get_errno(gettimeofday(&tv
, &tz
));
10326 if (!is_error(ret
)) {
10327 if (arg1
&& copy_to_user_timeval(arg1
, &tv
)) {
10328 return -TARGET_EFAULT
;
10330 if (arg2
&& copy_to_user_timezone(arg2
, &tz
)) {
10331 return -TARGET_EFAULT
;
10337 #if defined(TARGET_NR_settimeofday)
10338 case TARGET_NR_settimeofday
:
10340 struct timeval tv
, *ptv
= NULL
;
10341 struct timezone tz
, *ptz
= NULL
;
10344 if (copy_from_user_timeval(&tv
, arg1
)) {
10345 return -TARGET_EFAULT
;
10351 if (copy_from_user_timezone(&tz
, arg2
)) {
10352 return -TARGET_EFAULT
;
10357 return get_errno(settimeofday(ptv
, ptz
));
10360 #if defined(TARGET_NR_select)
10361 case TARGET_NR_select
:
10362 #if defined(TARGET_WANT_NI_OLD_SELECT)
10363 /* some architectures used to have old_select here
10364 * but now ENOSYS it.
10366 ret
= -TARGET_ENOSYS
;
10367 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
10368 ret
= do_old_select(arg1
);
10370 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
10374 #ifdef TARGET_NR_pselect6
10375 case TARGET_NR_pselect6
:
10376 return do_pselect6(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, false);
10378 #ifdef TARGET_NR_pselect6_time64
10379 case TARGET_NR_pselect6_time64
:
10380 return do_pselect6(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, true);
10382 #ifdef TARGET_NR_symlink
10383 case TARGET_NR_symlink
:
10386 p
= lock_user_string(arg1
);
10387 p2
= lock_user_string(arg2
);
10389 ret
= -TARGET_EFAULT
;
10391 ret
= get_errno(symlink(p
, p2
));
10392 unlock_user(p2
, arg2
, 0);
10393 unlock_user(p
, arg1
, 0);
10397 #if defined(TARGET_NR_symlinkat)
10398 case TARGET_NR_symlinkat
:
10401 p
= lock_user_string(arg1
);
10402 p2
= lock_user_string(arg3
);
10404 ret
= -TARGET_EFAULT
;
10406 ret
= get_errno(symlinkat(p
, arg2
, p2
));
10407 unlock_user(p2
, arg3
, 0);
10408 unlock_user(p
, arg1
, 0);
10412 #ifdef TARGET_NR_readlink
10413 case TARGET_NR_readlink
:
10416 p
= lock_user_string(arg1
);
10417 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
10418 ret
= get_errno(do_guest_readlink(p
, p2
, arg3
));
10419 unlock_user(p2
, arg2
, ret
);
10420 unlock_user(p
, arg1
, 0);
10424 #if defined(TARGET_NR_readlinkat)
10425 case TARGET_NR_readlinkat
:
10428 p
= lock_user_string(arg2
);
10429 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
10431 ret
= -TARGET_EFAULT
;
10432 } else if (!arg4
) {
10433 /* Short circuit this for the magic exe check. */
10434 ret
= -TARGET_EINVAL
;
10435 } else if (is_proc_myself((const char *)p
, "exe")) {
10437 * Don't worry about sign mismatch as earlier mapping
10438 * logic would have thrown a bad address error.
10440 ret
= MIN(strlen(exec_path
), arg4
);
10441 /* We cannot NUL terminate the string. */
10442 memcpy(p2
, exec_path
, ret
);
10444 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
10446 unlock_user(p2
, arg3
, ret
);
10447 unlock_user(p
, arg2
, 0);
10451 #ifdef TARGET_NR_swapon
10452 case TARGET_NR_swapon
:
10453 if (!(p
= lock_user_string(arg1
)))
10454 return -TARGET_EFAULT
;
10455 ret
= get_errno(swapon(p
, arg2
));
10456 unlock_user(p
, arg1
, 0);
10459 case TARGET_NR_reboot
:
10460 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
10461 /* arg4 must be ignored in all other cases */
10462 p
= lock_user_string(arg4
);
10464 return -TARGET_EFAULT
;
10466 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
10467 unlock_user(p
, arg4
, 0);
10469 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
10472 #ifdef TARGET_NR_mmap
10473 case TARGET_NR_mmap
:
10474 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
10475 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
10476 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
10477 || defined(TARGET_S390X)
10480 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
10481 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
10482 return -TARGET_EFAULT
;
10483 v1
= tswapal(v
[0]);
10484 v2
= tswapal(v
[1]);
10485 v3
= tswapal(v
[2]);
10486 v4
= tswapal(v
[3]);
10487 v5
= tswapal(v
[4]);
10488 v6
= tswapal(v
[5]);
10489 unlock_user(v
, arg1
, 0);
10490 return do_mmap(v1
, v2
, v3
, v4
, v5
, v6
);
10493 /* mmap pointers are always untagged */
10494 return do_mmap(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
10497 #ifdef TARGET_NR_mmap2
10498 case TARGET_NR_mmap2
:
10500 #define MMAP_SHIFT 12
10502 return do_mmap(arg1
, arg2
, arg3
, arg4
, arg5
,
10503 (off_t
)(abi_ulong
)arg6
<< MMAP_SHIFT
);
10505 case TARGET_NR_munmap
:
10506 arg1
= cpu_untagged_addr(cpu
, arg1
);
10507 return get_errno(target_munmap(arg1
, arg2
));
10508 case TARGET_NR_mprotect
:
10509 arg1
= cpu_untagged_addr(cpu
, arg1
);
10511 TaskState
*ts
= get_task_state(cpu
);
10512 /* Special hack to detect libc making the stack executable. */
10513 if ((arg3
& PROT_GROWSDOWN
)
10514 && arg1
>= ts
->info
->stack_limit
10515 && arg1
<= ts
->info
->start_stack
) {
10516 arg3
&= ~PROT_GROWSDOWN
;
10517 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
10518 arg1
= ts
->info
->stack_limit
;
10521 return get_errno(target_mprotect(arg1
, arg2
, arg3
));
10522 #ifdef TARGET_NR_mremap
10523 case TARGET_NR_mremap
:
10524 arg1
= cpu_untagged_addr(cpu
, arg1
);
10525 /* mremap new_addr (arg5) is always untagged */
10526 return get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
10528 /* ??? msync/mlock/munlock are broken for softmmu. */
10529 #ifdef TARGET_NR_msync
10530 case TARGET_NR_msync
:
10531 return get_errno(msync(g2h(cpu
, arg1
), arg2
,
10532 target_to_host_msync_arg(arg3
)));
10534 #ifdef TARGET_NR_mlock
10535 case TARGET_NR_mlock
:
10536 return get_errno(mlock(g2h(cpu
, arg1
), arg2
));
10538 #ifdef TARGET_NR_munlock
10539 case TARGET_NR_munlock
:
10540 return get_errno(munlock(g2h(cpu
, arg1
), arg2
));
10542 #ifdef TARGET_NR_mlockall
10543 case TARGET_NR_mlockall
:
10544 return get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
10546 #ifdef TARGET_NR_munlockall
10547 case TARGET_NR_munlockall
:
10548 return get_errno(munlockall());
10550 #ifdef TARGET_NR_truncate
10551 case TARGET_NR_truncate
:
10552 if (!(p
= lock_user_string(arg1
)))
10553 return -TARGET_EFAULT
;
10554 ret
= get_errno(truncate(p
, arg2
));
10555 unlock_user(p
, arg1
, 0);
10558 #ifdef TARGET_NR_ftruncate
10559 case TARGET_NR_ftruncate
:
10560 return get_errno(ftruncate(arg1
, arg2
));
10562 case TARGET_NR_fchmod
:
10563 return get_errno(fchmod(arg1
, arg2
));
10564 #if defined(TARGET_NR_fchmodat)
10565 case TARGET_NR_fchmodat
:
10566 if (!(p
= lock_user_string(arg2
)))
10567 return -TARGET_EFAULT
;
10568 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
10569 unlock_user(p
, arg2
, 0);
10572 case TARGET_NR_getpriority
:
10573 /* Note that negative values are valid for getpriority, so we must
10574 differentiate based on errno settings. */
10576 ret
= getpriority(arg1
, arg2
);
10577 if (ret
== -1 && errno
!= 0) {
10578 return -host_to_target_errno(errno
);
10580 #ifdef TARGET_ALPHA
10581 /* Return value is the unbiased priority. Signal no error. */
10582 cpu_env
->ir
[IR_V0
] = 0;
10584 /* Return value is a biased priority to avoid negative numbers. */
10588 case TARGET_NR_setpriority
:
10589 return get_errno(setpriority(arg1
, arg2
, arg3
));
10590 #ifdef TARGET_NR_statfs
10591 case TARGET_NR_statfs
:
10592 if (!(p
= lock_user_string(arg1
))) {
10593 return -TARGET_EFAULT
;
10595 ret
= get_errno(statfs(path(p
), &stfs
));
10596 unlock_user(p
, arg1
, 0);
10598 if (!is_error(ret
)) {
10599 struct target_statfs
*target_stfs
;
10601 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
10602 return -TARGET_EFAULT
;
10603 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
10604 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
10605 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
10606 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
10607 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
10608 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
10609 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
10610 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
10611 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
10612 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
10613 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
10614 #ifdef _STATFS_F_FLAGS
10615 __put_user(stfs
.f_flags
, &target_stfs
->f_flags
);
10617 __put_user(0, &target_stfs
->f_flags
);
10619 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
10620 unlock_user_struct(target_stfs
, arg2
, 1);
10624 #ifdef TARGET_NR_fstatfs
10625 case TARGET_NR_fstatfs
:
10626 ret
= get_errno(fstatfs(arg1
, &stfs
));
10627 goto convert_statfs
;
10629 #ifdef TARGET_NR_statfs64
10630 case TARGET_NR_statfs64
:
10631 if (!(p
= lock_user_string(arg1
))) {
10632 return -TARGET_EFAULT
;
10634 ret
= get_errno(statfs(path(p
), &stfs
));
10635 unlock_user(p
, arg1
, 0);
10637 if (!is_error(ret
)) {
10638 struct target_statfs64
*target_stfs
;
10640 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
10641 return -TARGET_EFAULT
;
10642 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
10643 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
10644 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
10645 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
10646 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
10647 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
10648 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
10649 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
10650 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
10651 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
10652 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
10653 #ifdef _STATFS_F_FLAGS
10654 __put_user(stfs
.f_flags
, &target_stfs
->f_flags
);
10656 __put_user(0, &target_stfs
->f_flags
);
10658 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
10659 unlock_user_struct(target_stfs
, arg3
, 1);
10662 case TARGET_NR_fstatfs64
:
10663 ret
= get_errno(fstatfs(arg1
, &stfs
));
10664 goto convert_statfs64
;
10666 #ifdef TARGET_NR_socketcall
10667 case TARGET_NR_socketcall
:
10668 return do_socketcall(arg1
, arg2
);
10670 #ifdef TARGET_NR_accept
10671 case TARGET_NR_accept
:
10672 return do_accept4(arg1
, arg2
, arg3
, 0);
10674 #ifdef TARGET_NR_accept4
10675 case TARGET_NR_accept4
:
10676 return do_accept4(arg1
, arg2
, arg3
, arg4
);
10678 #ifdef TARGET_NR_bind
10679 case TARGET_NR_bind
:
10680 return do_bind(arg1
, arg2
, arg3
);
10682 #ifdef TARGET_NR_connect
10683 case TARGET_NR_connect
:
10684 return do_connect(arg1
, arg2
, arg3
);
10686 #ifdef TARGET_NR_getpeername
10687 case TARGET_NR_getpeername
:
10688 return do_getpeername(arg1
, arg2
, arg3
);
10690 #ifdef TARGET_NR_getsockname
10691 case TARGET_NR_getsockname
:
10692 return do_getsockname(arg1
, arg2
, arg3
);
10694 #ifdef TARGET_NR_getsockopt
10695 case TARGET_NR_getsockopt
:
10696 return do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
10698 #ifdef TARGET_NR_listen
10699 case TARGET_NR_listen
:
10700 return get_errno(listen(arg1
, arg2
));
10702 #ifdef TARGET_NR_recv
10703 case TARGET_NR_recv
:
10704 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
10706 #ifdef TARGET_NR_recvfrom
10707 case TARGET_NR_recvfrom
:
10708 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
10710 #ifdef TARGET_NR_recvmsg
10711 case TARGET_NR_recvmsg
:
10712 return do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
10714 #ifdef TARGET_NR_send
10715 case TARGET_NR_send
:
10716 return do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
10718 #ifdef TARGET_NR_sendmsg
10719 case TARGET_NR_sendmsg
:
10720 return do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
10722 #ifdef TARGET_NR_sendmmsg
10723 case TARGET_NR_sendmmsg
:
10724 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
10726 #ifdef TARGET_NR_recvmmsg
10727 case TARGET_NR_recvmmsg
:
10728 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
10730 #ifdef TARGET_NR_sendto
10731 case TARGET_NR_sendto
:
10732 return do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
10734 #ifdef TARGET_NR_shutdown
10735 case TARGET_NR_shutdown
:
10736 return get_errno(shutdown(arg1
, arg2
));
10738 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
10739 case TARGET_NR_getrandom
:
10740 p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
10742 return -TARGET_EFAULT
;
10744 ret
= get_errno(getrandom(p
, arg2
, arg3
));
10745 unlock_user(p
, arg1
, ret
);
10748 #ifdef TARGET_NR_socket
10749 case TARGET_NR_socket
:
10750 return do_socket(arg1
, arg2
, arg3
);
10752 #ifdef TARGET_NR_socketpair
10753 case TARGET_NR_socketpair
:
10754 return do_socketpair(arg1
, arg2
, arg3
, arg4
);
10756 #ifdef TARGET_NR_setsockopt
10757 case TARGET_NR_setsockopt
:
10758 return do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
10760 #if defined(TARGET_NR_syslog)
10761 case TARGET_NR_syslog
:
10766 case TARGET_SYSLOG_ACTION_CLOSE
: /* Close log */
10767 case TARGET_SYSLOG_ACTION_OPEN
: /* Open log */
10768 case TARGET_SYSLOG_ACTION_CLEAR
: /* Clear ring buffer */
10769 case TARGET_SYSLOG_ACTION_CONSOLE_OFF
: /* Disable logging */
10770 case TARGET_SYSLOG_ACTION_CONSOLE_ON
: /* Enable logging */
10771 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL
: /* Set messages level */
10772 case TARGET_SYSLOG_ACTION_SIZE_UNREAD
: /* Number of chars */
10773 case TARGET_SYSLOG_ACTION_SIZE_BUFFER
: /* Size of the buffer */
10774 return get_errno(sys_syslog((int)arg1
, NULL
, (int)arg3
));
10775 case TARGET_SYSLOG_ACTION_READ
: /* Read from log */
10776 case TARGET_SYSLOG_ACTION_READ_CLEAR
: /* Read/clear msgs */
10777 case TARGET_SYSLOG_ACTION_READ_ALL
: /* Read last messages */
10780 return -TARGET_EINVAL
;
10785 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
10787 return -TARGET_EFAULT
;
10789 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
10790 unlock_user(p
, arg2
, arg3
);
10794 return -TARGET_EINVAL
;
10799 case TARGET_NR_setitimer
:
10801 struct itimerval value
, ovalue
, *pvalue
;
10805 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
10806 || copy_from_user_timeval(&pvalue
->it_value
,
10807 arg2
+ sizeof(struct target_timeval
)))
10808 return -TARGET_EFAULT
;
10812 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
10813 if (!is_error(ret
) && arg3
) {
10814 if (copy_to_user_timeval(arg3
,
10815 &ovalue
.it_interval
)
10816 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
10818 return -TARGET_EFAULT
;
10822 case TARGET_NR_getitimer
:
10824 struct itimerval value
;
10826 ret
= get_errno(getitimer(arg1
, &value
));
10827 if (!is_error(ret
) && arg2
) {
10828 if (copy_to_user_timeval(arg2
,
10829 &value
.it_interval
)
10830 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
10832 return -TARGET_EFAULT
;
10836 #ifdef TARGET_NR_stat
10837 case TARGET_NR_stat
:
10838 if (!(p
= lock_user_string(arg1
))) {
10839 return -TARGET_EFAULT
;
10841 ret
= get_errno(stat(path(p
), &st
));
10842 unlock_user(p
, arg1
, 0);
10845 #ifdef TARGET_NR_lstat
10846 case TARGET_NR_lstat
:
10847 if (!(p
= lock_user_string(arg1
))) {
10848 return -TARGET_EFAULT
;
10850 ret
= get_errno(lstat(path(p
), &st
));
10851 unlock_user(p
, arg1
, 0);
10854 #ifdef TARGET_NR_fstat
10855 case TARGET_NR_fstat
:
10857 ret
= get_errno(fstat(arg1
, &st
));
10858 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
10861 if (!is_error(ret
)) {
10862 struct target_stat
*target_st
;
10864 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
10865 return -TARGET_EFAULT
;
10866 memset(target_st
, 0, sizeof(*target_st
));
10867 __put_user(st
.st_dev
, &target_st
->st_dev
);
10868 __put_user(st
.st_ino
, &target_st
->st_ino
);
10869 __put_user(st
.st_mode
, &target_st
->st_mode
);
10870 __put_user(st
.st_uid
, &target_st
->st_uid
);
10871 __put_user(st
.st_gid
, &target_st
->st_gid
);
10872 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
10873 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
10874 __put_user(st
.st_size
, &target_st
->st_size
);
10875 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
10876 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
10877 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
10878 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
10879 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
10880 #if defined(HAVE_STRUCT_STAT_ST_ATIM) && defined(TARGET_STAT_HAVE_NSEC)
10881 __put_user(st
.st_atim
.tv_nsec
,
10882 &target_st
->target_st_atime_nsec
);
10883 __put_user(st
.st_mtim
.tv_nsec
,
10884 &target_st
->target_st_mtime_nsec
);
10885 __put_user(st
.st_ctim
.tv_nsec
,
10886 &target_st
->target_st_ctime_nsec
);
10888 unlock_user_struct(target_st
, arg2
, 1);
10893 case TARGET_NR_vhangup
:
10894 return get_errno(vhangup());
10895 #ifdef TARGET_NR_syscall
10896 case TARGET_NR_syscall
:
10897 return do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
10898 arg6
, arg7
, arg8
, 0);
10900 #if defined(TARGET_NR_wait4)
10901 case TARGET_NR_wait4
:
10904 abi_long status_ptr
= arg2
;
10905 struct rusage rusage
, *rusage_ptr
;
10906 abi_ulong target_rusage
= arg4
;
10907 abi_long rusage_err
;
10909 rusage_ptr
= &rusage
;
10912 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, rusage_ptr
));
10913 if (!is_error(ret
)) {
10914 if (status_ptr
&& ret
) {
10915 status
= host_to_target_waitstatus(status
);
10916 if (put_user_s32(status
, status_ptr
))
10917 return -TARGET_EFAULT
;
10919 if (target_rusage
) {
10920 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
10929 #ifdef TARGET_NR_swapoff
10930 case TARGET_NR_swapoff
:
10931 if (!(p
= lock_user_string(arg1
)))
10932 return -TARGET_EFAULT
;
10933 ret
= get_errno(swapoff(p
));
10934 unlock_user(p
, arg1
, 0);
10937 case TARGET_NR_sysinfo
:
10939 struct target_sysinfo
*target_value
;
10940 struct sysinfo value
;
10941 ret
= get_errno(sysinfo(&value
));
10942 if (!is_error(ret
) && arg1
)
10944 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
10945 return -TARGET_EFAULT
;
10946 __put_user(value
.uptime
, &target_value
->uptime
);
10947 __put_user(value
.loads
[0], &target_value
->loads
[0]);
10948 __put_user(value
.loads
[1], &target_value
->loads
[1]);
10949 __put_user(value
.loads
[2], &target_value
->loads
[2]);
10950 __put_user(value
.totalram
, &target_value
->totalram
);
10951 __put_user(value
.freeram
, &target_value
->freeram
);
10952 __put_user(value
.sharedram
, &target_value
->sharedram
);
10953 __put_user(value
.bufferram
, &target_value
->bufferram
);
10954 __put_user(value
.totalswap
, &target_value
->totalswap
);
10955 __put_user(value
.freeswap
, &target_value
->freeswap
);
10956 __put_user(value
.procs
, &target_value
->procs
);
10957 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
10958 __put_user(value
.freehigh
, &target_value
->freehigh
);
10959 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
10960 unlock_user_struct(target_value
, arg1
, 1);
10964 #ifdef TARGET_NR_ipc
10965 case TARGET_NR_ipc
:
10966 return do_ipc(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
10968 #ifdef TARGET_NR_semget
10969 case TARGET_NR_semget
:
10970 return get_errno(semget(arg1
, arg2
, arg3
));
10972 #ifdef TARGET_NR_semop
10973 case TARGET_NR_semop
:
10974 return do_semtimedop(arg1
, arg2
, arg3
, 0, false);
10976 #ifdef TARGET_NR_semtimedop
10977 case TARGET_NR_semtimedop
:
10978 return do_semtimedop(arg1
, arg2
, arg3
, arg4
, false);
10980 #ifdef TARGET_NR_semtimedop_time64
10981 case TARGET_NR_semtimedop_time64
:
10982 return do_semtimedop(arg1
, arg2
, arg3
, arg4
, true);
10984 #ifdef TARGET_NR_semctl
10985 case TARGET_NR_semctl
:
10986 return do_semctl(arg1
, arg2
, arg3
, arg4
);
10988 #ifdef TARGET_NR_msgctl
10989 case TARGET_NR_msgctl
:
10990 return do_msgctl(arg1
, arg2
, arg3
);
10992 #ifdef TARGET_NR_msgget
10993 case TARGET_NR_msgget
:
10994 return get_errno(msgget(arg1
, arg2
));
10996 #ifdef TARGET_NR_msgrcv
10997 case TARGET_NR_msgrcv
:
10998 return do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
11000 #ifdef TARGET_NR_msgsnd
11001 case TARGET_NR_msgsnd
:
11002 return do_msgsnd(arg1
, arg2
, arg3
, arg4
);
11004 #ifdef TARGET_NR_shmget
11005 case TARGET_NR_shmget
:
11006 return get_errno(shmget(arg1
, arg2
, arg3
));
11008 #ifdef TARGET_NR_shmctl
11009 case TARGET_NR_shmctl
:
11010 return do_shmctl(arg1
, arg2
, arg3
);
11012 #ifdef TARGET_NR_shmat
11013 case TARGET_NR_shmat
:
11014 return target_shmat(cpu_env
, arg1
, arg2
, arg3
);
11016 #ifdef TARGET_NR_shmdt
11017 case TARGET_NR_shmdt
:
11018 return target_shmdt(arg1
);
11020 case TARGET_NR_fsync
:
11021 return get_errno(fsync(arg1
));
11022 case TARGET_NR_clone
:
11023 /* Linux manages to have three different orderings for its
11024 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
11025 * match the kernel's CONFIG_CLONE_* settings.
11026 * Microblaze is further special in that it uses a sixth
11027 * implicit argument to clone for the TLS pointer.
11029 #if defined(TARGET_MICROBLAZE)
11030 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
11031 #elif defined(TARGET_CLONE_BACKWARDS)
11032 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
11033 #elif defined(TARGET_CLONE_BACKWARDS2)
11034 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
11036 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
11039 #ifdef __NR_exit_group
11040 /* new thread calls */
11041 case TARGET_NR_exit_group
:
11042 preexit_cleanup(cpu_env
, arg1
);
11043 return get_errno(exit_group(arg1
));
11045 case TARGET_NR_setdomainname
:
11046 if (!(p
= lock_user_string(arg1
)))
11047 return -TARGET_EFAULT
;
11048 ret
= get_errno(setdomainname(p
, arg2
));
11049 unlock_user(p
, arg1
, 0);
11051 case TARGET_NR_uname
:
11052 /* no need to transcode because we use the linux syscall */
11054 struct new_utsname
* buf
;
11056 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
11057 return -TARGET_EFAULT
;
11058 ret
= get_errno(sys_uname(buf
));
11059 if (!is_error(ret
)) {
11060 /* Overwrite the native machine name with whatever is being
11062 g_strlcpy(buf
->machine
, cpu_to_uname_machine(cpu_env
),
11063 sizeof(buf
->machine
));
11064 /* Allow the user to override the reported release. */
11065 if (qemu_uname_release
&& *qemu_uname_release
) {
11066 g_strlcpy(buf
->release
, qemu_uname_release
,
11067 sizeof(buf
->release
));
11070 unlock_user_struct(buf
, arg1
, 1);
11074 case TARGET_NR_modify_ldt
:
11075 return do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
11076 #if !defined(TARGET_X86_64)
11077 case TARGET_NR_vm86
:
11078 return do_vm86(cpu_env
, arg1
, arg2
);
11081 #if defined(TARGET_NR_adjtimex)
11082 case TARGET_NR_adjtimex
:
11084 struct timex host_buf
;
11086 if (target_to_host_timex(&host_buf
, arg1
) != 0) {
11087 return -TARGET_EFAULT
;
11089 ret
= get_errno(adjtimex(&host_buf
));
11090 if (!is_error(ret
)) {
11091 if (host_to_target_timex(arg1
, &host_buf
) != 0) {
11092 return -TARGET_EFAULT
;
11098 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
11099 case TARGET_NR_clock_adjtime
:
11103 if (target_to_host_timex(&htx
, arg2
) != 0) {
11104 return -TARGET_EFAULT
;
11106 ret
= get_errno(clock_adjtime(arg1
, &htx
));
11107 if (!is_error(ret
) && host_to_target_timex(arg2
, &htx
)) {
11108 return -TARGET_EFAULT
;
11113 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
11114 case TARGET_NR_clock_adjtime64
:
11118 if (target_to_host_timex64(&htx
, arg2
) != 0) {
11119 return -TARGET_EFAULT
;
11121 ret
= get_errno(clock_adjtime(arg1
, &htx
));
11122 if (!is_error(ret
) && host_to_target_timex64(arg2
, &htx
)) {
11123 return -TARGET_EFAULT
;
11128 case TARGET_NR_getpgid
:
11129 return get_errno(getpgid(arg1
));
11130 case TARGET_NR_fchdir
:
11131 return get_errno(fchdir(arg1
));
11132 case TARGET_NR_personality
:
11133 return get_errno(personality(arg1
));
11134 #ifdef TARGET_NR__llseek /* Not on alpha */
11135 case TARGET_NR__llseek
:
11138 #if !defined(__NR_llseek)
11139 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | (abi_ulong
)arg3
, arg5
);
11141 ret
= get_errno(res
);
11146 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
11148 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
11149 return -TARGET_EFAULT
;
11154 #ifdef TARGET_NR_getdents
11155 case TARGET_NR_getdents
:
11156 return do_getdents(arg1
, arg2
, arg3
);
11157 #endif /* TARGET_NR_getdents */
11158 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
11159 case TARGET_NR_getdents64
:
11160 return do_getdents64(arg1
, arg2
, arg3
);
11161 #endif /* TARGET_NR_getdents64 */
11162 #if defined(TARGET_NR__newselect)
11163 case TARGET_NR__newselect
:
11164 return do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
11166 #ifdef TARGET_NR_poll
11167 case TARGET_NR_poll
:
11168 return do_ppoll(arg1
, arg2
, arg3
, arg4
, arg5
, false, false);
11170 #ifdef TARGET_NR_ppoll
11171 case TARGET_NR_ppoll
:
11172 return do_ppoll(arg1
, arg2
, arg3
, arg4
, arg5
, true, false);
11174 #ifdef TARGET_NR_ppoll_time64
11175 case TARGET_NR_ppoll_time64
:
11176 return do_ppoll(arg1
, arg2
, arg3
, arg4
, arg5
, true, true);
11178 case TARGET_NR_flock
:
11179 /* NOTE: the flock constant seems to be the same for every
11181 return get_errno(safe_flock(arg1
, arg2
));
11182 case TARGET_NR_readv
:
11184 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
11186 ret
= get_errno(safe_readv(arg1
, vec
, arg3
));
11187 unlock_iovec(vec
, arg2
, arg3
, 1);
11189 ret
= -host_to_target_errno(errno
);
11193 case TARGET_NR_writev
:
11195 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
11197 ret
= get_errno(safe_writev(arg1
, vec
, arg3
));
11198 unlock_iovec(vec
, arg2
, arg3
, 0);
11200 ret
= -host_to_target_errno(errno
);
11204 #if defined(TARGET_NR_preadv)
11205 case TARGET_NR_preadv
:
11207 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
11209 unsigned long low
, high
;
11211 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
11212 ret
= get_errno(safe_preadv(arg1
, vec
, arg3
, low
, high
));
11213 unlock_iovec(vec
, arg2
, arg3
, 1);
11215 ret
= -host_to_target_errno(errno
);
11220 #if defined(TARGET_NR_pwritev)
11221 case TARGET_NR_pwritev
:
11223 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
11225 unsigned long low
, high
;
11227 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
11228 ret
= get_errno(safe_pwritev(arg1
, vec
, arg3
, low
, high
));
11229 unlock_iovec(vec
, arg2
, arg3
, 0);
11231 ret
= -host_to_target_errno(errno
);
11236 case TARGET_NR_getsid
:
11237 return get_errno(getsid(arg1
));
11238 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
11239 case TARGET_NR_fdatasync
:
11240 return get_errno(fdatasync(arg1
));
11242 case TARGET_NR_sched_getaffinity
:
11244 unsigned int mask_size
;
11245 unsigned long *mask
;
11248 * sched_getaffinity needs multiples of ulong, so need to take
11249 * care of mismatches between target ulong and host ulong sizes.
11251 if (arg2
& (sizeof(abi_ulong
) - 1)) {
11252 return -TARGET_EINVAL
;
11254 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
11256 mask
= alloca(mask_size
);
11257 memset(mask
, 0, mask_size
);
11258 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
11260 if (!is_error(ret
)) {
11262 /* More data returned than the caller's buffer will fit.
11263 * This only happens if sizeof(abi_long) < sizeof(long)
11264 * and the caller passed us a buffer holding an odd number
11265 * of abi_longs. If the host kernel is actually using the
11266 * extra 4 bytes then fail EINVAL; otherwise we can just
11267 * ignore them and only copy the interesting part.
11269 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
11270 if (numcpus
> arg2
* 8) {
11271 return -TARGET_EINVAL
;
11276 if (host_to_target_cpu_mask(mask
, mask_size
, arg3
, ret
)) {
11277 return -TARGET_EFAULT
;
11282 case TARGET_NR_sched_setaffinity
:
11284 unsigned int mask_size
;
11285 unsigned long *mask
;
11288 * sched_setaffinity needs multiples of ulong, so need to take
11289 * care of mismatches between target ulong and host ulong sizes.
11291 if (arg2
& (sizeof(abi_ulong
) - 1)) {
11292 return -TARGET_EINVAL
;
11294 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
11295 mask
= alloca(mask_size
);
11297 ret
= target_to_host_cpu_mask(mask
, mask_size
, arg3
, arg2
);
11302 return get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
11304 case TARGET_NR_getcpu
:
11306 unsigned cpuid
, node
;
11307 ret
= get_errno(sys_getcpu(arg1
? &cpuid
: NULL
,
11308 arg2
? &node
: NULL
,
11310 if (is_error(ret
)) {
11313 if (arg1
&& put_user_u32(cpuid
, arg1
)) {
11314 return -TARGET_EFAULT
;
11316 if (arg2
&& put_user_u32(node
, arg2
)) {
11317 return -TARGET_EFAULT
;
11321 case TARGET_NR_sched_setparam
:
11323 struct target_sched_param
*target_schp
;
11324 struct sched_param schp
;
11327 return -TARGET_EINVAL
;
11329 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1)) {
11330 return -TARGET_EFAULT
;
11332 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
11333 unlock_user_struct(target_schp
, arg2
, 0);
11334 return get_errno(sys_sched_setparam(arg1
, &schp
));
11336 case TARGET_NR_sched_getparam
:
11338 struct target_sched_param
*target_schp
;
11339 struct sched_param schp
;
11342 return -TARGET_EINVAL
;
11344 ret
= get_errno(sys_sched_getparam(arg1
, &schp
));
11345 if (!is_error(ret
)) {
11346 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0)) {
11347 return -TARGET_EFAULT
;
11349 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
11350 unlock_user_struct(target_schp
, arg2
, 1);
11354 case TARGET_NR_sched_setscheduler
:
11356 struct target_sched_param
*target_schp
;
11357 struct sched_param schp
;
11359 return -TARGET_EINVAL
;
11361 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1)) {
11362 return -TARGET_EFAULT
;
11364 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
11365 unlock_user_struct(target_schp
, arg3
, 0);
11366 return get_errno(sys_sched_setscheduler(arg1
, arg2
, &schp
));
11368 case TARGET_NR_sched_getscheduler
:
11369 return get_errno(sys_sched_getscheduler(arg1
));
11370 case TARGET_NR_sched_getattr
:
11372 struct target_sched_attr
*target_scha
;
11373 struct sched_attr scha
;
11375 return -TARGET_EINVAL
;
11377 if (arg3
> sizeof(scha
)) {
11378 arg3
= sizeof(scha
);
11380 ret
= get_errno(sys_sched_getattr(arg1
, &scha
, arg3
, arg4
));
11381 if (!is_error(ret
)) {
11382 target_scha
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11383 if (!target_scha
) {
11384 return -TARGET_EFAULT
;
11386 target_scha
->size
= tswap32(scha
.size
);
11387 target_scha
->sched_policy
= tswap32(scha
.sched_policy
);
11388 target_scha
->sched_flags
= tswap64(scha
.sched_flags
);
11389 target_scha
->sched_nice
= tswap32(scha
.sched_nice
);
11390 target_scha
->sched_priority
= tswap32(scha
.sched_priority
);
11391 target_scha
->sched_runtime
= tswap64(scha
.sched_runtime
);
11392 target_scha
->sched_deadline
= tswap64(scha
.sched_deadline
);
11393 target_scha
->sched_period
= tswap64(scha
.sched_period
);
11394 if (scha
.size
> offsetof(struct sched_attr
, sched_util_min
)) {
11395 target_scha
->sched_util_min
= tswap32(scha
.sched_util_min
);
11396 target_scha
->sched_util_max
= tswap32(scha
.sched_util_max
);
11398 unlock_user(target_scha
, arg2
, arg3
);
11402 case TARGET_NR_sched_setattr
:
11404 struct target_sched_attr
*target_scha
;
11405 struct sched_attr scha
;
11409 return -TARGET_EINVAL
;
11411 if (get_user_u32(size
, arg2
)) {
11412 return -TARGET_EFAULT
;
11415 size
= offsetof(struct target_sched_attr
, sched_util_min
);
11417 if (size
< offsetof(struct target_sched_attr
, sched_util_min
)) {
11418 if (put_user_u32(sizeof(struct target_sched_attr
), arg2
)) {
11419 return -TARGET_EFAULT
;
11421 return -TARGET_E2BIG
;
11424 zeroed
= check_zeroed_user(arg2
, sizeof(struct target_sched_attr
), size
);
11427 } else if (zeroed
== 0) {
11428 if (put_user_u32(sizeof(struct target_sched_attr
), arg2
)) {
11429 return -TARGET_EFAULT
;
11431 return -TARGET_E2BIG
;
11433 if (size
> sizeof(struct target_sched_attr
)) {
11434 size
= sizeof(struct target_sched_attr
);
11437 target_scha
= lock_user(VERIFY_READ
, arg2
, size
, 1);
11438 if (!target_scha
) {
11439 return -TARGET_EFAULT
;
11442 scha
.sched_policy
= tswap32(target_scha
->sched_policy
);
11443 scha
.sched_flags
= tswap64(target_scha
->sched_flags
);
11444 scha
.sched_nice
= tswap32(target_scha
->sched_nice
);
11445 scha
.sched_priority
= tswap32(target_scha
->sched_priority
);
11446 scha
.sched_runtime
= tswap64(target_scha
->sched_runtime
);
11447 scha
.sched_deadline
= tswap64(target_scha
->sched_deadline
);
11448 scha
.sched_period
= tswap64(target_scha
->sched_period
);
11449 if (size
> offsetof(struct target_sched_attr
, sched_util_min
)) {
11450 scha
.sched_util_min
= tswap32(target_scha
->sched_util_min
);
11451 scha
.sched_util_max
= tswap32(target_scha
->sched_util_max
);
11453 unlock_user(target_scha
, arg2
, 0);
11454 return get_errno(sys_sched_setattr(arg1
, &scha
, arg3
));
11456 case TARGET_NR_sched_yield
:
11457 return get_errno(sched_yield());
11458 case TARGET_NR_sched_get_priority_max
:
11459 return get_errno(sched_get_priority_max(arg1
));
11460 case TARGET_NR_sched_get_priority_min
:
11461 return get_errno(sched_get_priority_min(arg1
));
11462 #ifdef TARGET_NR_sched_rr_get_interval
11463 case TARGET_NR_sched_rr_get_interval
:
11465 struct timespec ts
;
11466 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
11467 if (!is_error(ret
)) {
11468 ret
= host_to_target_timespec(arg2
, &ts
);
11473 #ifdef TARGET_NR_sched_rr_get_interval_time64
11474 case TARGET_NR_sched_rr_get_interval_time64
:
11476 struct timespec ts
;
11477 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
11478 if (!is_error(ret
)) {
11479 ret
= host_to_target_timespec64(arg2
, &ts
);
11484 #if defined(TARGET_NR_nanosleep)
11485 case TARGET_NR_nanosleep
:
11487 struct timespec req
, rem
;
11488 target_to_host_timespec(&req
, arg1
);
11489 ret
= get_errno(safe_nanosleep(&req
, &rem
));
11490 if (is_error(ret
) && arg2
) {
11491 host_to_target_timespec(arg2
, &rem
);
11496 case TARGET_NR_prctl
:
11497 return do_prctl(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
);
11499 #ifdef TARGET_NR_arch_prctl
11500 case TARGET_NR_arch_prctl
:
11501 return do_arch_prctl(cpu_env
, arg1
, arg2
);
11503 #ifdef TARGET_NR_pread64
11504 case TARGET_NR_pread64
:
11505 if (regpairs_aligned(cpu_env
, num
)) {
11509 if (arg2
== 0 && arg3
== 0) {
11510 /* Special-case NULL buffer and zero length, which should succeed */
11513 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11515 return -TARGET_EFAULT
;
11518 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
11519 unlock_user(p
, arg2
, ret
);
11521 case TARGET_NR_pwrite64
:
11522 if (regpairs_aligned(cpu_env
, num
)) {
11526 if (arg2
== 0 && arg3
== 0) {
11527 /* Special-case NULL buffer and zero length, which should succeed */
11530 p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1);
11532 return -TARGET_EFAULT
;
11535 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
11536 unlock_user(p
, arg2
, 0);
11539 case TARGET_NR_getcwd
:
11540 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
11541 return -TARGET_EFAULT
;
11542 ret
= get_errno(sys_getcwd1(p
, arg2
));
11543 unlock_user(p
, arg1
, ret
);
11545 case TARGET_NR_capget
:
11546 case TARGET_NR_capset
:
11548 struct target_user_cap_header
*target_header
;
11549 struct target_user_cap_data
*target_data
= NULL
;
11550 struct __user_cap_header_struct header
;
11551 struct __user_cap_data_struct data
[2];
11552 struct __user_cap_data_struct
*dataptr
= NULL
;
11553 int i
, target_datalen
;
11554 int data_items
= 1;
11556 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
11557 return -TARGET_EFAULT
;
11559 header
.version
= tswap32(target_header
->version
);
11560 header
.pid
= tswap32(target_header
->pid
);
11562 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
11563 /* Version 2 and up takes pointer to two user_data structs */
11567 target_datalen
= sizeof(*target_data
) * data_items
;
11570 if (num
== TARGET_NR_capget
) {
11571 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
11573 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
11575 if (!target_data
) {
11576 unlock_user_struct(target_header
, arg1
, 0);
11577 return -TARGET_EFAULT
;
11580 if (num
== TARGET_NR_capset
) {
11581 for (i
= 0; i
< data_items
; i
++) {
11582 data
[i
].effective
= tswap32(target_data
[i
].effective
);
11583 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
11584 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
11591 if (num
== TARGET_NR_capget
) {
11592 ret
= get_errno(capget(&header
, dataptr
));
11594 ret
= get_errno(capset(&header
, dataptr
));
11597 /* The kernel always updates version for both capget and capset */
11598 target_header
->version
= tswap32(header
.version
);
11599 unlock_user_struct(target_header
, arg1
, 1);
11602 if (num
== TARGET_NR_capget
) {
11603 for (i
= 0; i
< data_items
; i
++) {
11604 target_data
[i
].effective
= tswap32(data
[i
].effective
);
11605 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
11606 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
11608 unlock_user(target_data
, arg2
, target_datalen
);
11610 unlock_user(target_data
, arg2
, 0);
11615 case TARGET_NR_sigaltstack
:
11616 return do_sigaltstack(arg1
, arg2
, cpu_env
);
11618 #ifdef CONFIG_SENDFILE
11619 #ifdef TARGET_NR_sendfile
11620 case TARGET_NR_sendfile
:
11622 off_t
*offp
= NULL
;
11625 ret
= get_user_sal(off
, arg3
);
11626 if (is_error(ret
)) {
11631 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
11632 if (!is_error(ret
) && arg3
) {
11633 abi_long ret2
= put_user_sal(off
, arg3
);
11634 if (is_error(ret2
)) {
11641 #ifdef TARGET_NR_sendfile64
11642 case TARGET_NR_sendfile64
:
11644 off_t
*offp
= NULL
;
11647 ret
= get_user_s64(off
, arg3
);
11648 if (is_error(ret
)) {
11653 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
11654 if (!is_error(ret
) && arg3
) {
11655 abi_long ret2
= put_user_s64(off
, arg3
);
11656 if (is_error(ret2
)) {
11664 #ifdef TARGET_NR_vfork
11665 case TARGET_NR_vfork
:
11666 return get_errno(do_fork(cpu_env
,
11667 CLONE_VFORK
| CLONE_VM
| TARGET_SIGCHLD
,
11670 #ifdef TARGET_NR_ugetrlimit
11671 case TARGET_NR_ugetrlimit
:
11673 struct rlimit rlim
;
11674 int resource
= target_to_host_resource(arg1
);
11675 ret
= get_errno(getrlimit(resource
, &rlim
));
11676 if (!is_error(ret
)) {
11677 struct target_rlimit
*target_rlim
;
11678 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
11679 return -TARGET_EFAULT
;
11680 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
11681 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
11682 unlock_user_struct(target_rlim
, arg2
, 1);
11687 #ifdef TARGET_NR_truncate64
11688 case TARGET_NR_truncate64
:
11689 if (!(p
= lock_user_string(arg1
)))
11690 return -TARGET_EFAULT
;
11691 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
11692 unlock_user(p
, arg1
, 0);
11695 #ifdef TARGET_NR_ftruncate64
11696 case TARGET_NR_ftruncate64
:
11697 return target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
11699 #ifdef TARGET_NR_stat64
11700 case TARGET_NR_stat64
:
11701 if (!(p
= lock_user_string(arg1
))) {
11702 return -TARGET_EFAULT
;
11704 ret
= get_errno(stat(path(p
), &st
));
11705 unlock_user(p
, arg1
, 0);
11706 if (!is_error(ret
))
11707 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11710 #ifdef TARGET_NR_lstat64
11711 case TARGET_NR_lstat64
:
11712 if (!(p
= lock_user_string(arg1
))) {
11713 return -TARGET_EFAULT
;
11715 ret
= get_errno(lstat(path(p
), &st
));
11716 unlock_user(p
, arg1
, 0);
11717 if (!is_error(ret
))
11718 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11721 #ifdef TARGET_NR_fstat64
11722 case TARGET_NR_fstat64
:
11723 ret
= get_errno(fstat(arg1
, &st
));
11724 if (!is_error(ret
))
11725 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11728 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
11729 #ifdef TARGET_NR_fstatat64
11730 case TARGET_NR_fstatat64
:
11732 #ifdef TARGET_NR_newfstatat
11733 case TARGET_NR_newfstatat
:
11735 if (!(p
= lock_user_string(arg2
))) {
11736 return -TARGET_EFAULT
;
11738 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
11739 unlock_user(p
, arg2
, 0);
11740 if (!is_error(ret
))
11741 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
11744 #if defined(TARGET_NR_statx)
11745 case TARGET_NR_statx
:
11747 struct target_statx
*target_stx
;
11751 p
= lock_user_string(arg2
);
11753 return -TARGET_EFAULT
;
11755 #if defined(__NR_statx)
11758 * It is assumed that struct statx is architecture independent.
11760 struct target_statx host_stx
;
11763 ret
= get_errno(sys_statx(dirfd
, p
, flags
, mask
, &host_stx
));
11764 if (!is_error(ret
)) {
11765 if (host_to_target_statx(&host_stx
, arg5
) != 0) {
11766 unlock_user(p
, arg2
, 0);
11767 return -TARGET_EFAULT
;
11771 if (ret
!= -TARGET_ENOSYS
) {
11772 unlock_user(p
, arg2
, 0);
11777 ret
= get_errno(fstatat(dirfd
, path(p
), &st
, flags
));
11778 unlock_user(p
, arg2
, 0);
11780 if (!is_error(ret
)) {
11781 if (!lock_user_struct(VERIFY_WRITE
, target_stx
, arg5
, 0)) {
11782 return -TARGET_EFAULT
;
11784 memset(target_stx
, 0, sizeof(*target_stx
));
11785 __put_user(major(st
.st_dev
), &target_stx
->stx_dev_major
);
11786 __put_user(minor(st
.st_dev
), &target_stx
->stx_dev_minor
);
11787 __put_user(st
.st_ino
, &target_stx
->stx_ino
);
11788 __put_user(st
.st_mode
, &target_stx
->stx_mode
);
11789 __put_user(st
.st_uid
, &target_stx
->stx_uid
);
11790 __put_user(st
.st_gid
, &target_stx
->stx_gid
);
11791 __put_user(st
.st_nlink
, &target_stx
->stx_nlink
);
11792 __put_user(major(st
.st_rdev
), &target_stx
->stx_rdev_major
);
11793 __put_user(minor(st
.st_rdev
), &target_stx
->stx_rdev_minor
);
11794 __put_user(st
.st_size
, &target_stx
->stx_size
);
11795 __put_user(st
.st_blksize
, &target_stx
->stx_blksize
);
11796 __put_user(st
.st_blocks
, &target_stx
->stx_blocks
);
11797 __put_user(st
.st_atime
, &target_stx
->stx_atime
.tv_sec
);
11798 __put_user(st
.st_mtime
, &target_stx
->stx_mtime
.tv_sec
);
11799 __put_user(st
.st_ctime
, &target_stx
->stx_ctime
.tv_sec
);
11800 unlock_user_struct(target_stx
, arg5
, 1);
11805 #ifdef TARGET_NR_lchown
11806 case TARGET_NR_lchown
:
11807 if (!(p
= lock_user_string(arg1
)))
11808 return -TARGET_EFAULT
;
11809 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
11810 unlock_user(p
, arg1
, 0);
11813 #ifdef TARGET_NR_getuid
11814 case TARGET_NR_getuid
:
11815 return get_errno(high2lowuid(getuid()));
11817 #ifdef TARGET_NR_getgid
11818 case TARGET_NR_getgid
:
11819 return get_errno(high2lowgid(getgid()));
11821 #ifdef TARGET_NR_geteuid
11822 case TARGET_NR_geteuid
:
11823 return get_errno(high2lowuid(geteuid()));
11825 #ifdef TARGET_NR_getegid
11826 case TARGET_NR_getegid
:
11827 return get_errno(high2lowgid(getegid()));
11829 case TARGET_NR_setreuid
:
11830 return get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
11831 case TARGET_NR_setregid
:
11832 return get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
11833 case TARGET_NR_getgroups
:
11834 { /* the same code as for TARGET_NR_getgroups32 */
11835 int gidsetsize
= arg1
;
11836 target_id
*target_grouplist
;
11837 g_autofree gid_t
*grouplist
= NULL
;
11840 if (gidsetsize
> NGROUPS_MAX
|| gidsetsize
< 0) {
11841 return -TARGET_EINVAL
;
11843 if (gidsetsize
> 0) {
11844 grouplist
= g_try_new(gid_t
, gidsetsize
);
11846 return -TARGET_ENOMEM
;
11849 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
11850 if (!is_error(ret
) && gidsetsize
> 0) {
11851 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
,
11852 gidsetsize
* sizeof(target_id
), 0);
11853 if (!target_grouplist
) {
11854 return -TARGET_EFAULT
;
11856 for (i
= 0; i
< ret
; i
++) {
11857 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
11859 unlock_user(target_grouplist
, arg2
,
11860 gidsetsize
* sizeof(target_id
));
11864 case TARGET_NR_setgroups
:
11865 { /* the same code as for TARGET_NR_setgroups32 */
11866 int gidsetsize
= arg1
;
11867 target_id
*target_grouplist
;
11868 g_autofree gid_t
*grouplist
= NULL
;
11871 if (gidsetsize
> NGROUPS_MAX
|| gidsetsize
< 0) {
11872 return -TARGET_EINVAL
;
11874 if (gidsetsize
> 0) {
11875 grouplist
= g_try_new(gid_t
, gidsetsize
);
11877 return -TARGET_ENOMEM
;
11879 target_grouplist
= lock_user(VERIFY_READ
, arg2
,
11880 gidsetsize
* sizeof(target_id
), 1);
11881 if (!target_grouplist
) {
11882 return -TARGET_EFAULT
;
11884 for (i
= 0; i
< gidsetsize
; i
++) {
11885 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
11887 unlock_user(target_grouplist
, arg2
,
11888 gidsetsize
* sizeof(target_id
));
11890 return get_errno(sys_setgroups(gidsetsize
, grouplist
));
11892 case TARGET_NR_fchown
:
11893 return get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
11894 #if defined(TARGET_NR_fchownat)
11895 case TARGET_NR_fchownat
:
11896 if (!(p
= lock_user_string(arg2
)))
11897 return -TARGET_EFAULT
;
11898 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
11899 low2highgid(arg4
), arg5
));
11900 unlock_user(p
, arg2
, 0);
11903 #ifdef TARGET_NR_setresuid
11904 case TARGET_NR_setresuid
:
11905 return get_errno(sys_setresuid(low2highuid(arg1
),
11907 low2highuid(arg3
)));
11909 #ifdef TARGET_NR_getresuid
11910 case TARGET_NR_getresuid
:
11912 uid_t ruid
, euid
, suid
;
11913 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
11914 if (!is_error(ret
)) {
11915 if (put_user_id(high2lowuid(ruid
), arg1
)
11916 || put_user_id(high2lowuid(euid
), arg2
)
11917 || put_user_id(high2lowuid(suid
), arg3
))
11918 return -TARGET_EFAULT
;
11923 #ifdef TARGET_NR_getresgid
11924 case TARGET_NR_setresgid
:
11925 return get_errno(sys_setresgid(low2highgid(arg1
),
11927 low2highgid(arg3
)));
11929 #ifdef TARGET_NR_getresgid
11930 case TARGET_NR_getresgid
:
11932 gid_t rgid
, egid
, sgid
;
11933 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
11934 if (!is_error(ret
)) {
11935 if (put_user_id(high2lowgid(rgid
), arg1
)
11936 || put_user_id(high2lowgid(egid
), arg2
)
11937 || put_user_id(high2lowgid(sgid
), arg3
))
11938 return -TARGET_EFAULT
;
11943 #ifdef TARGET_NR_chown
11944 case TARGET_NR_chown
:
11945 if (!(p
= lock_user_string(arg1
)))
11946 return -TARGET_EFAULT
;
11947 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
11948 unlock_user(p
, arg1
, 0);
11951 case TARGET_NR_setuid
:
11952 return get_errno(sys_setuid(low2highuid(arg1
)));
11953 case TARGET_NR_setgid
:
11954 return get_errno(sys_setgid(low2highgid(arg1
)));
11955 case TARGET_NR_setfsuid
:
11956 return get_errno(setfsuid(arg1
));
11957 case TARGET_NR_setfsgid
:
11958 return get_errno(setfsgid(arg1
));
11960 #ifdef TARGET_NR_lchown32
11961 case TARGET_NR_lchown32
:
11962 if (!(p
= lock_user_string(arg1
)))
11963 return -TARGET_EFAULT
;
11964 ret
= get_errno(lchown(p
, arg2
, arg3
));
11965 unlock_user(p
, arg1
, 0);
11968 #ifdef TARGET_NR_getuid32
11969 case TARGET_NR_getuid32
:
11970 return get_errno(getuid());
11973 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
11974 /* Alpha specific */
11975 case TARGET_NR_getxuid
:
11979 cpu_env
->ir
[IR_A4
]=euid
;
11981 return get_errno(getuid());
11983 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
11984 /* Alpha specific */
11985 case TARGET_NR_getxgid
:
11989 cpu_env
->ir
[IR_A4
]=egid
;
11991 return get_errno(getgid());
11993 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
11994 /* Alpha specific */
11995 case TARGET_NR_osf_getsysinfo
:
11996 ret
= -TARGET_EOPNOTSUPP
;
11998 case TARGET_GSI_IEEE_FP_CONTROL
:
12000 uint64_t fpcr
= cpu_alpha_load_fpcr(cpu_env
);
12001 uint64_t swcr
= cpu_env
->swcr
;
12003 swcr
&= ~SWCR_STATUS_MASK
;
12004 swcr
|= (fpcr
>> 35) & SWCR_STATUS_MASK
;
12006 if (put_user_u64 (swcr
, arg2
))
12007 return -TARGET_EFAULT
;
12012 /* case GSI_IEEE_STATE_AT_SIGNAL:
12013 -- Not implemented in linux kernel.
12015 -- Retrieves current unaligned access state; not much used.
12016 case GSI_PROC_TYPE:
12017 -- Retrieves implver information; surely not used.
12018 case GSI_GET_HWRPB:
12019 -- Grabs a copy of the HWRPB; surely not used.
12024 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
12025 /* Alpha specific */
12026 case TARGET_NR_osf_setsysinfo
:
12027 ret
= -TARGET_EOPNOTSUPP
;
12029 case TARGET_SSI_IEEE_FP_CONTROL
:
12031 uint64_t swcr
, fpcr
;
12033 if (get_user_u64 (swcr
, arg2
)) {
12034 return -TARGET_EFAULT
;
12038 * The kernel calls swcr_update_status to update the
12039 * status bits from the fpcr at every point that it
12040 * could be queried. Therefore, we store the status
12041 * bits only in FPCR.
12043 cpu_env
->swcr
= swcr
& (SWCR_TRAP_ENABLE_MASK
| SWCR_MAP_MASK
);
12045 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
12046 fpcr
&= ((uint64_t)FPCR_DYN_MASK
<< 32);
12047 fpcr
|= alpha_ieee_swcr_to_fpcr(swcr
);
12048 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
12053 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
12055 uint64_t exc
, fpcr
, fex
;
12057 if (get_user_u64(exc
, arg2
)) {
12058 return -TARGET_EFAULT
;
12060 exc
&= SWCR_STATUS_MASK
;
12061 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
12063 /* Old exceptions are not signaled. */
12064 fex
= alpha_ieee_fpcr_to_swcr(fpcr
);
12066 fex
>>= SWCR_STATUS_TO_EXCSUM_SHIFT
;
12067 fex
&= (cpu_env
)->swcr
;
12069 /* Update the hardware fpcr. */
12070 fpcr
|= alpha_ieee_swcr_to_fpcr(exc
);
12071 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
12074 int si_code
= TARGET_FPE_FLTUNK
;
12075 target_siginfo_t info
;
12077 if (fex
& SWCR_TRAP_ENABLE_DNO
) {
12078 si_code
= TARGET_FPE_FLTUND
;
12080 if (fex
& SWCR_TRAP_ENABLE_INE
) {
12081 si_code
= TARGET_FPE_FLTRES
;
12083 if (fex
& SWCR_TRAP_ENABLE_UNF
) {
12084 si_code
= TARGET_FPE_FLTUND
;
12086 if (fex
& SWCR_TRAP_ENABLE_OVF
) {
12087 si_code
= TARGET_FPE_FLTOVF
;
12089 if (fex
& SWCR_TRAP_ENABLE_DZE
) {
12090 si_code
= TARGET_FPE_FLTDIV
;
12092 if (fex
& SWCR_TRAP_ENABLE_INV
) {
12093 si_code
= TARGET_FPE_FLTINV
;
12096 info
.si_signo
= SIGFPE
;
12098 info
.si_code
= si_code
;
12099 info
._sifields
._sigfault
._addr
= (cpu_env
)->pc
;
12100 queue_signal(cpu_env
, info
.si_signo
,
12101 QEMU_SI_FAULT
, &info
);
12107 /* case SSI_NVPAIRS:
12108 -- Used with SSIN_UACPROC to enable unaligned accesses.
12109 case SSI_IEEE_STATE_AT_SIGNAL:
12110 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
12111 -- Not implemented in linux kernel
12116 #ifdef TARGET_NR_osf_sigprocmask
12117 /* Alpha specific. */
12118 case TARGET_NR_osf_sigprocmask
:
12122 sigset_t set
, oldset
;
12125 case TARGET_SIG_BLOCK
:
12128 case TARGET_SIG_UNBLOCK
:
12131 case TARGET_SIG_SETMASK
:
12135 return -TARGET_EINVAL
;
12138 target_to_host_old_sigset(&set
, &mask
);
12139 ret
= do_sigprocmask(how
, &set
, &oldset
);
12141 host_to_target_old_sigset(&mask
, &oldset
);
12148 #ifdef TARGET_NR_getgid32
12149 case TARGET_NR_getgid32
:
12150 return get_errno(getgid());
12152 #ifdef TARGET_NR_geteuid32
12153 case TARGET_NR_geteuid32
:
12154 return get_errno(geteuid());
12156 #ifdef TARGET_NR_getegid32
12157 case TARGET_NR_getegid32
:
12158 return get_errno(getegid());
12160 #ifdef TARGET_NR_setreuid32
12161 case TARGET_NR_setreuid32
:
12162 return get_errno(setreuid(arg1
, arg2
));
12164 #ifdef TARGET_NR_setregid32
12165 case TARGET_NR_setregid32
:
12166 return get_errno(setregid(arg1
, arg2
));
12168 #ifdef TARGET_NR_getgroups32
12169 case TARGET_NR_getgroups32
:
12170 { /* the same code as for TARGET_NR_getgroups */
12171 int gidsetsize
= arg1
;
12172 uint32_t *target_grouplist
;
12173 g_autofree gid_t
*grouplist
= NULL
;
12176 if (gidsetsize
> NGROUPS_MAX
|| gidsetsize
< 0) {
12177 return -TARGET_EINVAL
;
12179 if (gidsetsize
> 0) {
12180 grouplist
= g_try_new(gid_t
, gidsetsize
);
12182 return -TARGET_ENOMEM
;
12185 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
12186 if (!is_error(ret
) && gidsetsize
> 0) {
12187 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
,
12188 gidsetsize
* 4, 0);
12189 if (!target_grouplist
) {
12190 return -TARGET_EFAULT
;
12192 for (i
= 0; i
< ret
; i
++) {
12193 target_grouplist
[i
] = tswap32(grouplist
[i
]);
12195 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
12200 #ifdef TARGET_NR_setgroups32
12201 case TARGET_NR_setgroups32
:
12202 { /* the same code as for TARGET_NR_setgroups */
12203 int gidsetsize
= arg1
;
12204 uint32_t *target_grouplist
;
12205 g_autofree gid_t
*grouplist
= NULL
;
12208 if (gidsetsize
> NGROUPS_MAX
|| gidsetsize
< 0) {
12209 return -TARGET_EINVAL
;
12211 if (gidsetsize
> 0) {
12212 grouplist
= g_try_new(gid_t
, gidsetsize
);
12214 return -TARGET_ENOMEM
;
12216 target_grouplist
= lock_user(VERIFY_READ
, arg2
,
12217 gidsetsize
* 4, 1);
12218 if (!target_grouplist
) {
12219 return -TARGET_EFAULT
;
12221 for (i
= 0; i
< gidsetsize
; i
++) {
12222 grouplist
[i
] = tswap32(target_grouplist
[i
]);
12224 unlock_user(target_grouplist
, arg2
, 0);
12226 return get_errno(sys_setgroups(gidsetsize
, grouplist
));
12229 #ifdef TARGET_NR_fchown32
12230 case TARGET_NR_fchown32
:
12231 return get_errno(fchown(arg1
, arg2
, arg3
));
12233 #ifdef TARGET_NR_setresuid32
12234 case TARGET_NR_setresuid32
:
12235 return get_errno(sys_setresuid(arg1
, arg2
, arg3
));
12237 #ifdef TARGET_NR_getresuid32
12238 case TARGET_NR_getresuid32
:
12240 uid_t ruid
, euid
, suid
;
12241 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
12242 if (!is_error(ret
)) {
12243 if (put_user_u32(ruid
, arg1
)
12244 || put_user_u32(euid
, arg2
)
12245 || put_user_u32(suid
, arg3
))
12246 return -TARGET_EFAULT
;
12251 #ifdef TARGET_NR_setresgid32
12252 case TARGET_NR_setresgid32
:
12253 return get_errno(sys_setresgid(arg1
, arg2
, arg3
));
12255 #ifdef TARGET_NR_getresgid32
12256 case TARGET_NR_getresgid32
:
12258 gid_t rgid
, egid
, sgid
;
12259 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
12260 if (!is_error(ret
)) {
12261 if (put_user_u32(rgid
, arg1
)
12262 || put_user_u32(egid
, arg2
)
12263 || put_user_u32(sgid
, arg3
))
12264 return -TARGET_EFAULT
;
12269 #ifdef TARGET_NR_chown32
12270 case TARGET_NR_chown32
:
12271 if (!(p
= lock_user_string(arg1
)))
12272 return -TARGET_EFAULT
;
12273 ret
= get_errno(chown(p
, arg2
, arg3
));
12274 unlock_user(p
, arg1
, 0);
12277 #ifdef TARGET_NR_setuid32
12278 case TARGET_NR_setuid32
:
12279 return get_errno(sys_setuid(arg1
));
12281 #ifdef TARGET_NR_setgid32
12282 case TARGET_NR_setgid32
:
12283 return get_errno(sys_setgid(arg1
));
12285 #ifdef TARGET_NR_setfsuid32
12286 case TARGET_NR_setfsuid32
:
12287 return get_errno(setfsuid(arg1
));
12289 #ifdef TARGET_NR_setfsgid32
12290 case TARGET_NR_setfsgid32
:
12291 return get_errno(setfsgid(arg1
));
12293 #ifdef TARGET_NR_mincore
12294 case TARGET_NR_mincore
:
12296 void *a
= lock_user(VERIFY_NONE
, arg1
, arg2
, 0);
12298 return -TARGET_ENOMEM
;
12300 p
= lock_user_string(arg3
);
12302 ret
= -TARGET_EFAULT
;
12304 ret
= get_errno(mincore(a
, arg2
, p
));
12305 unlock_user(p
, arg3
, ret
);
12307 unlock_user(a
, arg1
, 0);
12311 #ifdef TARGET_NR_arm_fadvise64_64
12312 case TARGET_NR_arm_fadvise64_64
:
12313 /* arm_fadvise64_64 looks like fadvise64_64 but
12314 * with different argument order: fd, advice, offset, len
12315 * rather than the usual fd, offset, len, advice.
12316 * Note that offset and len are both 64-bit so appear as
12317 * pairs of 32-bit registers.
12319 ret
= posix_fadvise(arg1
, target_offset64(arg3
, arg4
),
12320 target_offset64(arg5
, arg6
), arg2
);
12321 return -host_to_target_errno(ret
);
12324 #if TARGET_ABI_BITS == 32 && !defined(TARGET_ABI_MIPSN32)
12326 #ifdef TARGET_NR_fadvise64_64
12327 case TARGET_NR_fadvise64_64
:
12328 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
12329 /* 6 args: fd, advice, offset (high, low), len (high, low) */
12337 /* 6 args: fd, offset (high, low), len (high, low), advice */
12338 if (regpairs_aligned(cpu_env
, num
)) {
12339 /* offset is in (3,4), len in (5,6) and advice in 7 */
12347 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
),
12348 target_offset64(arg4
, arg5
), arg6
);
12349 return -host_to_target_errno(ret
);
12352 #ifdef TARGET_NR_fadvise64
12353 case TARGET_NR_fadvise64
:
12354 /* 5 args: fd, offset (high, low), len, advice */
12355 if (regpairs_aligned(cpu_env
, num
)) {
12356 /* offset is in (3,4), len in 5 and advice in 6 */
12362 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
), arg4
, arg5
);
12363 return -host_to_target_errno(ret
);
12366 #else /* not a 32-bit ABI */
12367 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
12368 #ifdef TARGET_NR_fadvise64_64
12369 case TARGET_NR_fadvise64_64
:
12371 #ifdef TARGET_NR_fadvise64
12372 case TARGET_NR_fadvise64
:
12374 #ifdef TARGET_S390X
12376 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
12377 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
12378 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
12379 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
12383 return -host_to_target_errno(posix_fadvise(arg1
, arg2
, arg3
, arg4
));
12385 #endif /* end of 64-bit ABI fadvise handling */
12387 #ifdef TARGET_NR_madvise
12388 case TARGET_NR_madvise
:
12389 return target_madvise(arg1
, arg2
, arg3
);
12391 #ifdef TARGET_NR_fcntl64
12392 case TARGET_NR_fcntl64
:
12396 from_flock64_fn
*copyfrom
= copy_from_user_flock64
;
12397 to_flock64_fn
*copyto
= copy_to_user_flock64
;
12400 if (!cpu_env
->eabi
) {
12401 copyfrom
= copy_from_user_oabi_flock64
;
12402 copyto
= copy_to_user_oabi_flock64
;
12406 cmd
= target_to_host_fcntl_cmd(arg2
);
12407 if (cmd
== -TARGET_EINVAL
) {
12412 case TARGET_F_GETLK64
:
12413 ret
= copyfrom(&fl
, arg3
);
12417 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
12419 ret
= copyto(arg3
, &fl
);
12423 case TARGET_F_SETLK64
:
12424 case TARGET_F_SETLKW64
:
12425 ret
= copyfrom(&fl
, arg3
);
12429 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
12432 ret
= do_fcntl(arg1
, arg2
, arg3
);
12438 #ifdef TARGET_NR_cacheflush
12439 case TARGET_NR_cacheflush
:
12440 /* self-modifying code is handled automatically, so nothing needed */
12443 #ifdef TARGET_NR_getpagesize
12444 case TARGET_NR_getpagesize
:
12445 return TARGET_PAGE_SIZE
;
12447 case TARGET_NR_gettid
:
12448 return get_errno(sys_gettid());
12449 #ifdef TARGET_NR_readahead
12450 case TARGET_NR_readahead
:
12451 #if TARGET_ABI_BITS == 32 && !defined(TARGET_ABI_MIPSN32)
12452 if (regpairs_aligned(cpu_env
, num
)) {
12457 ret
= get_errno(readahead(arg1
, target_offset64(arg2
, arg3
) , arg4
));
12459 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
12464 #ifdef TARGET_NR_setxattr
12465 case TARGET_NR_listxattr
:
12466 case TARGET_NR_llistxattr
:
12470 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
12472 return -TARGET_EFAULT
;
12475 p
= lock_user_string(arg1
);
12477 if (num
== TARGET_NR_listxattr
) {
12478 ret
= get_errno(listxattr(p
, b
, arg3
));
12480 ret
= get_errno(llistxattr(p
, b
, arg3
));
12483 ret
= -TARGET_EFAULT
;
12485 unlock_user(p
, arg1
, 0);
12486 unlock_user(b
, arg2
, arg3
);
12489 case TARGET_NR_flistxattr
:
12493 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
12495 return -TARGET_EFAULT
;
12498 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
12499 unlock_user(b
, arg2
, arg3
);
12502 case TARGET_NR_setxattr
:
12503 case TARGET_NR_lsetxattr
:
12507 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
12509 return -TARGET_EFAULT
;
12512 p
= lock_user_string(arg1
);
12513 n
= lock_user_string(arg2
);
12515 if (num
== TARGET_NR_setxattr
) {
12516 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
12518 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
12521 ret
= -TARGET_EFAULT
;
12523 unlock_user(p
, arg1
, 0);
12524 unlock_user(n
, arg2
, 0);
12525 unlock_user(v
, arg3
, 0);
12528 case TARGET_NR_fsetxattr
:
12532 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
12534 return -TARGET_EFAULT
;
12537 n
= lock_user_string(arg2
);
12539 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
12541 ret
= -TARGET_EFAULT
;
12543 unlock_user(n
, arg2
, 0);
12544 unlock_user(v
, arg3
, 0);
12547 case TARGET_NR_getxattr
:
12548 case TARGET_NR_lgetxattr
:
12552 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
12554 return -TARGET_EFAULT
;
12557 p
= lock_user_string(arg1
);
12558 n
= lock_user_string(arg2
);
12560 if (num
== TARGET_NR_getxattr
) {
12561 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
12563 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
12566 ret
= -TARGET_EFAULT
;
12568 unlock_user(p
, arg1
, 0);
12569 unlock_user(n
, arg2
, 0);
12570 unlock_user(v
, arg3
, arg4
);
12573 case TARGET_NR_fgetxattr
:
12577 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
12579 return -TARGET_EFAULT
;
12582 n
= lock_user_string(arg2
);
12584 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
12586 ret
= -TARGET_EFAULT
;
12588 unlock_user(n
, arg2
, 0);
12589 unlock_user(v
, arg3
, arg4
);
12592 case TARGET_NR_removexattr
:
12593 case TARGET_NR_lremovexattr
:
12596 p
= lock_user_string(arg1
);
12597 n
= lock_user_string(arg2
);
12599 if (num
== TARGET_NR_removexattr
) {
12600 ret
= get_errno(removexattr(p
, n
));
12602 ret
= get_errno(lremovexattr(p
, n
));
12605 ret
= -TARGET_EFAULT
;
12607 unlock_user(p
, arg1
, 0);
12608 unlock_user(n
, arg2
, 0);
12611 case TARGET_NR_fremovexattr
:
12614 n
= lock_user_string(arg2
);
12616 ret
= get_errno(fremovexattr(arg1
, n
));
12618 ret
= -TARGET_EFAULT
;
12620 unlock_user(n
, arg2
, 0);
12624 #endif /* CONFIG_ATTR */
12625 #ifdef TARGET_NR_set_thread_area
12626 case TARGET_NR_set_thread_area
:
12627 #if defined(TARGET_MIPS)
12628 cpu_env
->active_tc
.CP0_UserLocal
= arg1
;
12630 #elif defined(TARGET_CRIS)
12632 ret
= -TARGET_EINVAL
;
12634 cpu_env
->pregs
[PR_PID
] = arg1
;
12638 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
12639 return do_set_thread_area(cpu_env
, arg1
);
12640 #elif defined(TARGET_M68K)
12642 TaskState
*ts
= get_task_state(cpu
);
12643 ts
->tp_value
= arg1
;
12647 return -TARGET_ENOSYS
;
12650 #ifdef TARGET_NR_get_thread_area
12651 case TARGET_NR_get_thread_area
:
12652 #if defined(TARGET_I386) && defined(TARGET_ABI32)
12653 return do_get_thread_area(cpu_env
, arg1
);
12654 #elif defined(TARGET_M68K)
12656 TaskState
*ts
= get_task_state(cpu
);
12657 return ts
->tp_value
;
12660 return -TARGET_ENOSYS
;
12663 #ifdef TARGET_NR_getdomainname
12664 case TARGET_NR_getdomainname
:
12665 return -TARGET_ENOSYS
;
12668 #ifdef TARGET_NR_clock_settime
12669 case TARGET_NR_clock_settime
:
12671 struct timespec ts
;
12673 ret
= target_to_host_timespec(&ts
, arg2
);
12674 if (!is_error(ret
)) {
12675 ret
= get_errno(clock_settime(arg1
, &ts
));
12680 #ifdef TARGET_NR_clock_settime64
12681 case TARGET_NR_clock_settime64
:
12683 struct timespec ts
;
12685 ret
= target_to_host_timespec64(&ts
, arg2
);
12686 if (!is_error(ret
)) {
12687 ret
= get_errno(clock_settime(arg1
, &ts
));
12692 #ifdef TARGET_NR_clock_gettime
12693 case TARGET_NR_clock_gettime
:
12695 struct timespec ts
;
12696 ret
= get_errno(clock_gettime(arg1
, &ts
));
12697 if (!is_error(ret
)) {
12698 ret
= host_to_target_timespec(arg2
, &ts
);
12703 #ifdef TARGET_NR_clock_gettime64
12704 case TARGET_NR_clock_gettime64
:
12706 struct timespec ts
;
12707 ret
= get_errno(clock_gettime(arg1
, &ts
));
12708 if (!is_error(ret
)) {
12709 ret
= host_to_target_timespec64(arg2
, &ts
);
12714 #ifdef TARGET_NR_clock_getres
12715 case TARGET_NR_clock_getres
:
12717 struct timespec ts
;
12718 ret
= get_errno(clock_getres(arg1
, &ts
));
12719 if (!is_error(ret
)) {
12720 host_to_target_timespec(arg2
, &ts
);
12725 #ifdef TARGET_NR_clock_getres_time64
12726 case TARGET_NR_clock_getres_time64
:
12728 struct timespec ts
;
12729 ret
= get_errno(clock_getres(arg1
, &ts
));
12730 if (!is_error(ret
)) {
12731 host_to_target_timespec64(arg2
, &ts
);
12736 #ifdef TARGET_NR_clock_nanosleep
12737 case TARGET_NR_clock_nanosleep
:
12739 struct timespec ts
;
12740 if (target_to_host_timespec(&ts
, arg3
)) {
12741 return -TARGET_EFAULT
;
12743 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
12744 &ts
, arg4
? &ts
: NULL
));
12746 * if the call is interrupted by a signal handler, it fails
12747 * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not
12748 * TIMER_ABSTIME, it returns the remaining unslept time in arg4.
12750 if (ret
== -TARGET_EINTR
&& arg4
&& arg2
!= TIMER_ABSTIME
&&
12751 host_to_target_timespec(arg4
, &ts
)) {
12752 return -TARGET_EFAULT
;
12758 #ifdef TARGET_NR_clock_nanosleep_time64
12759 case TARGET_NR_clock_nanosleep_time64
:
12761 struct timespec ts
;
12763 if (target_to_host_timespec64(&ts
, arg3
)) {
12764 return -TARGET_EFAULT
;
12767 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
12768 &ts
, arg4
? &ts
: NULL
));
12770 if (ret
== -TARGET_EINTR
&& arg4
&& arg2
!= TIMER_ABSTIME
&&
12771 host_to_target_timespec64(arg4
, &ts
)) {
12772 return -TARGET_EFAULT
;
12778 #if defined(TARGET_NR_set_tid_address)
12779 case TARGET_NR_set_tid_address
:
12781 TaskState
*ts
= get_task_state(cpu
);
12782 ts
->child_tidptr
= arg1
;
12783 /* do not call host set_tid_address() syscall, instead return tid() */
12784 return get_errno(sys_gettid());
12788 case TARGET_NR_tkill
:
12789 return get_errno(safe_tkill((int)arg1
, target_to_host_signal(arg2
)));
12791 case TARGET_NR_tgkill
:
12792 return get_errno(safe_tgkill((int)arg1
, (int)arg2
,
12793 target_to_host_signal(arg3
)));
12795 #ifdef TARGET_NR_set_robust_list
12796 case TARGET_NR_set_robust_list
:
12797 case TARGET_NR_get_robust_list
:
12798 /* The ABI for supporting robust futexes has userspace pass
12799 * the kernel a pointer to a linked list which is updated by
12800 * userspace after the syscall; the list is walked by the kernel
12801 * when the thread exits. Since the linked list in QEMU guest
12802 * memory isn't a valid linked list for the host and we have
12803 * no way to reliably intercept the thread-death event, we can't
12804 * support these. Silently return ENOSYS so that guest userspace
12805 * falls back to a non-robust futex implementation (which should
12806 * be OK except in the corner case of the guest crashing while
12807 * holding a mutex that is shared with another process via
12810 return -TARGET_ENOSYS
;
12813 #if defined(TARGET_NR_utimensat)
12814 case TARGET_NR_utimensat
:
12816 struct timespec
*tsp
, ts
[2];
12820 if (target_to_host_timespec(ts
, arg3
)) {
12821 return -TARGET_EFAULT
;
12823 if (target_to_host_timespec(ts
+ 1, arg3
+
12824 sizeof(struct target_timespec
))) {
12825 return -TARGET_EFAULT
;
12830 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
12832 if (!(p
= lock_user_string(arg2
))) {
12833 return -TARGET_EFAULT
;
12835 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
12836 unlock_user(p
, arg2
, 0);
12841 #ifdef TARGET_NR_utimensat_time64
12842 case TARGET_NR_utimensat_time64
:
12844 struct timespec
*tsp
, ts
[2];
12848 if (target_to_host_timespec64(ts
, arg3
)) {
12849 return -TARGET_EFAULT
;
12851 if (target_to_host_timespec64(ts
+ 1, arg3
+
12852 sizeof(struct target__kernel_timespec
))) {
12853 return -TARGET_EFAULT
;
12858 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
12860 p
= lock_user_string(arg2
);
12862 return -TARGET_EFAULT
;
12864 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
12865 unlock_user(p
, arg2
, 0);
12870 #ifdef TARGET_NR_futex
12871 case TARGET_NR_futex
:
12872 return do_futex(cpu
, false, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
12874 #ifdef TARGET_NR_futex_time64
12875 case TARGET_NR_futex_time64
:
12876 return do_futex(cpu
, true, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
12878 #ifdef CONFIG_INOTIFY
12879 #if defined(TARGET_NR_inotify_init)
12880 case TARGET_NR_inotify_init
:
12881 ret
= get_errno(inotify_init());
12883 fd_trans_register(ret
, &target_inotify_trans
);
12887 #if defined(TARGET_NR_inotify_init1) && defined(CONFIG_INOTIFY1)
12888 case TARGET_NR_inotify_init1
:
12889 ret
= get_errno(inotify_init1(target_to_host_bitmask(arg1
,
12890 fcntl_flags_tbl
)));
12892 fd_trans_register(ret
, &target_inotify_trans
);
12896 #if defined(TARGET_NR_inotify_add_watch)
12897 case TARGET_NR_inotify_add_watch
:
12898 p
= lock_user_string(arg2
);
12899 ret
= get_errno(inotify_add_watch(arg1
, path(p
), arg3
));
12900 unlock_user(p
, arg2
, 0);
12903 #if defined(TARGET_NR_inotify_rm_watch)
12904 case TARGET_NR_inotify_rm_watch
:
12905 return get_errno(inotify_rm_watch(arg1
, arg2
));
12909 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
12910 case TARGET_NR_mq_open
:
12912 struct mq_attr posix_mq_attr
;
12913 struct mq_attr
*pposix_mq_attr
;
12916 host_flags
= target_to_host_bitmask(arg2
, fcntl_flags_tbl
);
12917 pposix_mq_attr
= NULL
;
12919 if (copy_from_user_mq_attr(&posix_mq_attr
, arg4
) != 0) {
12920 return -TARGET_EFAULT
;
12922 pposix_mq_attr
= &posix_mq_attr
;
12924 p
= lock_user_string(arg1
- 1);
12926 return -TARGET_EFAULT
;
12928 ret
= get_errno(mq_open(p
, host_flags
, arg3
, pposix_mq_attr
));
12929 unlock_user (p
, arg1
, 0);
12933 case TARGET_NR_mq_unlink
:
12934 p
= lock_user_string(arg1
- 1);
12936 return -TARGET_EFAULT
;
12938 ret
= get_errno(mq_unlink(p
));
12939 unlock_user (p
, arg1
, 0);
12942 #ifdef TARGET_NR_mq_timedsend
12943 case TARGET_NR_mq_timedsend
:
12945 struct timespec ts
;
12947 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
12949 if (target_to_host_timespec(&ts
, arg5
)) {
12950 return -TARGET_EFAULT
;
12952 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
12953 if (!is_error(ret
) && host_to_target_timespec(arg5
, &ts
)) {
12954 return -TARGET_EFAULT
;
12957 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
12959 unlock_user (p
, arg2
, arg3
);
12963 #ifdef TARGET_NR_mq_timedsend_time64
12964 case TARGET_NR_mq_timedsend_time64
:
12966 struct timespec ts
;
12968 p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1);
12970 if (target_to_host_timespec64(&ts
, arg5
)) {
12971 return -TARGET_EFAULT
;
12973 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
12974 if (!is_error(ret
) && host_to_target_timespec64(arg5
, &ts
)) {
12975 return -TARGET_EFAULT
;
12978 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
12980 unlock_user(p
, arg2
, arg3
);
12985 #ifdef TARGET_NR_mq_timedreceive
12986 case TARGET_NR_mq_timedreceive
:
12988 struct timespec ts
;
12991 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
12993 if (target_to_host_timespec(&ts
, arg5
)) {
12994 return -TARGET_EFAULT
;
12996 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
12998 if (!is_error(ret
) && host_to_target_timespec(arg5
, &ts
)) {
12999 return -TARGET_EFAULT
;
13002 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
13005 unlock_user (p
, arg2
, arg3
);
13007 put_user_u32(prio
, arg4
);
13011 #ifdef TARGET_NR_mq_timedreceive_time64
13012 case TARGET_NR_mq_timedreceive_time64
:
13014 struct timespec ts
;
13017 p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1);
13019 if (target_to_host_timespec64(&ts
, arg5
)) {
13020 return -TARGET_EFAULT
;
13022 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
13024 if (!is_error(ret
) && host_to_target_timespec64(arg5
, &ts
)) {
13025 return -TARGET_EFAULT
;
13028 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
13031 unlock_user(p
, arg2
, arg3
);
13033 put_user_u32(prio
, arg4
);
13039 /* Not implemented for now... */
13040 /* case TARGET_NR_mq_notify: */
13043 case TARGET_NR_mq_getsetattr
:
13045 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
13048 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
13049 ret
= get_errno(mq_setattr(arg1
, &posix_mq_attr_in
,
13050 &posix_mq_attr_out
));
13051 } else if (arg3
!= 0) {
13052 ret
= get_errno(mq_getattr(arg1
, &posix_mq_attr_out
));
13054 if (ret
== 0 && arg3
!= 0) {
13055 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
13061 #ifdef CONFIG_SPLICE
13062 #ifdef TARGET_NR_tee
13063 case TARGET_NR_tee
:
13065 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
13069 #ifdef TARGET_NR_splice
13070 case TARGET_NR_splice
:
13072 loff_t loff_in
, loff_out
;
13073 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
13075 if (get_user_u64(loff_in
, arg2
)) {
13076 return -TARGET_EFAULT
;
13078 ploff_in
= &loff_in
;
13081 if (get_user_u64(loff_out
, arg4
)) {
13082 return -TARGET_EFAULT
;
13084 ploff_out
= &loff_out
;
13086 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
13088 if (put_user_u64(loff_in
, arg2
)) {
13089 return -TARGET_EFAULT
;
13093 if (put_user_u64(loff_out
, arg4
)) {
13094 return -TARGET_EFAULT
;
13100 #ifdef TARGET_NR_vmsplice
13101 case TARGET_NR_vmsplice
:
13103 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
13105 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
13106 unlock_iovec(vec
, arg2
, arg3
, 0);
13108 ret
= -host_to_target_errno(errno
);
13113 #endif /* CONFIG_SPLICE */
13114 #ifdef CONFIG_EVENTFD
13115 #if defined(TARGET_NR_eventfd)
13116 case TARGET_NR_eventfd
:
13117 ret
= get_errno(eventfd(arg1
, 0));
13119 fd_trans_register(ret
, &target_eventfd_trans
);
13123 #if defined(TARGET_NR_eventfd2)
13124 case TARGET_NR_eventfd2
:
13126 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK_MASK
| TARGET_O_CLOEXEC
));
13127 if (arg2
& TARGET_O_NONBLOCK
) {
13128 host_flags
|= O_NONBLOCK
;
13130 if (arg2
& TARGET_O_CLOEXEC
) {
13131 host_flags
|= O_CLOEXEC
;
13133 ret
= get_errno(eventfd(arg1
, host_flags
));
13135 fd_trans_register(ret
, &target_eventfd_trans
);
13140 #endif /* CONFIG_EVENTFD */
13141 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
13142 case TARGET_NR_fallocate
:
13143 #if TARGET_ABI_BITS == 32 && !defined(TARGET_ABI_MIPSN32)
13144 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
13145 target_offset64(arg5
, arg6
)));
13147 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
13151 #if defined(CONFIG_SYNC_FILE_RANGE)
13152 #if defined(TARGET_NR_sync_file_range)
13153 case TARGET_NR_sync_file_range
:
13154 #if TARGET_ABI_BITS == 32 && !defined(TARGET_ABI_MIPSN32)
13155 #if defined(TARGET_MIPS)
13156 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
13157 target_offset64(arg5
, arg6
), arg7
));
13159 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
13160 target_offset64(arg4
, arg5
), arg6
));
13161 #endif /* !TARGET_MIPS */
13163 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
13167 #if defined(TARGET_NR_sync_file_range2) || \
13168 defined(TARGET_NR_arm_sync_file_range)
13169 #if defined(TARGET_NR_sync_file_range2)
13170 case TARGET_NR_sync_file_range2
:
13172 #if defined(TARGET_NR_arm_sync_file_range)
13173 case TARGET_NR_arm_sync_file_range
:
13175 /* This is like sync_file_range but the arguments are reordered */
13176 #if TARGET_ABI_BITS == 32 && !defined(TARGET_ABI_MIPSN32)
13177 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
13178 target_offset64(arg5
, arg6
), arg2
));
13180 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
13185 #if defined(TARGET_NR_signalfd4)
13186 case TARGET_NR_signalfd4
:
13187 return do_signalfd4(arg1
, arg2
, arg4
);
13189 #if defined(TARGET_NR_signalfd)
13190 case TARGET_NR_signalfd
:
13191 return do_signalfd4(arg1
, arg2
, 0);
13193 #if defined(CONFIG_EPOLL)
13194 #if defined(TARGET_NR_epoll_create)
13195 case TARGET_NR_epoll_create
:
13196 return get_errno(epoll_create(arg1
));
13198 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
13199 case TARGET_NR_epoll_create1
:
13200 return get_errno(epoll_create1(target_to_host_bitmask(arg1
, fcntl_flags_tbl
)));
13202 #if defined(TARGET_NR_epoll_ctl)
13203 case TARGET_NR_epoll_ctl
:
13205 struct epoll_event ep
;
13206 struct epoll_event
*epp
= 0;
13208 if (arg2
!= EPOLL_CTL_DEL
) {
13209 struct target_epoll_event
*target_ep
;
13210 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
13211 return -TARGET_EFAULT
;
13213 ep
.events
= tswap32(target_ep
->events
);
13215 * The epoll_data_t union is just opaque data to the kernel,
13216 * so we transfer all 64 bits across and need not worry what
13217 * actual data type it is.
13219 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
13220 unlock_user_struct(target_ep
, arg4
, 0);
13223 * before kernel 2.6.9, EPOLL_CTL_DEL operation required a
13224 * non-null pointer, even though this argument is ignored.
13229 return get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
13233 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
13234 #if defined(TARGET_NR_epoll_wait)
13235 case TARGET_NR_epoll_wait
:
13237 #if defined(TARGET_NR_epoll_pwait)
13238 case TARGET_NR_epoll_pwait
:
13241 struct target_epoll_event
*target_ep
;
13242 struct epoll_event
*ep
;
13244 int maxevents
= arg3
;
13245 int timeout
= arg4
;
13247 if (maxevents
<= 0 || maxevents
> TARGET_EP_MAX_EVENTS
) {
13248 return -TARGET_EINVAL
;
13251 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
13252 maxevents
* sizeof(struct target_epoll_event
), 1);
13254 return -TARGET_EFAULT
;
13257 ep
= g_try_new(struct epoll_event
, maxevents
);
13259 unlock_user(target_ep
, arg2
, 0);
13260 return -TARGET_ENOMEM
;
13264 #if defined(TARGET_NR_epoll_pwait)
13265 case TARGET_NR_epoll_pwait
:
13267 sigset_t
*set
= NULL
;
13270 ret
= process_sigsuspend_mask(&set
, arg5
, arg6
);
13276 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
13277 set
, SIGSET_T_SIZE
));
13280 finish_sigsuspend_mask(ret
);
13285 #if defined(TARGET_NR_epoll_wait)
13286 case TARGET_NR_epoll_wait
:
13287 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
13292 ret
= -TARGET_ENOSYS
;
13294 if (!is_error(ret
)) {
13296 for (i
= 0; i
< ret
; i
++) {
13297 target_ep
[i
].events
= tswap32(ep
[i
].events
);
13298 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
13300 unlock_user(target_ep
, arg2
,
13301 ret
* sizeof(struct target_epoll_event
));
13303 unlock_user(target_ep
, arg2
, 0);
13310 #ifdef TARGET_NR_prlimit64
13311 case TARGET_NR_prlimit64
:
13313 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
13314 struct target_rlimit64
*target_rnew
, *target_rold
;
13315 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
13316 int resource
= target_to_host_resource(arg2
);
13318 if (arg3
&& (resource
!= RLIMIT_AS
&&
13319 resource
!= RLIMIT_DATA
&&
13320 resource
!= RLIMIT_STACK
)) {
13321 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
13322 return -TARGET_EFAULT
;
13324 __get_user(rnew
.rlim_cur
, &target_rnew
->rlim_cur
);
13325 __get_user(rnew
.rlim_max
, &target_rnew
->rlim_max
);
13326 unlock_user_struct(target_rnew
, arg3
, 0);
13330 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
13331 if (!is_error(ret
) && arg4
) {
13332 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
13333 return -TARGET_EFAULT
;
13335 __put_user(rold
.rlim_cur
, &target_rold
->rlim_cur
);
13336 __put_user(rold
.rlim_max
, &target_rold
->rlim_max
);
13337 unlock_user_struct(target_rold
, arg4
, 1);
13342 #ifdef TARGET_NR_gethostname
13343 case TARGET_NR_gethostname
:
13345 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
13347 ret
= get_errno(gethostname(name
, arg2
));
13348 unlock_user(name
, arg1
, arg2
);
13350 ret
= -TARGET_EFAULT
;
13355 #ifdef TARGET_NR_atomic_cmpxchg_32
13356 case TARGET_NR_atomic_cmpxchg_32
:
13358 /* should use start_exclusive from main.c */
13359 abi_ulong mem_value
;
13360 if (get_user_u32(mem_value
, arg6
)) {
13361 target_siginfo_t info
;
13362 info
.si_signo
= SIGSEGV
;
13364 info
.si_code
= TARGET_SEGV_MAPERR
;
13365 info
._sifields
._sigfault
._addr
= arg6
;
13366 queue_signal(cpu_env
, info
.si_signo
, QEMU_SI_FAULT
, &info
);
13370 if (mem_value
== arg2
)
13371 put_user_u32(arg1
, arg6
);
13375 #ifdef TARGET_NR_atomic_barrier
13376 case TARGET_NR_atomic_barrier
:
13377 /* Like the kernel implementation and the
13378 qemu arm barrier, no-op this? */
13382 #ifdef TARGET_NR_timer_create
13383 case TARGET_NR_timer_create
:
13385 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
13387 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
13390 int timer_index
= next_free_host_timer();
13392 if (timer_index
< 0) {
13393 ret
= -TARGET_EAGAIN
;
13395 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
13398 phost_sevp
= &host_sevp
;
13399 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
13401 free_host_timer_slot(timer_index
);
13406 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
13408 free_host_timer_slot(timer_index
);
13410 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
13411 timer_delete(*phtimer
);
13412 free_host_timer_slot(timer_index
);
13413 return -TARGET_EFAULT
;
13421 #ifdef TARGET_NR_timer_settime
13422 case TARGET_NR_timer_settime
:
13424 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
13425 * struct itimerspec * old_value */
13426 target_timer_t timerid
= get_timer_id(arg1
);
13430 } else if (arg3
== 0) {
13431 ret
= -TARGET_EINVAL
;
13433 timer_t htimer
= g_posix_timers
[timerid
];
13434 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
13436 if (target_to_host_itimerspec(&hspec_new
, arg3
)) {
13437 return -TARGET_EFAULT
;
13440 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
13441 if (arg4
&& host_to_target_itimerspec(arg4
, &hspec_old
)) {
13442 return -TARGET_EFAULT
;
13449 #ifdef TARGET_NR_timer_settime64
13450 case TARGET_NR_timer_settime64
:
13452 target_timer_t timerid
= get_timer_id(arg1
);
13456 } else if (arg3
== 0) {
13457 ret
= -TARGET_EINVAL
;
13459 timer_t htimer
= g_posix_timers
[timerid
];
13460 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
13462 if (target_to_host_itimerspec64(&hspec_new
, arg3
)) {
13463 return -TARGET_EFAULT
;
13466 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
13467 if (arg4
&& host_to_target_itimerspec64(arg4
, &hspec_old
)) {
13468 return -TARGET_EFAULT
;
13475 #ifdef TARGET_NR_timer_gettime
13476 case TARGET_NR_timer_gettime
:
13478 /* args: timer_t timerid, struct itimerspec *curr_value */
13479 target_timer_t timerid
= get_timer_id(arg1
);
13483 } else if (!arg2
) {
13484 ret
= -TARGET_EFAULT
;
13486 timer_t htimer
= g_posix_timers
[timerid
];
13487 struct itimerspec hspec
;
13488 ret
= get_errno(timer_gettime(htimer
, &hspec
));
13490 if (host_to_target_itimerspec(arg2
, &hspec
)) {
13491 ret
= -TARGET_EFAULT
;
13498 #ifdef TARGET_NR_timer_gettime64
13499 case TARGET_NR_timer_gettime64
:
13501 /* args: timer_t timerid, struct itimerspec64 *curr_value */
13502 target_timer_t timerid
= get_timer_id(arg1
);
13506 } else if (!arg2
) {
13507 ret
= -TARGET_EFAULT
;
13509 timer_t htimer
= g_posix_timers
[timerid
];
13510 struct itimerspec hspec
;
13511 ret
= get_errno(timer_gettime(htimer
, &hspec
));
13513 if (host_to_target_itimerspec64(arg2
, &hspec
)) {
13514 ret
= -TARGET_EFAULT
;
13521 #ifdef TARGET_NR_timer_getoverrun
13522 case TARGET_NR_timer_getoverrun
:
13524 /* args: timer_t timerid */
13525 target_timer_t timerid
= get_timer_id(arg1
);
13530 timer_t htimer
= g_posix_timers
[timerid
];
13531 ret
= get_errno(timer_getoverrun(htimer
));
13537 #ifdef TARGET_NR_timer_delete
13538 case TARGET_NR_timer_delete
:
13540 /* args: timer_t timerid */
13541 target_timer_t timerid
= get_timer_id(arg1
);
13546 timer_t htimer
= g_posix_timers
[timerid
];
13547 ret
= get_errno(timer_delete(htimer
));
13548 free_host_timer_slot(timerid
);
13554 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
13555 case TARGET_NR_timerfd_create
:
13556 ret
= get_errno(timerfd_create(arg1
,
13557 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
13559 fd_trans_register(ret
, &target_timerfd_trans
);
13564 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
13565 case TARGET_NR_timerfd_gettime
:
13567 struct itimerspec its_curr
;
13569 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
13571 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
13572 return -TARGET_EFAULT
;
13578 #if defined(TARGET_NR_timerfd_gettime64) && defined(CONFIG_TIMERFD)
13579 case TARGET_NR_timerfd_gettime64
:
13581 struct itimerspec its_curr
;
13583 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
13585 if (arg2
&& host_to_target_itimerspec64(arg2
, &its_curr
)) {
13586 return -TARGET_EFAULT
;
13592 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
13593 case TARGET_NR_timerfd_settime
:
13595 struct itimerspec its_new
, its_old
, *p_new
;
13598 if (target_to_host_itimerspec(&its_new
, arg3
)) {
13599 return -TARGET_EFAULT
;
13606 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
13608 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
13609 return -TARGET_EFAULT
;
13615 #if defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)
13616 case TARGET_NR_timerfd_settime64
:
13618 struct itimerspec its_new
, its_old
, *p_new
;
13621 if (target_to_host_itimerspec64(&its_new
, arg3
)) {
13622 return -TARGET_EFAULT
;
13629 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
13631 if (arg4
&& host_to_target_itimerspec64(arg4
, &its_old
)) {
13632 return -TARGET_EFAULT
;
13638 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
13639 case TARGET_NR_ioprio_get
:
13640 return get_errno(ioprio_get(arg1
, arg2
));
13643 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
13644 case TARGET_NR_ioprio_set
:
13645 return get_errno(ioprio_set(arg1
, arg2
, arg3
));
13648 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
13649 case TARGET_NR_setns
:
13650 return get_errno(setns(arg1
, arg2
));
13652 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
13653 case TARGET_NR_unshare
:
13654 return get_errno(unshare(arg1
));
13656 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
13657 case TARGET_NR_kcmp
:
13658 return get_errno(kcmp(arg1
, arg2
, arg3
, arg4
, arg5
));
13660 #ifdef TARGET_NR_swapcontext
13661 case TARGET_NR_swapcontext
:
13662 /* PowerPC specific. */
13663 return do_swapcontext(cpu_env
, arg1
, arg2
, arg3
);
13665 #ifdef TARGET_NR_memfd_create
13666 case TARGET_NR_memfd_create
:
13667 p
= lock_user_string(arg1
);
13669 return -TARGET_EFAULT
;
13671 ret
= get_errno(memfd_create(p
, arg2
));
13672 fd_trans_unregister(ret
);
13673 unlock_user(p
, arg1
, 0);
13676 #if defined TARGET_NR_membarrier && defined __NR_membarrier
13677 case TARGET_NR_membarrier
:
13678 return get_errno(membarrier(arg1
, arg2
));
13681 #if defined(TARGET_NR_copy_file_range) && defined(__NR_copy_file_range)
13682 case TARGET_NR_copy_file_range
:
13684 loff_t inoff
, outoff
;
13685 loff_t
*pinoff
= NULL
, *poutoff
= NULL
;
13688 if (get_user_u64(inoff
, arg2
)) {
13689 return -TARGET_EFAULT
;
13694 if (get_user_u64(outoff
, arg4
)) {
13695 return -TARGET_EFAULT
;
13699 /* Do not sign-extend the count parameter. */
13700 ret
= get_errno(safe_copy_file_range(arg1
, pinoff
, arg3
, poutoff
,
13701 (abi_ulong
)arg5
, arg6
));
13702 if (!is_error(ret
) && ret
> 0) {
13704 if (put_user_u64(inoff
, arg2
)) {
13705 return -TARGET_EFAULT
;
13709 if (put_user_u64(outoff
, arg4
)) {
13710 return -TARGET_EFAULT
;
13718 #if defined(TARGET_NR_pivot_root)
13719 case TARGET_NR_pivot_root
:
13722 p
= lock_user_string(arg1
); /* new_root */
13723 p2
= lock_user_string(arg2
); /* put_old */
13725 ret
= -TARGET_EFAULT
;
13727 ret
= get_errno(pivot_root(p
, p2
));
13729 unlock_user(p2
, arg2
, 0);
13730 unlock_user(p
, arg1
, 0);
13735 #if defined(TARGET_NR_riscv_hwprobe)
13736 case TARGET_NR_riscv_hwprobe
:
13737 return do_riscv_hwprobe(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
);
13741 qemu_log_mask(LOG_UNIMP
, "Unsupported syscall: %d\n", num
);
13742 return -TARGET_ENOSYS
;
13747 abi_long
do_syscall(CPUArchState
*cpu_env
, int num
, abi_long arg1
,
13748 abi_long arg2
, abi_long arg3
, abi_long arg4
,
13749 abi_long arg5
, abi_long arg6
, abi_long arg7
,
13752 CPUState
*cpu
= env_cpu(cpu_env
);
13755 #ifdef DEBUG_ERESTARTSYS
13756 /* Debug-only code for exercising the syscall-restart code paths
13757 * in the per-architecture cpu main loops: restart every syscall
13758 * the guest makes once before letting it through.
13764 return -QEMU_ERESTARTSYS
;
13769 record_syscall_start(cpu
, num
, arg1
,
13770 arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
);
13772 if (unlikely(qemu_loglevel_mask(LOG_STRACE
))) {
13773 print_syscall(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
13776 ret
= do_syscall1(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
,
13777 arg5
, arg6
, arg7
, arg8
);
13779 if (unlikely(qemu_loglevel_mask(LOG_STRACE
))) {
13780 print_syscall_ret(cpu_env
, num
, ret
, arg1
, arg2
,
13781 arg3
, arg4
, arg5
, arg6
);
13784 record_syscall_return(cpu
, num
, ret
);