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"
29 #include <sys/mount.h>
31 #include <sys/fsuid.h>
32 #include <sys/personality.h>
33 #include <sys/prctl.h>
34 #include <sys/resource.h>
36 #include <linux/capability.h>
38 #include <sys/timex.h>
39 #include <sys/socket.h>
40 #include <linux/sockios.h>
44 #include <sys/times.h>
47 #include <sys/statfs.h>
49 #include <sys/sysinfo.h>
50 #include <sys/signalfd.h>
51 //#include <sys/user.h>
52 #include <netinet/ip.h>
53 #include <netinet/tcp.h>
54 #include <linux/wireless.h>
55 #include <linux/icmp.h>
56 #include <linux/icmpv6.h>
57 #include <linux/errqueue.h>
58 #include <linux/random.h>
60 #include <sys/timerfd.h>
63 #include <sys/eventfd.h>
66 #include <sys/epoll.h>
69 #include "qemu/xattr.h"
71 #ifdef CONFIG_SENDFILE
72 #include <sys/sendfile.h>
75 #define termios host_termios
76 #define winsize host_winsize
77 #define termio host_termio
78 #define sgttyb host_sgttyb /* same as target */
79 #define tchars host_tchars /* same as target */
80 #define ltchars host_ltchars /* same as target */
82 #include <linux/termios.h>
83 #include <linux/unistd.h>
84 #include <linux/cdrom.h>
85 #include <linux/hdreg.h>
86 #include <linux/soundcard.h>
88 #include <linux/mtio.h>
90 #if defined(CONFIG_FIEMAP)
91 #include <linux/fiemap.h>
94 #if defined(CONFIG_USBFS)
95 #include <linux/usbdevice_fs.h>
96 #include <linux/usb/ch9.h>
99 #include <linux/dm-ioctl.h>
100 #include <linux/reboot.h>
101 #include <linux/route.h>
102 #include <linux/filter.h>
103 #include <linux/blkpg.h>
104 #include <netpacket/packet.h>
105 #include <linux/netlink.h>
106 #include <linux/if_alg.h>
107 #include "linux_loop.h"
111 #include "qemu/guest-random.h"
112 #include "qapi/error.h"
113 #include "fd-trans.h"
116 #define CLONE_IO 0x80000000 /* Clone io context */
119 /* We can't directly call the host clone syscall, because this will
120 * badly confuse libc (breaking mutexes, for example). So we must
121 * divide clone flags into:
122 * * flag combinations that look like pthread_create()
123 * * flag combinations that look like fork()
124 * * flags we can implement within QEMU itself
125 * * flags we can't support and will return an error for
127 /* For thread creation, all these flags must be present; for
128 * fork, none must be present.
130 #define CLONE_THREAD_FLAGS \
131 (CLONE_VM | CLONE_FS | CLONE_FILES | \
132 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
134 /* These flags are ignored:
135 * CLONE_DETACHED is now ignored by the kernel;
136 * CLONE_IO is just an optimisation hint to the I/O scheduler
138 #define CLONE_IGNORED_FLAGS \
139 (CLONE_DETACHED | CLONE_IO)
141 /* Flags for fork which we can implement within QEMU itself */
142 #define CLONE_OPTIONAL_FORK_FLAGS \
143 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
144 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
146 /* Flags for thread creation which we can implement within QEMU itself */
147 #define CLONE_OPTIONAL_THREAD_FLAGS \
148 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
149 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
151 #define CLONE_INVALID_FORK_FLAGS \
152 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
154 #define CLONE_INVALID_THREAD_FLAGS \
155 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
156 CLONE_IGNORED_FLAGS))
158 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
159 * have almost all been allocated. We cannot support any of
160 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
161 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
162 * The checks against the invalid thread masks above will catch these.
163 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
166 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
167 * once. This exercises the codepaths for restart.
169 //#define DEBUG_ERESTARTSYS
171 //#include <linux/msdos_fs.h>
172 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
173 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
183 #define _syscall0(type,name) \
184 static type name (void) \
186 return syscall(__NR_##name); \
189 #define _syscall1(type,name,type1,arg1) \
190 static type name (type1 arg1) \
192 return syscall(__NR_##name, arg1); \
195 #define _syscall2(type,name,type1,arg1,type2,arg2) \
196 static type name (type1 arg1,type2 arg2) \
198 return syscall(__NR_##name, arg1, arg2); \
201 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
202 static type name (type1 arg1,type2 arg2,type3 arg3) \
204 return syscall(__NR_##name, arg1, arg2, arg3); \
207 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
208 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
210 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
213 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
215 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
217 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
221 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
222 type5,arg5,type6,arg6) \
223 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
226 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
230 #define __NR_sys_uname __NR_uname
231 #define __NR_sys_getcwd1 __NR_getcwd
232 #define __NR_sys_getdents __NR_getdents
233 #define __NR_sys_getdents64 __NR_getdents64
234 #define __NR_sys_getpriority __NR_getpriority
235 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
236 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
237 #define __NR_sys_syslog __NR_syslog
238 #define __NR_sys_futex __NR_futex
239 #define __NR_sys_inotify_init __NR_inotify_init
240 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
241 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
242 #define __NR_sys_statx __NR_statx
244 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
245 #define __NR__llseek __NR_lseek
248 /* Newer kernel ports have llseek() instead of _llseek() */
249 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
250 #define TARGET_NR__llseek TARGET_NR_llseek
253 #define __NR_sys_gettid __NR_gettid
254 _syscall0(int, sys_gettid
)
256 /* For the 64-bit guest on 32-bit host case we must emulate
257 * getdents using getdents64, because otherwise the host
258 * might hand us back more dirent records than we can fit
259 * into the guest buffer after structure format conversion.
260 * Otherwise we emulate getdents with getdents if the host has it.
262 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
263 #define EMULATE_GETDENTS_WITH_GETDENTS
266 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
267 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
269 #if (defined(TARGET_NR_getdents) && \
270 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
271 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
272 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
274 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
275 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
276 loff_t
*, res
, uint
, wh
);
278 _syscall3(int, sys_rt_sigqueueinfo
, pid_t
, pid
, int, sig
, siginfo_t
*, uinfo
)
279 _syscall4(int, sys_rt_tgsigqueueinfo
, pid_t
, pid
, pid_t
, tid
, int, sig
,
281 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
282 #ifdef __NR_exit_group
283 _syscall1(int,exit_group
,int,error_code
)
285 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
286 _syscall1(int,set_tid_address
,int *,tidptr
)
288 #if defined(TARGET_NR_futex) && defined(__NR_futex)
289 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
290 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
292 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
293 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
294 unsigned long *, user_mask_ptr
);
295 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
296 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
297 unsigned long *, user_mask_ptr
);
298 #define __NR_sys_getcpu __NR_getcpu
299 _syscall3(int, sys_getcpu
, unsigned *, cpu
, unsigned *, node
, void *, tcache
);
300 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
302 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
303 struct __user_cap_data_struct
*, data
);
304 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
305 struct __user_cap_data_struct
*, data
);
306 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
307 _syscall2(int, ioprio_get
, int, which
, int, who
)
309 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
310 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
312 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
313 _syscall3(int, getrandom
, void *, buf
, size_t, buflen
, unsigned int, flags
)
316 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
317 _syscall5(int, kcmp
, pid_t
, pid1
, pid_t
, pid2
, int, type
,
318 unsigned long, idx1
, unsigned long, idx2
)
322 * It is assumed that struct statx is architecture independent.
324 #if defined(TARGET_NR_statx) && defined(__NR_statx)
325 _syscall5(int, sys_statx
, int, dirfd
, const char *, pathname
, int, flags
,
326 unsigned int, mask
, struct target_statx
*, statxbuf
)
329 static bitmask_transtbl fcntl_flags_tbl
[] = {
330 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
331 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
332 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
333 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
334 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
335 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
336 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
337 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
338 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
339 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
340 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
341 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
342 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
343 #if defined(O_DIRECT)
344 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
346 #if defined(O_NOATIME)
347 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
349 #if defined(O_CLOEXEC)
350 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
353 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
355 #if defined(O_TMPFILE)
356 { TARGET_O_TMPFILE
, TARGET_O_TMPFILE
, O_TMPFILE
, O_TMPFILE
},
358 /* Don't terminate the list prematurely on 64-bit host+guest. */
359 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
360 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
365 static int sys_getcwd1(char *buf
, size_t size
)
367 if (getcwd(buf
, size
) == NULL
) {
368 /* getcwd() sets errno */
371 return strlen(buf
)+1;
374 #ifdef TARGET_NR_utimensat
375 #if defined(__NR_utimensat)
376 #define __NR_sys_utimensat __NR_utimensat
377 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
378 const struct timespec
*,tsp
,int,flags
)
380 static int sys_utimensat(int dirfd
, const char *pathname
,
381 const struct timespec times
[2], int flags
)
387 #endif /* TARGET_NR_utimensat */
389 #ifdef TARGET_NR_renameat2
390 #if defined(__NR_renameat2)
391 #define __NR_sys_renameat2 __NR_renameat2
392 _syscall5(int, sys_renameat2
, int, oldfd
, const char *, old
, int, newfd
,
393 const char *, new, unsigned int, flags
)
395 static int sys_renameat2(int oldfd
, const char *old
,
396 int newfd
, const char *new, int flags
)
399 return renameat(oldfd
, old
, newfd
, new);
405 #endif /* TARGET_NR_renameat2 */
407 #ifdef CONFIG_INOTIFY
408 #include <sys/inotify.h>
410 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
411 static int sys_inotify_init(void)
413 return (inotify_init());
416 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
417 static int sys_inotify_add_watch(int fd
,const char *pathname
, int32_t mask
)
419 return (inotify_add_watch(fd
, pathname
, mask
));
422 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
423 static int sys_inotify_rm_watch(int fd
, int32_t wd
)
425 return (inotify_rm_watch(fd
, wd
));
428 #ifdef CONFIG_INOTIFY1
429 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
430 static int sys_inotify_init1(int flags
)
432 return (inotify_init1(flags
));
437 /* Userspace can usually survive runtime without inotify */
438 #undef TARGET_NR_inotify_init
439 #undef TARGET_NR_inotify_init1
440 #undef TARGET_NR_inotify_add_watch
441 #undef TARGET_NR_inotify_rm_watch
442 #endif /* CONFIG_INOTIFY */
444 #if defined(TARGET_NR_prlimit64)
445 #ifndef __NR_prlimit64
446 # define __NR_prlimit64 -1
448 #define __NR_sys_prlimit64 __NR_prlimit64
449 /* The glibc rlimit structure may not be that used by the underlying syscall */
450 struct host_rlimit64
{
454 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
455 const struct host_rlimit64
*, new_limit
,
456 struct host_rlimit64
*, old_limit
)
460 #if defined(TARGET_NR_timer_create)
461 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
462 static timer_t g_posix_timers
[32] = { 0, } ;
464 static inline int next_free_host_timer(void)
467 /* FIXME: Does finding the next free slot require a lock? */
468 for (k
= 0; k
< ARRAY_SIZE(g_posix_timers
); k
++) {
469 if (g_posix_timers
[k
] == 0) {
470 g_posix_timers
[k
] = (timer_t
) 1;
478 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
480 static inline int regpairs_aligned(void *cpu_env
, int num
)
482 return ((((CPUARMState
*)cpu_env
)->eabi
) == 1) ;
484 #elif defined(TARGET_MIPS) && (TARGET_ABI_BITS == 32)
485 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
486 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
487 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
488 * of registers which translates to the same as ARM/MIPS, because we start with
490 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
491 #elif defined(TARGET_SH4)
492 /* SH4 doesn't align register pairs, except for p{read,write}64 */
493 static inline int regpairs_aligned(void *cpu_env
, int num
)
496 case TARGET_NR_pread64
:
497 case TARGET_NR_pwrite64
:
504 #elif defined(TARGET_XTENSA)
505 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
507 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 0; }
510 #define ERRNO_TABLE_SIZE 1200
512 /* target_to_host_errno_table[] is initialized from
513 * host_to_target_errno_table[] in syscall_init(). */
514 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
518 * This list is the union of errno values overridden in asm-<arch>/errno.h
519 * minus the errnos that are not actually generic to all archs.
521 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
522 [EAGAIN
] = TARGET_EAGAIN
,
523 [EIDRM
] = TARGET_EIDRM
,
524 [ECHRNG
] = TARGET_ECHRNG
,
525 [EL2NSYNC
] = TARGET_EL2NSYNC
,
526 [EL3HLT
] = TARGET_EL3HLT
,
527 [EL3RST
] = TARGET_EL3RST
,
528 [ELNRNG
] = TARGET_ELNRNG
,
529 [EUNATCH
] = TARGET_EUNATCH
,
530 [ENOCSI
] = TARGET_ENOCSI
,
531 [EL2HLT
] = TARGET_EL2HLT
,
532 [EDEADLK
] = TARGET_EDEADLK
,
533 [ENOLCK
] = TARGET_ENOLCK
,
534 [EBADE
] = TARGET_EBADE
,
535 [EBADR
] = TARGET_EBADR
,
536 [EXFULL
] = TARGET_EXFULL
,
537 [ENOANO
] = TARGET_ENOANO
,
538 [EBADRQC
] = TARGET_EBADRQC
,
539 [EBADSLT
] = TARGET_EBADSLT
,
540 [EBFONT
] = TARGET_EBFONT
,
541 [ENOSTR
] = TARGET_ENOSTR
,
542 [ENODATA
] = TARGET_ENODATA
,
543 [ETIME
] = TARGET_ETIME
,
544 [ENOSR
] = TARGET_ENOSR
,
545 [ENONET
] = TARGET_ENONET
,
546 [ENOPKG
] = TARGET_ENOPKG
,
547 [EREMOTE
] = TARGET_EREMOTE
,
548 [ENOLINK
] = TARGET_ENOLINK
,
549 [EADV
] = TARGET_EADV
,
550 [ESRMNT
] = TARGET_ESRMNT
,
551 [ECOMM
] = TARGET_ECOMM
,
552 [EPROTO
] = TARGET_EPROTO
,
553 [EDOTDOT
] = TARGET_EDOTDOT
,
554 [EMULTIHOP
] = TARGET_EMULTIHOP
,
555 [EBADMSG
] = TARGET_EBADMSG
,
556 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
557 [EOVERFLOW
] = TARGET_EOVERFLOW
,
558 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
559 [EBADFD
] = TARGET_EBADFD
,
560 [EREMCHG
] = TARGET_EREMCHG
,
561 [ELIBACC
] = TARGET_ELIBACC
,
562 [ELIBBAD
] = TARGET_ELIBBAD
,
563 [ELIBSCN
] = TARGET_ELIBSCN
,
564 [ELIBMAX
] = TARGET_ELIBMAX
,
565 [ELIBEXEC
] = TARGET_ELIBEXEC
,
566 [EILSEQ
] = TARGET_EILSEQ
,
567 [ENOSYS
] = TARGET_ENOSYS
,
568 [ELOOP
] = TARGET_ELOOP
,
569 [ERESTART
] = TARGET_ERESTART
,
570 [ESTRPIPE
] = TARGET_ESTRPIPE
,
571 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
572 [EUSERS
] = TARGET_EUSERS
,
573 [ENOTSOCK
] = TARGET_ENOTSOCK
,
574 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
575 [EMSGSIZE
] = TARGET_EMSGSIZE
,
576 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
577 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
578 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
579 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
580 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
581 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
582 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
583 [EADDRINUSE
] = TARGET_EADDRINUSE
,
584 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
585 [ENETDOWN
] = TARGET_ENETDOWN
,
586 [ENETUNREACH
] = TARGET_ENETUNREACH
,
587 [ENETRESET
] = TARGET_ENETRESET
,
588 [ECONNABORTED
] = TARGET_ECONNABORTED
,
589 [ECONNRESET
] = TARGET_ECONNRESET
,
590 [ENOBUFS
] = TARGET_ENOBUFS
,
591 [EISCONN
] = TARGET_EISCONN
,
592 [ENOTCONN
] = TARGET_ENOTCONN
,
593 [EUCLEAN
] = TARGET_EUCLEAN
,
594 [ENOTNAM
] = TARGET_ENOTNAM
,
595 [ENAVAIL
] = TARGET_ENAVAIL
,
596 [EISNAM
] = TARGET_EISNAM
,
597 [EREMOTEIO
] = TARGET_EREMOTEIO
,
598 [EDQUOT
] = TARGET_EDQUOT
,
599 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
600 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
601 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
602 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
603 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
604 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
605 [EALREADY
] = TARGET_EALREADY
,
606 [EINPROGRESS
] = TARGET_EINPROGRESS
,
607 [ESTALE
] = TARGET_ESTALE
,
608 [ECANCELED
] = TARGET_ECANCELED
,
609 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
610 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
612 [ENOKEY
] = TARGET_ENOKEY
,
615 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
618 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
621 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
624 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
626 #ifdef ENOTRECOVERABLE
627 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
630 [ENOMSG
] = TARGET_ENOMSG
,
633 [ERFKILL
] = TARGET_ERFKILL
,
636 [EHWPOISON
] = TARGET_EHWPOISON
,
640 static inline int host_to_target_errno(int err
)
642 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
643 host_to_target_errno_table
[err
]) {
644 return host_to_target_errno_table
[err
];
649 static inline int target_to_host_errno(int err
)
651 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
652 target_to_host_errno_table
[err
]) {
653 return target_to_host_errno_table
[err
];
658 static inline abi_long
get_errno(abi_long ret
)
661 return -host_to_target_errno(errno
);
666 const char *target_strerror(int err
)
668 if (err
== TARGET_ERESTARTSYS
) {
669 return "To be restarted";
671 if (err
== TARGET_QEMU_ESIGRETURN
) {
672 return "Successful exit from sigreturn";
675 if ((err
>= ERRNO_TABLE_SIZE
) || (err
< 0)) {
678 return strerror(target_to_host_errno(err
));
681 #define safe_syscall0(type, name) \
682 static type safe_##name(void) \
684 return safe_syscall(__NR_##name); \
687 #define safe_syscall1(type, name, type1, arg1) \
688 static type safe_##name(type1 arg1) \
690 return safe_syscall(__NR_##name, arg1); \
693 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
694 static type safe_##name(type1 arg1, type2 arg2) \
696 return safe_syscall(__NR_##name, arg1, arg2); \
699 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
700 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
702 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
705 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
707 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
709 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
712 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
713 type4, arg4, type5, arg5) \
714 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
717 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
720 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
721 type4, arg4, type5, arg5, type6, arg6) \
722 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
723 type5 arg5, type6 arg6) \
725 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
728 safe_syscall3(ssize_t
, read
, int, fd
, void *, buff
, size_t, count
)
729 safe_syscall3(ssize_t
, write
, int, fd
, const void *, buff
, size_t, count
)
730 safe_syscall4(int, openat
, int, dirfd
, const char *, pathname
, \
731 int, flags
, mode_t
, mode
)
732 safe_syscall4(pid_t
, wait4
, pid_t
, pid
, int *, status
, int, options
, \
733 struct rusage
*, rusage
)
734 safe_syscall5(int, waitid
, idtype_t
, idtype
, id_t
, id
, siginfo_t
*, infop
, \
735 int, options
, struct rusage
*, rusage
)
736 safe_syscall3(int, execve
, const char *, filename
, char **, argv
, char **, envp
)
737 safe_syscall6(int, pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
, \
738 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
)
739 safe_syscall5(int, ppoll
, struct pollfd
*, ufds
, unsigned int, nfds
,
740 struct timespec
*, tsp
, const sigset_t
*, sigmask
,
742 safe_syscall6(int, epoll_pwait
, int, epfd
, struct epoll_event
*, events
,
743 int, maxevents
, int, timeout
, const sigset_t
*, sigmask
,
745 safe_syscall6(int,futex
,int *,uaddr
,int,op
,int,val
, \
746 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
747 safe_syscall2(int, rt_sigsuspend
, sigset_t
*, newset
, size_t, sigsetsize
)
748 safe_syscall2(int, kill
, pid_t
, pid
, int, sig
)
749 safe_syscall2(int, tkill
, int, tid
, int, sig
)
750 safe_syscall3(int, tgkill
, int, tgid
, int, pid
, int, sig
)
751 safe_syscall3(ssize_t
, readv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
752 safe_syscall3(ssize_t
, writev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
753 safe_syscall5(ssize_t
, preadv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
754 unsigned long, pos_l
, unsigned long, pos_h
)
755 safe_syscall5(ssize_t
, pwritev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
756 unsigned long, pos_l
, unsigned long, pos_h
)
757 safe_syscall3(int, connect
, int, fd
, const struct sockaddr
*, addr
,
759 safe_syscall6(ssize_t
, sendto
, int, fd
, const void *, buf
, size_t, len
,
760 int, flags
, const struct sockaddr
*, addr
, socklen_t
, addrlen
)
761 safe_syscall6(ssize_t
, recvfrom
, int, fd
, void *, buf
, size_t, len
,
762 int, flags
, struct sockaddr
*, addr
, socklen_t
*, addrlen
)
763 safe_syscall3(ssize_t
, sendmsg
, int, fd
, const struct msghdr
*, msg
, int, flags
)
764 safe_syscall3(ssize_t
, recvmsg
, int, fd
, struct msghdr
*, msg
, int, flags
)
765 safe_syscall2(int, flock
, int, fd
, int, operation
)
766 safe_syscall4(int, rt_sigtimedwait
, const sigset_t
*, these
, siginfo_t
*, uinfo
,
767 const struct timespec
*, uts
, size_t, sigsetsize
)
768 safe_syscall4(int, accept4
, int, fd
, struct sockaddr
*, addr
, socklen_t
*, len
,
770 safe_syscall2(int, nanosleep
, const struct timespec
*, req
,
771 struct timespec
*, rem
)
772 #ifdef TARGET_NR_clock_nanosleep
773 safe_syscall4(int, clock_nanosleep
, const clockid_t
, clock
, int, flags
,
774 const struct timespec
*, req
, struct timespec
*, rem
)
777 safe_syscall6(int, ipc
, int, call
, long, first
, long, second
, long, third
,
778 void *, ptr
, long, fifth
)
781 safe_syscall4(int, msgsnd
, int, msgid
, const void *, msgp
, size_t, sz
,
785 safe_syscall5(int, msgrcv
, int, msgid
, void *, msgp
, size_t, sz
,
786 long, msgtype
, int, flags
)
788 #ifdef __NR_semtimedop
789 safe_syscall4(int, semtimedop
, int, semid
, struct sembuf
*, tsops
,
790 unsigned, nsops
, const struct timespec
*, timeout
)
792 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
793 safe_syscall5(int, mq_timedsend
, int, mqdes
, const char *, msg_ptr
,
794 size_t, len
, unsigned, prio
, const struct timespec
*, timeout
)
795 safe_syscall5(int, mq_timedreceive
, int, mqdes
, char *, msg_ptr
,
796 size_t, len
, unsigned *, prio
, const struct timespec
*, timeout
)
798 /* We do ioctl like this rather than via safe_syscall3 to preserve the
799 * "third argument might be integer or pointer or not present" behaviour of
802 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
803 /* Similarly for fcntl. Note that callers must always:
804 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
805 * use the flock64 struct rather than unsuffixed flock
806 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
809 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
811 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
814 static inline int host_to_target_sock_type(int host_type
)
818 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
820 target_type
= TARGET_SOCK_DGRAM
;
823 target_type
= TARGET_SOCK_STREAM
;
826 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
830 #if defined(SOCK_CLOEXEC)
831 if (host_type
& SOCK_CLOEXEC
) {
832 target_type
|= TARGET_SOCK_CLOEXEC
;
836 #if defined(SOCK_NONBLOCK)
837 if (host_type
& SOCK_NONBLOCK
) {
838 target_type
|= TARGET_SOCK_NONBLOCK
;
845 static abi_ulong target_brk
;
846 static abi_ulong target_original_brk
;
847 static abi_ulong brk_page
;
849 void target_set_brk(abi_ulong new_brk
)
851 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
852 brk_page
= HOST_PAGE_ALIGN(target_brk
);
855 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
856 #define DEBUGF_BRK(message, args...)
858 /* do_brk() must return target values and target errnos. */
859 abi_long
do_brk(abi_ulong new_brk
)
861 abi_long mapped_addr
;
862 abi_ulong new_alloc_size
;
864 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx
") -> ", new_brk
);
867 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (!new_brk)\n", target_brk
);
870 if (new_brk
< target_original_brk
) {
871 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk < target_original_brk)\n",
876 /* If the new brk is less than the highest page reserved to the
877 * target heap allocation, set it and we're almost done... */
878 if (new_brk
<= brk_page
) {
879 /* Heap contents are initialized to zero, as for anonymous
881 if (new_brk
> target_brk
) {
882 memset(g2h(target_brk
), 0, new_brk
- target_brk
);
884 target_brk
= new_brk
;
885 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk <= brk_page)\n", target_brk
);
889 /* We need to allocate more memory after the brk... Note that
890 * we don't use MAP_FIXED because that will map over the top of
891 * any existing mapping (like the one with the host libc or qemu
892 * itself); instead we treat "mapped but at wrong address" as
893 * a failure and unmap again.
895 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
);
896 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
897 PROT_READ
|PROT_WRITE
,
898 MAP_ANON
|MAP_PRIVATE
, 0, 0));
900 if (mapped_addr
== brk_page
) {
901 /* Heap contents are initialized to zero, as for anonymous
902 * mapped pages. Technically the new pages are already
903 * initialized to zero since they *are* anonymous mapped
904 * pages, however we have to take care with the contents that
905 * come from the remaining part of the previous page: it may
906 * contains garbage data due to a previous heap usage (grown
908 memset(g2h(target_brk
), 0, brk_page
- target_brk
);
910 target_brk
= new_brk
;
911 brk_page
= HOST_PAGE_ALIGN(target_brk
);
912 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr == brk_page)\n",
915 } else if (mapped_addr
!= -1) {
916 /* Mapped but at wrong address, meaning there wasn't actually
917 * enough space for this brk.
919 target_munmap(mapped_addr
, new_alloc_size
);
921 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr != -1)\n", target_brk
);
924 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (otherwise)\n", target_brk
);
927 #if defined(TARGET_ALPHA)
928 /* We (partially) emulate OSF/1 on Alpha, which requires we
929 return a proper errno, not an unchanged brk value. */
930 return -TARGET_ENOMEM
;
932 /* For everything else, return the previous break. */
936 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
937 abi_ulong target_fds_addr
,
941 abi_ulong b
, *target_fds
;
943 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
944 if (!(target_fds
= lock_user(VERIFY_READ
,
946 sizeof(abi_ulong
) * nw
,
948 return -TARGET_EFAULT
;
952 for (i
= 0; i
< nw
; i
++) {
953 /* grab the abi_ulong */
954 __get_user(b
, &target_fds
[i
]);
955 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
956 /* check the bit inside the abi_ulong */
963 unlock_user(target_fds
, target_fds_addr
, 0);
968 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
969 abi_ulong target_fds_addr
,
972 if (target_fds_addr
) {
973 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
974 return -TARGET_EFAULT
;
982 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
988 abi_ulong
*target_fds
;
990 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
991 if (!(target_fds
= lock_user(VERIFY_WRITE
,
993 sizeof(abi_ulong
) * nw
,
995 return -TARGET_EFAULT
;
998 for (i
= 0; i
< nw
; i
++) {
1000 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1001 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
1004 __put_user(v
, &target_fds
[i
]);
1007 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
1012 #if defined(__alpha__)
1013 #define HOST_HZ 1024
1018 static inline abi_long
host_to_target_clock_t(long ticks
)
1020 #if HOST_HZ == TARGET_HZ
1023 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
1027 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
1028 const struct rusage
*rusage
)
1030 struct target_rusage
*target_rusage
;
1032 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
1033 return -TARGET_EFAULT
;
1034 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
1035 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
1036 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
1037 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
1038 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
1039 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
1040 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
1041 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
1042 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
1043 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
1044 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
1045 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
1046 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
1047 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
1048 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
1049 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
1050 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
1051 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
1052 unlock_user_struct(target_rusage
, target_addr
, 1);
1057 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
1059 abi_ulong target_rlim_swap
;
1062 target_rlim_swap
= tswapal(target_rlim
);
1063 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
1064 return RLIM_INFINITY
;
1066 result
= target_rlim_swap
;
1067 if (target_rlim_swap
!= (rlim_t
)result
)
1068 return RLIM_INFINITY
;
1073 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
1075 abi_ulong target_rlim_swap
;
1078 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
1079 target_rlim_swap
= TARGET_RLIM_INFINITY
;
1081 target_rlim_swap
= rlim
;
1082 result
= tswapal(target_rlim_swap
);
1087 static inline int target_to_host_resource(int code
)
1090 case TARGET_RLIMIT_AS
:
1092 case TARGET_RLIMIT_CORE
:
1094 case TARGET_RLIMIT_CPU
:
1096 case TARGET_RLIMIT_DATA
:
1098 case TARGET_RLIMIT_FSIZE
:
1099 return RLIMIT_FSIZE
;
1100 case TARGET_RLIMIT_LOCKS
:
1101 return RLIMIT_LOCKS
;
1102 case TARGET_RLIMIT_MEMLOCK
:
1103 return RLIMIT_MEMLOCK
;
1104 case TARGET_RLIMIT_MSGQUEUE
:
1105 return RLIMIT_MSGQUEUE
;
1106 case TARGET_RLIMIT_NICE
:
1108 case TARGET_RLIMIT_NOFILE
:
1109 return RLIMIT_NOFILE
;
1110 case TARGET_RLIMIT_NPROC
:
1111 return RLIMIT_NPROC
;
1112 case TARGET_RLIMIT_RSS
:
1114 case TARGET_RLIMIT_RTPRIO
:
1115 return RLIMIT_RTPRIO
;
1116 case TARGET_RLIMIT_SIGPENDING
:
1117 return RLIMIT_SIGPENDING
;
1118 case TARGET_RLIMIT_STACK
:
1119 return RLIMIT_STACK
;
1125 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
1126 abi_ulong target_tv_addr
)
1128 struct target_timeval
*target_tv
;
1130 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1)) {
1131 return -TARGET_EFAULT
;
1134 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1135 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1137 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1142 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
1143 const struct timeval
*tv
)
1145 struct target_timeval
*target_tv
;
1147 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0)) {
1148 return -TARGET_EFAULT
;
1151 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1152 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1154 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1159 static inline abi_long
copy_to_user_timeval64(abi_ulong target_tv_addr
,
1160 const struct timeval
*tv
)
1162 struct target__kernel_sock_timeval
*target_tv
;
1164 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0)) {
1165 return -TARGET_EFAULT
;
1168 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1169 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1171 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1176 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
1177 abi_ulong target_addr
)
1179 struct target_timespec
*target_ts
;
1181 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1)) {
1182 return -TARGET_EFAULT
;
1184 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1185 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1186 unlock_user_struct(target_ts
, target_addr
, 0);
1190 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
1191 struct timespec
*host_ts
)
1193 struct target_timespec
*target_ts
;
1195 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0)) {
1196 return -TARGET_EFAULT
;
1198 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1199 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1200 unlock_user_struct(target_ts
, target_addr
, 1);
1204 static inline abi_long
host_to_target_timespec64(abi_ulong target_addr
,
1205 struct timespec
*host_ts
)
1207 struct target__kernel_timespec
*target_ts
;
1209 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0)) {
1210 return -TARGET_EFAULT
;
1212 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
1213 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
1214 unlock_user_struct(target_ts
, target_addr
, 1);
1218 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
1219 abi_ulong target_tz_addr
)
1221 struct target_timezone
*target_tz
;
1223 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
1224 return -TARGET_EFAULT
;
1227 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1228 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1230 unlock_user_struct(target_tz
, target_tz_addr
, 0);
1235 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1238 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
1239 abi_ulong target_mq_attr_addr
)
1241 struct target_mq_attr
*target_mq_attr
;
1243 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
1244 target_mq_attr_addr
, 1))
1245 return -TARGET_EFAULT
;
1247 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1248 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1249 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1250 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1252 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
1257 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
1258 const struct mq_attr
*attr
)
1260 struct target_mq_attr
*target_mq_attr
;
1262 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
1263 target_mq_attr_addr
, 0))
1264 return -TARGET_EFAULT
;
1266 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1267 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1268 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1269 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1271 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1277 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1278 /* do_select() must return target values and target errnos. */
1279 static abi_long
do_select(int n
,
1280 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1281 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1283 fd_set rfds
, wfds
, efds
;
1284 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1286 struct timespec ts
, *ts_ptr
;
1289 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1293 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1297 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1302 if (target_tv_addr
) {
1303 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1304 return -TARGET_EFAULT
;
1305 ts
.tv_sec
= tv
.tv_sec
;
1306 ts
.tv_nsec
= tv
.tv_usec
* 1000;
1312 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1315 if (!is_error(ret
)) {
1316 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1317 return -TARGET_EFAULT
;
1318 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1319 return -TARGET_EFAULT
;
1320 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1321 return -TARGET_EFAULT
;
1323 if (target_tv_addr
) {
1324 tv
.tv_sec
= ts
.tv_sec
;
1325 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
1326 if (copy_to_user_timeval(target_tv_addr
, &tv
)) {
1327 return -TARGET_EFAULT
;
1335 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1336 static abi_long
do_old_select(abi_ulong arg1
)
1338 struct target_sel_arg_struct
*sel
;
1339 abi_ulong inp
, outp
, exp
, tvp
;
1342 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1)) {
1343 return -TARGET_EFAULT
;
1346 nsel
= tswapal(sel
->n
);
1347 inp
= tswapal(sel
->inp
);
1348 outp
= tswapal(sel
->outp
);
1349 exp
= tswapal(sel
->exp
);
1350 tvp
= tswapal(sel
->tvp
);
1352 unlock_user_struct(sel
, arg1
, 0);
1354 return do_select(nsel
, inp
, outp
, exp
, tvp
);
1359 static abi_long
do_pipe2(int host_pipe
[], int flags
)
1362 return pipe2(host_pipe
, flags
);
1368 static abi_long
do_pipe(void *cpu_env
, abi_ulong pipedes
,
1369 int flags
, int is_pipe2
)
1373 ret
= flags
? do_pipe2(host_pipe
, flags
) : pipe(host_pipe
);
1376 return get_errno(ret
);
1378 /* Several targets have special calling conventions for the original
1379 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1381 #if defined(TARGET_ALPHA)
1382 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = host_pipe
[1];
1383 return host_pipe
[0];
1384 #elif defined(TARGET_MIPS)
1385 ((CPUMIPSState
*)cpu_env
)->active_tc
.gpr
[3] = host_pipe
[1];
1386 return host_pipe
[0];
1387 #elif defined(TARGET_SH4)
1388 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
1389 return host_pipe
[0];
1390 #elif defined(TARGET_SPARC)
1391 ((CPUSPARCState
*)cpu_env
)->regwptr
[1] = host_pipe
[1];
1392 return host_pipe
[0];
1396 if (put_user_s32(host_pipe
[0], pipedes
)
1397 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(host_pipe
[0])))
1398 return -TARGET_EFAULT
;
1399 return get_errno(ret
);
1402 static inline abi_long
target_to_host_ip_mreq(struct ip_mreqn
*mreqn
,
1403 abi_ulong target_addr
,
1406 struct target_ip_mreqn
*target_smreqn
;
1408 target_smreqn
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1410 return -TARGET_EFAULT
;
1411 mreqn
->imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
1412 mreqn
->imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
1413 if (len
== sizeof(struct target_ip_mreqn
))
1414 mreqn
->imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
1415 unlock_user(target_smreqn
, target_addr
, 0);
1420 static inline abi_long
target_to_host_sockaddr(int fd
, struct sockaddr
*addr
,
1421 abi_ulong target_addr
,
1424 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1425 sa_family_t sa_family
;
1426 struct target_sockaddr
*target_saddr
;
1428 if (fd_trans_target_to_host_addr(fd
)) {
1429 return fd_trans_target_to_host_addr(fd
)(addr
, target_addr
, len
);
1432 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1434 return -TARGET_EFAULT
;
1436 sa_family
= tswap16(target_saddr
->sa_family
);
1438 /* Oops. The caller might send a incomplete sun_path; sun_path
1439 * must be terminated by \0 (see the manual page), but
1440 * unfortunately it is quite common to specify sockaddr_un
1441 * length as "strlen(x->sun_path)" while it should be
1442 * "strlen(...) + 1". We'll fix that here if needed.
1443 * Linux kernel has a similar feature.
1446 if (sa_family
== AF_UNIX
) {
1447 if (len
< unix_maxlen
&& len
> 0) {
1448 char *cp
= (char*)target_saddr
;
1450 if ( cp
[len
-1] && !cp
[len
] )
1453 if (len
> unix_maxlen
)
1457 memcpy(addr
, target_saddr
, len
);
1458 addr
->sa_family
= sa_family
;
1459 if (sa_family
== AF_NETLINK
) {
1460 struct sockaddr_nl
*nladdr
;
1462 nladdr
= (struct sockaddr_nl
*)addr
;
1463 nladdr
->nl_pid
= tswap32(nladdr
->nl_pid
);
1464 nladdr
->nl_groups
= tswap32(nladdr
->nl_groups
);
1465 } else if (sa_family
== AF_PACKET
) {
1466 struct target_sockaddr_ll
*lladdr
;
1468 lladdr
= (struct target_sockaddr_ll
*)addr
;
1469 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1470 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1472 unlock_user(target_saddr
, target_addr
, 0);
1477 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1478 struct sockaddr
*addr
,
1481 struct target_sockaddr
*target_saddr
;
1488 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1490 return -TARGET_EFAULT
;
1491 memcpy(target_saddr
, addr
, len
);
1492 if (len
>= offsetof(struct target_sockaddr
, sa_family
) +
1493 sizeof(target_saddr
->sa_family
)) {
1494 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1496 if (addr
->sa_family
== AF_NETLINK
&& len
>= sizeof(struct sockaddr_nl
)) {
1497 struct sockaddr_nl
*target_nl
= (struct sockaddr_nl
*)target_saddr
;
1498 target_nl
->nl_pid
= tswap32(target_nl
->nl_pid
);
1499 target_nl
->nl_groups
= tswap32(target_nl
->nl_groups
);
1500 } else if (addr
->sa_family
== AF_PACKET
) {
1501 struct sockaddr_ll
*target_ll
= (struct sockaddr_ll
*)target_saddr
;
1502 target_ll
->sll_ifindex
= tswap32(target_ll
->sll_ifindex
);
1503 target_ll
->sll_hatype
= tswap16(target_ll
->sll_hatype
);
1504 } else if (addr
->sa_family
== AF_INET6
&&
1505 len
>= sizeof(struct target_sockaddr_in6
)) {
1506 struct target_sockaddr_in6
*target_in6
=
1507 (struct target_sockaddr_in6
*)target_saddr
;
1508 target_in6
->sin6_scope_id
= tswap16(target_in6
->sin6_scope_id
);
1510 unlock_user(target_saddr
, target_addr
, len
);
1515 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1516 struct target_msghdr
*target_msgh
)
1518 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1519 abi_long msg_controllen
;
1520 abi_ulong target_cmsg_addr
;
1521 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1522 socklen_t space
= 0;
1524 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1525 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1527 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1528 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1529 target_cmsg_start
= target_cmsg
;
1531 return -TARGET_EFAULT
;
1533 while (cmsg
&& target_cmsg
) {
1534 void *data
= CMSG_DATA(cmsg
);
1535 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1537 int len
= tswapal(target_cmsg
->cmsg_len
)
1538 - sizeof(struct target_cmsghdr
);
1540 space
+= CMSG_SPACE(len
);
1541 if (space
> msgh
->msg_controllen
) {
1542 space
-= CMSG_SPACE(len
);
1543 /* This is a QEMU bug, since we allocated the payload
1544 * area ourselves (unlike overflow in host-to-target
1545 * conversion, which is just the guest giving us a buffer
1546 * that's too small). It can't happen for the payload types
1547 * we currently support; if it becomes an issue in future
1548 * we would need to improve our allocation strategy to
1549 * something more intelligent than "twice the size of the
1550 * target buffer we're reading from".
1552 gemu_log("Host cmsg overflow\n");
1556 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1557 cmsg
->cmsg_level
= SOL_SOCKET
;
1559 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1561 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1562 cmsg
->cmsg_len
= CMSG_LEN(len
);
1564 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1565 int *fd
= (int *)data
;
1566 int *target_fd
= (int *)target_data
;
1567 int i
, numfds
= len
/ sizeof(int);
1569 for (i
= 0; i
< numfds
; i
++) {
1570 __get_user(fd
[i
], target_fd
+ i
);
1572 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1573 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1574 struct ucred
*cred
= (struct ucred
*)data
;
1575 struct target_ucred
*target_cred
=
1576 (struct target_ucred
*)target_data
;
1578 __get_user(cred
->pid
, &target_cred
->pid
);
1579 __get_user(cred
->uid
, &target_cred
->uid
);
1580 __get_user(cred
->gid
, &target_cred
->gid
);
1582 gemu_log("Unsupported ancillary data: %d/%d\n",
1583 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1584 memcpy(data
, target_data
, len
);
1587 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1588 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1591 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1593 msgh
->msg_controllen
= space
;
1597 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1598 struct msghdr
*msgh
)
1600 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1601 abi_long msg_controllen
;
1602 abi_ulong target_cmsg_addr
;
1603 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1604 socklen_t space
= 0;
1606 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1607 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1609 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1610 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1611 target_cmsg_start
= target_cmsg
;
1613 return -TARGET_EFAULT
;
1615 while (cmsg
&& target_cmsg
) {
1616 void *data
= CMSG_DATA(cmsg
);
1617 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1619 int len
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1620 int tgt_len
, tgt_space
;
1622 /* We never copy a half-header but may copy half-data;
1623 * this is Linux's behaviour in put_cmsg(). Note that
1624 * truncation here is a guest problem (which we report
1625 * to the guest via the CTRUNC bit), unlike truncation
1626 * in target_to_host_cmsg, which is a QEMU bug.
1628 if (msg_controllen
< sizeof(struct target_cmsghdr
)) {
1629 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1633 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1634 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1636 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1638 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1640 /* Payload types which need a different size of payload on
1641 * the target must adjust tgt_len here.
1644 switch (cmsg
->cmsg_level
) {
1646 switch (cmsg
->cmsg_type
) {
1648 tgt_len
= sizeof(struct target_timeval
);
1658 if (msg_controllen
< TARGET_CMSG_LEN(tgt_len
)) {
1659 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1660 tgt_len
= msg_controllen
- sizeof(struct target_cmsghdr
);
1663 /* We must now copy-and-convert len bytes of payload
1664 * into tgt_len bytes of destination space. Bear in mind
1665 * that in both source and destination we may be dealing
1666 * with a truncated value!
1668 switch (cmsg
->cmsg_level
) {
1670 switch (cmsg
->cmsg_type
) {
1673 int *fd
= (int *)data
;
1674 int *target_fd
= (int *)target_data
;
1675 int i
, numfds
= tgt_len
/ sizeof(int);
1677 for (i
= 0; i
< numfds
; i
++) {
1678 __put_user(fd
[i
], target_fd
+ i
);
1684 struct timeval
*tv
= (struct timeval
*)data
;
1685 struct target_timeval
*target_tv
=
1686 (struct target_timeval
*)target_data
;
1688 if (len
!= sizeof(struct timeval
) ||
1689 tgt_len
!= sizeof(struct target_timeval
)) {
1693 /* copy struct timeval to target */
1694 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1695 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1698 case SCM_CREDENTIALS
:
1700 struct ucred
*cred
= (struct ucred
*)data
;
1701 struct target_ucred
*target_cred
=
1702 (struct target_ucred
*)target_data
;
1704 __put_user(cred
->pid
, &target_cred
->pid
);
1705 __put_user(cred
->uid
, &target_cred
->uid
);
1706 __put_user(cred
->gid
, &target_cred
->gid
);
1715 switch (cmsg
->cmsg_type
) {
1718 uint32_t *v
= (uint32_t *)data
;
1719 uint32_t *t_int
= (uint32_t *)target_data
;
1721 if (len
!= sizeof(uint32_t) ||
1722 tgt_len
!= sizeof(uint32_t)) {
1725 __put_user(*v
, t_int
);
1731 struct sock_extended_err ee
;
1732 struct sockaddr_in offender
;
1734 struct errhdr_t
*errh
= (struct errhdr_t
*)data
;
1735 struct errhdr_t
*target_errh
=
1736 (struct errhdr_t
*)target_data
;
1738 if (len
!= sizeof(struct errhdr_t
) ||
1739 tgt_len
!= sizeof(struct errhdr_t
)) {
1742 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1743 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1744 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1745 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1746 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1747 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1748 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1749 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1750 (void *) &errh
->offender
, sizeof(errh
->offender
));
1759 switch (cmsg
->cmsg_type
) {
1762 uint32_t *v
= (uint32_t *)data
;
1763 uint32_t *t_int
= (uint32_t *)target_data
;
1765 if (len
!= sizeof(uint32_t) ||
1766 tgt_len
!= sizeof(uint32_t)) {
1769 __put_user(*v
, t_int
);
1775 struct sock_extended_err ee
;
1776 struct sockaddr_in6 offender
;
1778 struct errhdr6_t
*errh
= (struct errhdr6_t
*)data
;
1779 struct errhdr6_t
*target_errh
=
1780 (struct errhdr6_t
*)target_data
;
1782 if (len
!= sizeof(struct errhdr6_t
) ||
1783 tgt_len
!= sizeof(struct errhdr6_t
)) {
1786 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1787 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1788 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1789 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1790 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1791 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1792 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1793 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1794 (void *) &errh
->offender
, sizeof(errh
->offender
));
1804 gemu_log("Unsupported ancillary data: %d/%d\n",
1805 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1806 memcpy(target_data
, data
, MIN(len
, tgt_len
));
1807 if (tgt_len
> len
) {
1808 memset(target_data
+ len
, 0, tgt_len
- len
);
1812 target_cmsg
->cmsg_len
= tswapal(TARGET_CMSG_LEN(tgt_len
));
1813 tgt_space
= TARGET_CMSG_SPACE(tgt_len
);
1814 if (msg_controllen
< tgt_space
) {
1815 tgt_space
= msg_controllen
;
1817 msg_controllen
-= tgt_space
;
1819 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1820 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1823 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
1825 target_msgh
->msg_controllen
= tswapal(space
);
1829 /* do_setsockopt() Must return target values and target errnos. */
1830 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
1831 abi_ulong optval_addr
, socklen_t optlen
)
1835 struct ip_mreqn
*ip_mreq
;
1836 struct ip_mreq_source
*ip_mreq_source
;
1840 /* TCP options all take an 'int' value. */
1841 if (optlen
< sizeof(uint32_t))
1842 return -TARGET_EINVAL
;
1844 if (get_user_u32(val
, optval_addr
))
1845 return -TARGET_EFAULT
;
1846 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1853 case IP_ROUTER_ALERT
:
1857 case IP_MTU_DISCOVER
:
1864 case IP_MULTICAST_TTL
:
1865 case IP_MULTICAST_LOOP
:
1867 if (optlen
>= sizeof(uint32_t)) {
1868 if (get_user_u32(val
, optval_addr
))
1869 return -TARGET_EFAULT
;
1870 } else if (optlen
>= 1) {
1871 if (get_user_u8(val
, optval_addr
))
1872 return -TARGET_EFAULT
;
1874 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1876 case IP_ADD_MEMBERSHIP
:
1877 case IP_DROP_MEMBERSHIP
:
1878 if (optlen
< sizeof (struct target_ip_mreq
) ||
1879 optlen
> sizeof (struct target_ip_mreqn
))
1880 return -TARGET_EINVAL
;
1882 ip_mreq
= (struct ip_mreqn
*) alloca(optlen
);
1883 target_to_host_ip_mreq(ip_mreq
, optval_addr
, optlen
);
1884 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq
, optlen
));
1887 case IP_BLOCK_SOURCE
:
1888 case IP_UNBLOCK_SOURCE
:
1889 case IP_ADD_SOURCE_MEMBERSHIP
:
1890 case IP_DROP_SOURCE_MEMBERSHIP
:
1891 if (optlen
!= sizeof (struct target_ip_mreq_source
))
1892 return -TARGET_EINVAL
;
1894 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
1895 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
1896 unlock_user (ip_mreq_source
, optval_addr
, 0);
1905 case IPV6_MTU_DISCOVER
:
1908 case IPV6_RECVPKTINFO
:
1909 case IPV6_UNICAST_HOPS
:
1910 case IPV6_MULTICAST_HOPS
:
1911 case IPV6_MULTICAST_LOOP
:
1913 case IPV6_RECVHOPLIMIT
:
1914 case IPV6_2292HOPLIMIT
:
1917 case IPV6_2292PKTINFO
:
1918 case IPV6_RECVTCLASS
:
1919 case IPV6_RECVRTHDR
:
1920 case IPV6_2292RTHDR
:
1921 case IPV6_RECVHOPOPTS
:
1922 case IPV6_2292HOPOPTS
:
1923 case IPV6_RECVDSTOPTS
:
1924 case IPV6_2292DSTOPTS
:
1926 #ifdef IPV6_RECVPATHMTU
1927 case IPV6_RECVPATHMTU
:
1929 #ifdef IPV6_TRANSPARENT
1930 case IPV6_TRANSPARENT
:
1932 #ifdef IPV6_FREEBIND
1935 #ifdef IPV6_RECVORIGDSTADDR
1936 case IPV6_RECVORIGDSTADDR
:
1939 if (optlen
< sizeof(uint32_t)) {
1940 return -TARGET_EINVAL
;
1942 if (get_user_u32(val
, optval_addr
)) {
1943 return -TARGET_EFAULT
;
1945 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1946 &val
, sizeof(val
)));
1950 struct in6_pktinfo pki
;
1952 if (optlen
< sizeof(pki
)) {
1953 return -TARGET_EINVAL
;
1956 if (copy_from_user(&pki
, optval_addr
, sizeof(pki
))) {
1957 return -TARGET_EFAULT
;
1960 pki
.ipi6_ifindex
= tswap32(pki
.ipi6_ifindex
);
1962 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1963 &pki
, sizeof(pki
)));
1966 case IPV6_ADD_MEMBERSHIP
:
1967 case IPV6_DROP_MEMBERSHIP
:
1969 struct ipv6_mreq ipv6mreq
;
1971 if (optlen
< sizeof(ipv6mreq
)) {
1972 return -TARGET_EINVAL
;
1975 if (copy_from_user(&ipv6mreq
, optval_addr
, sizeof(ipv6mreq
))) {
1976 return -TARGET_EFAULT
;
1979 ipv6mreq
.ipv6mr_interface
= tswap32(ipv6mreq
.ipv6mr_interface
);
1981 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1982 &ipv6mreq
, sizeof(ipv6mreq
)));
1993 struct icmp6_filter icmp6f
;
1995 if (optlen
> sizeof(icmp6f
)) {
1996 optlen
= sizeof(icmp6f
);
1999 if (copy_from_user(&icmp6f
, optval_addr
, optlen
)) {
2000 return -TARGET_EFAULT
;
2003 for (val
= 0; val
< 8; val
++) {
2004 icmp6f
.data
[val
] = tswap32(icmp6f
.data
[val
]);
2007 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2019 /* those take an u32 value */
2020 if (optlen
< sizeof(uint32_t)) {
2021 return -TARGET_EINVAL
;
2024 if (get_user_u32(val
, optval_addr
)) {
2025 return -TARGET_EFAULT
;
2027 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2028 &val
, sizeof(val
)));
2035 #if defined(SOL_ALG) && defined(ALG_SET_KEY) && defined(ALG_SET_AEAD_AUTHSIZE)
2040 char *alg_key
= g_malloc(optlen
);
2043 return -TARGET_ENOMEM
;
2045 if (copy_from_user(alg_key
, optval_addr
, optlen
)) {
2047 return -TARGET_EFAULT
;
2049 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2054 case ALG_SET_AEAD_AUTHSIZE
:
2056 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2065 case TARGET_SOL_SOCKET
:
2067 case TARGET_SO_RCVTIMEO
:
2071 optname
= SO_RCVTIMEO
;
2074 if (optlen
!= sizeof(struct target_timeval
)) {
2075 return -TARGET_EINVAL
;
2078 if (copy_from_user_timeval(&tv
, optval_addr
)) {
2079 return -TARGET_EFAULT
;
2082 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
2086 case TARGET_SO_SNDTIMEO
:
2087 optname
= SO_SNDTIMEO
;
2089 case TARGET_SO_ATTACH_FILTER
:
2091 struct target_sock_fprog
*tfprog
;
2092 struct target_sock_filter
*tfilter
;
2093 struct sock_fprog fprog
;
2094 struct sock_filter
*filter
;
2097 if (optlen
!= sizeof(*tfprog
)) {
2098 return -TARGET_EINVAL
;
2100 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
2101 return -TARGET_EFAULT
;
2103 if (!lock_user_struct(VERIFY_READ
, tfilter
,
2104 tswapal(tfprog
->filter
), 0)) {
2105 unlock_user_struct(tfprog
, optval_addr
, 1);
2106 return -TARGET_EFAULT
;
2109 fprog
.len
= tswap16(tfprog
->len
);
2110 filter
= g_try_new(struct sock_filter
, fprog
.len
);
2111 if (filter
== NULL
) {
2112 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2113 unlock_user_struct(tfprog
, optval_addr
, 1);
2114 return -TARGET_ENOMEM
;
2116 for (i
= 0; i
< fprog
.len
; i
++) {
2117 filter
[i
].code
= tswap16(tfilter
[i
].code
);
2118 filter
[i
].jt
= tfilter
[i
].jt
;
2119 filter
[i
].jf
= tfilter
[i
].jf
;
2120 filter
[i
].k
= tswap32(tfilter
[i
].k
);
2122 fprog
.filter
= filter
;
2124 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
2125 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
2128 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2129 unlock_user_struct(tfprog
, optval_addr
, 1);
2132 case TARGET_SO_BINDTODEVICE
:
2134 char *dev_ifname
, *addr_ifname
;
2136 if (optlen
> IFNAMSIZ
- 1) {
2137 optlen
= IFNAMSIZ
- 1;
2139 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2141 return -TARGET_EFAULT
;
2143 optname
= SO_BINDTODEVICE
;
2144 addr_ifname
= alloca(IFNAMSIZ
);
2145 memcpy(addr_ifname
, dev_ifname
, optlen
);
2146 addr_ifname
[optlen
] = 0;
2147 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
2148 addr_ifname
, optlen
));
2149 unlock_user (dev_ifname
, optval_addr
, 0);
2152 case TARGET_SO_LINGER
:
2155 struct target_linger
*tlg
;
2157 if (optlen
!= sizeof(struct target_linger
)) {
2158 return -TARGET_EINVAL
;
2160 if (!lock_user_struct(VERIFY_READ
, tlg
, optval_addr
, 1)) {
2161 return -TARGET_EFAULT
;
2163 __get_user(lg
.l_onoff
, &tlg
->l_onoff
);
2164 __get_user(lg
.l_linger
, &tlg
->l_linger
);
2165 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, SO_LINGER
,
2167 unlock_user_struct(tlg
, optval_addr
, 0);
2170 /* Options with 'int' argument. */
2171 case TARGET_SO_DEBUG
:
2174 case TARGET_SO_REUSEADDR
:
2175 optname
= SO_REUSEADDR
;
2178 case TARGET_SO_REUSEPORT
:
2179 optname
= SO_REUSEPORT
;
2182 case TARGET_SO_TYPE
:
2185 case TARGET_SO_ERROR
:
2188 case TARGET_SO_DONTROUTE
:
2189 optname
= SO_DONTROUTE
;
2191 case TARGET_SO_BROADCAST
:
2192 optname
= SO_BROADCAST
;
2194 case TARGET_SO_SNDBUF
:
2195 optname
= SO_SNDBUF
;
2197 case TARGET_SO_SNDBUFFORCE
:
2198 optname
= SO_SNDBUFFORCE
;
2200 case TARGET_SO_RCVBUF
:
2201 optname
= SO_RCVBUF
;
2203 case TARGET_SO_RCVBUFFORCE
:
2204 optname
= SO_RCVBUFFORCE
;
2206 case TARGET_SO_KEEPALIVE
:
2207 optname
= SO_KEEPALIVE
;
2209 case TARGET_SO_OOBINLINE
:
2210 optname
= SO_OOBINLINE
;
2212 case TARGET_SO_NO_CHECK
:
2213 optname
= SO_NO_CHECK
;
2215 case TARGET_SO_PRIORITY
:
2216 optname
= SO_PRIORITY
;
2219 case TARGET_SO_BSDCOMPAT
:
2220 optname
= SO_BSDCOMPAT
;
2223 case TARGET_SO_PASSCRED
:
2224 optname
= SO_PASSCRED
;
2226 case TARGET_SO_PASSSEC
:
2227 optname
= SO_PASSSEC
;
2229 case TARGET_SO_TIMESTAMP
:
2230 optname
= SO_TIMESTAMP
;
2232 case TARGET_SO_RCVLOWAT
:
2233 optname
= SO_RCVLOWAT
;
2238 if (optlen
< sizeof(uint32_t))
2239 return -TARGET_EINVAL
;
2241 if (get_user_u32(val
, optval_addr
))
2242 return -TARGET_EFAULT
;
2243 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
2247 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level
, optname
);
2248 ret
= -TARGET_ENOPROTOOPT
;
2253 /* do_getsockopt() Must return target values and target errnos. */
2254 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
2255 abi_ulong optval_addr
, abi_ulong optlen
)
2262 case TARGET_SOL_SOCKET
:
2265 /* These don't just return a single integer */
2266 case TARGET_SO_RCVTIMEO
:
2267 case TARGET_SO_SNDTIMEO
:
2268 case TARGET_SO_PEERNAME
:
2270 case TARGET_SO_PEERCRED
: {
2273 struct target_ucred
*tcr
;
2275 if (get_user_u32(len
, optlen
)) {
2276 return -TARGET_EFAULT
;
2279 return -TARGET_EINVAL
;
2283 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
2291 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
2292 return -TARGET_EFAULT
;
2294 __put_user(cr
.pid
, &tcr
->pid
);
2295 __put_user(cr
.uid
, &tcr
->uid
);
2296 __put_user(cr
.gid
, &tcr
->gid
);
2297 unlock_user_struct(tcr
, optval_addr
, 1);
2298 if (put_user_u32(len
, optlen
)) {
2299 return -TARGET_EFAULT
;
2303 case TARGET_SO_LINGER
:
2307 struct target_linger
*tlg
;
2309 if (get_user_u32(len
, optlen
)) {
2310 return -TARGET_EFAULT
;
2313 return -TARGET_EINVAL
;
2317 ret
= get_errno(getsockopt(sockfd
, level
, SO_LINGER
,
2325 if (!lock_user_struct(VERIFY_WRITE
, tlg
, optval_addr
, 0)) {
2326 return -TARGET_EFAULT
;
2328 __put_user(lg
.l_onoff
, &tlg
->l_onoff
);
2329 __put_user(lg
.l_linger
, &tlg
->l_linger
);
2330 unlock_user_struct(tlg
, optval_addr
, 1);
2331 if (put_user_u32(len
, optlen
)) {
2332 return -TARGET_EFAULT
;
2336 /* Options with 'int' argument. */
2337 case TARGET_SO_DEBUG
:
2340 case TARGET_SO_REUSEADDR
:
2341 optname
= SO_REUSEADDR
;
2344 case TARGET_SO_REUSEPORT
:
2345 optname
= SO_REUSEPORT
;
2348 case TARGET_SO_TYPE
:
2351 case TARGET_SO_ERROR
:
2354 case TARGET_SO_DONTROUTE
:
2355 optname
= SO_DONTROUTE
;
2357 case TARGET_SO_BROADCAST
:
2358 optname
= SO_BROADCAST
;
2360 case TARGET_SO_SNDBUF
:
2361 optname
= SO_SNDBUF
;
2363 case TARGET_SO_RCVBUF
:
2364 optname
= SO_RCVBUF
;
2366 case TARGET_SO_KEEPALIVE
:
2367 optname
= SO_KEEPALIVE
;
2369 case TARGET_SO_OOBINLINE
:
2370 optname
= SO_OOBINLINE
;
2372 case TARGET_SO_NO_CHECK
:
2373 optname
= SO_NO_CHECK
;
2375 case TARGET_SO_PRIORITY
:
2376 optname
= SO_PRIORITY
;
2379 case TARGET_SO_BSDCOMPAT
:
2380 optname
= SO_BSDCOMPAT
;
2383 case TARGET_SO_PASSCRED
:
2384 optname
= SO_PASSCRED
;
2386 case TARGET_SO_TIMESTAMP
:
2387 optname
= SO_TIMESTAMP
;
2389 case TARGET_SO_RCVLOWAT
:
2390 optname
= SO_RCVLOWAT
;
2392 case TARGET_SO_ACCEPTCONN
:
2393 optname
= SO_ACCEPTCONN
;
2400 /* TCP options all take an 'int' value. */
2402 if (get_user_u32(len
, optlen
))
2403 return -TARGET_EFAULT
;
2405 return -TARGET_EINVAL
;
2407 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2410 if (optname
== SO_TYPE
) {
2411 val
= host_to_target_sock_type(val
);
2416 if (put_user_u32(val
, optval_addr
))
2417 return -TARGET_EFAULT
;
2419 if (put_user_u8(val
, optval_addr
))
2420 return -TARGET_EFAULT
;
2422 if (put_user_u32(len
, optlen
))
2423 return -TARGET_EFAULT
;
2430 case IP_ROUTER_ALERT
:
2434 case IP_MTU_DISCOVER
:
2440 case IP_MULTICAST_TTL
:
2441 case IP_MULTICAST_LOOP
:
2442 if (get_user_u32(len
, optlen
))
2443 return -TARGET_EFAULT
;
2445 return -TARGET_EINVAL
;
2447 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2450 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2452 if (put_user_u32(len
, optlen
)
2453 || put_user_u8(val
, optval_addr
))
2454 return -TARGET_EFAULT
;
2456 if (len
> sizeof(int))
2458 if (put_user_u32(len
, optlen
)
2459 || put_user_u32(val
, optval_addr
))
2460 return -TARGET_EFAULT
;
2464 ret
= -TARGET_ENOPROTOOPT
;
2470 case IPV6_MTU_DISCOVER
:
2473 case IPV6_RECVPKTINFO
:
2474 case IPV6_UNICAST_HOPS
:
2475 case IPV6_MULTICAST_HOPS
:
2476 case IPV6_MULTICAST_LOOP
:
2478 case IPV6_RECVHOPLIMIT
:
2479 case IPV6_2292HOPLIMIT
:
2482 case IPV6_2292PKTINFO
:
2483 case IPV6_RECVTCLASS
:
2484 case IPV6_RECVRTHDR
:
2485 case IPV6_2292RTHDR
:
2486 case IPV6_RECVHOPOPTS
:
2487 case IPV6_2292HOPOPTS
:
2488 case IPV6_RECVDSTOPTS
:
2489 case IPV6_2292DSTOPTS
:
2491 #ifdef IPV6_RECVPATHMTU
2492 case IPV6_RECVPATHMTU
:
2494 #ifdef IPV6_TRANSPARENT
2495 case IPV6_TRANSPARENT
:
2497 #ifdef IPV6_FREEBIND
2500 #ifdef IPV6_RECVORIGDSTADDR
2501 case IPV6_RECVORIGDSTADDR
:
2503 if (get_user_u32(len
, optlen
))
2504 return -TARGET_EFAULT
;
2506 return -TARGET_EINVAL
;
2508 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2511 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2513 if (put_user_u32(len
, optlen
)
2514 || put_user_u8(val
, optval_addr
))
2515 return -TARGET_EFAULT
;
2517 if (len
> sizeof(int))
2519 if (put_user_u32(len
, optlen
)
2520 || put_user_u32(val
, optval_addr
))
2521 return -TARGET_EFAULT
;
2525 ret
= -TARGET_ENOPROTOOPT
;
2531 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
2533 ret
= -TARGET_EOPNOTSUPP
;
2539 /* Convert target low/high pair representing file offset into the host
2540 * low/high pair. This function doesn't handle offsets bigger than 64 bits
2541 * as the kernel doesn't handle them either.
2543 static void target_to_host_low_high(abi_ulong tlow
,
2545 unsigned long *hlow
,
2546 unsigned long *hhigh
)
2548 uint64_t off
= tlow
|
2549 ((unsigned long long)thigh
<< TARGET_LONG_BITS
/ 2) <<
2550 TARGET_LONG_BITS
/ 2;
2553 *hhigh
= (off
>> HOST_LONG_BITS
/ 2) >> HOST_LONG_BITS
/ 2;
2556 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
2557 abi_ulong count
, int copy
)
2559 struct target_iovec
*target_vec
;
2561 abi_ulong total_len
, max_len
;
2564 bool bad_address
= false;
2570 if (count
> IOV_MAX
) {
2575 vec
= g_try_new0(struct iovec
, count
);
2581 target_vec
= lock_user(VERIFY_READ
, target_addr
,
2582 count
* sizeof(struct target_iovec
), 1);
2583 if (target_vec
== NULL
) {
2588 /* ??? If host page size > target page size, this will result in a
2589 value larger than what we can actually support. */
2590 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
2593 for (i
= 0; i
< count
; i
++) {
2594 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
2595 abi_long len
= tswapal(target_vec
[i
].iov_len
);
2600 } else if (len
== 0) {
2601 /* Zero length pointer is ignored. */
2602 vec
[i
].iov_base
= 0;
2604 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
2605 /* If the first buffer pointer is bad, this is a fault. But
2606 * subsequent bad buffers will result in a partial write; this
2607 * is realized by filling the vector with null pointers and
2609 if (!vec
[i
].iov_base
) {
2620 if (len
> max_len
- total_len
) {
2621 len
= max_len
- total_len
;
2624 vec
[i
].iov_len
= len
;
2628 unlock_user(target_vec
, target_addr
, 0);
2633 if (tswapal(target_vec
[i
].iov_len
) > 0) {
2634 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
2637 unlock_user(target_vec
, target_addr
, 0);
2644 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
2645 abi_ulong count
, int copy
)
2647 struct target_iovec
*target_vec
;
2650 target_vec
= lock_user(VERIFY_READ
, target_addr
,
2651 count
* sizeof(struct target_iovec
), 1);
2653 for (i
= 0; i
< count
; i
++) {
2654 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
2655 abi_long len
= tswapal(target_vec
[i
].iov_len
);
2659 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
2661 unlock_user(target_vec
, target_addr
, 0);
2667 static inline int target_to_host_sock_type(int *type
)
2670 int target_type
= *type
;
2672 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
2673 case TARGET_SOCK_DGRAM
:
2674 host_type
= SOCK_DGRAM
;
2676 case TARGET_SOCK_STREAM
:
2677 host_type
= SOCK_STREAM
;
2680 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
2683 if (target_type
& TARGET_SOCK_CLOEXEC
) {
2684 #if defined(SOCK_CLOEXEC)
2685 host_type
|= SOCK_CLOEXEC
;
2687 return -TARGET_EINVAL
;
2690 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2691 #if defined(SOCK_NONBLOCK)
2692 host_type
|= SOCK_NONBLOCK
;
2693 #elif !defined(O_NONBLOCK)
2694 return -TARGET_EINVAL
;
2701 /* Try to emulate socket type flags after socket creation. */
2702 static int sock_flags_fixup(int fd
, int target_type
)
2704 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
2705 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2706 int flags
= fcntl(fd
, F_GETFL
);
2707 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
2709 return -TARGET_EINVAL
;
2716 /* do_socket() Must return target values and target errnos. */
2717 static abi_long
do_socket(int domain
, int type
, int protocol
)
2719 int target_type
= type
;
2722 ret
= target_to_host_sock_type(&type
);
2727 if (domain
== PF_NETLINK
&& !(
2728 #ifdef CONFIG_RTNETLINK
2729 protocol
== NETLINK_ROUTE
||
2731 protocol
== NETLINK_KOBJECT_UEVENT
||
2732 protocol
== NETLINK_AUDIT
)) {
2733 return -EPFNOSUPPORT
;
2736 if (domain
== AF_PACKET
||
2737 (domain
== AF_INET
&& type
== SOCK_PACKET
)) {
2738 protocol
= tswap16(protocol
);
2741 ret
= get_errno(socket(domain
, type
, protocol
));
2743 ret
= sock_flags_fixup(ret
, target_type
);
2744 if (type
== SOCK_PACKET
) {
2745 /* Manage an obsolete case :
2746 * if socket type is SOCK_PACKET, bind by name
2748 fd_trans_register(ret
, &target_packet_trans
);
2749 } else if (domain
== PF_NETLINK
) {
2751 #ifdef CONFIG_RTNETLINK
2753 fd_trans_register(ret
, &target_netlink_route_trans
);
2756 case NETLINK_KOBJECT_UEVENT
:
2757 /* nothing to do: messages are strings */
2760 fd_trans_register(ret
, &target_netlink_audit_trans
);
2763 g_assert_not_reached();
2770 /* do_bind() Must return target values and target errnos. */
2771 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
2777 if ((int)addrlen
< 0) {
2778 return -TARGET_EINVAL
;
2781 addr
= alloca(addrlen
+1);
2783 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
2787 return get_errno(bind(sockfd
, addr
, addrlen
));
2790 /* do_connect() Must return target values and target errnos. */
2791 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
2797 if ((int)addrlen
< 0) {
2798 return -TARGET_EINVAL
;
2801 addr
= alloca(addrlen
+1);
2803 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
2807 return get_errno(safe_connect(sockfd
, addr
, addrlen
));
2810 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
2811 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
2812 int flags
, int send
)
2818 abi_ulong target_vec
;
2820 if (msgp
->msg_name
) {
2821 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
2822 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
2823 ret
= target_to_host_sockaddr(fd
, msg
.msg_name
,
2824 tswapal(msgp
->msg_name
),
2826 if (ret
== -TARGET_EFAULT
) {
2827 /* For connected sockets msg_name and msg_namelen must
2828 * be ignored, so returning EFAULT immediately is wrong.
2829 * Instead, pass a bad msg_name to the host kernel, and
2830 * let it decide whether to return EFAULT or not.
2832 msg
.msg_name
= (void *)-1;
2837 msg
.msg_name
= NULL
;
2838 msg
.msg_namelen
= 0;
2840 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
2841 msg
.msg_control
= alloca(msg
.msg_controllen
);
2842 memset(msg
.msg_control
, 0, msg
.msg_controllen
);
2844 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
2846 count
= tswapal(msgp
->msg_iovlen
);
2847 target_vec
= tswapal(msgp
->msg_iov
);
2849 if (count
> IOV_MAX
) {
2850 /* sendrcvmsg returns a different errno for this condition than
2851 * readv/writev, so we must catch it here before lock_iovec() does.
2853 ret
= -TARGET_EMSGSIZE
;
2857 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
2858 target_vec
, count
, send
);
2860 ret
= -host_to_target_errno(errno
);
2863 msg
.msg_iovlen
= count
;
2867 if (fd_trans_target_to_host_data(fd
)) {
2870 host_msg
= g_malloc(msg
.msg_iov
->iov_len
);
2871 memcpy(host_msg
, msg
.msg_iov
->iov_base
, msg
.msg_iov
->iov_len
);
2872 ret
= fd_trans_target_to_host_data(fd
)(host_msg
,
2873 msg
.msg_iov
->iov_len
);
2875 msg
.msg_iov
->iov_base
= host_msg
;
2876 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
2880 ret
= target_to_host_cmsg(&msg
, msgp
);
2882 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
2886 ret
= get_errno(safe_recvmsg(fd
, &msg
, flags
));
2887 if (!is_error(ret
)) {
2889 if (fd_trans_host_to_target_data(fd
)) {
2890 ret
= fd_trans_host_to_target_data(fd
)(msg
.msg_iov
->iov_base
,
2891 MIN(msg
.msg_iov
->iov_len
, len
));
2893 ret
= host_to_target_cmsg(msgp
, &msg
);
2895 if (!is_error(ret
)) {
2896 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
2897 msgp
->msg_flags
= tswap32(msg
.msg_flags
);
2898 if (msg
.msg_name
!= NULL
&& msg
.msg_name
!= (void *)-1) {
2899 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
2900 msg
.msg_name
, msg
.msg_namelen
);
2912 unlock_iovec(vec
, target_vec
, count
, !send
);
2917 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
2918 int flags
, int send
)
2921 struct target_msghdr
*msgp
;
2923 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
2927 return -TARGET_EFAULT
;
2929 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
2930 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
2934 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
2935 * so it might not have this *mmsg-specific flag either.
2937 #ifndef MSG_WAITFORONE
2938 #define MSG_WAITFORONE 0x10000
2941 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
2942 unsigned int vlen
, unsigned int flags
,
2945 struct target_mmsghdr
*mmsgp
;
2949 if (vlen
> UIO_MAXIOV
) {
2953 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
2955 return -TARGET_EFAULT
;
2958 for (i
= 0; i
< vlen
; i
++) {
2959 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
2960 if (is_error(ret
)) {
2963 mmsgp
[i
].msg_len
= tswap32(ret
);
2964 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2965 if (flags
& MSG_WAITFORONE
) {
2966 flags
|= MSG_DONTWAIT
;
2970 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
2972 /* Return number of datagrams sent if we sent any at all;
2973 * otherwise return the error.
2981 /* do_accept4() Must return target values and target errnos. */
2982 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
2983 abi_ulong target_addrlen_addr
, int flags
)
2985 socklen_t addrlen
, ret_addrlen
;
2990 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
2992 if (target_addr
== 0) {
2993 return get_errno(safe_accept4(fd
, NULL
, NULL
, host_flags
));
2996 /* linux returns EINVAL if addrlen pointer is invalid */
2997 if (get_user_u32(addrlen
, target_addrlen_addr
))
2998 return -TARGET_EINVAL
;
3000 if ((int)addrlen
< 0) {
3001 return -TARGET_EINVAL
;
3004 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3005 return -TARGET_EINVAL
;
3007 addr
= alloca(addrlen
);
3009 ret_addrlen
= addrlen
;
3010 ret
= get_errno(safe_accept4(fd
, addr
, &ret_addrlen
, host_flags
));
3011 if (!is_error(ret
)) {
3012 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3013 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3014 ret
= -TARGET_EFAULT
;
3020 /* do_getpeername() Must return target values and target errnos. */
3021 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
3022 abi_ulong target_addrlen_addr
)
3024 socklen_t addrlen
, ret_addrlen
;
3028 if (get_user_u32(addrlen
, target_addrlen_addr
))
3029 return -TARGET_EFAULT
;
3031 if ((int)addrlen
< 0) {
3032 return -TARGET_EINVAL
;
3035 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3036 return -TARGET_EFAULT
;
3038 addr
= alloca(addrlen
);
3040 ret_addrlen
= addrlen
;
3041 ret
= get_errno(getpeername(fd
, addr
, &ret_addrlen
));
3042 if (!is_error(ret
)) {
3043 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3044 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3045 ret
= -TARGET_EFAULT
;
3051 /* do_getsockname() Must return target values and target errnos. */
3052 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
3053 abi_ulong target_addrlen_addr
)
3055 socklen_t addrlen
, ret_addrlen
;
3059 if (get_user_u32(addrlen
, target_addrlen_addr
))
3060 return -TARGET_EFAULT
;
3062 if ((int)addrlen
< 0) {
3063 return -TARGET_EINVAL
;
3066 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3067 return -TARGET_EFAULT
;
3069 addr
= alloca(addrlen
);
3071 ret_addrlen
= addrlen
;
3072 ret
= get_errno(getsockname(fd
, addr
, &ret_addrlen
));
3073 if (!is_error(ret
)) {
3074 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
3075 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
3076 ret
= -TARGET_EFAULT
;
3082 /* do_socketpair() Must return target values and target errnos. */
3083 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
3084 abi_ulong target_tab_addr
)
3089 target_to_host_sock_type(&type
);
3091 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
3092 if (!is_error(ret
)) {
3093 if (put_user_s32(tab
[0], target_tab_addr
)
3094 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
3095 ret
= -TARGET_EFAULT
;
3100 /* do_sendto() Must return target values and target errnos. */
3101 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
3102 abi_ulong target_addr
, socklen_t addrlen
)
3106 void *copy_msg
= NULL
;
3109 if ((int)addrlen
< 0) {
3110 return -TARGET_EINVAL
;
3113 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
3115 return -TARGET_EFAULT
;
3116 if (fd_trans_target_to_host_data(fd
)) {
3117 copy_msg
= host_msg
;
3118 host_msg
= g_malloc(len
);
3119 memcpy(host_msg
, copy_msg
, len
);
3120 ret
= fd_trans_target_to_host_data(fd
)(host_msg
, len
);
3126 addr
= alloca(addrlen
+1);
3127 ret
= target_to_host_sockaddr(fd
, addr
, target_addr
, addrlen
);
3131 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
3133 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, NULL
, 0));
3138 host_msg
= copy_msg
;
3140 unlock_user(host_msg
, msg
, 0);
3144 /* do_recvfrom() Must return target values and target errnos. */
3145 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
3146 abi_ulong target_addr
,
3147 abi_ulong target_addrlen
)
3149 socklen_t addrlen
, ret_addrlen
;
3154 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
3156 return -TARGET_EFAULT
;
3158 if (get_user_u32(addrlen
, target_addrlen
)) {
3159 ret
= -TARGET_EFAULT
;
3162 if ((int)addrlen
< 0) {
3163 ret
= -TARGET_EINVAL
;
3166 addr
= alloca(addrlen
);
3167 ret_addrlen
= addrlen
;
3168 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
,
3169 addr
, &ret_addrlen
));
3171 addr
= NULL
; /* To keep compiler quiet. */
3172 addrlen
= 0; /* To keep compiler quiet. */
3173 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
, NULL
, 0));
3175 if (!is_error(ret
)) {
3176 if (fd_trans_host_to_target_data(fd
)) {
3178 trans
= fd_trans_host_to_target_data(fd
)(host_msg
, MIN(ret
, len
));
3179 if (is_error(trans
)) {
3185 host_to_target_sockaddr(target_addr
, addr
,
3186 MIN(addrlen
, ret_addrlen
));
3187 if (put_user_u32(ret_addrlen
, target_addrlen
)) {
3188 ret
= -TARGET_EFAULT
;
3192 unlock_user(host_msg
, msg
, len
);
3195 unlock_user(host_msg
, msg
, 0);
3200 #ifdef TARGET_NR_socketcall
3201 /* do_socketcall() must return target values and target errnos. */
3202 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
3204 static const unsigned nargs
[] = { /* number of arguments per operation */
3205 [TARGET_SYS_SOCKET
] = 3, /* domain, type, protocol */
3206 [TARGET_SYS_BIND
] = 3, /* fd, addr, addrlen */
3207 [TARGET_SYS_CONNECT
] = 3, /* fd, addr, addrlen */
3208 [TARGET_SYS_LISTEN
] = 2, /* fd, backlog */
3209 [TARGET_SYS_ACCEPT
] = 3, /* fd, addr, addrlen */
3210 [TARGET_SYS_GETSOCKNAME
] = 3, /* fd, addr, addrlen */
3211 [TARGET_SYS_GETPEERNAME
] = 3, /* fd, addr, addrlen */
3212 [TARGET_SYS_SOCKETPAIR
] = 4, /* domain, type, protocol, tab */
3213 [TARGET_SYS_SEND
] = 4, /* fd, msg, len, flags */
3214 [TARGET_SYS_RECV
] = 4, /* fd, msg, len, flags */
3215 [TARGET_SYS_SENDTO
] = 6, /* fd, msg, len, flags, addr, addrlen */
3216 [TARGET_SYS_RECVFROM
] = 6, /* fd, msg, len, flags, addr, addrlen */
3217 [TARGET_SYS_SHUTDOWN
] = 2, /* fd, how */
3218 [TARGET_SYS_SETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3219 [TARGET_SYS_GETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3220 [TARGET_SYS_SENDMSG
] = 3, /* fd, msg, flags */
3221 [TARGET_SYS_RECVMSG
] = 3, /* fd, msg, flags */
3222 [TARGET_SYS_ACCEPT4
] = 4, /* fd, addr, addrlen, flags */
3223 [TARGET_SYS_RECVMMSG
] = 4, /* fd, msgvec, vlen, flags */
3224 [TARGET_SYS_SENDMMSG
] = 4, /* fd, msgvec, vlen, flags */
3226 abi_long a
[6]; /* max 6 args */
3229 /* check the range of the first argument num */
3230 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
3231 if (num
< 1 || num
> TARGET_SYS_SENDMMSG
) {
3232 return -TARGET_EINVAL
;
3234 /* ensure we have space for args */
3235 if (nargs
[num
] > ARRAY_SIZE(a
)) {
3236 return -TARGET_EINVAL
;
3238 /* collect the arguments in a[] according to nargs[] */
3239 for (i
= 0; i
< nargs
[num
]; ++i
) {
3240 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
3241 return -TARGET_EFAULT
;
3244 /* now when we have the args, invoke the appropriate underlying function */
3246 case TARGET_SYS_SOCKET
: /* domain, type, protocol */
3247 return do_socket(a
[0], a
[1], a
[2]);
3248 case TARGET_SYS_BIND
: /* sockfd, addr, addrlen */
3249 return do_bind(a
[0], a
[1], a
[2]);
3250 case TARGET_SYS_CONNECT
: /* sockfd, addr, addrlen */
3251 return do_connect(a
[0], a
[1], a
[2]);
3252 case TARGET_SYS_LISTEN
: /* sockfd, backlog */
3253 return get_errno(listen(a
[0], a
[1]));
3254 case TARGET_SYS_ACCEPT
: /* sockfd, addr, addrlen */
3255 return do_accept4(a
[0], a
[1], a
[2], 0);
3256 case TARGET_SYS_GETSOCKNAME
: /* sockfd, addr, addrlen */
3257 return do_getsockname(a
[0], a
[1], a
[2]);
3258 case TARGET_SYS_GETPEERNAME
: /* sockfd, addr, addrlen */
3259 return do_getpeername(a
[0], a
[1], a
[2]);
3260 case TARGET_SYS_SOCKETPAIR
: /* domain, type, protocol, tab */
3261 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
3262 case TARGET_SYS_SEND
: /* sockfd, msg, len, flags */
3263 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
3264 case TARGET_SYS_RECV
: /* sockfd, msg, len, flags */
3265 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
3266 case TARGET_SYS_SENDTO
: /* sockfd, msg, len, flags, addr, addrlen */
3267 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3268 case TARGET_SYS_RECVFROM
: /* sockfd, msg, len, flags, addr, addrlen */
3269 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3270 case TARGET_SYS_SHUTDOWN
: /* sockfd, how */
3271 return get_errno(shutdown(a
[0], a
[1]));
3272 case TARGET_SYS_SETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3273 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3274 case TARGET_SYS_GETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3275 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3276 case TARGET_SYS_SENDMSG
: /* sockfd, msg, flags */
3277 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
3278 case TARGET_SYS_RECVMSG
: /* sockfd, msg, flags */
3279 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
3280 case TARGET_SYS_ACCEPT4
: /* sockfd, addr, addrlen, flags */
3281 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
3282 case TARGET_SYS_RECVMMSG
: /* sockfd, msgvec, vlen, flags */
3283 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 0);
3284 case TARGET_SYS_SENDMMSG
: /* sockfd, msgvec, vlen, flags */
3285 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 1);
3287 gemu_log("Unsupported socketcall: %d\n", num
);
3288 return -TARGET_EINVAL
;
3293 #define N_SHM_REGIONS 32
3295 static struct shm_region
{
3299 } shm_regions
[N_SHM_REGIONS
];
3301 #ifndef TARGET_SEMID64_DS
3302 /* asm-generic version of this struct */
3303 struct target_semid64_ds
3305 struct target_ipc_perm sem_perm
;
3306 abi_ulong sem_otime
;
3307 #if TARGET_ABI_BITS == 32
3308 abi_ulong __unused1
;
3310 abi_ulong sem_ctime
;
3311 #if TARGET_ABI_BITS == 32
3312 abi_ulong __unused2
;
3314 abi_ulong sem_nsems
;
3315 abi_ulong __unused3
;
3316 abi_ulong __unused4
;
3320 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
3321 abi_ulong target_addr
)
3323 struct target_ipc_perm
*target_ip
;
3324 struct target_semid64_ds
*target_sd
;
3326 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3327 return -TARGET_EFAULT
;
3328 target_ip
= &(target_sd
->sem_perm
);
3329 host_ip
->__key
= tswap32(target_ip
->__key
);
3330 host_ip
->uid
= tswap32(target_ip
->uid
);
3331 host_ip
->gid
= tswap32(target_ip
->gid
);
3332 host_ip
->cuid
= tswap32(target_ip
->cuid
);
3333 host_ip
->cgid
= tswap32(target_ip
->cgid
);
3334 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3335 host_ip
->mode
= tswap32(target_ip
->mode
);
3337 host_ip
->mode
= tswap16(target_ip
->mode
);
3339 #if defined(TARGET_PPC)
3340 host_ip
->__seq
= tswap32(target_ip
->__seq
);
3342 host_ip
->__seq
= tswap16(target_ip
->__seq
);
3344 unlock_user_struct(target_sd
, target_addr
, 0);
3348 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
3349 struct ipc_perm
*host_ip
)
3351 struct target_ipc_perm
*target_ip
;
3352 struct target_semid64_ds
*target_sd
;
3354 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3355 return -TARGET_EFAULT
;
3356 target_ip
= &(target_sd
->sem_perm
);
3357 target_ip
->__key
= tswap32(host_ip
->__key
);
3358 target_ip
->uid
= tswap32(host_ip
->uid
);
3359 target_ip
->gid
= tswap32(host_ip
->gid
);
3360 target_ip
->cuid
= tswap32(host_ip
->cuid
);
3361 target_ip
->cgid
= tswap32(host_ip
->cgid
);
3362 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3363 target_ip
->mode
= tswap32(host_ip
->mode
);
3365 target_ip
->mode
= tswap16(host_ip
->mode
);
3367 #if defined(TARGET_PPC)
3368 target_ip
->__seq
= tswap32(host_ip
->__seq
);
3370 target_ip
->__seq
= tswap16(host_ip
->__seq
);
3372 unlock_user_struct(target_sd
, target_addr
, 1);
3376 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
3377 abi_ulong target_addr
)
3379 struct target_semid64_ds
*target_sd
;
3381 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3382 return -TARGET_EFAULT
;
3383 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
3384 return -TARGET_EFAULT
;
3385 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
3386 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
3387 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
3388 unlock_user_struct(target_sd
, target_addr
, 0);
3392 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
3393 struct semid_ds
*host_sd
)
3395 struct target_semid64_ds
*target_sd
;
3397 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3398 return -TARGET_EFAULT
;
3399 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
3400 return -TARGET_EFAULT
;
3401 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
3402 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
3403 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
3404 unlock_user_struct(target_sd
, target_addr
, 1);
3408 struct target_seminfo
{
3421 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
3422 struct seminfo
*host_seminfo
)
3424 struct target_seminfo
*target_seminfo
;
3425 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
3426 return -TARGET_EFAULT
;
3427 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
3428 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
3429 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
3430 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
3431 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
3432 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
3433 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
3434 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
3435 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
3436 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
3437 unlock_user_struct(target_seminfo
, target_addr
, 1);
3443 struct semid_ds
*buf
;
3444 unsigned short *array
;
3445 struct seminfo
*__buf
;
3448 union target_semun
{
3455 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
3456 abi_ulong target_addr
)
3459 unsigned short *array
;
3461 struct semid_ds semid_ds
;
3464 semun
.buf
= &semid_ds
;
3466 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3468 return get_errno(ret
);
3470 nsems
= semid_ds
.sem_nsems
;
3472 *host_array
= g_try_new(unsigned short, nsems
);
3474 return -TARGET_ENOMEM
;
3476 array
= lock_user(VERIFY_READ
, target_addr
,
3477 nsems
*sizeof(unsigned short), 1);
3479 g_free(*host_array
);
3480 return -TARGET_EFAULT
;
3483 for(i
=0; i
<nsems
; i
++) {
3484 __get_user((*host_array
)[i
], &array
[i
]);
3486 unlock_user(array
, target_addr
, 0);
3491 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
3492 unsigned short **host_array
)
3495 unsigned short *array
;
3497 struct semid_ds semid_ds
;
3500 semun
.buf
= &semid_ds
;
3502 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3504 return get_errno(ret
);
3506 nsems
= semid_ds
.sem_nsems
;
3508 array
= lock_user(VERIFY_WRITE
, target_addr
,
3509 nsems
*sizeof(unsigned short), 0);
3511 return -TARGET_EFAULT
;
3513 for(i
=0; i
<nsems
; i
++) {
3514 __put_user((*host_array
)[i
], &array
[i
]);
3516 g_free(*host_array
);
3517 unlock_user(array
, target_addr
, 1);
3522 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
3523 abi_ulong target_arg
)
3525 union target_semun target_su
= { .buf
= target_arg
};
3527 struct semid_ds dsarg
;
3528 unsigned short *array
= NULL
;
3529 struct seminfo seminfo
;
3530 abi_long ret
= -TARGET_EINVAL
;
3537 /* In 64 bit cross-endian situations, we will erroneously pick up
3538 * the wrong half of the union for the "val" element. To rectify
3539 * this, the entire 8-byte structure is byteswapped, followed by
3540 * a swap of the 4 byte val field. In other cases, the data is
3541 * already in proper host byte order. */
3542 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
3543 target_su
.buf
= tswapal(target_su
.buf
);
3544 arg
.val
= tswap32(target_su
.val
);
3546 arg
.val
= target_su
.val
;
3548 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3552 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
3556 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3557 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
3564 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
3568 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3569 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
3575 arg
.__buf
= &seminfo
;
3576 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3577 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
3585 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
3592 struct target_sembuf
{
3593 unsigned short sem_num
;
3598 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
3599 abi_ulong target_addr
,
3602 struct target_sembuf
*target_sembuf
;
3605 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
3606 nsops
*sizeof(struct target_sembuf
), 1);
3608 return -TARGET_EFAULT
;
3610 for(i
=0; i
<nsops
; i
++) {
3611 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
3612 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
3613 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
3616 unlock_user(target_sembuf
, target_addr
, 0);
3621 static inline abi_long
do_semop(int semid
, abi_long ptr
, unsigned nsops
)
3623 struct sembuf sops
[nsops
];
3626 if (target_to_host_sembuf(sops
, ptr
, nsops
))
3627 return -TARGET_EFAULT
;
3629 ret
= -TARGET_ENOSYS
;
3630 #ifdef __NR_semtimedop
3631 ret
= get_errno(safe_semtimedop(semid
, sops
, nsops
, NULL
));
3634 if (ret
== -TARGET_ENOSYS
) {
3635 ret
= get_errno(safe_ipc(IPCOP_semtimedop
, semid
, nsops
, 0, sops
, 0));
3641 struct target_msqid_ds
3643 struct target_ipc_perm msg_perm
;
3644 abi_ulong msg_stime
;
3645 #if TARGET_ABI_BITS == 32
3646 abi_ulong __unused1
;
3648 abi_ulong msg_rtime
;
3649 #if TARGET_ABI_BITS == 32
3650 abi_ulong __unused2
;
3652 abi_ulong msg_ctime
;
3653 #if TARGET_ABI_BITS == 32
3654 abi_ulong __unused3
;
3656 abi_ulong __msg_cbytes
;
3658 abi_ulong msg_qbytes
;
3659 abi_ulong msg_lspid
;
3660 abi_ulong msg_lrpid
;
3661 abi_ulong __unused4
;
3662 abi_ulong __unused5
;
3665 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
3666 abi_ulong target_addr
)
3668 struct target_msqid_ds
*target_md
;
3670 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
3671 return -TARGET_EFAULT
;
3672 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
3673 return -TARGET_EFAULT
;
3674 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
3675 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
3676 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
3677 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
3678 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
3679 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
3680 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
3681 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
3682 unlock_user_struct(target_md
, target_addr
, 0);
3686 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
3687 struct msqid_ds
*host_md
)
3689 struct target_msqid_ds
*target_md
;
3691 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
3692 return -TARGET_EFAULT
;
3693 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
3694 return -TARGET_EFAULT
;
3695 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
3696 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
3697 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
3698 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
3699 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
3700 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
3701 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
3702 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
3703 unlock_user_struct(target_md
, target_addr
, 1);
3707 struct target_msginfo
{
3715 unsigned short int msgseg
;
3718 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
3719 struct msginfo
*host_msginfo
)
3721 struct target_msginfo
*target_msginfo
;
3722 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
3723 return -TARGET_EFAULT
;
3724 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
3725 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
3726 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
3727 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
3728 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
3729 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
3730 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
3731 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
3732 unlock_user_struct(target_msginfo
, target_addr
, 1);
3736 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
3738 struct msqid_ds dsarg
;
3739 struct msginfo msginfo
;
3740 abi_long ret
= -TARGET_EINVAL
;
3748 if (target_to_host_msqid_ds(&dsarg
,ptr
))
3749 return -TARGET_EFAULT
;
3750 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
3751 if (host_to_target_msqid_ds(ptr
,&dsarg
))
3752 return -TARGET_EFAULT
;
3755 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
3759 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
3760 if (host_to_target_msginfo(ptr
, &msginfo
))
3761 return -TARGET_EFAULT
;
3768 struct target_msgbuf
{
3773 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
3774 ssize_t msgsz
, int msgflg
)
3776 struct target_msgbuf
*target_mb
;
3777 struct msgbuf
*host_mb
;
3781 return -TARGET_EINVAL
;
3784 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
3785 return -TARGET_EFAULT
;
3786 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
3788 unlock_user_struct(target_mb
, msgp
, 0);
3789 return -TARGET_ENOMEM
;
3791 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
3792 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
3793 ret
= -TARGET_ENOSYS
;
3795 ret
= get_errno(safe_msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
3798 if (ret
== -TARGET_ENOSYS
) {
3799 ret
= get_errno(safe_ipc(IPCOP_msgsnd
, msqid
, msgsz
, msgflg
,
3804 unlock_user_struct(target_mb
, msgp
, 0);
3809 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
3810 ssize_t msgsz
, abi_long msgtyp
,
3813 struct target_msgbuf
*target_mb
;
3815 struct msgbuf
*host_mb
;
3819 return -TARGET_EINVAL
;
3822 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
3823 return -TARGET_EFAULT
;
3825 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
3827 ret
= -TARGET_ENOMEM
;
3830 ret
= -TARGET_ENOSYS
;
3832 ret
= get_errno(safe_msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
3835 if (ret
== -TARGET_ENOSYS
) {
3836 ret
= get_errno(safe_ipc(IPCOP_CALL(1, IPCOP_msgrcv
), msqid
, msgsz
,
3837 msgflg
, host_mb
, msgtyp
));
3842 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
3843 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
3844 if (!target_mtext
) {
3845 ret
= -TARGET_EFAULT
;
3848 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
3849 unlock_user(target_mtext
, target_mtext_addr
, ret
);
3852 target_mb
->mtype
= tswapal(host_mb
->mtype
);
3856 unlock_user_struct(target_mb
, msgp
, 1);
3861 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
3862 abi_ulong target_addr
)
3864 struct target_shmid_ds
*target_sd
;
3866 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3867 return -TARGET_EFAULT
;
3868 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
3869 return -TARGET_EFAULT
;
3870 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3871 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3872 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3873 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3874 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3875 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3876 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3877 unlock_user_struct(target_sd
, target_addr
, 0);
3881 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
3882 struct shmid_ds
*host_sd
)
3884 struct target_shmid_ds
*target_sd
;
3886 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3887 return -TARGET_EFAULT
;
3888 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
3889 return -TARGET_EFAULT
;
3890 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3891 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3892 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3893 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3894 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3895 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3896 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3897 unlock_user_struct(target_sd
, target_addr
, 1);
3901 struct target_shminfo
{
3909 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
3910 struct shminfo
*host_shminfo
)
3912 struct target_shminfo
*target_shminfo
;
3913 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
3914 return -TARGET_EFAULT
;
3915 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
3916 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
3917 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
3918 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
3919 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
3920 unlock_user_struct(target_shminfo
, target_addr
, 1);
3924 struct target_shm_info
{
3929 abi_ulong swap_attempts
;
3930 abi_ulong swap_successes
;
3933 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
3934 struct shm_info
*host_shm_info
)
3936 struct target_shm_info
*target_shm_info
;
3937 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
3938 return -TARGET_EFAULT
;
3939 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
3940 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
3941 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
3942 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
3943 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
3944 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
3945 unlock_user_struct(target_shm_info
, target_addr
, 1);
3949 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
3951 struct shmid_ds dsarg
;
3952 struct shminfo shminfo
;
3953 struct shm_info shm_info
;
3954 abi_long ret
= -TARGET_EINVAL
;
3962 if (target_to_host_shmid_ds(&dsarg
, buf
))
3963 return -TARGET_EFAULT
;
3964 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
3965 if (host_to_target_shmid_ds(buf
, &dsarg
))
3966 return -TARGET_EFAULT
;
3969 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
3970 if (host_to_target_shminfo(buf
, &shminfo
))
3971 return -TARGET_EFAULT
;
3974 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
3975 if (host_to_target_shm_info(buf
, &shm_info
))
3976 return -TARGET_EFAULT
;
3981 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
3988 #ifndef TARGET_FORCE_SHMLBA
3989 /* For most architectures, SHMLBA is the same as the page size;
3990 * some architectures have larger values, in which case they should
3991 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
3992 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
3993 * and defining its own value for SHMLBA.
3995 * The kernel also permits SHMLBA to be set by the architecture to a
3996 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
3997 * this means that addresses are rounded to the large size if
3998 * SHM_RND is set but addresses not aligned to that size are not rejected
3999 * as long as they are at least page-aligned. Since the only architecture
4000 * which uses this is ia64 this code doesn't provide for that oddity.
4002 static inline abi_ulong
target_shmlba(CPUArchState
*cpu_env
)
4004 return TARGET_PAGE_SIZE
;
4008 static inline abi_ulong
do_shmat(CPUArchState
*cpu_env
,
4009 int shmid
, abi_ulong shmaddr
, int shmflg
)
4013 struct shmid_ds shm_info
;
4017 /* find out the length of the shared memory segment */
4018 ret
= get_errno(shmctl(shmid
, IPC_STAT
, &shm_info
));
4019 if (is_error(ret
)) {
4020 /* can't get length, bail out */
4024 shmlba
= target_shmlba(cpu_env
);
4026 if (shmaddr
& (shmlba
- 1)) {
4027 if (shmflg
& SHM_RND
) {
4028 shmaddr
&= ~(shmlba
- 1);
4030 return -TARGET_EINVAL
;
4033 if (!guest_range_valid(shmaddr
, shm_info
.shm_segsz
)) {
4034 return -TARGET_EINVAL
;
4040 host_raddr
= shmat(shmid
, (void *)g2h(shmaddr
), shmflg
);
4042 abi_ulong mmap_start
;
4044 /* In order to use the host shmat, we need to honor host SHMLBA. */
4045 mmap_start
= mmap_find_vma(0, shm_info
.shm_segsz
, MAX(SHMLBA
, shmlba
));
4047 if (mmap_start
== -1) {
4049 host_raddr
= (void *)-1;
4051 host_raddr
= shmat(shmid
, g2h(mmap_start
), shmflg
| SHM_REMAP
);
4054 if (host_raddr
== (void *)-1) {
4056 return get_errno((long)host_raddr
);
4058 raddr
=h2g((unsigned long)host_raddr
);
4060 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
4061 PAGE_VALID
| PAGE_READ
|
4062 ((shmflg
& SHM_RDONLY
)? 0 : PAGE_WRITE
));
4064 for (i
= 0; i
< N_SHM_REGIONS
; i
++) {
4065 if (!shm_regions
[i
].in_use
) {
4066 shm_regions
[i
].in_use
= true;
4067 shm_regions
[i
].start
= raddr
;
4068 shm_regions
[i
].size
= shm_info
.shm_segsz
;
4078 static inline abi_long
do_shmdt(abi_ulong shmaddr
)
4085 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
4086 if (shm_regions
[i
].in_use
&& shm_regions
[i
].start
== shmaddr
) {
4087 shm_regions
[i
].in_use
= false;
4088 page_set_flags(shmaddr
, shmaddr
+ shm_regions
[i
].size
, 0);
4092 rv
= get_errno(shmdt(g2h(shmaddr
)));
4099 #ifdef TARGET_NR_ipc
4100 /* ??? This only works with linear mappings. */
4101 /* do_ipc() must return target values and target errnos. */
4102 static abi_long
do_ipc(CPUArchState
*cpu_env
,
4103 unsigned int call
, abi_long first
,
4104 abi_long second
, abi_long third
,
4105 abi_long ptr
, abi_long fifth
)
4110 version
= call
>> 16;
4115 ret
= do_semop(first
, ptr
, second
);
4119 ret
= get_errno(semget(first
, second
, third
));
4122 case IPCOP_semctl
: {
4123 /* The semun argument to semctl is passed by value, so dereference the
4126 get_user_ual(atptr
, ptr
);
4127 ret
= do_semctl(first
, second
, third
, atptr
);
4132 ret
= get_errno(msgget(first
, second
));
4136 ret
= do_msgsnd(first
, ptr
, second
, third
);
4140 ret
= do_msgctl(first
, second
, ptr
);
4147 struct target_ipc_kludge
{
4152 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
4153 ret
= -TARGET_EFAULT
;
4157 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
4159 unlock_user_struct(tmp
, ptr
, 0);
4163 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
4172 raddr
= do_shmat(cpu_env
, first
, ptr
, second
);
4173 if (is_error(raddr
))
4174 return get_errno(raddr
);
4175 if (put_user_ual(raddr
, third
))
4176 return -TARGET_EFAULT
;
4180 ret
= -TARGET_EINVAL
;
4185 ret
= do_shmdt(ptr
);
4189 /* IPC_* flag values are the same on all linux platforms */
4190 ret
= get_errno(shmget(first
, second
, third
));
4193 /* IPC_* and SHM_* command values are the same on all linux platforms */
4195 ret
= do_shmctl(first
, second
, ptr
);
4198 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
4199 ret
= -TARGET_ENOSYS
;
4206 /* kernel structure types definitions */
4208 #define STRUCT(name, ...) STRUCT_ ## name,
4209 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
4211 #include "syscall_types.h"
4215 #undef STRUCT_SPECIAL
4217 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
4218 #define STRUCT_SPECIAL(name)
4219 #include "syscall_types.h"
4221 #undef STRUCT_SPECIAL
4223 typedef struct IOCTLEntry IOCTLEntry
;
4225 typedef abi_long
do_ioctl_fn(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4226 int fd
, int cmd
, abi_long arg
);
4230 unsigned int host_cmd
;
4233 do_ioctl_fn
*do_ioctl
;
4234 const argtype arg_type
[5];
4237 #define IOC_R 0x0001
4238 #define IOC_W 0x0002
4239 #define IOC_RW (IOC_R | IOC_W)
4241 #define MAX_STRUCT_SIZE 4096
4243 #ifdef CONFIG_FIEMAP
4244 /* So fiemap access checks don't overflow on 32 bit systems.
4245 * This is very slightly smaller than the limit imposed by
4246 * the underlying kernel.
4248 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
4249 / sizeof(struct fiemap_extent))
4251 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4252 int fd
, int cmd
, abi_long arg
)
4254 /* The parameter for this ioctl is a struct fiemap followed
4255 * by an array of struct fiemap_extent whose size is set
4256 * in fiemap->fm_extent_count. The array is filled in by the
4259 int target_size_in
, target_size_out
;
4261 const argtype
*arg_type
= ie
->arg_type
;
4262 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
4265 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
4269 assert(arg_type
[0] == TYPE_PTR
);
4270 assert(ie
->access
== IOC_RW
);
4272 target_size_in
= thunk_type_size(arg_type
, 0);
4273 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
4275 return -TARGET_EFAULT
;
4277 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4278 unlock_user(argptr
, arg
, 0);
4279 fm
= (struct fiemap
*)buf_temp
;
4280 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
4281 return -TARGET_EINVAL
;
4284 outbufsz
= sizeof (*fm
) +
4285 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
4287 if (outbufsz
> MAX_STRUCT_SIZE
) {
4288 /* We can't fit all the extents into the fixed size buffer.
4289 * Allocate one that is large enough and use it instead.
4291 fm
= g_try_malloc(outbufsz
);
4293 return -TARGET_ENOMEM
;
4295 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
4298 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, fm
));
4299 if (!is_error(ret
)) {
4300 target_size_out
= target_size_in
;
4301 /* An extent_count of 0 means we were only counting the extents
4302 * so there are no structs to copy
4304 if (fm
->fm_extent_count
!= 0) {
4305 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
4307 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
4309 ret
= -TARGET_EFAULT
;
4311 /* Convert the struct fiemap */
4312 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
4313 if (fm
->fm_extent_count
!= 0) {
4314 p
= argptr
+ target_size_in
;
4315 /* ...and then all the struct fiemap_extents */
4316 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
4317 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
4322 unlock_user(argptr
, arg
, target_size_out
);
4332 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4333 int fd
, int cmd
, abi_long arg
)
4335 const argtype
*arg_type
= ie
->arg_type
;
4339 struct ifconf
*host_ifconf
;
4341 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
4342 int target_ifreq_size
;
4347 abi_long target_ifc_buf
;
4351 assert(arg_type
[0] == TYPE_PTR
);
4352 assert(ie
->access
== IOC_RW
);
4355 target_size
= thunk_type_size(arg_type
, 0);
4357 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4359 return -TARGET_EFAULT
;
4360 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4361 unlock_user(argptr
, arg
, 0);
4363 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
4364 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
4365 target_ifreq_size
= thunk_type_size(ifreq_arg_type
, 0);
4367 if (target_ifc_buf
!= 0) {
4368 target_ifc_len
= host_ifconf
->ifc_len
;
4369 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
4370 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
4372 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
4373 if (outbufsz
> MAX_STRUCT_SIZE
) {
4375 * We can't fit all the extents into the fixed size buffer.
4376 * Allocate one that is large enough and use it instead.
4378 host_ifconf
= malloc(outbufsz
);
4380 return -TARGET_ENOMEM
;
4382 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
4385 host_ifc_buf
= (char *)host_ifconf
+ sizeof(*host_ifconf
);
4387 host_ifconf
->ifc_len
= host_ifc_len
;
4389 host_ifc_buf
= NULL
;
4391 host_ifconf
->ifc_buf
= host_ifc_buf
;
4393 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_ifconf
));
4394 if (!is_error(ret
)) {
4395 /* convert host ifc_len to target ifc_len */
4397 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
4398 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
4399 host_ifconf
->ifc_len
= target_ifc_len
;
4401 /* restore target ifc_buf */
4403 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
4405 /* copy struct ifconf to target user */
4407 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4409 return -TARGET_EFAULT
;
4410 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
4411 unlock_user(argptr
, arg
, target_size
);
4413 if (target_ifc_buf
!= 0) {
4414 /* copy ifreq[] to target user */
4415 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
4416 for (i
= 0; i
< nb_ifreq
; i
++) {
4417 thunk_convert(argptr
+ i
* target_ifreq_size
,
4418 host_ifc_buf
+ i
* sizeof(struct ifreq
),
4419 ifreq_arg_type
, THUNK_TARGET
);
4421 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
4432 #if defined(CONFIG_USBFS)
4433 #if HOST_LONG_BITS > 64
4434 #error USBDEVFS thunks do not support >64 bit hosts yet.
4437 uint64_t target_urb_adr
;
4438 uint64_t target_buf_adr
;
4439 char *target_buf_ptr
;
4440 struct usbdevfs_urb host_urb
;
4443 static GHashTable
*usbdevfs_urb_hashtable(void)
4445 static GHashTable
*urb_hashtable
;
4447 if (!urb_hashtable
) {
4448 urb_hashtable
= g_hash_table_new(g_int64_hash
, g_int64_equal
);
4450 return urb_hashtable
;
4453 static void urb_hashtable_insert(struct live_urb
*urb
)
4455 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4456 g_hash_table_insert(urb_hashtable
, urb
, urb
);
4459 static struct live_urb
*urb_hashtable_lookup(uint64_t target_urb_adr
)
4461 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4462 return g_hash_table_lookup(urb_hashtable
, &target_urb_adr
);
4465 static void urb_hashtable_remove(struct live_urb
*urb
)
4467 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4468 g_hash_table_remove(urb_hashtable
, urb
);
4472 do_ioctl_usbdevfs_reapurb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4473 int fd
, int cmd
, abi_long arg
)
4475 const argtype usbfsurb_arg_type
[] = { MK_STRUCT(STRUCT_usbdevfs_urb
) };
4476 const argtype ptrvoid_arg_type
[] = { TYPE_PTRVOID
, 0, 0 };
4477 struct live_urb
*lurb
;
4481 uintptr_t target_urb_adr
;
4484 target_size
= thunk_type_size(usbfsurb_arg_type
, THUNK_TARGET
);
4486 memset(buf_temp
, 0, sizeof(uint64_t));
4487 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4488 if (is_error(ret
)) {
4492 memcpy(&hurb
, buf_temp
, sizeof(uint64_t));
4493 lurb
= (void *)((uintptr_t)hurb
- offsetof(struct live_urb
, host_urb
));
4494 if (!lurb
->target_urb_adr
) {
4495 return -TARGET_EFAULT
;
4497 urb_hashtable_remove(lurb
);
4498 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
,
4499 lurb
->host_urb
.buffer_length
);
4500 lurb
->target_buf_ptr
= NULL
;
4502 /* restore the guest buffer pointer */
4503 lurb
->host_urb
.buffer
= (void *)(uintptr_t)lurb
->target_buf_adr
;
4505 /* update the guest urb struct */
4506 argptr
= lock_user(VERIFY_WRITE
, lurb
->target_urb_adr
, target_size
, 0);
4509 return -TARGET_EFAULT
;
4511 thunk_convert(argptr
, &lurb
->host_urb
, usbfsurb_arg_type
, THUNK_TARGET
);
4512 unlock_user(argptr
, lurb
->target_urb_adr
, target_size
);
4514 target_size
= thunk_type_size(ptrvoid_arg_type
, THUNK_TARGET
);
4515 /* write back the urb handle */
4516 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4519 return -TARGET_EFAULT
;
4522 /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */
4523 target_urb_adr
= lurb
->target_urb_adr
;
4524 thunk_convert(argptr
, &target_urb_adr
, ptrvoid_arg_type
, THUNK_TARGET
);
4525 unlock_user(argptr
, arg
, target_size
);
4532 do_ioctl_usbdevfs_discardurb(const IOCTLEntry
*ie
,
4533 uint8_t *buf_temp
__attribute__((unused
)),
4534 int fd
, int cmd
, abi_long arg
)
4536 struct live_urb
*lurb
;
4538 /* map target address back to host URB with metadata. */
4539 lurb
= urb_hashtable_lookup(arg
);
4541 return -TARGET_EFAULT
;
4543 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4547 do_ioctl_usbdevfs_submiturb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4548 int fd
, int cmd
, abi_long arg
)
4550 const argtype
*arg_type
= ie
->arg_type
;
4555 struct live_urb
*lurb
;
4558 * each submitted URB needs to map to a unique ID for the
4559 * kernel, and that unique ID needs to be a pointer to
4560 * host memory. hence, we need to malloc for each URB.
4561 * isochronous transfers have a variable length struct.
4564 target_size
= thunk_type_size(arg_type
, THUNK_TARGET
);
4566 /* construct host copy of urb and metadata */
4567 lurb
= g_try_malloc0(sizeof(struct live_urb
));
4569 return -TARGET_ENOMEM
;
4572 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4575 return -TARGET_EFAULT
;
4577 thunk_convert(&lurb
->host_urb
, argptr
, arg_type
, THUNK_HOST
);
4578 unlock_user(argptr
, arg
, 0);
4580 lurb
->target_urb_adr
= arg
;
4581 lurb
->target_buf_adr
= (uintptr_t)lurb
->host_urb
.buffer
;
4583 /* buffer space used depends on endpoint type so lock the entire buffer */
4584 /* control type urbs should check the buffer contents for true direction */
4585 rw_dir
= lurb
->host_urb
.endpoint
& USB_DIR_IN
? VERIFY_WRITE
: VERIFY_READ
;
4586 lurb
->target_buf_ptr
= lock_user(rw_dir
, lurb
->target_buf_adr
,
4587 lurb
->host_urb
.buffer_length
, 1);
4588 if (lurb
->target_buf_ptr
== NULL
) {
4590 return -TARGET_EFAULT
;
4593 /* update buffer pointer in host copy */
4594 lurb
->host_urb
.buffer
= lurb
->target_buf_ptr
;
4596 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4597 if (is_error(ret
)) {
4598 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
, 0);
4601 urb_hashtable_insert(lurb
);
4606 #endif /* CONFIG_USBFS */
4608 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
4609 int cmd
, abi_long arg
)
4612 struct dm_ioctl
*host_dm
;
4613 abi_long guest_data
;
4614 uint32_t guest_data_size
;
4616 const argtype
*arg_type
= ie
->arg_type
;
4618 void *big_buf
= NULL
;
4622 target_size
= thunk_type_size(arg_type
, 0);
4623 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4625 ret
= -TARGET_EFAULT
;
4628 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4629 unlock_user(argptr
, arg
, 0);
4631 /* buf_temp is too small, so fetch things into a bigger buffer */
4632 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
4633 memcpy(big_buf
, buf_temp
, target_size
);
4637 guest_data
= arg
+ host_dm
->data_start
;
4638 if ((guest_data
- arg
) < 0) {
4639 ret
= -TARGET_EINVAL
;
4642 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
4643 host_data
= (char*)host_dm
+ host_dm
->data_start
;
4645 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
4647 ret
= -TARGET_EFAULT
;
4651 switch (ie
->host_cmd
) {
4653 case DM_LIST_DEVICES
:
4656 case DM_DEV_SUSPEND
:
4659 case DM_TABLE_STATUS
:
4660 case DM_TABLE_CLEAR
:
4662 case DM_LIST_VERSIONS
:
4666 case DM_DEV_SET_GEOMETRY
:
4667 /* data contains only strings */
4668 memcpy(host_data
, argptr
, guest_data_size
);
4671 memcpy(host_data
, argptr
, guest_data_size
);
4672 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
4676 void *gspec
= argptr
;
4677 void *cur_data
= host_data
;
4678 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
4679 int spec_size
= thunk_type_size(arg_type
, 0);
4682 for (i
= 0; i
< host_dm
->target_count
; i
++) {
4683 struct dm_target_spec
*spec
= cur_data
;
4687 thunk_convert(spec
, gspec
, arg_type
, THUNK_HOST
);
4688 slen
= strlen((char*)gspec
+ spec_size
) + 1;
4690 spec
->next
= sizeof(*spec
) + slen
;
4691 strcpy((char*)&spec
[1], gspec
+ spec_size
);
4693 cur_data
+= spec
->next
;
4698 ret
= -TARGET_EINVAL
;
4699 unlock_user(argptr
, guest_data
, 0);
4702 unlock_user(argptr
, guest_data
, 0);
4704 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4705 if (!is_error(ret
)) {
4706 guest_data
= arg
+ host_dm
->data_start
;
4707 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
4708 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
4709 switch (ie
->host_cmd
) {
4714 case DM_DEV_SUSPEND
:
4717 case DM_TABLE_CLEAR
:
4719 case DM_DEV_SET_GEOMETRY
:
4720 /* no return data */
4722 case DM_LIST_DEVICES
:
4724 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
4725 uint32_t remaining_data
= guest_data_size
;
4726 void *cur_data
= argptr
;
4727 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
4728 int nl_size
= 12; /* can't use thunk_size due to alignment */
4731 uint32_t next
= nl
->next
;
4733 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
4735 if (remaining_data
< nl
->next
) {
4736 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4739 thunk_convert(cur_data
, nl
, arg_type
, THUNK_TARGET
);
4740 strcpy(cur_data
+ nl_size
, nl
->name
);
4741 cur_data
+= nl
->next
;
4742 remaining_data
-= nl
->next
;
4746 nl
= (void*)nl
+ next
;
4751 case DM_TABLE_STATUS
:
4753 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
4754 void *cur_data
= argptr
;
4755 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
4756 int spec_size
= thunk_type_size(arg_type
, 0);
4759 for (i
= 0; i
< host_dm
->target_count
; i
++) {
4760 uint32_t next
= spec
->next
;
4761 int slen
= strlen((char*)&spec
[1]) + 1;
4762 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
4763 if (guest_data_size
< spec
->next
) {
4764 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4767 thunk_convert(cur_data
, spec
, arg_type
, THUNK_TARGET
);
4768 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
4769 cur_data
= argptr
+ spec
->next
;
4770 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
4776 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
4777 int count
= *(uint32_t*)hdata
;
4778 uint64_t *hdev
= hdata
+ 8;
4779 uint64_t *gdev
= argptr
+ 8;
4782 *(uint32_t*)argptr
= tswap32(count
);
4783 for (i
= 0; i
< count
; i
++) {
4784 *gdev
= tswap64(*hdev
);
4790 case DM_LIST_VERSIONS
:
4792 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
4793 uint32_t remaining_data
= guest_data_size
;
4794 void *cur_data
= argptr
;
4795 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
4796 int vers_size
= thunk_type_size(arg_type
, 0);
4799 uint32_t next
= vers
->next
;
4801 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
4803 if (remaining_data
< vers
->next
) {
4804 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4807 thunk_convert(cur_data
, vers
, arg_type
, THUNK_TARGET
);
4808 strcpy(cur_data
+ vers_size
, vers
->name
);
4809 cur_data
+= vers
->next
;
4810 remaining_data
-= vers
->next
;
4814 vers
= (void*)vers
+ next
;
4819 unlock_user(argptr
, guest_data
, 0);
4820 ret
= -TARGET_EINVAL
;
4823 unlock_user(argptr
, guest_data
, guest_data_size
);
4825 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4827 ret
= -TARGET_EFAULT
;
4830 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
4831 unlock_user(argptr
, arg
, target_size
);
4838 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
4839 int cmd
, abi_long arg
)
4843 const argtype
*arg_type
= ie
->arg_type
;
4844 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
4847 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
4848 struct blkpg_partition host_part
;
4850 /* Read and convert blkpg */
4852 target_size
= thunk_type_size(arg_type
, 0);
4853 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4855 ret
= -TARGET_EFAULT
;
4858 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4859 unlock_user(argptr
, arg
, 0);
4861 switch (host_blkpg
->op
) {
4862 case BLKPG_ADD_PARTITION
:
4863 case BLKPG_DEL_PARTITION
:
4864 /* payload is struct blkpg_partition */
4867 /* Unknown opcode */
4868 ret
= -TARGET_EINVAL
;
4872 /* Read and convert blkpg->data */
4873 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
4874 target_size
= thunk_type_size(part_arg_type
, 0);
4875 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4877 ret
= -TARGET_EFAULT
;
4880 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
4881 unlock_user(argptr
, arg
, 0);
4883 /* Swizzle the data pointer to our local copy and call! */
4884 host_blkpg
->data
= &host_part
;
4885 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_blkpg
));
4891 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4892 int fd
, int cmd
, abi_long arg
)
4894 const argtype
*arg_type
= ie
->arg_type
;
4895 const StructEntry
*se
;
4896 const argtype
*field_types
;
4897 const int *dst_offsets
, *src_offsets
;
4900 abi_ulong
*target_rt_dev_ptr
= NULL
;
4901 unsigned long *host_rt_dev_ptr
= NULL
;
4905 assert(ie
->access
== IOC_W
);
4906 assert(*arg_type
== TYPE_PTR
);
4908 assert(*arg_type
== TYPE_STRUCT
);
4909 target_size
= thunk_type_size(arg_type
, 0);
4910 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4912 return -TARGET_EFAULT
;
4915 assert(*arg_type
== (int)STRUCT_rtentry
);
4916 se
= struct_entries
+ *arg_type
++;
4917 assert(se
->convert
[0] == NULL
);
4918 /* convert struct here to be able to catch rt_dev string */
4919 field_types
= se
->field_types
;
4920 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
4921 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
4922 for (i
= 0; i
< se
->nb_fields
; i
++) {
4923 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
4924 assert(*field_types
== TYPE_PTRVOID
);
4925 target_rt_dev_ptr
= (abi_ulong
*)(argptr
+ src_offsets
[i
]);
4926 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
4927 if (*target_rt_dev_ptr
!= 0) {
4928 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
4929 tswapal(*target_rt_dev_ptr
));
4930 if (!*host_rt_dev_ptr
) {
4931 unlock_user(argptr
, arg
, 0);
4932 return -TARGET_EFAULT
;
4935 *host_rt_dev_ptr
= 0;
4940 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
4941 argptr
+ src_offsets
[i
],
4942 field_types
, THUNK_HOST
);
4944 unlock_user(argptr
, arg
, 0);
4946 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4948 assert(host_rt_dev_ptr
!= NULL
);
4949 assert(target_rt_dev_ptr
!= NULL
);
4950 if (*host_rt_dev_ptr
!= 0) {
4951 unlock_user((void *)*host_rt_dev_ptr
,
4952 *target_rt_dev_ptr
, 0);
4957 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4958 int fd
, int cmd
, abi_long arg
)
4960 int sig
= target_to_host_signal(arg
);
4961 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, sig
));
4964 static abi_long
do_ioctl_SIOCGSTAMP(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4965 int fd
, int cmd
, abi_long arg
)
4970 ret
= get_errno(safe_ioctl(fd
, SIOCGSTAMP
, &tv
));
4971 if (is_error(ret
)) {
4975 if (cmd
== (int)TARGET_SIOCGSTAMP_OLD
) {
4976 if (copy_to_user_timeval(arg
, &tv
)) {
4977 return -TARGET_EFAULT
;
4980 if (copy_to_user_timeval64(arg
, &tv
)) {
4981 return -TARGET_EFAULT
;
4988 static abi_long
do_ioctl_SIOCGSTAMPNS(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4989 int fd
, int cmd
, abi_long arg
)
4994 ret
= get_errno(safe_ioctl(fd
, SIOCGSTAMPNS
, &ts
));
4995 if (is_error(ret
)) {
4999 if (cmd
== (int)TARGET_SIOCGSTAMPNS_OLD
) {
5000 if (host_to_target_timespec(arg
, &ts
)) {
5001 return -TARGET_EFAULT
;
5004 if (host_to_target_timespec64(arg
, &ts
)) {
5005 return -TARGET_EFAULT
;
5013 static abi_long
do_ioctl_tiocgptpeer(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5014 int fd
, int cmd
, abi_long arg
)
5016 int flags
= target_to_host_bitmask(arg
, fcntl_flags_tbl
);
5017 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, flags
));
5021 static IOCTLEntry ioctl_entries
[] = {
5022 #define IOCTL(cmd, access, ...) \
5023 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5024 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5025 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
5026 #define IOCTL_IGNORE(cmd) \
5027 { TARGET_ ## cmd, 0, #cmd },
5032 /* ??? Implement proper locking for ioctls. */
5033 /* do_ioctl() Must return target values and target errnos. */
5034 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
5036 const IOCTLEntry
*ie
;
5037 const argtype
*arg_type
;
5039 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
5045 if (ie
->target_cmd
== 0) {
5046 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
5047 return -TARGET_ENOSYS
;
5049 if (ie
->target_cmd
== cmd
)
5053 arg_type
= ie
->arg_type
;
5055 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
5056 } else if (!ie
->host_cmd
) {
5057 /* Some architectures define BSD ioctls in their headers
5058 that are not implemented in Linux. */
5059 return -TARGET_ENOSYS
;
5062 switch(arg_type
[0]) {
5065 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
));
5069 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, arg
));
5073 target_size
= thunk_type_size(arg_type
, 0);
5074 switch(ie
->access
) {
5076 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5077 if (!is_error(ret
)) {
5078 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5080 return -TARGET_EFAULT
;
5081 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5082 unlock_user(argptr
, arg
, target_size
);
5086 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5088 return -TARGET_EFAULT
;
5089 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5090 unlock_user(argptr
, arg
, 0);
5091 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5095 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5097 return -TARGET_EFAULT
;
5098 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5099 unlock_user(argptr
, arg
, 0);
5100 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5101 if (!is_error(ret
)) {
5102 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5104 return -TARGET_EFAULT
;
5105 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5106 unlock_user(argptr
, arg
, target_size
);
5112 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5113 (long)cmd
, arg_type
[0]);
5114 ret
= -TARGET_ENOSYS
;
5120 static const bitmask_transtbl iflag_tbl
[] = {
5121 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
5122 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
5123 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
5124 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
5125 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
5126 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
5127 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
5128 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
5129 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
5130 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
5131 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
5132 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
5133 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
5134 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
5138 static const bitmask_transtbl oflag_tbl
[] = {
5139 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
5140 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
5141 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
5142 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
5143 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
5144 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
5145 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
5146 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
5147 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
5148 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
5149 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
5150 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
5151 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
5152 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
5153 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
5154 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
5155 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
5156 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
5157 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
5158 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
5159 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
5160 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
5161 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
5162 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
5166 static const bitmask_transtbl cflag_tbl
[] = {
5167 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
5168 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
5169 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
5170 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
5171 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
5172 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
5173 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
5174 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
5175 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
5176 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
5177 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
5178 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
5179 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
5180 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
5181 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
5182 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
5183 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
5184 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
5185 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
5186 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
5187 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
5188 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
5189 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
5190 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
5191 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
5192 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
5193 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
5194 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
5195 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
5196 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
5197 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
5201 static const bitmask_transtbl lflag_tbl
[] = {
5202 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
5203 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
5204 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
5205 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
5206 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
5207 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
5208 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
5209 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
5210 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
5211 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
5212 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
5213 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
5214 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
5215 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
5216 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
5220 static void target_to_host_termios (void *dst
, const void *src
)
5222 struct host_termios
*host
= dst
;
5223 const struct target_termios
*target
= src
;
5226 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
5228 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
5230 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
5232 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
5233 host
->c_line
= target
->c_line
;
5235 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
5236 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
5237 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
5238 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
5239 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
5240 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
5241 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
5242 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
5243 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
5244 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
5245 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
5246 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
5247 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
5248 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
5249 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
5250 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
5251 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
5252 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
5255 static void host_to_target_termios (void *dst
, const void *src
)
5257 struct target_termios
*target
= dst
;
5258 const struct host_termios
*host
= src
;
5261 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
5263 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
5265 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
5267 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
5268 target
->c_line
= host
->c_line
;
5270 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
5271 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
5272 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
5273 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
5274 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
5275 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
5276 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
5277 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
5278 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
5279 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
5280 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
5281 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
5282 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
5283 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
5284 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
5285 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
5286 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
5287 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
5290 static const StructEntry struct_termios_def
= {
5291 .convert
= { host_to_target_termios
, target_to_host_termios
},
5292 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
5293 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
5296 static bitmask_transtbl mmap_flags_tbl
[] = {
5297 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
5298 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
5299 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
5300 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
,
5301 MAP_ANONYMOUS
, MAP_ANONYMOUS
},
5302 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
,
5303 MAP_GROWSDOWN
, MAP_GROWSDOWN
},
5304 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
,
5305 MAP_DENYWRITE
, MAP_DENYWRITE
},
5306 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
,
5307 MAP_EXECUTABLE
, MAP_EXECUTABLE
},
5308 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
5309 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
,
5310 MAP_NORESERVE
, MAP_NORESERVE
},
5311 { TARGET_MAP_HUGETLB
, TARGET_MAP_HUGETLB
, MAP_HUGETLB
, MAP_HUGETLB
},
5312 /* MAP_STACK had been ignored by the kernel for quite some time.
5313 Recognize it for the target insofar as we do not want to pass
5314 it through to the host. */
5315 { TARGET_MAP_STACK
, TARGET_MAP_STACK
, 0, 0 },
5319 #if defined(TARGET_I386)
5321 /* NOTE: there is really one LDT for all the threads */
5322 static uint8_t *ldt_table
;
5324 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
5331 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
5332 if (size
> bytecount
)
5334 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
5336 return -TARGET_EFAULT
;
5337 /* ??? Should this by byteswapped? */
5338 memcpy(p
, ldt_table
, size
);
5339 unlock_user(p
, ptr
, size
);
5343 /* XXX: add locking support */
5344 static abi_long
write_ldt(CPUX86State
*env
,
5345 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
5347 struct target_modify_ldt_ldt_s ldt_info
;
5348 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5349 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5350 int seg_not_present
, useable
, lm
;
5351 uint32_t *lp
, entry_1
, entry_2
;
5353 if (bytecount
!= sizeof(ldt_info
))
5354 return -TARGET_EINVAL
;
5355 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
5356 return -TARGET_EFAULT
;
5357 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5358 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5359 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5360 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5361 unlock_user_struct(target_ldt_info
, ptr
, 0);
5363 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
5364 return -TARGET_EINVAL
;
5365 seg_32bit
= ldt_info
.flags
& 1;
5366 contents
= (ldt_info
.flags
>> 1) & 3;
5367 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5368 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5369 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5370 useable
= (ldt_info
.flags
>> 6) & 1;
5374 lm
= (ldt_info
.flags
>> 7) & 1;
5376 if (contents
== 3) {
5378 return -TARGET_EINVAL
;
5379 if (seg_not_present
== 0)
5380 return -TARGET_EINVAL
;
5382 /* allocate the LDT */
5384 env
->ldt
.base
= target_mmap(0,
5385 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
5386 PROT_READ
|PROT_WRITE
,
5387 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
5388 if (env
->ldt
.base
== -1)
5389 return -TARGET_ENOMEM
;
5390 memset(g2h(env
->ldt
.base
), 0,
5391 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
5392 env
->ldt
.limit
= 0xffff;
5393 ldt_table
= g2h(env
->ldt
.base
);
5396 /* NOTE: same code as Linux kernel */
5397 /* Allow LDTs to be cleared by the user. */
5398 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
5401 read_exec_only
== 1 &&
5403 limit_in_pages
== 0 &&
5404 seg_not_present
== 1 &&
5412 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
5413 (ldt_info
.limit
& 0x0ffff);
5414 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
5415 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
5416 (ldt_info
.limit
& 0xf0000) |
5417 ((read_exec_only
^ 1) << 9) |
5419 ((seg_not_present
^ 1) << 15) |
5421 (limit_in_pages
<< 23) |
5425 entry_2
|= (useable
<< 20);
5427 /* Install the new entry ... */
5429 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
5430 lp
[0] = tswap32(entry_1
);
5431 lp
[1] = tswap32(entry_2
);
5435 /* specific and weird i386 syscalls */
5436 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
5437 unsigned long bytecount
)
5443 ret
= read_ldt(ptr
, bytecount
);
5446 ret
= write_ldt(env
, ptr
, bytecount
, 1);
5449 ret
= write_ldt(env
, ptr
, bytecount
, 0);
5452 ret
= -TARGET_ENOSYS
;
5458 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5459 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
5461 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
5462 struct target_modify_ldt_ldt_s ldt_info
;
5463 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5464 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5465 int seg_not_present
, useable
, lm
;
5466 uint32_t *lp
, entry_1
, entry_2
;
5469 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
5470 if (!target_ldt_info
)
5471 return -TARGET_EFAULT
;
5472 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5473 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5474 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5475 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5476 if (ldt_info
.entry_number
== -1) {
5477 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
5478 if (gdt_table
[i
] == 0) {
5479 ldt_info
.entry_number
= i
;
5480 target_ldt_info
->entry_number
= tswap32(i
);
5485 unlock_user_struct(target_ldt_info
, ptr
, 1);
5487 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
5488 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
5489 return -TARGET_EINVAL
;
5490 seg_32bit
= ldt_info
.flags
& 1;
5491 contents
= (ldt_info
.flags
>> 1) & 3;
5492 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5493 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5494 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5495 useable
= (ldt_info
.flags
>> 6) & 1;
5499 lm
= (ldt_info
.flags
>> 7) & 1;
5502 if (contents
== 3) {
5503 if (seg_not_present
== 0)
5504 return -TARGET_EINVAL
;
5507 /* NOTE: same code as Linux kernel */
5508 /* Allow LDTs to be cleared by the user. */
5509 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
5510 if ((contents
== 0 &&
5511 read_exec_only
== 1 &&
5513 limit_in_pages
== 0 &&
5514 seg_not_present
== 1 &&
5522 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
5523 (ldt_info
.limit
& 0x0ffff);
5524 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
5525 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
5526 (ldt_info
.limit
& 0xf0000) |
5527 ((read_exec_only
^ 1) << 9) |
5529 ((seg_not_present
^ 1) << 15) |
5531 (limit_in_pages
<< 23) |
5536 /* Install the new entry ... */
5538 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
5539 lp
[0] = tswap32(entry_1
);
5540 lp
[1] = tswap32(entry_2
);
5544 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
5546 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5547 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
5548 uint32_t base_addr
, limit
, flags
;
5549 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
5550 int seg_not_present
, useable
, lm
;
5551 uint32_t *lp
, entry_1
, entry_2
;
5553 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
5554 if (!target_ldt_info
)
5555 return -TARGET_EFAULT
;
5556 idx
= tswap32(target_ldt_info
->entry_number
);
5557 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
5558 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
5559 unlock_user_struct(target_ldt_info
, ptr
, 1);
5560 return -TARGET_EINVAL
;
5562 lp
= (uint32_t *)(gdt_table
+ idx
);
5563 entry_1
= tswap32(lp
[0]);
5564 entry_2
= tswap32(lp
[1]);
5566 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
5567 contents
= (entry_2
>> 10) & 3;
5568 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
5569 seg_32bit
= (entry_2
>> 22) & 1;
5570 limit_in_pages
= (entry_2
>> 23) & 1;
5571 useable
= (entry_2
>> 20) & 1;
5575 lm
= (entry_2
>> 21) & 1;
5577 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
5578 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
5579 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
5580 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
5581 base_addr
= (entry_1
>> 16) |
5582 (entry_2
& 0xff000000) |
5583 ((entry_2
& 0xff) << 16);
5584 target_ldt_info
->base_addr
= tswapal(base_addr
);
5585 target_ldt_info
->limit
= tswap32(limit
);
5586 target_ldt_info
->flags
= tswap32(flags
);
5587 unlock_user_struct(target_ldt_info
, ptr
, 1);
5590 #endif /* TARGET_I386 && TARGET_ABI32 */
5592 #ifndef TARGET_ABI32
5593 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
5600 case TARGET_ARCH_SET_GS
:
5601 case TARGET_ARCH_SET_FS
:
5602 if (code
== TARGET_ARCH_SET_GS
)
5606 cpu_x86_load_seg(env
, idx
, 0);
5607 env
->segs
[idx
].base
= addr
;
5609 case TARGET_ARCH_GET_GS
:
5610 case TARGET_ARCH_GET_FS
:
5611 if (code
== TARGET_ARCH_GET_GS
)
5615 val
= env
->segs
[idx
].base
;
5616 if (put_user(val
, addr
, abi_ulong
))
5617 ret
= -TARGET_EFAULT
;
5620 ret
= -TARGET_EINVAL
;
5627 #endif /* defined(TARGET_I386) */
5629 #define NEW_STACK_SIZE 0x40000
5632 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
5635 pthread_mutex_t mutex
;
5636 pthread_cond_t cond
;
5639 abi_ulong child_tidptr
;
5640 abi_ulong parent_tidptr
;
5644 static void *clone_func(void *arg
)
5646 new_thread_info
*info
= arg
;
5651 rcu_register_thread();
5652 tcg_register_thread();
5656 ts
= (TaskState
*)cpu
->opaque
;
5657 info
->tid
= sys_gettid();
5659 if (info
->child_tidptr
)
5660 put_user_u32(info
->tid
, info
->child_tidptr
);
5661 if (info
->parent_tidptr
)
5662 put_user_u32(info
->tid
, info
->parent_tidptr
);
5663 qemu_guest_random_seed_thread_part2(cpu
->random_seed
);
5664 /* Enable signals. */
5665 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
5666 /* Signal to the parent that we're ready. */
5667 pthread_mutex_lock(&info
->mutex
);
5668 pthread_cond_broadcast(&info
->cond
);
5669 pthread_mutex_unlock(&info
->mutex
);
5670 /* Wait until the parent has finished initializing the tls state. */
5671 pthread_mutex_lock(&clone_lock
);
5672 pthread_mutex_unlock(&clone_lock
);
5678 /* do_fork() Must return host values and target errnos (unlike most
5679 do_*() functions). */
5680 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
5681 abi_ulong parent_tidptr
, target_ulong newtls
,
5682 abi_ulong child_tidptr
)
5684 CPUState
*cpu
= env_cpu(env
);
5688 CPUArchState
*new_env
;
5691 flags
&= ~CLONE_IGNORED_FLAGS
;
5693 /* Emulate vfork() with fork() */
5694 if (flags
& CLONE_VFORK
)
5695 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
5697 if (flags
& CLONE_VM
) {
5698 TaskState
*parent_ts
= (TaskState
*)cpu
->opaque
;
5699 new_thread_info info
;
5700 pthread_attr_t attr
;
5702 if (((flags
& CLONE_THREAD_FLAGS
) != CLONE_THREAD_FLAGS
) ||
5703 (flags
& CLONE_INVALID_THREAD_FLAGS
)) {
5704 return -TARGET_EINVAL
;
5707 ts
= g_new0(TaskState
, 1);
5708 init_task_state(ts
);
5710 /* Grab a mutex so that thread setup appears atomic. */
5711 pthread_mutex_lock(&clone_lock
);
5713 /* we create a new CPU instance. */
5714 new_env
= cpu_copy(env
);
5715 /* Init regs that differ from the parent. */
5716 cpu_clone_regs(new_env
, newsp
);
5717 new_cpu
= env_cpu(new_env
);
5718 new_cpu
->opaque
= ts
;
5719 ts
->bprm
= parent_ts
->bprm
;
5720 ts
->info
= parent_ts
->info
;
5721 ts
->signal_mask
= parent_ts
->signal_mask
;
5723 if (flags
& CLONE_CHILD_CLEARTID
) {
5724 ts
->child_tidptr
= child_tidptr
;
5727 if (flags
& CLONE_SETTLS
) {
5728 cpu_set_tls (new_env
, newtls
);
5731 memset(&info
, 0, sizeof(info
));
5732 pthread_mutex_init(&info
.mutex
, NULL
);
5733 pthread_mutex_lock(&info
.mutex
);
5734 pthread_cond_init(&info
.cond
, NULL
);
5736 if (flags
& CLONE_CHILD_SETTID
) {
5737 info
.child_tidptr
= child_tidptr
;
5739 if (flags
& CLONE_PARENT_SETTID
) {
5740 info
.parent_tidptr
= parent_tidptr
;
5743 ret
= pthread_attr_init(&attr
);
5744 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
5745 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
5746 /* It is not safe to deliver signals until the child has finished
5747 initializing, so temporarily block all signals. */
5748 sigfillset(&sigmask
);
5749 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
5750 cpu
->random_seed
= qemu_guest_random_seed_thread_part1();
5752 /* If this is our first additional thread, we need to ensure we
5753 * generate code for parallel execution and flush old translations.
5755 if (!parallel_cpus
) {
5756 parallel_cpus
= true;
5760 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
5761 /* TODO: Free new CPU state if thread creation failed. */
5763 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
5764 pthread_attr_destroy(&attr
);
5766 /* Wait for the child to initialize. */
5767 pthread_cond_wait(&info
.cond
, &info
.mutex
);
5772 pthread_mutex_unlock(&info
.mutex
);
5773 pthread_cond_destroy(&info
.cond
);
5774 pthread_mutex_destroy(&info
.mutex
);
5775 pthread_mutex_unlock(&clone_lock
);
5777 /* if no CLONE_VM, we consider it is a fork */
5778 if (flags
& CLONE_INVALID_FORK_FLAGS
) {
5779 return -TARGET_EINVAL
;
5782 /* We can't support custom termination signals */
5783 if ((flags
& CSIGNAL
) != TARGET_SIGCHLD
) {
5784 return -TARGET_EINVAL
;
5787 if (block_signals()) {
5788 return -TARGET_ERESTARTSYS
;
5794 /* Child Process. */
5795 cpu_clone_regs(env
, newsp
);
5797 /* There is a race condition here. The parent process could
5798 theoretically read the TID in the child process before the child
5799 tid is set. This would require using either ptrace
5800 (not implemented) or having *_tidptr to point at a shared memory
5801 mapping. We can't repeat the spinlock hack used above because
5802 the child process gets its own copy of the lock. */
5803 if (flags
& CLONE_CHILD_SETTID
)
5804 put_user_u32(sys_gettid(), child_tidptr
);
5805 if (flags
& CLONE_PARENT_SETTID
)
5806 put_user_u32(sys_gettid(), parent_tidptr
);
5807 ts
= (TaskState
*)cpu
->opaque
;
5808 if (flags
& CLONE_SETTLS
)
5809 cpu_set_tls (env
, newtls
);
5810 if (flags
& CLONE_CHILD_CLEARTID
)
5811 ts
->child_tidptr
= child_tidptr
;
5819 /* warning : doesn't handle linux specific flags... */
5820 static int target_to_host_fcntl_cmd(int cmd
)
5825 case TARGET_F_DUPFD
:
5826 case TARGET_F_GETFD
:
5827 case TARGET_F_SETFD
:
5828 case TARGET_F_GETFL
:
5829 case TARGET_F_SETFL
:
5832 case TARGET_F_GETLK
:
5835 case TARGET_F_SETLK
:
5838 case TARGET_F_SETLKW
:
5841 case TARGET_F_GETOWN
:
5844 case TARGET_F_SETOWN
:
5847 case TARGET_F_GETSIG
:
5850 case TARGET_F_SETSIG
:
5853 #if TARGET_ABI_BITS == 32
5854 case TARGET_F_GETLK64
:
5857 case TARGET_F_SETLK64
:
5860 case TARGET_F_SETLKW64
:
5864 case TARGET_F_SETLEASE
:
5867 case TARGET_F_GETLEASE
:
5870 #ifdef F_DUPFD_CLOEXEC
5871 case TARGET_F_DUPFD_CLOEXEC
:
5872 ret
= F_DUPFD_CLOEXEC
;
5875 case TARGET_F_NOTIFY
:
5879 case TARGET_F_GETOWN_EX
:
5884 case TARGET_F_SETOWN_EX
:
5889 case TARGET_F_SETPIPE_SZ
:
5892 case TARGET_F_GETPIPE_SZ
:
5897 ret
= -TARGET_EINVAL
;
5901 #if defined(__powerpc64__)
5902 /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and
5903 * is not supported by kernel. The glibc fcntl call actually adjusts
5904 * them to 5, 6 and 7 before making the syscall(). Since we make the
5905 * syscall directly, adjust to what is supported by the kernel.
5907 if (ret
>= F_GETLK64
&& ret
<= F_SETLKW64
) {
5908 ret
-= F_GETLK64
- 5;
5915 #define FLOCK_TRANSTBL \
5917 TRANSTBL_CONVERT(F_RDLCK); \
5918 TRANSTBL_CONVERT(F_WRLCK); \
5919 TRANSTBL_CONVERT(F_UNLCK); \
5920 TRANSTBL_CONVERT(F_EXLCK); \
5921 TRANSTBL_CONVERT(F_SHLCK); \
5924 static int target_to_host_flock(int type
)
5926 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
5928 #undef TRANSTBL_CONVERT
5929 return -TARGET_EINVAL
;
5932 static int host_to_target_flock(int type
)
5934 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
5936 #undef TRANSTBL_CONVERT
5937 /* if we don't know how to convert the value coming
5938 * from the host we copy to the target field as-is
5943 static inline abi_long
copy_from_user_flock(struct flock64
*fl
,
5944 abi_ulong target_flock_addr
)
5946 struct target_flock
*target_fl
;
5949 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
5950 return -TARGET_EFAULT
;
5953 __get_user(l_type
, &target_fl
->l_type
);
5954 l_type
= target_to_host_flock(l_type
);
5958 fl
->l_type
= l_type
;
5959 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
5960 __get_user(fl
->l_start
, &target_fl
->l_start
);
5961 __get_user(fl
->l_len
, &target_fl
->l_len
);
5962 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
5963 unlock_user_struct(target_fl
, target_flock_addr
, 0);
5967 static inline abi_long
copy_to_user_flock(abi_ulong target_flock_addr
,
5968 const struct flock64
*fl
)
5970 struct target_flock
*target_fl
;
5973 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
5974 return -TARGET_EFAULT
;
5977 l_type
= host_to_target_flock(fl
->l_type
);
5978 __put_user(l_type
, &target_fl
->l_type
);
5979 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
5980 __put_user(fl
->l_start
, &target_fl
->l_start
);
5981 __put_user(fl
->l_len
, &target_fl
->l_len
);
5982 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
5983 unlock_user_struct(target_fl
, target_flock_addr
, 1);
5987 typedef abi_long
from_flock64_fn(struct flock64
*fl
, abi_ulong target_addr
);
5988 typedef abi_long
to_flock64_fn(abi_ulong target_addr
, const struct flock64
*fl
);
5990 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
5991 static inline abi_long
copy_from_user_oabi_flock64(struct flock64
*fl
,
5992 abi_ulong target_flock_addr
)
5994 struct target_oabi_flock64
*target_fl
;
5997 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
5998 return -TARGET_EFAULT
;
6001 __get_user(l_type
, &target_fl
->l_type
);
6002 l_type
= target_to_host_flock(l_type
);
6006 fl
->l_type
= l_type
;
6007 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6008 __get_user(fl
->l_start
, &target_fl
->l_start
);
6009 __get_user(fl
->l_len
, &target_fl
->l_len
);
6010 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6011 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6015 static inline abi_long
copy_to_user_oabi_flock64(abi_ulong target_flock_addr
,
6016 const struct flock64
*fl
)
6018 struct target_oabi_flock64
*target_fl
;
6021 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6022 return -TARGET_EFAULT
;
6025 l_type
= host_to_target_flock(fl
->l_type
);
6026 __put_user(l_type
, &target_fl
->l_type
);
6027 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6028 __put_user(fl
->l_start
, &target_fl
->l_start
);
6029 __put_user(fl
->l_len
, &target_fl
->l_len
);
6030 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6031 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6036 static inline abi_long
copy_from_user_flock64(struct flock64
*fl
,
6037 abi_ulong target_flock_addr
)
6039 struct target_flock64
*target_fl
;
6042 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6043 return -TARGET_EFAULT
;
6046 __get_user(l_type
, &target_fl
->l_type
);
6047 l_type
= target_to_host_flock(l_type
);
6051 fl
->l_type
= l_type
;
6052 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6053 __get_user(fl
->l_start
, &target_fl
->l_start
);
6054 __get_user(fl
->l_len
, &target_fl
->l_len
);
6055 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6056 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6060 static inline abi_long
copy_to_user_flock64(abi_ulong target_flock_addr
,
6061 const struct flock64
*fl
)
6063 struct target_flock64
*target_fl
;
6066 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6067 return -TARGET_EFAULT
;
6070 l_type
= host_to_target_flock(fl
->l_type
);
6071 __put_user(l_type
, &target_fl
->l_type
);
6072 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6073 __put_user(fl
->l_start
, &target_fl
->l_start
);
6074 __put_user(fl
->l_len
, &target_fl
->l_len
);
6075 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6076 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6080 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
6082 struct flock64 fl64
;
6084 struct f_owner_ex fox
;
6085 struct target_f_owner_ex
*target_fox
;
6088 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
6090 if (host_cmd
== -TARGET_EINVAL
)
6094 case TARGET_F_GETLK
:
6095 ret
= copy_from_user_flock(&fl64
, arg
);
6099 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6101 ret
= copy_to_user_flock(arg
, &fl64
);
6105 case TARGET_F_SETLK
:
6106 case TARGET_F_SETLKW
:
6107 ret
= copy_from_user_flock(&fl64
, arg
);
6111 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6114 case TARGET_F_GETLK64
:
6115 ret
= copy_from_user_flock64(&fl64
, arg
);
6119 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6121 ret
= copy_to_user_flock64(arg
, &fl64
);
6124 case TARGET_F_SETLK64
:
6125 case TARGET_F_SETLKW64
:
6126 ret
= copy_from_user_flock64(&fl64
, arg
);
6130 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6133 case TARGET_F_GETFL
:
6134 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6136 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
6140 case TARGET_F_SETFL
:
6141 ret
= get_errno(safe_fcntl(fd
, host_cmd
,
6142 target_to_host_bitmask(arg
,
6147 case TARGET_F_GETOWN_EX
:
6148 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6150 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
6151 return -TARGET_EFAULT
;
6152 target_fox
->type
= tswap32(fox
.type
);
6153 target_fox
->pid
= tswap32(fox
.pid
);
6154 unlock_user_struct(target_fox
, arg
, 1);
6160 case TARGET_F_SETOWN_EX
:
6161 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
6162 return -TARGET_EFAULT
;
6163 fox
.type
= tswap32(target_fox
->type
);
6164 fox
.pid
= tswap32(target_fox
->pid
);
6165 unlock_user_struct(target_fox
, arg
, 0);
6166 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6170 case TARGET_F_SETOWN
:
6171 case TARGET_F_GETOWN
:
6172 case TARGET_F_SETSIG
:
6173 case TARGET_F_GETSIG
:
6174 case TARGET_F_SETLEASE
:
6175 case TARGET_F_GETLEASE
:
6176 case TARGET_F_SETPIPE_SZ
:
6177 case TARGET_F_GETPIPE_SZ
:
6178 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6182 ret
= get_errno(safe_fcntl(fd
, cmd
, arg
));
6190 static inline int high2lowuid(int uid
)
6198 static inline int high2lowgid(int gid
)
6206 static inline int low2highuid(int uid
)
6208 if ((int16_t)uid
== -1)
6214 static inline int low2highgid(int gid
)
6216 if ((int16_t)gid
== -1)
6221 static inline int tswapid(int id
)
6226 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6228 #else /* !USE_UID16 */
6229 static inline int high2lowuid(int uid
)
6233 static inline int high2lowgid(int gid
)
6237 static inline int low2highuid(int uid
)
6241 static inline int low2highgid(int gid
)
6245 static inline int tswapid(int id
)
6250 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6252 #endif /* USE_UID16 */
6254 /* We must do direct syscalls for setting UID/GID, because we want to
6255 * implement the Linux system call semantics of "change only for this thread",
6256 * not the libc/POSIX semantics of "change for all threads in process".
6257 * (See http://ewontfix.com/17/ for more details.)
6258 * We use the 32-bit version of the syscalls if present; if it is not
6259 * then either the host architecture supports 32-bit UIDs natively with
6260 * the standard syscall, or the 16-bit UID is the best we can do.
6262 #ifdef __NR_setuid32
6263 #define __NR_sys_setuid __NR_setuid32
6265 #define __NR_sys_setuid __NR_setuid
6267 #ifdef __NR_setgid32
6268 #define __NR_sys_setgid __NR_setgid32
6270 #define __NR_sys_setgid __NR_setgid
6272 #ifdef __NR_setresuid32
6273 #define __NR_sys_setresuid __NR_setresuid32
6275 #define __NR_sys_setresuid __NR_setresuid
6277 #ifdef __NR_setresgid32
6278 #define __NR_sys_setresgid __NR_setresgid32
6280 #define __NR_sys_setresgid __NR_setresgid
6283 _syscall1(int, sys_setuid
, uid_t
, uid
)
6284 _syscall1(int, sys_setgid
, gid_t
, gid
)
6285 _syscall3(int, sys_setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
6286 _syscall3(int, sys_setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
6288 void syscall_init(void)
6291 const argtype
*arg_type
;
6295 thunk_init(STRUCT_MAX
);
6297 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
6298 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
6299 #include "syscall_types.h"
6301 #undef STRUCT_SPECIAL
6303 /* Build target_to_host_errno_table[] table from
6304 * host_to_target_errno_table[]. */
6305 for (i
= 0; i
< ERRNO_TABLE_SIZE
; i
++) {
6306 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
6309 /* we patch the ioctl size if necessary. We rely on the fact that
6310 no ioctl has all the bits at '1' in the size field */
6312 while (ie
->target_cmd
!= 0) {
6313 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
6314 TARGET_IOC_SIZEMASK
) {
6315 arg_type
= ie
->arg_type
;
6316 if (arg_type
[0] != TYPE_PTR
) {
6317 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
6322 size
= thunk_type_size(arg_type
, 0);
6323 ie
->target_cmd
= (ie
->target_cmd
&
6324 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
6325 (size
<< TARGET_IOC_SIZESHIFT
);
6328 /* automatic consistency check if same arch */
6329 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6330 (defined(__x86_64__) && defined(TARGET_X86_64))
6331 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
6332 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6333 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
6340 #if TARGET_ABI_BITS == 32
6341 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
6343 #ifdef TARGET_WORDS_BIGENDIAN
6344 return ((uint64_t)word0
<< 32) | word1
;
6346 return ((uint64_t)word1
<< 32) | word0
;
6349 #else /* TARGET_ABI_BITS == 32 */
6350 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
6354 #endif /* TARGET_ABI_BITS != 32 */
6356 #ifdef TARGET_NR_truncate64
6357 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
6362 if (regpairs_aligned(cpu_env
, TARGET_NR_truncate64
)) {
6366 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
6370 #ifdef TARGET_NR_ftruncate64
6371 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
6376 if (regpairs_aligned(cpu_env
, TARGET_NR_ftruncate64
)) {
6380 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
6384 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_itspec
,
6385 abi_ulong target_addr
)
6387 struct target_itimerspec
*target_itspec
;
6389 if (!lock_user_struct(VERIFY_READ
, target_itspec
, target_addr
, 1)) {
6390 return -TARGET_EFAULT
;
6393 host_itspec
->it_interval
.tv_sec
=
6394 tswapal(target_itspec
->it_interval
.tv_sec
);
6395 host_itspec
->it_interval
.tv_nsec
=
6396 tswapal(target_itspec
->it_interval
.tv_nsec
);
6397 host_itspec
->it_value
.tv_sec
= tswapal(target_itspec
->it_value
.tv_sec
);
6398 host_itspec
->it_value
.tv_nsec
= tswapal(target_itspec
->it_value
.tv_nsec
);
6400 unlock_user_struct(target_itspec
, target_addr
, 1);
6404 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
6405 struct itimerspec
*host_its
)
6407 struct target_itimerspec
*target_itspec
;
6409 if (!lock_user_struct(VERIFY_WRITE
, target_itspec
, target_addr
, 0)) {
6410 return -TARGET_EFAULT
;
6413 target_itspec
->it_interval
.tv_sec
= tswapal(host_its
->it_interval
.tv_sec
);
6414 target_itspec
->it_interval
.tv_nsec
= tswapal(host_its
->it_interval
.tv_nsec
);
6416 target_itspec
->it_value
.tv_sec
= tswapal(host_its
->it_value
.tv_sec
);
6417 target_itspec
->it_value
.tv_nsec
= tswapal(host_its
->it_value
.tv_nsec
);
6419 unlock_user_struct(target_itspec
, target_addr
, 0);
6423 static inline abi_long
target_to_host_timex(struct timex
*host_tx
,
6424 abi_long target_addr
)
6426 struct target_timex
*target_tx
;
6428 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
6429 return -TARGET_EFAULT
;
6432 __get_user(host_tx
->modes
, &target_tx
->modes
);
6433 __get_user(host_tx
->offset
, &target_tx
->offset
);
6434 __get_user(host_tx
->freq
, &target_tx
->freq
);
6435 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
6436 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
6437 __get_user(host_tx
->status
, &target_tx
->status
);
6438 __get_user(host_tx
->constant
, &target_tx
->constant
);
6439 __get_user(host_tx
->precision
, &target_tx
->precision
);
6440 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
6441 __get_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
6442 __get_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
6443 __get_user(host_tx
->tick
, &target_tx
->tick
);
6444 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
6445 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
6446 __get_user(host_tx
->shift
, &target_tx
->shift
);
6447 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
6448 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
6449 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
6450 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
6451 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
6452 __get_user(host_tx
->tai
, &target_tx
->tai
);
6454 unlock_user_struct(target_tx
, target_addr
, 0);
6458 static inline abi_long
host_to_target_timex(abi_long target_addr
,
6459 struct timex
*host_tx
)
6461 struct target_timex
*target_tx
;
6463 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
6464 return -TARGET_EFAULT
;
6467 __put_user(host_tx
->modes
, &target_tx
->modes
);
6468 __put_user(host_tx
->offset
, &target_tx
->offset
);
6469 __put_user(host_tx
->freq
, &target_tx
->freq
);
6470 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
6471 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
6472 __put_user(host_tx
->status
, &target_tx
->status
);
6473 __put_user(host_tx
->constant
, &target_tx
->constant
);
6474 __put_user(host_tx
->precision
, &target_tx
->precision
);
6475 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
6476 __put_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
6477 __put_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
6478 __put_user(host_tx
->tick
, &target_tx
->tick
);
6479 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
6480 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
6481 __put_user(host_tx
->shift
, &target_tx
->shift
);
6482 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
6483 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
6484 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
6485 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
6486 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
6487 __put_user(host_tx
->tai
, &target_tx
->tai
);
6489 unlock_user_struct(target_tx
, target_addr
, 1);
6494 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
6495 abi_ulong target_addr
)
6497 struct target_sigevent
*target_sevp
;
6499 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
6500 return -TARGET_EFAULT
;
6503 /* This union is awkward on 64 bit systems because it has a 32 bit
6504 * integer and a pointer in it; we follow the conversion approach
6505 * used for handling sigval types in signal.c so the guest should get
6506 * the correct value back even if we did a 64 bit byteswap and it's
6507 * using the 32 bit integer.
6509 host_sevp
->sigev_value
.sival_ptr
=
6510 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
6511 host_sevp
->sigev_signo
=
6512 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
6513 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
6514 host_sevp
->_sigev_un
._tid
= tswap32(target_sevp
->_sigev_un
._tid
);
6516 unlock_user_struct(target_sevp
, target_addr
, 1);
6520 #if defined(TARGET_NR_mlockall)
6521 static inline int target_to_host_mlockall_arg(int arg
)
6525 if (arg
& TARGET_MLOCKALL_MCL_CURRENT
) {
6526 result
|= MCL_CURRENT
;
6528 if (arg
& TARGET_MLOCKALL_MCL_FUTURE
) {
6529 result
|= MCL_FUTURE
;
6535 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) || \
6536 defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) || \
6537 defined(TARGET_NR_newfstatat))
6538 static inline abi_long
host_to_target_stat64(void *cpu_env
,
6539 abi_ulong target_addr
,
6540 struct stat
*host_st
)
6542 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
6543 if (((CPUARMState
*)cpu_env
)->eabi
) {
6544 struct target_eabi_stat64
*target_st
;
6546 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
6547 return -TARGET_EFAULT
;
6548 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
6549 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
6550 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
6551 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6552 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
6554 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
6555 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
6556 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
6557 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
6558 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
6559 __put_user(host_st
->st_size
, &target_st
->st_size
);
6560 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
6561 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
6562 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
6563 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
6564 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
6565 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
6566 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
6567 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
6568 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
6570 unlock_user_struct(target_st
, target_addr
, 1);
6574 #if defined(TARGET_HAS_STRUCT_STAT64)
6575 struct target_stat64
*target_st
;
6577 struct target_stat
*target_st
;
6580 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
6581 return -TARGET_EFAULT
;
6582 memset(target_st
, 0, sizeof(*target_st
));
6583 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
6584 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
6585 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6586 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
6588 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
6589 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
6590 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
6591 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
6592 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
6593 /* XXX: better use of kernel struct */
6594 __put_user(host_st
->st_size
, &target_st
->st_size
);
6595 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
6596 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
6597 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
6598 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
6599 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
6600 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
6601 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
6602 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
6603 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
6605 unlock_user_struct(target_st
, target_addr
, 1);
6612 #if defined(TARGET_NR_statx) && defined(__NR_statx)
6613 static inline abi_long
host_to_target_statx(struct target_statx
*host_stx
,
6614 abi_ulong target_addr
)
6616 struct target_statx
*target_stx
;
6618 if (!lock_user_struct(VERIFY_WRITE
, target_stx
, target_addr
, 0)) {
6619 return -TARGET_EFAULT
;
6621 memset(target_stx
, 0, sizeof(*target_stx
));
6623 __put_user(host_stx
->stx_mask
, &target_stx
->stx_mask
);
6624 __put_user(host_stx
->stx_blksize
, &target_stx
->stx_blksize
);
6625 __put_user(host_stx
->stx_attributes
, &target_stx
->stx_attributes
);
6626 __put_user(host_stx
->stx_nlink
, &target_stx
->stx_nlink
);
6627 __put_user(host_stx
->stx_uid
, &target_stx
->stx_uid
);
6628 __put_user(host_stx
->stx_gid
, &target_stx
->stx_gid
);
6629 __put_user(host_stx
->stx_mode
, &target_stx
->stx_mode
);
6630 __put_user(host_stx
->stx_ino
, &target_stx
->stx_ino
);
6631 __put_user(host_stx
->stx_size
, &target_stx
->stx_size
);
6632 __put_user(host_stx
->stx_blocks
, &target_stx
->stx_blocks
);
6633 __put_user(host_stx
->stx_attributes_mask
, &target_stx
->stx_attributes_mask
);
6634 __put_user(host_stx
->stx_atime
.tv_sec
, &target_stx
->stx_atime
.tv_sec
);
6635 __put_user(host_stx
->stx_atime
.tv_nsec
, &target_stx
->stx_atime
.tv_nsec
);
6636 __put_user(host_stx
->stx_btime
.tv_sec
, &target_stx
->stx_atime
.tv_sec
);
6637 __put_user(host_stx
->stx_btime
.tv_nsec
, &target_stx
->stx_atime
.tv_nsec
);
6638 __put_user(host_stx
->stx_ctime
.tv_sec
, &target_stx
->stx_atime
.tv_sec
);
6639 __put_user(host_stx
->stx_ctime
.tv_nsec
, &target_stx
->stx_atime
.tv_nsec
);
6640 __put_user(host_stx
->stx_mtime
.tv_sec
, &target_stx
->stx_atime
.tv_sec
);
6641 __put_user(host_stx
->stx_mtime
.tv_nsec
, &target_stx
->stx_atime
.tv_nsec
);
6642 __put_user(host_stx
->stx_rdev_major
, &target_stx
->stx_rdev_major
);
6643 __put_user(host_stx
->stx_rdev_minor
, &target_stx
->stx_rdev_minor
);
6644 __put_user(host_stx
->stx_dev_major
, &target_stx
->stx_dev_major
);
6645 __put_user(host_stx
->stx_dev_minor
, &target_stx
->stx_dev_minor
);
6647 unlock_user_struct(target_stx
, target_addr
, 1);
6654 /* ??? Using host futex calls even when target atomic operations
6655 are not really atomic probably breaks things. However implementing
6656 futexes locally would make futexes shared between multiple processes
6657 tricky. However they're probably useless because guest atomic
6658 operations won't work either. */
6659 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
6660 target_ulong uaddr2
, int val3
)
6662 struct timespec ts
, *pts
;
6665 /* ??? We assume FUTEX_* constants are the same on both host
6667 #ifdef FUTEX_CMD_MASK
6668 base_op
= op
& FUTEX_CMD_MASK
;
6674 case FUTEX_WAIT_BITSET
:
6677 target_to_host_timespec(pts
, timeout
);
6681 return get_errno(safe_futex(g2h(uaddr
), op
, tswap32(val
),
6684 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
6686 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
6688 case FUTEX_CMP_REQUEUE
:
6690 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
6691 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
6692 But the prototype takes a `struct timespec *'; insert casts
6693 to satisfy the compiler. We do not need to tswap TIMEOUT
6694 since it's not compared to guest memory. */
6695 pts
= (struct timespec
*)(uintptr_t) timeout
;
6696 return get_errno(safe_futex(g2h(uaddr
), op
, val
, pts
,
6698 (base_op
== FUTEX_CMP_REQUEUE
6702 return -TARGET_ENOSYS
;
6705 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6706 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
6707 abi_long handle
, abi_long mount_id
,
6710 struct file_handle
*target_fh
;
6711 struct file_handle
*fh
;
6715 unsigned int size
, total_size
;
6717 if (get_user_s32(size
, handle
)) {
6718 return -TARGET_EFAULT
;
6721 name
= lock_user_string(pathname
);
6723 return -TARGET_EFAULT
;
6726 total_size
= sizeof(struct file_handle
) + size
;
6727 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
6729 unlock_user(name
, pathname
, 0);
6730 return -TARGET_EFAULT
;
6733 fh
= g_malloc0(total_size
);
6734 fh
->handle_bytes
= size
;
6736 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
6737 unlock_user(name
, pathname
, 0);
6739 /* man name_to_handle_at(2):
6740 * Other than the use of the handle_bytes field, the caller should treat
6741 * the file_handle structure as an opaque data type
6744 memcpy(target_fh
, fh
, total_size
);
6745 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
6746 target_fh
->handle_type
= tswap32(fh
->handle_type
);
6748 unlock_user(target_fh
, handle
, total_size
);
6750 if (put_user_s32(mid
, mount_id
)) {
6751 return -TARGET_EFAULT
;
6759 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6760 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
6763 struct file_handle
*target_fh
;
6764 struct file_handle
*fh
;
6765 unsigned int size
, total_size
;
6768 if (get_user_s32(size
, handle
)) {
6769 return -TARGET_EFAULT
;
6772 total_size
= sizeof(struct file_handle
) + size
;
6773 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
6775 return -TARGET_EFAULT
;
6778 fh
= g_memdup(target_fh
, total_size
);
6779 fh
->handle_bytes
= size
;
6780 fh
->handle_type
= tswap32(target_fh
->handle_type
);
6782 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
6783 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
6787 unlock_user(target_fh
, handle
, total_size
);
6793 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
6795 static abi_long
do_signalfd4(int fd
, abi_long mask
, int flags
)
6798 target_sigset_t
*target_mask
;
6802 if (flags
& ~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
)) {
6803 return -TARGET_EINVAL
;
6805 if (!lock_user_struct(VERIFY_READ
, target_mask
, mask
, 1)) {
6806 return -TARGET_EFAULT
;
6809 target_to_host_sigset(&host_mask
, target_mask
);
6811 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
6813 ret
= get_errno(signalfd(fd
, &host_mask
, host_flags
));
6815 fd_trans_register(ret
, &target_signalfd_trans
);
6818 unlock_user_struct(target_mask
, mask
, 0);
6824 /* Map host to target signal numbers for the wait family of syscalls.
6825 Assume all other status bits are the same. */
6826 int host_to_target_waitstatus(int status
)
6828 if (WIFSIGNALED(status
)) {
6829 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
6831 if (WIFSTOPPED(status
)) {
6832 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
6838 static int open_self_cmdline(void *cpu_env
, int fd
)
6840 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6841 struct linux_binprm
*bprm
= ((TaskState
*)cpu
->opaque
)->bprm
;
6844 for (i
= 0; i
< bprm
->argc
; i
++) {
6845 size_t len
= strlen(bprm
->argv
[i
]) + 1;
6847 if (write(fd
, bprm
->argv
[i
], len
) != len
) {
6855 static int open_self_maps(void *cpu_env
, int fd
)
6857 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6858 TaskState
*ts
= cpu
->opaque
;
6864 fp
= fopen("/proc/self/maps", "r");
6869 while ((read
= getline(&line
, &len
, fp
)) != -1) {
6870 int fields
, dev_maj
, dev_min
, inode
;
6871 uint64_t min
, max
, offset
;
6872 char flag_r
, flag_w
, flag_x
, flag_p
;
6873 char path
[512] = "";
6874 fields
= sscanf(line
, "%"PRIx64
"-%"PRIx64
" %c%c%c%c %"PRIx64
" %x:%x %d"
6875 " %512s", &min
, &max
, &flag_r
, &flag_w
, &flag_x
,
6876 &flag_p
, &offset
, &dev_maj
, &dev_min
, &inode
, path
);
6878 if ((fields
< 10) || (fields
> 11)) {
6881 if (h2g_valid(min
)) {
6882 int flags
= page_get_flags(h2g(min
));
6883 max
= h2g_valid(max
- 1) ? max
: (uintptr_t)g2h(GUEST_ADDR_MAX
) + 1;
6884 if (page_check_range(h2g(min
), max
- min
, flags
) == -1) {
6887 if (h2g(min
) == ts
->info
->stack_limit
) {
6888 pstrcpy(path
, sizeof(path
), " [stack]");
6890 dprintf(fd
, TARGET_ABI_FMT_ptr
"-" TARGET_ABI_FMT_ptr
6891 " %c%c%c%c %08" PRIx64
" %02x:%02x %d %s%s\n",
6892 h2g(min
), h2g(max
- 1) + 1, flag_r
, flag_w
,
6893 flag_x
, flag_p
, offset
, dev_maj
, dev_min
, inode
,
6894 path
[0] ? " " : "", path
);
6904 static int open_self_stat(void *cpu_env
, int fd
)
6906 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6907 TaskState
*ts
= cpu
->opaque
;
6908 abi_ulong start_stack
= ts
->info
->start_stack
;
6911 for (i
= 0; i
< 44; i
++) {
6919 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
6920 } else if (i
== 1) {
6922 snprintf(buf
, sizeof(buf
), "(%s) ", ts
->bprm
->argv
[0]);
6923 } else if (i
== 27) {
6926 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
6928 /* for the rest, there is MasterCard */
6929 snprintf(buf
, sizeof(buf
), "0%c", i
== 43 ? '\n' : ' ');
6933 if (write(fd
, buf
, len
) != len
) {
6941 static int open_self_auxv(void *cpu_env
, int fd
)
6943 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6944 TaskState
*ts
= cpu
->opaque
;
6945 abi_ulong auxv
= ts
->info
->saved_auxv
;
6946 abi_ulong len
= ts
->info
->auxv_len
;
6950 * Auxiliary vector is stored in target process stack.
6951 * read in whole auxv vector and copy it to file
6953 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
6957 r
= write(fd
, ptr
, len
);
6964 lseek(fd
, 0, SEEK_SET
);
6965 unlock_user(ptr
, auxv
, len
);
6971 static int is_proc_myself(const char *filename
, const char *entry
)
6973 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
6974 filename
+= strlen("/proc/");
6975 if (!strncmp(filename
, "self/", strlen("self/"))) {
6976 filename
+= strlen("self/");
6977 } else if (*filename
>= '1' && *filename
<= '9') {
6979 snprintf(myself
, sizeof(myself
), "%d/", getpid());
6980 if (!strncmp(filename
, myself
, strlen(myself
))) {
6981 filename
+= strlen(myself
);
6988 if (!strcmp(filename
, entry
)) {
6995 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) || \
6996 defined(TARGET_SPARC) || defined(TARGET_M68K)
6997 static int is_proc(const char *filename
, const char *entry
)
6999 return strcmp(filename
, entry
) == 0;
7003 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7004 static int open_net_route(void *cpu_env
, int fd
)
7011 fp
= fopen("/proc/net/route", "r");
7018 read
= getline(&line
, &len
, fp
);
7019 dprintf(fd
, "%s", line
);
7023 while ((read
= getline(&line
, &len
, fp
)) != -1) {
7025 uint32_t dest
, gw
, mask
;
7026 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
7029 fields
= sscanf(line
,
7030 "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7031 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
7032 &mask
, &mtu
, &window
, &irtt
);
7036 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7037 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
7038 metric
, tswap32(mask
), mtu
, window
, irtt
);
7048 #if defined(TARGET_SPARC)
7049 static int open_cpuinfo(void *cpu_env
, int fd
)
7051 dprintf(fd
, "type\t\t: sun4u\n");
7056 #if defined(TARGET_M68K)
7057 static int open_hardware(void *cpu_env
, int fd
)
7059 dprintf(fd
, "Model:\t\tqemu-m68k\n");
7064 static int do_openat(void *cpu_env
, int dirfd
, const char *pathname
, int flags
, mode_t mode
)
7067 const char *filename
;
7068 int (*fill
)(void *cpu_env
, int fd
);
7069 int (*cmp
)(const char *s1
, const char *s2
);
7071 const struct fake_open
*fake_open
;
7072 static const struct fake_open fakes
[] = {
7073 { "maps", open_self_maps
, is_proc_myself
},
7074 { "stat", open_self_stat
, is_proc_myself
},
7075 { "auxv", open_self_auxv
, is_proc_myself
},
7076 { "cmdline", open_self_cmdline
, is_proc_myself
},
7077 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7078 { "/proc/net/route", open_net_route
, is_proc
},
7080 #if defined(TARGET_SPARC)
7081 { "/proc/cpuinfo", open_cpuinfo
, is_proc
},
7083 #if defined(TARGET_M68K)
7084 { "/proc/hardware", open_hardware
, is_proc
},
7086 { NULL
, NULL
, NULL
}
7089 if (is_proc_myself(pathname
, "exe")) {
7090 int execfd
= qemu_getauxval(AT_EXECFD
);
7091 return execfd
? execfd
: safe_openat(dirfd
, exec_path
, flags
, mode
);
7094 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
7095 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
7100 if (fake_open
->filename
) {
7102 char filename
[PATH_MAX
];
7105 /* create temporary file to map stat to */
7106 tmpdir
= getenv("TMPDIR");
7109 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
7110 fd
= mkstemp(filename
);
7116 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
7122 lseek(fd
, 0, SEEK_SET
);
7127 return safe_openat(dirfd
, path(pathname
), flags
, mode
);
7130 #define TIMER_MAGIC 0x0caf0000
7131 #define TIMER_MAGIC_MASK 0xffff0000
7133 /* Convert QEMU provided timer ID back to internal 16bit index format */
7134 static target_timer_t
get_timer_id(abi_long arg
)
7136 target_timer_t timerid
= arg
;
7138 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
7139 return -TARGET_EINVAL
;
7144 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
7145 return -TARGET_EINVAL
;
7151 static int target_to_host_cpu_mask(unsigned long *host_mask
,
7153 abi_ulong target_addr
,
7156 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7157 unsigned host_bits
= sizeof(*host_mask
) * 8;
7158 abi_ulong
*target_mask
;
7161 assert(host_size
>= target_size
);
7163 target_mask
= lock_user(VERIFY_READ
, target_addr
, target_size
, 1);
7165 return -TARGET_EFAULT
;
7167 memset(host_mask
, 0, host_size
);
7169 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7170 unsigned bit
= i
* target_bits
;
7173 __get_user(val
, &target_mask
[i
]);
7174 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7175 if (val
& (1UL << j
)) {
7176 host_mask
[bit
/ host_bits
] |= 1UL << (bit
% host_bits
);
7181 unlock_user(target_mask
, target_addr
, 0);
7185 static int host_to_target_cpu_mask(const unsigned long *host_mask
,
7187 abi_ulong target_addr
,
7190 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7191 unsigned host_bits
= sizeof(*host_mask
) * 8;
7192 abi_ulong
*target_mask
;
7195 assert(host_size
>= target_size
);
7197 target_mask
= lock_user(VERIFY_WRITE
, target_addr
, target_size
, 0);
7199 return -TARGET_EFAULT
;
7202 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7203 unsigned bit
= i
* target_bits
;
7206 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7207 if (host_mask
[bit
/ host_bits
] & (1UL << (bit
% host_bits
))) {
7211 __put_user(val
, &target_mask
[i
]);
7214 unlock_user(target_mask
, target_addr
, target_size
);
7218 /* This is an internal helper for do_syscall so that it is easier
7219 * to have a single return point, so that actions, such as logging
7220 * of syscall results, can be performed.
7221 * All errnos that do_syscall() returns must be -TARGET_<errcode>.
7223 static abi_long
do_syscall1(void *cpu_env
, int num
, abi_long arg1
,
7224 abi_long arg2
, abi_long arg3
, abi_long arg4
,
7225 abi_long arg5
, abi_long arg6
, abi_long arg7
,
7228 CPUState
*cpu
= env_cpu(cpu_env
);
7230 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \
7231 || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \
7232 || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) \
7233 || defined(TARGET_NR_statx)
7236 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \
7237 || defined(TARGET_NR_fstatfs)
7243 case TARGET_NR_exit
:
7244 /* In old applications this may be used to implement _exit(2).
7245 However in threaded applictions it is used for thread termination,
7246 and _exit_group is used for application termination.
7247 Do thread termination if we have more then one thread. */
7249 if (block_signals()) {
7250 return -TARGET_ERESTARTSYS
;
7255 if (CPU_NEXT(first_cpu
)) {
7258 /* Remove the CPU from the list. */
7259 QTAILQ_REMOVE_RCU(&cpus
, cpu
, node
);
7264 if (ts
->child_tidptr
) {
7265 put_user_u32(0, ts
->child_tidptr
);
7266 sys_futex(g2h(ts
->child_tidptr
), FUTEX_WAKE
, INT_MAX
,
7270 object_unref(OBJECT(cpu
));
7272 rcu_unregister_thread();
7277 preexit_cleanup(cpu_env
, arg1
);
7279 return 0; /* avoid warning */
7280 case TARGET_NR_read
:
7281 if (arg2
== 0 && arg3
== 0) {
7282 return get_errno(safe_read(arg1
, 0, 0));
7284 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
7285 return -TARGET_EFAULT
;
7286 ret
= get_errno(safe_read(arg1
, p
, arg3
));
7288 fd_trans_host_to_target_data(arg1
)) {
7289 ret
= fd_trans_host_to_target_data(arg1
)(p
, ret
);
7291 unlock_user(p
, arg2
, ret
);
7294 case TARGET_NR_write
:
7295 if (arg2
== 0 && arg3
== 0) {
7296 return get_errno(safe_write(arg1
, 0, 0));
7298 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
7299 return -TARGET_EFAULT
;
7300 if (fd_trans_target_to_host_data(arg1
)) {
7301 void *copy
= g_malloc(arg3
);
7302 memcpy(copy
, p
, arg3
);
7303 ret
= fd_trans_target_to_host_data(arg1
)(copy
, arg3
);
7305 ret
= get_errno(safe_write(arg1
, copy
, ret
));
7309 ret
= get_errno(safe_write(arg1
, p
, arg3
));
7311 unlock_user(p
, arg2
, 0);
7314 #ifdef TARGET_NR_open
7315 case TARGET_NR_open
:
7316 if (!(p
= lock_user_string(arg1
)))
7317 return -TARGET_EFAULT
;
7318 ret
= get_errno(do_openat(cpu_env
, AT_FDCWD
, p
,
7319 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
7321 fd_trans_unregister(ret
);
7322 unlock_user(p
, arg1
, 0);
7325 case TARGET_NR_openat
:
7326 if (!(p
= lock_user_string(arg2
)))
7327 return -TARGET_EFAULT
;
7328 ret
= get_errno(do_openat(cpu_env
, arg1
, p
,
7329 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
7331 fd_trans_unregister(ret
);
7332 unlock_user(p
, arg2
, 0);
7334 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7335 case TARGET_NR_name_to_handle_at
:
7336 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
7339 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7340 case TARGET_NR_open_by_handle_at
:
7341 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
7342 fd_trans_unregister(ret
);
7345 case TARGET_NR_close
:
7346 fd_trans_unregister(arg1
);
7347 return get_errno(close(arg1
));
7350 return do_brk(arg1
);
7351 #ifdef TARGET_NR_fork
7352 case TARGET_NR_fork
:
7353 return get_errno(do_fork(cpu_env
, TARGET_SIGCHLD
, 0, 0, 0, 0));
7355 #ifdef TARGET_NR_waitpid
7356 case TARGET_NR_waitpid
:
7359 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, 0));
7360 if (!is_error(ret
) && arg2
&& ret
7361 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
7362 return -TARGET_EFAULT
;
7366 #ifdef TARGET_NR_waitid
7367 case TARGET_NR_waitid
:
7371 ret
= get_errno(safe_waitid(arg1
, arg2
, &info
, arg4
, NULL
));
7372 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
7373 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
7374 return -TARGET_EFAULT
;
7375 host_to_target_siginfo(p
, &info
);
7376 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
7381 #ifdef TARGET_NR_creat /* not on alpha */
7382 case TARGET_NR_creat
:
7383 if (!(p
= lock_user_string(arg1
)))
7384 return -TARGET_EFAULT
;
7385 ret
= get_errno(creat(p
, arg2
));
7386 fd_trans_unregister(ret
);
7387 unlock_user(p
, arg1
, 0);
7390 #ifdef TARGET_NR_link
7391 case TARGET_NR_link
:
7394 p
= lock_user_string(arg1
);
7395 p2
= lock_user_string(arg2
);
7397 ret
= -TARGET_EFAULT
;
7399 ret
= get_errno(link(p
, p2
));
7400 unlock_user(p2
, arg2
, 0);
7401 unlock_user(p
, arg1
, 0);
7405 #if defined(TARGET_NR_linkat)
7406 case TARGET_NR_linkat
:
7410 return -TARGET_EFAULT
;
7411 p
= lock_user_string(arg2
);
7412 p2
= lock_user_string(arg4
);
7414 ret
= -TARGET_EFAULT
;
7416 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
7417 unlock_user(p
, arg2
, 0);
7418 unlock_user(p2
, arg4
, 0);
7422 #ifdef TARGET_NR_unlink
7423 case TARGET_NR_unlink
:
7424 if (!(p
= lock_user_string(arg1
)))
7425 return -TARGET_EFAULT
;
7426 ret
= get_errno(unlink(p
));
7427 unlock_user(p
, arg1
, 0);
7430 #if defined(TARGET_NR_unlinkat)
7431 case TARGET_NR_unlinkat
:
7432 if (!(p
= lock_user_string(arg2
)))
7433 return -TARGET_EFAULT
;
7434 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
7435 unlock_user(p
, arg2
, 0);
7438 case TARGET_NR_execve
:
7440 char **argp
, **envp
;
7443 abi_ulong guest_argp
;
7444 abi_ulong guest_envp
;
7451 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
7452 if (get_user_ual(addr
, gp
))
7453 return -TARGET_EFAULT
;
7460 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
7461 if (get_user_ual(addr
, gp
))
7462 return -TARGET_EFAULT
;
7468 argp
= g_new0(char *, argc
+ 1);
7469 envp
= g_new0(char *, envc
+ 1);
7471 for (gp
= guest_argp
, q
= argp
; gp
;
7472 gp
+= sizeof(abi_ulong
), q
++) {
7473 if (get_user_ual(addr
, gp
))
7477 if (!(*q
= lock_user_string(addr
)))
7479 total_size
+= strlen(*q
) + 1;
7483 for (gp
= guest_envp
, q
= envp
; gp
;
7484 gp
+= sizeof(abi_ulong
), q
++) {
7485 if (get_user_ual(addr
, gp
))
7489 if (!(*q
= lock_user_string(addr
)))
7491 total_size
+= strlen(*q
) + 1;
7495 if (!(p
= lock_user_string(arg1
)))
7497 /* Although execve() is not an interruptible syscall it is
7498 * a special case where we must use the safe_syscall wrapper:
7499 * if we allow a signal to happen before we make the host
7500 * syscall then we will 'lose' it, because at the point of
7501 * execve the process leaves QEMU's control. So we use the
7502 * safe syscall wrapper to ensure that we either take the
7503 * signal as a guest signal, or else it does not happen
7504 * before the execve completes and makes it the other
7505 * program's problem.
7507 ret
= get_errno(safe_execve(p
, argp
, envp
));
7508 unlock_user(p
, arg1
, 0);
7513 ret
= -TARGET_EFAULT
;
7516 for (gp
= guest_argp
, q
= argp
; *q
;
7517 gp
+= sizeof(abi_ulong
), q
++) {
7518 if (get_user_ual(addr
, gp
)
7521 unlock_user(*q
, addr
, 0);
7523 for (gp
= guest_envp
, q
= envp
; *q
;
7524 gp
+= sizeof(abi_ulong
), q
++) {
7525 if (get_user_ual(addr
, gp
)
7528 unlock_user(*q
, addr
, 0);
7535 case TARGET_NR_chdir
:
7536 if (!(p
= lock_user_string(arg1
)))
7537 return -TARGET_EFAULT
;
7538 ret
= get_errno(chdir(p
));
7539 unlock_user(p
, arg1
, 0);
7541 #ifdef TARGET_NR_time
7542 case TARGET_NR_time
:
7545 ret
= get_errno(time(&host_time
));
7548 && put_user_sal(host_time
, arg1
))
7549 return -TARGET_EFAULT
;
7553 #ifdef TARGET_NR_mknod
7554 case TARGET_NR_mknod
:
7555 if (!(p
= lock_user_string(arg1
)))
7556 return -TARGET_EFAULT
;
7557 ret
= get_errno(mknod(p
, arg2
, arg3
));
7558 unlock_user(p
, arg1
, 0);
7561 #if defined(TARGET_NR_mknodat)
7562 case TARGET_NR_mknodat
:
7563 if (!(p
= lock_user_string(arg2
)))
7564 return -TARGET_EFAULT
;
7565 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
7566 unlock_user(p
, arg2
, 0);
7569 #ifdef TARGET_NR_chmod
7570 case TARGET_NR_chmod
:
7571 if (!(p
= lock_user_string(arg1
)))
7572 return -TARGET_EFAULT
;
7573 ret
= get_errno(chmod(p
, arg2
));
7574 unlock_user(p
, arg1
, 0);
7577 #ifdef TARGET_NR_lseek
7578 case TARGET_NR_lseek
:
7579 return get_errno(lseek(arg1
, arg2
, arg3
));
7581 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
7582 /* Alpha specific */
7583 case TARGET_NR_getxpid
:
7584 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = getppid();
7585 return get_errno(getpid());
7587 #ifdef TARGET_NR_getpid
7588 case TARGET_NR_getpid
:
7589 return get_errno(getpid());
7591 case TARGET_NR_mount
:
7593 /* need to look at the data field */
7597 p
= lock_user_string(arg1
);
7599 return -TARGET_EFAULT
;
7605 p2
= lock_user_string(arg2
);
7608 unlock_user(p
, arg1
, 0);
7610 return -TARGET_EFAULT
;
7614 p3
= lock_user_string(arg3
);
7617 unlock_user(p
, arg1
, 0);
7619 unlock_user(p2
, arg2
, 0);
7620 return -TARGET_EFAULT
;
7626 /* FIXME - arg5 should be locked, but it isn't clear how to
7627 * do that since it's not guaranteed to be a NULL-terminated
7631 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
7633 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
));
7635 ret
= get_errno(ret
);
7638 unlock_user(p
, arg1
, 0);
7640 unlock_user(p2
, arg2
, 0);
7642 unlock_user(p3
, arg3
, 0);
7646 #ifdef TARGET_NR_umount
7647 case TARGET_NR_umount
:
7648 if (!(p
= lock_user_string(arg1
)))
7649 return -TARGET_EFAULT
;
7650 ret
= get_errno(umount(p
));
7651 unlock_user(p
, arg1
, 0);
7654 #ifdef TARGET_NR_stime /* not on alpha */
7655 case TARGET_NR_stime
:
7658 if (get_user_sal(host_time
, arg1
))
7659 return -TARGET_EFAULT
;
7660 return get_errno(stime(&host_time
));
7663 #ifdef TARGET_NR_alarm /* not on alpha */
7664 case TARGET_NR_alarm
:
7667 #ifdef TARGET_NR_pause /* not on alpha */
7668 case TARGET_NR_pause
:
7669 if (!block_signals()) {
7670 sigsuspend(&((TaskState
*)cpu
->opaque
)->signal_mask
);
7672 return -TARGET_EINTR
;
7674 #ifdef TARGET_NR_utime
7675 case TARGET_NR_utime
:
7677 struct utimbuf tbuf
, *host_tbuf
;
7678 struct target_utimbuf
*target_tbuf
;
7680 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
7681 return -TARGET_EFAULT
;
7682 tbuf
.actime
= tswapal(target_tbuf
->actime
);
7683 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
7684 unlock_user_struct(target_tbuf
, arg2
, 0);
7689 if (!(p
= lock_user_string(arg1
)))
7690 return -TARGET_EFAULT
;
7691 ret
= get_errno(utime(p
, host_tbuf
));
7692 unlock_user(p
, arg1
, 0);
7696 #ifdef TARGET_NR_utimes
7697 case TARGET_NR_utimes
:
7699 struct timeval
*tvp
, tv
[2];
7701 if (copy_from_user_timeval(&tv
[0], arg2
)
7702 || copy_from_user_timeval(&tv
[1],
7703 arg2
+ sizeof(struct target_timeval
)))
7704 return -TARGET_EFAULT
;
7709 if (!(p
= lock_user_string(arg1
)))
7710 return -TARGET_EFAULT
;
7711 ret
= get_errno(utimes(p
, tvp
));
7712 unlock_user(p
, arg1
, 0);
7716 #if defined(TARGET_NR_futimesat)
7717 case TARGET_NR_futimesat
:
7719 struct timeval
*tvp
, tv
[2];
7721 if (copy_from_user_timeval(&tv
[0], arg3
)
7722 || copy_from_user_timeval(&tv
[1],
7723 arg3
+ sizeof(struct target_timeval
)))
7724 return -TARGET_EFAULT
;
7729 if (!(p
= lock_user_string(arg2
))) {
7730 return -TARGET_EFAULT
;
7732 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
7733 unlock_user(p
, arg2
, 0);
7737 #ifdef TARGET_NR_access
7738 case TARGET_NR_access
:
7739 if (!(p
= lock_user_string(arg1
))) {
7740 return -TARGET_EFAULT
;
7742 ret
= get_errno(access(path(p
), arg2
));
7743 unlock_user(p
, arg1
, 0);
7746 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
7747 case TARGET_NR_faccessat
:
7748 if (!(p
= lock_user_string(arg2
))) {
7749 return -TARGET_EFAULT
;
7751 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
7752 unlock_user(p
, arg2
, 0);
7755 #ifdef TARGET_NR_nice /* not on alpha */
7756 case TARGET_NR_nice
:
7757 return get_errno(nice(arg1
));
7759 case TARGET_NR_sync
:
7762 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
7763 case TARGET_NR_syncfs
:
7764 return get_errno(syncfs(arg1
));
7766 case TARGET_NR_kill
:
7767 return get_errno(safe_kill(arg1
, target_to_host_signal(arg2
)));
7768 #ifdef TARGET_NR_rename
7769 case TARGET_NR_rename
:
7772 p
= lock_user_string(arg1
);
7773 p2
= lock_user_string(arg2
);
7775 ret
= -TARGET_EFAULT
;
7777 ret
= get_errno(rename(p
, p2
));
7778 unlock_user(p2
, arg2
, 0);
7779 unlock_user(p
, arg1
, 0);
7783 #if defined(TARGET_NR_renameat)
7784 case TARGET_NR_renameat
:
7787 p
= lock_user_string(arg2
);
7788 p2
= lock_user_string(arg4
);
7790 ret
= -TARGET_EFAULT
;
7792 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
7793 unlock_user(p2
, arg4
, 0);
7794 unlock_user(p
, arg2
, 0);
7798 #if defined(TARGET_NR_renameat2)
7799 case TARGET_NR_renameat2
:
7802 p
= lock_user_string(arg2
);
7803 p2
= lock_user_string(arg4
);
7805 ret
= -TARGET_EFAULT
;
7807 ret
= get_errno(sys_renameat2(arg1
, p
, arg3
, p2
, arg5
));
7809 unlock_user(p2
, arg4
, 0);
7810 unlock_user(p
, arg2
, 0);
7814 #ifdef TARGET_NR_mkdir
7815 case TARGET_NR_mkdir
:
7816 if (!(p
= lock_user_string(arg1
)))
7817 return -TARGET_EFAULT
;
7818 ret
= get_errno(mkdir(p
, arg2
));
7819 unlock_user(p
, arg1
, 0);
7822 #if defined(TARGET_NR_mkdirat)
7823 case TARGET_NR_mkdirat
:
7824 if (!(p
= lock_user_string(arg2
)))
7825 return -TARGET_EFAULT
;
7826 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
7827 unlock_user(p
, arg2
, 0);
7830 #ifdef TARGET_NR_rmdir
7831 case TARGET_NR_rmdir
:
7832 if (!(p
= lock_user_string(arg1
)))
7833 return -TARGET_EFAULT
;
7834 ret
= get_errno(rmdir(p
));
7835 unlock_user(p
, arg1
, 0);
7839 ret
= get_errno(dup(arg1
));
7841 fd_trans_dup(arg1
, ret
);
7844 #ifdef TARGET_NR_pipe
7845 case TARGET_NR_pipe
:
7846 return do_pipe(cpu_env
, arg1
, 0, 0);
7848 #ifdef TARGET_NR_pipe2
7849 case TARGET_NR_pipe2
:
7850 return do_pipe(cpu_env
, arg1
,
7851 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
7853 case TARGET_NR_times
:
7855 struct target_tms
*tmsp
;
7857 ret
= get_errno(times(&tms
));
7859 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
7861 return -TARGET_EFAULT
;
7862 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
7863 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
7864 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
7865 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
7868 ret
= host_to_target_clock_t(ret
);
7871 case TARGET_NR_acct
:
7873 ret
= get_errno(acct(NULL
));
7875 if (!(p
= lock_user_string(arg1
))) {
7876 return -TARGET_EFAULT
;
7878 ret
= get_errno(acct(path(p
)));
7879 unlock_user(p
, arg1
, 0);
7882 #ifdef TARGET_NR_umount2
7883 case TARGET_NR_umount2
:
7884 if (!(p
= lock_user_string(arg1
)))
7885 return -TARGET_EFAULT
;
7886 ret
= get_errno(umount2(p
, arg2
));
7887 unlock_user(p
, arg1
, 0);
7890 case TARGET_NR_ioctl
:
7891 return do_ioctl(arg1
, arg2
, arg3
);
7892 #ifdef TARGET_NR_fcntl
7893 case TARGET_NR_fcntl
:
7894 return do_fcntl(arg1
, arg2
, arg3
);
7896 case TARGET_NR_setpgid
:
7897 return get_errno(setpgid(arg1
, arg2
));
7898 case TARGET_NR_umask
:
7899 return get_errno(umask(arg1
));
7900 case TARGET_NR_chroot
:
7901 if (!(p
= lock_user_string(arg1
)))
7902 return -TARGET_EFAULT
;
7903 ret
= get_errno(chroot(p
));
7904 unlock_user(p
, arg1
, 0);
7906 #ifdef TARGET_NR_dup2
7907 case TARGET_NR_dup2
:
7908 ret
= get_errno(dup2(arg1
, arg2
));
7910 fd_trans_dup(arg1
, arg2
);
7914 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
7915 case TARGET_NR_dup3
:
7919 if ((arg3
& ~TARGET_O_CLOEXEC
) != 0) {
7922 host_flags
= target_to_host_bitmask(arg3
, fcntl_flags_tbl
);
7923 ret
= get_errno(dup3(arg1
, arg2
, host_flags
));
7925 fd_trans_dup(arg1
, arg2
);
7930 #ifdef TARGET_NR_getppid /* not on alpha */
7931 case TARGET_NR_getppid
:
7932 return get_errno(getppid());
7934 #ifdef TARGET_NR_getpgrp
7935 case TARGET_NR_getpgrp
:
7936 return get_errno(getpgrp());
7938 case TARGET_NR_setsid
:
7939 return get_errno(setsid());
7940 #ifdef TARGET_NR_sigaction
7941 case TARGET_NR_sigaction
:
7943 #if defined(TARGET_ALPHA)
7944 struct target_sigaction act
, oact
, *pact
= 0;
7945 struct target_old_sigaction
*old_act
;
7947 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7948 return -TARGET_EFAULT
;
7949 act
._sa_handler
= old_act
->_sa_handler
;
7950 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
7951 act
.sa_flags
= old_act
->sa_flags
;
7952 act
.sa_restorer
= 0;
7953 unlock_user_struct(old_act
, arg2
, 0);
7956 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7957 if (!is_error(ret
) && arg3
) {
7958 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
7959 return -TARGET_EFAULT
;
7960 old_act
->_sa_handler
= oact
._sa_handler
;
7961 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
7962 old_act
->sa_flags
= oact
.sa_flags
;
7963 unlock_user_struct(old_act
, arg3
, 1);
7965 #elif defined(TARGET_MIPS)
7966 struct target_sigaction act
, oact
, *pact
, *old_act
;
7969 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7970 return -TARGET_EFAULT
;
7971 act
._sa_handler
= old_act
->_sa_handler
;
7972 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
7973 act
.sa_flags
= old_act
->sa_flags
;
7974 unlock_user_struct(old_act
, arg2
, 0);
7980 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7982 if (!is_error(ret
) && arg3
) {
7983 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
7984 return -TARGET_EFAULT
;
7985 old_act
->_sa_handler
= oact
._sa_handler
;
7986 old_act
->sa_flags
= oact
.sa_flags
;
7987 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
7988 old_act
->sa_mask
.sig
[1] = 0;
7989 old_act
->sa_mask
.sig
[2] = 0;
7990 old_act
->sa_mask
.sig
[3] = 0;
7991 unlock_user_struct(old_act
, arg3
, 1);
7994 struct target_old_sigaction
*old_act
;
7995 struct target_sigaction act
, oact
, *pact
;
7997 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7998 return -TARGET_EFAULT
;
7999 act
._sa_handler
= old_act
->_sa_handler
;
8000 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
8001 act
.sa_flags
= old_act
->sa_flags
;
8002 act
.sa_restorer
= old_act
->sa_restorer
;
8003 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8004 act
.ka_restorer
= 0;
8006 unlock_user_struct(old_act
, arg2
, 0);
8011 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8012 if (!is_error(ret
) && arg3
) {
8013 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8014 return -TARGET_EFAULT
;
8015 old_act
->_sa_handler
= oact
._sa_handler
;
8016 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
8017 old_act
->sa_flags
= oact
.sa_flags
;
8018 old_act
->sa_restorer
= oact
.sa_restorer
;
8019 unlock_user_struct(old_act
, arg3
, 1);
8025 case TARGET_NR_rt_sigaction
:
8027 #if defined(TARGET_ALPHA)
8028 /* For Alpha and SPARC this is a 5 argument syscall, with
8029 * a 'restorer' parameter which must be copied into the
8030 * sa_restorer field of the sigaction struct.
8031 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
8032 * and arg5 is the sigsetsize.
8033 * Alpha also has a separate rt_sigaction struct that it uses
8034 * here; SPARC uses the usual sigaction struct.
8036 struct target_rt_sigaction
*rt_act
;
8037 struct target_sigaction act
, oact
, *pact
= 0;
8039 if (arg4
!= sizeof(target_sigset_t
)) {
8040 return -TARGET_EINVAL
;
8043 if (!lock_user_struct(VERIFY_READ
, rt_act
, arg2
, 1))
8044 return -TARGET_EFAULT
;
8045 act
._sa_handler
= rt_act
->_sa_handler
;
8046 act
.sa_mask
= rt_act
->sa_mask
;
8047 act
.sa_flags
= rt_act
->sa_flags
;
8048 act
.sa_restorer
= arg5
;
8049 unlock_user_struct(rt_act
, arg2
, 0);
8052 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8053 if (!is_error(ret
) && arg3
) {
8054 if (!lock_user_struct(VERIFY_WRITE
, rt_act
, arg3
, 0))
8055 return -TARGET_EFAULT
;
8056 rt_act
->_sa_handler
= oact
._sa_handler
;
8057 rt_act
->sa_mask
= oact
.sa_mask
;
8058 rt_act
->sa_flags
= oact
.sa_flags
;
8059 unlock_user_struct(rt_act
, arg3
, 1);
8063 target_ulong restorer
= arg4
;
8064 target_ulong sigsetsize
= arg5
;
8066 target_ulong sigsetsize
= arg4
;
8068 struct target_sigaction
*act
;
8069 struct target_sigaction
*oact
;
8071 if (sigsetsize
!= sizeof(target_sigset_t
)) {
8072 return -TARGET_EINVAL
;
8075 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1)) {
8076 return -TARGET_EFAULT
;
8078 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8079 act
->ka_restorer
= restorer
;
8085 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
8086 ret
= -TARGET_EFAULT
;
8087 goto rt_sigaction_fail
;
8091 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
8094 unlock_user_struct(act
, arg2
, 0);
8096 unlock_user_struct(oact
, arg3
, 1);
8100 #ifdef TARGET_NR_sgetmask /* not on alpha */
8101 case TARGET_NR_sgetmask
:
8104 abi_ulong target_set
;
8105 ret
= do_sigprocmask(0, NULL
, &cur_set
);
8107 host_to_target_old_sigset(&target_set
, &cur_set
);
8113 #ifdef TARGET_NR_ssetmask /* not on alpha */
8114 case TARGET_NR_ssetmask
:
8117 abi_ulong target_set
= arg1
;
8118 target_to_host_old_sigset(&set
, &target_set
);
8119 ret
= do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
8121 host_to_target_old_sigset(&target_set
, &oset
);
8127 #ifdef TARGET_NR_sigprocmask
8128 case TARGET_NR_sigprocmask
:
8130 #if defined(TARGET_ALPHA)
8131 sigset_t set
, oldset
;
8136 case TARGET_SIG_BLOCK
:
8139 case TARGET_SIG_UNBLOCK
:
8142 case TARGET_SIG_SETMASK
:
8146 return -TARGET_EINVAL
;
8149 target_to_host_old_sigset(&set
, &mask
);
8151 ret
= do_sigprocmask(how
, &set
, &oldset
);
8152 if (!is_error(ret
)) {
8153 host_to_target_old_sigset(&mask
, &oldset
);
8155 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0; /* force no error */
8158 sigset_t set
, oldset
, *set_ptr
;
8163 case TARGET_SIG_BLOCK
:
8166 case TARGET_SIG_UNBLOCK
:
8169 case TARGET_SIG_SETMASK
:
8173 return -TARGET_EINVAL
;
8175 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8176 return -TARGET_EFAULT
;
8177 target_to_host_old_sigset(&set
, p
);
8178 unlock_user(p
, arg2
, 0);
8184 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8185 if (!is_error(ret
) && arg3
) {
8186 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8187 return -TARGET_EFAULT
;
8188 host_to_target_old_sigset(p
, &oldset
);
8189 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8195 case TARGET_NR_rt_sigprocmask
:
8198 sigset_t set
, oldset
, *set_ptr
;
8200 if (arg4
!= sizeof(target_sigset_t
)) {
8201 return -TARGET_EINVAL
;
8206 case TARGET_SIG_BLOCK
:
8209 case TARGET_SIG_UNBLOCK
:
8212 case TARGET_SIG_SETMASK
:
8216 return -TARGET_EINVAL
;
8218 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8219 return -TARGET_EFAULT
;
8220 target_to_host_sigset(&set
, p
);
8221 unlock_user(p
, arg2
, 0);
8227 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8228 if (!is_error(ret
) && arg3
) {
8229 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8230 return -TARGET_EFAULT
;
8231 host_to_target_sigset(p
, &oldset
);
8232 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8236 #ifdef TARGET_NR_sigpending
8237 case TARGET_NR_sigpending
:
8240 ret
= get_errno(sigpending(&set
));
8241 if (!is_error(ret
)) {
8242 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8243 return -TARGET_EFAULT
;
8244 host_to_target_old_sigset(p
, &set
);
8245 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8250 case TARGET_NR_rt_sigpending
:
8254 /* Yes, this check is >, not != like most. We follow the kernel's
8255 * logic and it does it like this because it implements
8256 * NR_sigpending through the same code path, and in that case
8257 * the old_sigset_t is smaller in size.
8259 if (arg2
> sizeof(target_sigset_t
)) {
8260 return -TARGET_EINVAL
;
8263 ret
= get_errno(sigpending(&set
));
8264 if (!is_error(ret
)) {
8265 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8266 return -TARGET_EFAULT
;
8267 host_to_target_sigset(p
, &set
);
8268 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8272 #ifdef TARGET_NR_sigsuspend
8273 case TARGET_NR_sigsuspend
:
8275 TaskState
*ts
= cpu
->opaque
;
8276 #if defined(TARGET_ALPHA)
8277 abi_ulong mask
= arg1
;
8278 target_to_host_old_sigset(&ts
->sigsuspend_mask
, &mask
);
8280 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8281 return -TARGET_EFAULT
;
8282 target_to_host_old_sigset(&ts
->sigsuspend_mask
, p
);
8283 unlock_user(p
, arg1
, 0);
8285 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8287 if (ret
!= -TARGET_ERESTARTSYS
) {
8288 ts
->in_sigsuspend
= 1;
8293 case TARGET_NR_rt_sigsuspend
:
8295 TaskState
*ts
= cpu
->opaque
;
8297 if (arg2
!= sizeof(target_sigset_t
)) {
8298 return -TARGET_EINVAL
;
8300 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8301 return -TARGET_EFAULT
;
8302 target_to_host_sigset(&ts
->sigsuspend_mask
, p
);
8303 unlock_user(p
, arg1
, 0);
8304 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8306 if (ret
!= -TARGET_ERESTARTSYS
) {
8307 ts
->in_sigsuspend
= 1;
8311 case TARGET_NR_rt_sigtimedwait
:
8314 struct timespec uts
, *puts
;
8317 if (arg4
!= sizeof(target_sigset_t
)) {
8318 return -TARGET_EINVAL
;
8321 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8322 return -TARGET_EFAULT
;
8323 target_to_host_sigset(&set
, p
);
8324 unlock_user(p
, arg1
, 0);
8327 target_to_host_timespec(puts
, arg3
);
8331 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
8333 if (!is_error(ret
)) {
8335 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
8338 return -TARGET_EFAULT
;
8340 host_to_target_siginfo(p
, &uinfo
);
8341 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
8343 ret
= host_to_target_signal(ret
);
8347 case TARGET_NR_rt_sigqueueinfo
:
8351 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
8353 return -TARGET_EFAULT
;
8355 target_to_host_siginfo(&uinfo
, p
);
8356 unlock_user(p
, arg3
, 0);
8357 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
8360 case TARGET_NR_rt_tgsigqueueinfo
:
8364 p
= lock_user(VERIFY_READ
, arg4
, sizeof(target_siginfo_t
), 1);
8366 return -TARGET_EFAULT
;
8368 target_to_host_siginfo(&uinfo
, p
);
8369 unlock_user(p
, arg4
, 0);
8370 ret
= get_errno(sys_rt_tgsigqueueinfo(arg1
, arg2
, arg3
, &uinfo
));
8373 #ifdef TARGET_NR_sigreturn
8374 case TARGET_NR_sigreturn
:
8375 if (block_signals()) {
8376 return -TARGET_ERESTARTSYS
;
8378 return do_sigreturn(cpu_env
);
8380 case TARGET_NR_rt_sigreturn
:
8381 if (block_signals()) {
8382 return -TARGET_ERESTARTSYS
;
8384 return do_rt_sigreturn(cpu_env
);
8385 case TARGET_NR_sethostname
:
8386 if (!(p
= lock_user_string(arg1
)))
8387 return -TARGET_EFAULT
;
8388 ret
= get_errno(sethostname(p
, arg2
));
8389 unlock_user(p
, arg1
, 0);
8391 #ifdef TARGET_NR_setrlimit
8392 case TARGET_NR_setrlimit
:
8394 int resource
= target_to_host_resource(arg1
);
8395 struct target_rlimit
*target_rlim
;
8397 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
8398 return -TARGET_EFAULT
;
8399 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
8400 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
8401 unlock_user_struct(target_rlim
, arg2
, 0);
8403 * If we just passed through resource limit settings for memory then
8404 * they would also apply to QEMU's own allocations, and QEMU will
8405 * crash or hang or die if its allocations fail. Ideally we would
8406 * track the guest allocations in QEMU and apply the limits ourselves.
8407 * For now, just tell the guest the call succeeded but don't actually
8410 if (resource
!= RLIMIT_AS
&&
8411 resource
!= RLIMIT_DATA
&&
8412 resource
!= RLIMIT_STACK
) {
8413 return get_errno(setrlimit(resource
, &rlim
));
8419 #ifdef TARGET_NR_getrlimit
8420 case TARGET_NR_getrlimit
:
8422 int resource
= target_to_host_resource(arg1
);
8423 struct target_rlimit
*target_rlim
;
8426 ret
= get_errno(getrlimit(resource
, &rlim
));
8427 if (!is_error(ret
)) {
8428 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
8429 return -TARGET_EFAULT
;
8430 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
8431 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
8432 unlock_user_struct(target_rlim
, arg2
, 1);
8437 case TARGET_NR_getrusage
:
8439 struct rusage rusage
;
8440 ret
= get_errno(getrusage(arg1
, &rusage
));
8441 if (!is_error(ret
)) {
8442 ret
= host_to_target_rusage(arg2
, &rusage
);
8446 case TARGET_NR_gettimeofday
:
8449 ret
= get_errno(gettimeofday(&tv
, NULL
));
8450 if (!is_error(ret
)) {
8451 if (copy_to_user_timeval(arg1
, &tv
))
8452 return -TARGET_EFAULT
;
8456 case TARGET_NR_settimeofday
:
8458 struct timeval tv
, *ptv
= NULL
;
8459 struct timezone tz
, *ptz
= NULL
;
8462 if (copy_from_user_timeval(&tv
, arg1
)) {
8463 return -TARGET_EFAULT
;
8469 if (copy_from_user_timezone(&tz
, arg2
)) {
8470 return -TARGET_EFAULT
;
8475 return get_errno(settimeofday(ptv
, ptz
));
8477 #if defined(TARGET_NR_select)
8478 case TARGET_NR_select
:
8479 #if defined(TARGET_WANT_NI_OLD_SELECT)
8480 /* some architectures used to have old_select here
8481 * but now ENOSYS it.
8483 ret
= -TARGET_ENOSYS
;
8484 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
8485 ret
= do_old_select(arg1
);
8487 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
8491 #ifdef TARGET_NR_pselect6
8492 case TARGET_NR_pselect6
:
8494 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
8495 fd_set rfds
, wfds
, efds
;
8496 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
8497 struct timespec ts
, *ts_ptr
;
8500 * The 6th arg is actually two args smashed together,
8501 * so we cannot use the C library.
8509 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
8510 target_sigset_t
*target_sigset
;
8518 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
8522 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
8526 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
8532 * This takes a timespec, and not a timeval, so we cannot
8533 * use the do_select() helper ...
8536 if (target_to_host_timespec(&ts
, ts_addr
)) {
8537 return -TARGET_EFAULT
;
8544 /* Extract the two packed args for the sigset */
8547 sig
.size
= SIGSET_T_SIZE
;
8549 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
8551 return -TARGET_EFAULT
;
8553 arg_sigset
= tswapal(arg7
[0]);
8554 arg_sigsize
= tswapal(arg7
[1]);
8555 unlock_user(arg7
, arg6
, 0);
8559 if (arg_sigsize
!= sizeof(*target_sigset
)) {
8560 /* Like the kernel, we enforce correct size sigsets */
8561 return -TARGET_EINVAL
;
8563 target_sigset
= lock_user(VERIFY_READ
, arg_sigset
,
8564 sizeof(*target_sigset
), 1);
8565 if (!target_sigset
) {
8566 return -TARGET_EFAULT
;
8568 target_to_host_sigset(&set
, target_sigset
);
8569 unlock_user(target_sigset
, arg_sigset
, 0);
8577 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
8580 if (!is_error(ret
)) {
8581 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
8582 return -TARGET_EFAULT
;
8583 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
8584 return -TARGET_EFAULT
;
8585 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
8586 return -TARGET_EFAULT
;
8588 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
))
8589 return -TARGET_EFAULT
;
8594 #ifdef TARGET_NR_symlink
8595 case TARGET_NR_symlink
:
8598 p
= lock_user_string(arg1
);
8599 p2
= lock_user_string(arg2
);
8601 ret
= -TARGET_EFAULT
;
8603 ret
= get_errno(symlink(p
, p2
));
8604 unlock_user(p2
, arg2
, 0);
8605 unlock_user(p
, arg1
, 0);
8609 #if defined(TARGET_NR_symlinkat)
8610 case TARGET_NR_symlinkat
:
8613 p
= lock_user_string(arg1
);
8614 p2
= lock_user_string(arg3
);
8616 ret
= -TARGET_EFAULT
;
8618 ret
= get_errno(symlinkat(p
, arg2
, p2
));
8619 unlock_user(p2
, arg3
, 0);
8620 unlock_user(p
, arg1
, 0);
8624 #ifdef TARGET_NR_readlink
8625 case TARGET_NR_readlink
:
8628 p
= lock_user_string(arg1
);
8629 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
8631 ret
= -TARGET_EFAULT
;
8633 /* Short circuit this for the magic exe check. */
8634 ret
= -TARGET_EINVAL
;
8635 } else if (is_proc_myself((const char *)p
, "exe")) {
8636 char real
[PATH_MAX
], *temp
;
8637 temp
= realpath(exec_path
, real
);
8638 /* Return value is # of bytes that we wrote to the buffer. */
8640 ret
= get_errno(-1);
8642 /* Don't worry about sign mismatch as earlier mapping
8643 * logic would have thrown a bad address error. */
8644 ret
= MIN(strlen(real
), arg3
);
8645 /* We cannot NUL terminate the string. */
8646 memcpy(p2
, real
, ret
);
8649 ret
= get_errno(readlink(path(p
), p2
, arg3
));
8651 unlock_user(p2
, arg2
, ret
);
8652 unlock_user(p
, arg1
, 0);
8656 #if defined(TARGET_NR_readlinkat)
8657 case TARGET_NR_readlinkat
:
8660 p
= lock_user_string(arg2
);
8661 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
8663 ret
= -TARGET_EFAULT
;
8664 } else if (is_proc_myself((const char *)p
, "exe")) {
8665 char real
[PATH_MAX
], *temp
;
8666 temp
= realpath(exec_path
, real
);
8667 ret
= temp
== NULL
? get_errno(-1) : strlen(real
) ;
8668 snprintf((char *)p2
, arg4
, "%s", real
);
8670 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
8672 unlock_user(p2
, arg3
, ret
);
8673 unlock_user(p
, arg2
, 0);
8677 #ifdef TARGET_NR_swapon
8678 case TARGET_NR_swapon
:
8679 if (!(p
= lock_user_string(arg1
)))
8680 return -TARGET_EFAULT
;
8681 ret
= get_errno(swapon(p
, arg2
));
8682 unlock_user(p
, arg1
, 0);
8685 case TARGET_NR_reboot
:
8686 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
8687 /* arg4 must be ignored in all other cases */
8688 p
= lock_user_string(arg4
);
8690 return -TARGET_EFAULT
;
8692 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
8693 unlock_user(p
, arg4
, 0);
8695 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
8698 #ifdef TARGET_NR_mmap
8699 case TARGET_NR_mmap
:
8700 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
8701 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
8702 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
8703 || defined(TARGET_S390X)
8706 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
8707 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
8708 return -TARGET_EFAULT
;
8715 unlock_user(v
, arg1
, 0);
8716 ret
= get_errno(target_mmap(v1
, v2
, v3
,
8717 target_to_host_bitmask(v4
, mmap_flags_tbl
),
8721 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
8722 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
8728 #ifdef TARGET_NR_mmap2
8729 case TARGET_NR_mmap2
:
8731 #define MMAP_SHIFT 12
8733 ret
= target_mmap(arg1
, arg2
, arg3
,
8734 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
8735 arg5
, arg6
<< MMAP_SHIFT
);
8736 return get_errno(ret
);
8738 case TARGET_NR_munmap
:
8739 return get_errno(target_munmap(arg1
, arg2
));
8740 case TARGET_NR_mprotect
:
8742 TaskState
*ts
= cpu
->opaque
;
8743 /* Special hack to detect libc making the stack executable. */
8744 if ((arg3
& PROT_GROWSDOWN
)
8745 && arg1
>= ts
->info
->stack_limit
8746 && arg1
<= ts
->info
->start_stack
) {
8747 arg3
&= ~PROT_GROWSDOWN
;
8748 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
8749 arg1
= ts
->info
->stack_limit
;
8752 return get_errno(target_mprotect(arg1
, arg2
, arg3
));
8753 #ifdef TARGET_NR_mremap
8754 case TARGET_NR_mremap
:
8755 return get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
8757 /* ??? msync/mlock/munlock are broken for softmmu. */
8758 #ifdef TARGET_NR_msync
8759 case TARGET_NR_msync
:
8760 return get_errno(msync(g2h(arg1
), arg2
, arg3
));
8762 #ifdef TARGET_NR_mlock
8763 case TARGET_NR_mlock
:
8764 return get_errno(mlock(g2h(arg1
), arg2
));
8766 #ifdef TARGET_NR_munlock
8767 case TARGET_NR_munlock
:
8768 return get_errno(munlock(g2h(arg1
), arg2
));
8770 #ifdef TARGET_NR_mlockall
8771 case TARGET_NR_mlockall
:
8772 return get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
8774 #ifdef TARGET_NR_munlockall
8775 case TARGET_NR_munlockall
:
8776 return get_errno(munlockall());
8778 #ifdef TARGET_NR_truncate
8779 case TARGET_NR_truncate
:
8780 if (!(p
= lock_user_string(arg1
)))
8781 return -TARGET_EFAULT
;
8782 ret
= get_errno(truncate(p
, arg2
));
8783 unlock_user(p
, arg1
, 0);
8786 #ifdef TARGET_NR_ftruncate
8787 case TARGET_NR_ftruncate
:
8788 return get_errno(ftruncate(arg1
, arg2
));
8790 case TARGET_NR_fchmod
:
8791 return get_errno(fchmod(arg1
, arg2
));
8792 #if defined(TARGET_NR_fchmodat)
8793 case TARGET_NR_fchmodat
:
8794 if (!(p
= lock_user_string(arg2
)))
8795 return -TARGET_EFAULT
;
8796 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
8797 unlock_user(p
, arg2
, 0);
8800 case TARGET_NR_getpriority
:
8801 /* Note that negative values are valid for getpriority, so we must
8802 differentiate based on errno settings. */
8804 ret
= getpriority(arg1
, arg2
);
8805 if (ret
== -1 && errno
!= 0) {
8806 return -host_to_target_errno(errno
);
8809 /* Return value is the unbiased priority. Signal no error. */
8810 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0;
8812 /* Return value is a biased priority to avoid negative numbers. */
8816 case TARGET_NR_setpriority
:
8817 return get_errno(setpriority(arg1
, arg2
, arg3
));
8818 #ifdef TARGET_NR_statfs
8819 case TARGET_NR_statfs
:
8820 if (!(p
= lock_user_string(arg1
))) {
8821 return -TARGET_EFAULT
;
8823 ret
= get_errno(statfs(path(p
), &stfs
));
8824 unlock_user(p
, arg1
, 0);
8826 if (!is_error(ret
)) {
8827 struct target_statfs
*target_stfs
;
8829 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
8830 return -TARGET_EFAULT
;
8831 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
8832 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
8833 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
8834 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
8835 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
8836 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
8837 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
8838 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
8839 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
8840 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
8841 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
8842 #ifdef _STATFS_F_FLAGS
8843 __put_user(stfs
.f_flags
, &target_stfs
->f_flags
);
8845 __put_user(0, &target_stfs
->f_flags
);
8847 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
8848 unlock_user_struct(target_stfs
, arg2
, 1);
8852 #ifdef TARGET_NR_fstatfs
8853 case TARGET_NR_fstatfs
:
8854 ret
= get_errno(fstatfs(arg1
, &stfs
));
8855 goto convert_statfs
;
8857 #ifdef TARGET_NR_statfs64
8858 case TARGET_NR_statfs64
:
8859 if (!(p
= lock_user_string(arg1
))) {
8860 return -TARGET_EFAULT
;
8862 ret
= get_errno(statfs(path(p
), &stfs
));
8863 unlock_user(p
, arg1
, 0);
8865 if (!is_error(ret
)) {
8866 struct target_statfs64
*target_stfs
;
8868 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
8869 return -TARGET_EFAULT
;
8870 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
8871 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
8872 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
8873 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
8874 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
8875 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
8876 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
8877 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
8878 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
8879 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
8880 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
8881 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
8882 unlock_user_struct(target_stfs
, arg3
, 1);
8885 case TARGET_NR_fstatfs64
:
8886 ret
= get_errno(fstatfs(arg1
, &stfs
));
8887 goto convert_statfs64
;
8889 #ifdef TARGET_NR_socketcall
8890 case TARGET_NR_socketcall
:
8891 return do_socketcall(arg1
, arg2
);
8893 #ifdef TARGET_NR_accept
8894 case TARGET_NR_accept
:
8895 return do_accept4(arg1
, arg2
, arg3
, 0);
8897 #ifdef TARGET_NR_accept4
8898 case TARGET_NR_accept4
:
8899 return do_accept4(arg1
, arg2
, arg3
, arg4
);
8901 #ifdef TARGET_NR_bind
8902 case TARGET_NR_bind
:
8903 return do_bind(arg1
, arg2
, arg3
);
8905 #ifdef TARGET_NR_connect
8906 case TARGET_NR_connect
:
8907 return do_connect(arg1
, arg2
, arg3
);
8909 #ifdef TARGET_NR_getpeername
8910 case TARGET_NR_getpeername
:
8911 return do_getpeername(arg1
, arg2
, arg3
);
8913 #ifdef TARGET_NR_getsockname
8914 case TARGET_NR_getsockname
:
8915 return do_getsockname(arg1
, arg2
, arg3
);
8917 #ifdef TARGET_NR_getsockopt
8918 case TARGET_NR_getsockopt
:
8919 return do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
8921 #ifdef TARGET_NR_listen
8922 case TARGET_NR_listen
:
8923 return get_errno(listen(arg1
, arg2
));
8925 #ifdef TARGET_NR_recv
8926 case TARGET_NR_recv
:
8927 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
8929 #ifdef TARGET_NR_recvfrom
8930 case TARGET_NR_recvfrom
:
8931 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
8933 #ifdef TARGET_NR_recvmsg
8934 case TARGET_NR_recvmsg
:
8935 return do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
8937 #ifdef TARGET_NR_send
8938 case TARGET_NR_send
:
8939 return do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
8941 #ifdef TARGET_NR_sendmsg
8942 case TARGET_NR_sendmsg
:
8943 return do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
8945 #ifdef TARGET_NR_sendmmsg
8946 case TARGET_NR_sendmmsg
:
8947 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
8948 case TARGET_NR_recvmmsg
:
8949 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
8951 #ifdef TARGET_NR_sendto
8952 case TARGET_NR_sendto
:
8953 return do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
8955 #ifdef TARGET_NR_shutdown
8956 case TARGET_NR_shutdown
:
8957 return get_errno(shutdown(arg1
, arg2
));
8959 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
8960 case TARGET_NR_getrandom
:
8961 p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
8963 return -TARGET_EFAULT
;
8965 ret
= get_errno(getrandom(p
, arg2
, arg3
));
8966 unlock_user(p
, arg1
, ret
);
8969 #ifdef TARGET_NR_socket
8970 case TARGET_NR_socket
:
8971 return do_socket(arg1
, arg2
, arg3
);
8973 #ifdef TARGET_NR_socketpair
8974 case TARGET_NR_socketpair
:
8975 return do_socketpair(arg1
, arg2
, arg3
, arg4
);
8977 #ifdef TARGET_NR_setsockopt
8978 case TARGET_NR_setsockopt
:
8979 return do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
8981 #if defined(TARGET_NR_syslog)
8982 case TARGET_NR_syslog
:
8987 case TARGET_SYSLOG_ACTION_CLOSE
: /* Close log */
8988 case TARGET_SYSLOG_ACTION_OPEN
: /* Open log */
8989 case TARGET_SYSLOG_ACTION_CLEAR
: /* Clear ring buffer */
8990 case TARGET_SYSLOG_ACTION_CONSOLE_OFF
: /* Disable logging */
8991 case TARGET_SYSLOG_ACTION_CONSOLE_ON
: /* Enable logging */
8992 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL
: /* Set messages level */
8993 case TARGET_SYSLOG_ACTION_SIZE_UNREAD
: /* Number of chars */
8994 case TARGET_SYSLOG_ACTION_SIZE_BUFFER
: /* Size of the buffer */
8995 return get_errno(sys_syslog((int)arg1
, NULL
, (int)arg3
));
8996 case TARGET_SYSLOG_ACTION_READ
: /* Read from log */
8997 case TARGET_SYSLOG_ACTION_READ_CLEAR
: /* Read/clear msgs */
8998 case TARGET_SYSLOG_ACTION_READ_ALL
: /* Read last messages */
9001 return -TARGET_EINVAL
;
9006 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9008 return -TARGET_EFAULT
;
9010 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
9011 unlock_user(p
, arg2
, arg3
);
9015 return -TARGET_EINVAL
;
9020 case TARGET_NR_setitimer
:
9022 struct itimerval value
, ovalue
, *pvalue
;
9026 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
9027 || copy_from_user_timeval(&pvalue
->it_value
,
9028 arg2
+ sizeof(struct target_timeval
)))
9029 return -TARGET_EFAULT
;
9033 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
9034 if (!is_error(ret
) && arg3
) {
9035 if (copy_to_user_timeval(arg3
,
9036 &ovalue
.it_interval
)
9037 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
9039 return -TARGET_EFAULT
;
9043 case TARGET_NR_getitimer
:
9045 struct itimerval value
;
9047 ret
= get_errno(getitimer(arg1
, &value
));
9048 if (!is_error(ret
) && arg2
) {
9049 if (copy_to_user_timeval(arg2
,
9051 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
9053 return -TARGET_EFAULT
;
9057 #ifdef TARGET_NR_stat
9058 case TARGET_NR_stat
:
9059 if (!(p
= lock_user_string(arg1
))) {
9060 return -TARGET_EFAULT
;
9062 ret
= get_errno(stat(path(p
), &st
));
9063 unlock_user(p
, arg1
, 0);
9066 #ifdef TARGET_NR_lstat
9067 case TARGET_NR_lstat
:
9068 if (!(p
= lock_user_string(arg1
))) {
9069 return -TARGET_EFAULT
;
9071 ret
= get_errno(lstat(path(p
), &st
));
9072 unlock_user(p
, arg1
, 0);
9075 #ifdef TARGET_NR_fstat
9076 case TARGET_NR_fstat
:
9078 ret
= get_errno(fstat(arg1
, &st
));
9079 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
9082 if (!is_error(ret
)) {
9083 struct target_stat
*target_st
;
9085 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
9086 return -TARGET_EFAULT
;
9087 memset(target_st
, 0, sizeof(*target_st
));
9088 __put_user(st
.st_dev
, &target_st
->st_dev
);
9089 __put_user(st
.st_ino
, &target_st
->st_ino
);
9090 __put_user(st
.st_mode
, &target_st
->st_mode
);
9091 __put_user(st
.st_uid
, &target_st
->st_uid
);
9092 __put_user(st
.st_gid
, &target_st
->st_gid
);
9093 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
9094 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
9095 __put_user(st
.st_size
, &target_st
->st_size
);
9096 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
9097 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
9098 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
9099 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
9100 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
9101 #if (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700) && \
9102 defined(TARGET_STAT_HAVE_NSEC)
9103 __put_user(st
.st_atim
.tv_nsec
,
9104 &target_st
->target_st_atime_nsec
);
9105 __put_user(st
.st_mtim
.tv_nsec
,
9106 &target_st
->target_st_mtime_nsec
);
9107 __put_user(st
.st_ctim
.tv_nsec
,
9108 &target_st
->target_st_ctime_nsec
);
9110 unlock_user_struct(target_st
, arg2
, 1);
9115 case TARGET_NR_vhangup
:
9116 return get_errno(vhangup());
9117 #ifdef TARGET_NR_syscall
9118 case TARGET_NR_syscall
:
9119 return do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
9120 arg6
, arg7
, arg8
, 0);
9122 case TARGET_NR_wait4
:
9125 abi_long status_ptr
= arg2
;
9126 struct rusage rusage
, *rusage_ptr
;
9127 abi_ulong target_rusage
= arg4
;
9128 abi_long rusage_err
;
9130 rusage_ptr
= &rusage
;
9133 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, rusage_ptr
));
9134 if (!is_error(ret
)) {
9135 if (status_ptr
&& ret
) {
9136 status
= host_to_target_waitstatus(status
);
9137 if (put_user_s32(status
, status_ptr
))
9138 return -TARGET_EFAULT
;
9140 if (target_rusage
) {
9141 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
9149 #ifdef TARGET_NR_swapoff
9150 case TARGET_NR_swapoff
:
9151 if (!(p
= lock_user_string(arg1
)))
9152 return -TARGET_EFAULT
;
9153 ret
= get_errno(swapoff(p
));
9154 unlock_user(p
, arg1
, 0);
9157 case TARGET_NR_sysinfo
:
9159 struct target_sysinfo
*target_value
;
9160 struct sysinfo value
;
9161 ret
= get_errno(sysinfo(&value
));
9162 if (!is_error(ret
) && arg1
)
9164 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
9165 return -TARGET_EFAULT
;
9166 __put_user(value
.uptime
, &target_value
->uptime
);
9167 __put_user(value
.loads
[0], &target_value
->loads
[0]);
9168 __put_user(value
.loads
[1], &target_value
->loads
[1]);
9169 __put_user(value
.loads
[2], &target_value
->loads
[2]);
9170 __put_user(value
.totalram
, &target_value
->totalram
);
9171 __put_user(value
.freeram
, &target_value
->freeram
);
9172 __put_user(value
.sharedram
, &target_value
->sharedram
);
9173 __put_user(value
.bufferram
, &target_value
->bufferram
);
9174 __put_user(value
.totalswap
, &target_value
->totalswap
);
9175 __put_user(value
.freeswap
, &target_value
->freeswap
);
9176 __put_user(value
.procs
, &target_value
->procs
);
9177 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
9178 __put_user(value
.freehigh
, &target_value
->freehigh
);
9179 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
9180 unlock_user_struct(target_value
, arg1
, 1);
9184 #ifdef TARGET_NR_ipc
9186 return do_ipc(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9188 #ifdef TARGET_NR_semget
9189 case TARGET_NR_semget
:
9190 return get_errno(semget(arg1
, arg2
, arg3
));
9192 #ifdef TARGET_NR_semop
9193 case TARGET_NR_semop
:
9194 return do_semop(arg1
, arg2
, arg3
);
9196 #ifdef TARGET_NR_semctl
9197 case TARGET_NR_semctl
:
9198 return do_semctl(arg1
, arg2
, arg3
, arg4
);
9200 #ifdef TARGET_NR_msgctl
9201 case TARGET_NR_msgctl
:
9202 return do_msgctl(arg1
, arg2
, arg3
);
9204 #ifdef TARGET_NR_msgget
9205 case TARGET_NR_msgget
:
9206 return get_errno(msgget(arg1
, arg2
));
9208 #ifdef TARGET_NR_msgrcv
9209 case TARGET_NR_msgrcv
:
9210 return do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
9212 #ifdef TARGET_NR_msgsnd
9213 case TARGET_NR_msgsnd
:
9214 return do_msgsnd(arg1
, arg2
, arg3
, arg4
);
9216 #ifdef TARGET_NR_shmget
9217 case TARGET_NR_shmget
:
9218 return get_errno(shmget(arg1
, arg2
, arg3
));
9220 #ifdef TARGET_NR_shmctl
9221 case TARGET_NR_shmctl
:
9222 return do_shmctl(arg1
, arg2
, arg3
);
9224 #ifdef TARGET_NR_shmat
9225 case TARGET_NR_shmat
:
9226 return do_shmat(cpu_env
, arg1
, arg2
, arg3
);
9228 #ifdef TARGET_NR_shmdt
9229 case TARGET_NR_shmdt
:
9230 return do_shmdt(arg1
);
9232 case TARGET_NR_fsync
:
9233 return get_errno(fsync(arg1
));
9234 case TARGET_NR_clone
:
9235 /* Linux manages to have three different orderings for its
9236 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
9237 * match the kernel's CONFIG_CLONE_* settings.
9238 * Microblaze is further special in that it uses a sixth
9239 * implicit argument to clone for the TLS pointer.
9241 #if defined(TARGET_MICROBLAZE)
9242 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
9243 #elif defined(TARGET_CLONE_BACKWARDS)
9244 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
9245 #elif defined(TARGET_CLONE_BACKWARDS2)
9246 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
9248 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
9251 #ifdef __NR_exit_group
9252 /* new thread calls */
9253 case TARGET_NR_exit_group
:
9254 preexit_cleanup(cpu_env
, arg1
);
9255 return get_errno(exit_group(arg1
));
9257 case TARGET_NR_setdomainname
:
9258 if (!(p
= lock_user_string(arg1
)))
9259 return -TARGET_EFAULT
;
9260 ret
= get_errno(setdomainname(p
, arg2
));
9261 unlock_user(p
, arg1
, 0);
9263 case TARGET_NR_uname
:
9264 /* no need to transcode because we use the linux syscall */
9266 struct new_utsname
* buf
;
9268 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
9269 return -TARGET_EFAULT
;
9270 ret
= get_errno(sys_uname(buf
));
9271 if (!is_error(ret
)) {
9272 /* Overwrite the native machine name with whatever is being
9274 g_strlcpy(buf
->machine
, cpu_to_uname_machine(cpu_env
),
9275 sizeof(buf
->machine
));
9276 /* Allow the user to override the reported release. */
9277 if (qemu_uname_release
&& *qemu_uname_release
) {
9278 g_strlcpy(buf
->release
, qemu_uname_release
,
9279 sizeof(buf
->release
));
9282 unlock_user_struct(buf
, arg1
, 1);
9286 case TARGET_NR_modify_ldt
:
9287 return do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
9288 #if !defined(TARGET_X86_64)
9289 case TARGET_NR_vm86
:
9290 return do_vm86(cpu_env
, arg1
, arg2
);
9293 case TARGET_NR_adjtimex
:
9295 struct timex host_buf
;
9297 if (target_to_host_timex(&host_buf
, arg1
) != 0) {
9298 return -TARGET_EFAULT
;
9300 ret
= get_errno(adjtimex(&host_buf
));
9301 if (!is_error(ret
)) {
9302 if (host_to_target_timex(arg1
, &host_buf
) != 0) {
9303 return -TARGET_EFAULT
;
9308 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
9309 case TARGET_NR_clock_adjtime
:
9311 struct timex htx
, *phtx
= &htx
;
9313 if (target_to_host_timex(phtx
, arg2
) != 0) {
9314 return -TARGET_EFAULT
;
9316 ret
= get_errno(clock_adjtime(arg1
, phtx
));
9317 if (!is_error(ret
) && phtx
) {
9318 if (host_to_target_timex(arg2
, phtx
) != 0) {
9319 return -TARGET_EFAULT
;
9325 case TARGET_NR_getpgid
:
9326 return get_errno(getpgid(arg1
));
9327 case TARGET_NR_fchdir
:
9328 return get_errno(fchdir(arg1
));
9329 case TARGET_NR_personality
:
9330 return get_errno(personality(arg1
));
9331 #ifdef TARGET_NR__llseek /* Not on alpha */
9332 case TARGET_NR__llseek
:
9335 #if !defined(__NR_llseek)
9336 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | (abi_ulong
)arg3
, arg5
);
9338 ret
= get_errno(res
);
9343 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
9345 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
9346 return -TARGET_EFAULT
;
9351 #ifdef TARGET_NR_getdents
9352 case TARGET_NR_getdents
:
9353 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
9354 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
9356 struct target_dirent
*target_dirp
;
9357 struct linux_dirent
*dirp
;
9358 abi_long count
= arg3
;
9360 dirp
= g_try_malloc(count
);
9362 return -TARGET_ENOMEM
;
9365 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
9366 if (!is_error(ret
)) {
9367 struct linux_dirent
*de
;
9368 struct target_dirent
*tde
;
9370 int reclen
, treclen
;
9371 int count1
, tnamelen
;
9375 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9376 return -TARGET_EFAULT
;
9379 reclen
= de
->d_reclen
;
9380 tnamelen
= reclen
- offsetof(struct linux_dirent
, d_name
);
9381 assert(tnamelen
>= 0);
9382 treclen
= tnamelen
+ offsetof(struct target_dirent
, d_name
);
9383 assert(count1
+ treclen
<= count
);
9384 tde
->d_reclen
= tswap16(treclen
);
9385 tde
->d_ino
= tswapal(de
->d_ino
);
9386 tde
->d_off
= tswapal(de
->d_off
);
9387 memcpy(tde
->d_name
, de
->d_name
, tnamelen
);
9388 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
9390 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
9394 unlock_user(target_dirp
, arg2
, ret
);
9400 struct linux_dirent
*dirp
;
9401 abi_long count
= arg3
;
9403 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9404 return -TARGET_EFAULT
;
9405 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
9406 if (!is_error(ret
)) {
9407 struct linux_dirent
*de
;
9412 reclen
= de
->d_reclen
;
9415 de
->d_reclen
= tswap16(reclen
);
9416 tswapls(&de
->d_ino
);
9417 tswapls(&de
->d_off
);
9418 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
9422 unlock_user(dirp
, arg2
, ret
);
9426 /* Implement getdents in terms of getdents64 */
9428 struct linux_dirent64
*dirp
;
9429 abi_long count
= arg3
;
9431 dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
9433 return -TARGET_EFAULT
;
9435 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
9436 if (!is_error(ret
)) {
9437 /* Convert the dirent64 structs to target dirent. We do this
9438 * in-place, since we can guarantee that a target_dirent is no
9439 * larger than a dirent64; however this means we have to be
9440 * careful to read everything before writing in the new format.
9442 struct linux_dirent64
*de
;
9443 struct target_dirent
*tde
;
9448 tde
= (struct target_dirent
*)dirp
;
9450 int namelen
, treclen
;
9451 int reclen
= de
->d_reclen
;
9452 uint64_t ino
= de
->d_ino
;
9453 int64_t off
= de
->d_off
;
9454 uint8_t type
= de
->d_type
;
9456 namelen
= strlen(de
->d_name
);
9457 treclen
= offsetof(struct target_dirent
, d_name
)
9459 treclen
= QEMU_ALIGN_UP(treclen
, sizeof(abi_long
));
9461 memmove(tde
->d_name
, de
->d_name
, namelen
+ 1);
9462 tde
->d_ino
= tswapal(ino
);
9463 tde
->d_off
= tswapal(off
);
9464 tde
->d_reclen
= tswap16(treclen
);
9465 /* The target_dirent type is in what was formerly a padding
9466 * byte at the end of the structure:
9468 *(((char *)tde
) + treclen
- 1) = type
;
9470 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
9471 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
9477 unlock_user(dirp
, arg2
, ret
);
9481 #endif /* TARGET_NR_getdents */
9482 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
9483 case TARGET_NR_getdents64
:
9485 struct linux_dirent64
*dirp
;
9486 abi_long count
= arg3
;
9487 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9488 return -TARGET_EFAULT
;
9489 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
9490 if (!is_error(ret
)) {
9491 struct linux_dirent64
*de
;
9496 reclen
= de
->d_reclen
;
9499 de
->d_reclen
= tswap16(reclen
);
9500 tswap64s((uint64_t *)&de
->d_ino
);
9501 tswap64s((uint64_t *)&de
->d_off
);
9502 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
9506 unlock_user(dirp
, arg2
, ret
);
9509 #endif /* TARGET_NR_getdents64 */
9510 #if defined(TARGET_NR__newselect)
9511 case TARGET_NR__newselect
:
9512 return do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
9514 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
9515 # ifdef TARGET_NR_poll
9516 case TARGET_NR_poll
:
9518 # ifdef TARGET_NR_ppoll
9519 case TARGET_NR_ppoll
:
9522 struct target_pollfd
*target_pfd
;
9523 unsigned int nfds
= arg2
;
9530 if (nfds
> (INT_MAX
/ sizeof(struct target_pollfd
))) {
9531 return -TARGET_EINVAL
;
9534 target_pfd
= lock_user(VERIFY_WRITE
, arg1
,
9535 sizeof(struct target_pollfd
) * nfds
, 1);
9537 return -TARGET_EFAULT
;
9540 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
9541 for (i
= 0; i
< nfds
; i
++) {
9542 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
9543 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
9548 # ifdef TARGET_NR_ppoll
9549 case TARGET_NR_ppoll
:
9551 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
9552 target_sigset_t
*target_set
;
9553 sigset_t _set
, *set
= &_set
;
9556 if (target_to_host_timespec(timeout_ts
, arg3
)) {
9557 unlock_user(target_pfd
, arg1
, 0);
9558 return -TARGET_EFAULT
;
9565 if (arg5
!= sizeof(target_sigset_t
)) {
9566 unlock_user(target_pfd
, arg1
, 0);
9567 return -TARGET_EINVAL
;
9570 target_set
= lock_user(VERIFY_READ
, arg4
, sizeof(target_sigset_t
), 1);
9572 unlock_user(target_pfd
, arg1
, 0);
9573 return -TARGET_EFAULT
;
9575 target_to_host_sigset(set
, target_set
);
9580 ret
= get_errno(safe_ppoll(pfd
, nfds
, timeout_ts
,
9581 set
, SIGSET_T_SIZE
));
9583 if (!is_error(ret
) && arg3
) {
9584 host_to_target_timespec(arg3
, timeout_ts
);
9587 unlock_user(target_set
, arg4
, 0);
9592 # ifdef TARGET_NR_poll
9593 case TARGET_NR_poll
:
9595 struct timespec ts
, *pts
;
9598 /* Convert ms to secs, ns */
9599 ts
.tv_sec
= arg3
/ 1000;
9600 ts
.tv_nsec
= (arg3
% 1000) * 1000000LL;
9603 /* -ve poll() timeout means "infinite" */
9606 ret
= get_errno(safe_ppoll(pfd
, nfds
, pts
, NULL
, 0));
9611 g_assert_not_reached();
9614 if (!is_error(ret
)) {
9615 for(i
= 0; i
< nfds
; i
++) {
9616 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
9619 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
9623 case TARGET_NR_flock
:
9624 /* NOTE: the flock constant seems to be the same for every
9626 return get_errno(safe_flock(arg1
, arg2
));
9627 case TARGET_NR_readv
:
9629 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
9631 ret
= get_errno(safe_readv(arg1
, vec
, arg3
));
9632 unlock_iovec(vec
, arg2
, arg3
, 1);
9634 ret
= -host_to_target_errno(errno
);
9638 case TARGET_NR_writev
:
9640 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
9642 ret
= get_errno(safe_writev(arg1
, vec
, arg3
));
9643 unlock_iovec(vec
, arg2
, arg3
, 0);
9645 ret
= -host_to_target_errno(errno
);
9649 #if defined(TARGET_NR_preadv)
9650 case TARGET_NR_preadv
:
9652 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
9654 unsigned long low
, high
;
9656 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
9657 ret
= get_errno(safe_preadv(arg1
, vec
, arg3
, low
, high
));
9658 unlock_iovec(vec
, arg2
, arg3
, 1);
9660 ret
= -host_to_target_errno(errno
);
9665 #if defined(TARGET_NR_pwritev)
9666 case TARGET_NR_pwritev
:
9668 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
9670 unsigned long low
, high
;
9672 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
9673 ret
= get_errno(safe_pwritev(arg1
, vec
, arg3
, low
, high
));
9674 unlock_iovec(vec
, arg2
, arg3
, 0);
9676 ret
= -host_to_target_errno(errno
);
9681 case TARGET_NR_getsid
:
9682 return get_errno(getsid(arg1
));
9683 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
9684 case TARGET_NR_fdatasync
:
9685 return get_errno(fdatasync(arg1
));
9687 #ifdef TARGET_NR__sysctl
9688 case TARGET_NR__sysctl
:
9689 /* We don't implement this, but ENOTDIR is always a safe
9691 return -TARGET_ENOTDIR
;
9693 case TARGET_NR_sched_getaffinity
:
9695 unsigned int mask_size
;
9696 unsigned long *mask
;
9699 * sched_getaffinity needs multiples of ulong, so need to take
9700 * care of mismatches between target ulong and host ulong sizes.
9702 if (arg2
& (sizeof(abi_ulong
) - 1)) {
9703 return -TARGET_EINVAL
;
9705 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
9707 mask
= alloca(mask_size
);
9708 memset(mask
, 0, mask_size
);
9709 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
9711 if (!is_error(ret
)) {
9713 /* More data returned than the caller's buffer will fit.
9714 * This only happens if sizeof(abi_long) < sizeof(long)
9715 * and the caller passed us a buffer holding an odd number
9716 * of abi_longs. If the host kernel is actually using the
9717 * extra 4 bytes then fail EINVAL; otherwise we can just
9718 * ignore them and only copy the interesting part.
9720 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
9721 if (numcpus
> arg2
* 8) {
9722 return -TARGET_EINVAL
;
9727 if (host_to_target_cpu_mask(mask
, mask_size
, arg3
, ret
)) {
9728 return -TARGET_EFAULT
;
9733 case TARGET_NR_sched_setaffinity
:
9735 unsigned int mask_size
;
9736 unsigned long *mask
;
9739 * sched_setaffinity needs multiples of ulong, so need to take
9740 * care of mismatches between target ulong and host ulong sizes.
9742 if (arg2
& (sizeof(abi_ulong
) - 1)) {
9743 return -TARGET_EINVAL
;
9745 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
9746 mask
= alloca(mask_size
);
9748 ret
= target_to_host_cpu_mask(mask
, mask_size
, arg3
, arg2
);
9753 return get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
9755 case TARGET_NR_getcpu
:
9758 ret
= get_errno(sys_getcpu(arg1
? &cpu
: NULL
,
9759 arg2
? &node
: NULL
,
9761 if (is_error(ret
)) {
9764 if (arg1
&& put_user_u32(cpu
, arg1
)) {
9765 return -TARGET_EFAULT
;
9767 if (arg2
&& put_user_u32(node
, arg2
)) {
9768 return -TARGET_EFAULT
;
9772 case TARGET_NR_sched_setparam
:
9774 struct sched_param
*target_schp
;
9775 struct sched_param schp
;
9778 return -TARGET_EINVAL
;
9780 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
9781 return -TARGET_EFAULT
;
9782 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
9783 unlock_user_struct(target_schp
, arg2
, 0);
9784 return get_errno(sched_setparam(arg1
, &schp
));
9786 case TARGET_NR_sched_getparam
:
9788 struct sched_param
*target_schp
;
9789 struct sched_param schp
;
9792 return -TARGET_EINVAL
;
9794 ret
= get_errno(sched_getparam(arg1
, &schp
));
9795 if (!is_error(ret
)) {
9796 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
9797 return -TARGET_EFAULT
;
9798 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
9799 unlock_user_struct(target_schp
, arg2
, 1);
9803 case TARGET_NR_sched_setscheduler
:
9805 struct sched_param
*target_schp
;
9806 struct sched_param schp
;
9808 return -TARGET_EINVAL
;
9810 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
9811 return -TARGET_EFAULT
;
9812 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
9813 unlock_user_struct(target_schp
, arg3
, 0);
9814 return get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
9816 case TARGET_NR_sched_getscheduler
:
9817 return get_errno(sched_getscheduler(arg1
));
9818 case TARGET_NR_sched_yield
:
9819 return get_errno(sched_yield());
9820 case TARGET_NR_sched_get_priority_max
:
9821 return get_errno(sched_get_priority_max(arg1
));
9822 case TARGET_NR_sched_get_priority_min
:
9823 return get_errno(sched_get_priority_min(arg1
));
9824 case TARGET_NR_sched_rr_get_interval
:
9827 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
9828 if (!is_error(ret
)) {
9829 ret
= host_to_target_timespec(arg2
, &ts
);
9833 case TARGET_NR_nanosleep
:
9835 struct timespec req
, rem
;
9836 target_to_host_timespec(&req
, arg1
);
9837 ret
= get_errno(safe_nanosleep(&req
, &rem
));
9838 if (is_error(ret
) && arg2
) {
9839 host_to_target_timespec(arg2
, &rem
);
9843 case TARGET_NR_prctl
:
9845 case PR_GET_PDEATHSIG
:
9848 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
9849 if (!is_error(ret
) && arg2
9850 && put_user_ual(deathsig
, arg2
)) {
9851 return -TARGET_EFAULT
;
9858 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
9860 return -TARGET_EFAULT
;
9862 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
9864 unlock_user(name
, arg2
, 16);
9869 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
9871 return -TARGET_EFAULT
;
9873 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
9875 unlock_user(name
, arg2
, 0);
9880 case TARGET_PR_GET_FP_MODE
:
9882 CPUMIPSState
*env
= ((CPUMIPSState
*)cpu_env
);
9884 if (env
->CP0_Status
& (1 << CP0St_FR
)) {
9885 ret
|= TARGET_PR_FP_MODE_FR
;
9887 if (env
->CP0_Config5
& (1 << CP0C5_FRE
)) {
9888 ret
|= TARGET_PR_FP_MODE_FRE
;
9892 case TARGET_PR_SET_FP_MODE
:
9894 CPUMIPSState
*env
= ((CPUMIPSState
*)cpu_env
);
9895 bool old_fr
= env
->CP0_Status
& (1 << CP0St_FR
);
9896 bool old_fre
= env
->CP0_Config5
& (1 << CP0C5_FRE
);
9897 bool new_fr
= arg2
& TARGET_PR_FP_MODE_FR
;
9898 bool new_fre
= arg2
& TARGET_PR_FP_MODE_FRE
;
9900 const unsigned int known_bits
= TARGET_PR_FP_MODE_FR
|
9901 TARGET_PR_FP_MODE_FRE
;
9903 /* If nothing to change, return right away, successfully. */
9904 if (old_fr
== new_fr
&& old_fre
== new_fre
) {
9907 /* Check the value is valid */
9908 if (arg2
& ~known_bits
) {
9909 return -TARGET_EOPNOTSUPP
;
9911 /* Setting FRE without FR is not supported. */
9912 if (new_fre
&& !new_fr
) {
9913 return -TARGET_EOPNOTSUPP
;
9915 if (new_fr
&& !(env
->active_fpu
.fcr0
& (1 << FCR0_F64
))) {
9916 /* FR1 is not supported */
9917 return -TARGET_EOPNOTSUPP
;
9919 if (!new_fr
&& (env
->active_fpu
.fcr0
& (1 << FCR0_F64
))
9920 && !(env
->CP0_Status_rw_bitmask
& (1 << CP0St_FR
))) {
9921 /* cannot set FR=0 */
9922 return -TARGET_EOPNOTSUPP
;
9924 if (new_fre
&& !(env
->active_fpu
.fcr0
& (1 << FCR0_FREP
))) {
9925 /* Cannot set FRE=1 */
9926 return -TARGET_EOPNOTSUPP
;
9930 fpr_t
*fpr
= env
->active_fpu
.fpr
;
9931 for (i
= 0; i
< 32 ; i
+= 2) {
9932 if (!old_fr
&& new_fr
) {
9933 fpr
[i
].w
[!FP_ENDIAN_IDX
] = fpr
[i
+ 1].w
[FP_ENDIAN_IDX
];
9934 } else if (old_fr
&& !new_fr
) {
9935 fpr
[i
+ 1].w
[FP_ENDIAN_IDX
] = fpr
[i
].w
[!FP_ENDIAN_IDX
];
9940 env
->CP0_Status
|= (1 << CP0St_FR
);
9941 env
->hflags
|= MIPS_HFLAG_F64
;
9943 env
->CP0_Status
&= ~(1 << CP0St_FR
);
9944 env
->hflags
&= ~MIPS_HFLAG_F64
;
9947 env
->CP0_Config5
|= (1 << CP0C5_FRE
);
9948 if (env
->active_fpu
.fcr0
& (1 << FCR0_FREP
)) {
9949 env
->hflags
|= MIPS_HFLAG_FRE
;
9952 env
->CP0_Config5
&= ~(1 << CP0C5_FRE
);
9953 env
->hflags
&= ~MIPS_HFLAG_FRE
;
9959 #ifdef TARGET_AARCH64
9960 case TARGET_PR_SVE_SET_VL
:
9962 * We cannot support either PR_SVE_SET_VL_ONEXEC or
9963 * PR_SVE_VL_INHERIT. Note the kernel definition
9964 * of sve_vl_valid allows for VQ=512, i.e. VL=8192,
9965 * even though the current architectural maximum is VQ=16.
9967 ret
= -TARGET_EINVAL
;
9968 if (cpu_isar_feature(aa64_sve
, env_archcpu(cpu_env
))
9969 && arg2
>= 0 && arg2
<= 512 * 16 && !(arg2
& 15)) {
9970 CPUARMState
*env
= cpu_env
;
9971 ARMCPU
*cpu
= env_archcpu(env
);
9972 uint32_t vq
, old_vq
;
9974 old_vq
= (env
->vfp
.zcr_el
[1] & 0xf) + 1;
9975 vq
= MAX(arg2
/ 16, 1);
9976 vq
= MIN(vq
, cpu
->sve_max_vq
);
9979 aarch64_sve_narrow_vq(env
, vq
);
9981 env
->vfp
.zcr_el
[1] = vq
- 1;
9985 case TARGET_PR_SVE_GET_VL
:
9986 ret
= -TARGET_EINVAL
;
9988 ARMCPU
*cpu
= env_archcpu(cpu_env
);
9989 if (cpu_isar_feature(aa64_sve
, cpu
)) {
9990 ret
= ((cpu
->env
.vfp
.zcr_el
[1] & 0xf) + 1) * 16;
9994 case TARGET_PR_PAC_RESET_KEYS
:
9996 CPUARMState
*env
= cpu_env
;
9997 ARMCPU
*cpu
= env_archcpu(env
);
9999 if (arg3
|| arg4
|| arg5
) {
10000 return -TARGET_EINVAL
;
10002 if (cpu_isar_feature(aa64_pauth
, cpu
)) {
10003 int all
= (TARGET_PR_PAC_APIAKEY
| TARGET_PR_PAC_APIBKEY
|
10004 TARGET_PR_PAC_APDAKEY
| TARGET_PR_PAC_APDBKEY
|
10005 TARGET_PR_PAC_APGAKEY
);
10011 } else if (arg2
& ~all
) {
10012 return -TARGET_EINVAL
;
10014 if (arg2
& TARGET_PR_PAC_APIAKEY
) {
10015 ret
|= qemu_guest_getrandom(&env
->keys
.apia
,
10016 sizeof(ARMPACKey
), &err
);
10018 if (arg2
& TARGET_PR_PAC_APIBKEY
) {
10019 ret
|= qemu_guest_getrandom(&env
->keys
.apib
,
10020 sizeof(ARMPACKey
), &err
);
10022 if (arg2
& TARGET_PR_PAC_APDAKEY
) {
10023 ret
|= qemu_guest_getrandom(&env
->keys
.apda
,
10024 sizeof(ARMPACKey
), &err
);
10026 if (arg2
& TARGET_PR_PAC_APDBKEY
) {
10027 ret
|= qemu_guest_getrandom(&env
->keys
.apdb
,
10028 sizeof(ARMPACKey
), &err
);
10030 if (arg2
& TARGET_PR_PAC_APGAKEY
) {
10031 ret
|= qemu_guest_getrandom(&env
->keys
.apga
,
10032 sizeof(ARMPACKey
), &err
);
10036 * Some unknown failure in the crypto. The best
10037 * we can do is log it and fail the syscall.
10038 * The real syscall cannot fail this way.
10040 qemu_log_mask(LOG_UNIMP
,
10041 "PR_PAC_RESET_KEYS: Crypto failure: %s",
10042 error_get_pretty(err
));
10044 return -TARGET_EIO
;
10049 return -TARGET_EINVAL
;
10050 #endif /* AARCH64 */
10051 case PR_GET_SECCOMP
:
10052 case PR_SET_SECCOMP
:
10053 /* Disable seccomp to prevent the target disabling syscalls we
10055 return -TARGET_EINVAL
;
10057 /* Most prctl options have no pointer arguments */
10058 return get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
10061 #ifdef TARGET_NR_arch_prctl
10062 case TARGET_NR_arch_prctl
:
10063 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
10064 return do_arch_prctl(cpu_env
, arg1
, arg2
);
10069 #ifdef TARGET_NR_pread64
10070 case TARGET_NR_pread64
:
10071 if (regpairs_aligned(cpu_env
, num
)) {
10075 if (arg2
== 0 && arg3
== 0) {
10076 /* Special-case NULL buffer and zero length, which should succeed */
10079 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
10081 return -TARGET_EFAULT
;
10084 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10085 unlock_user(p
, arg2
, ret
);
10087 case TARGET_NR_pwrite64
:
10088 if (regpairs_aligned(cpu_env
, num
)) {
10092 if (arg2
== 0 && arg3
== 0) {
10093 /* Special-case NULL buffer and zero length, which should succeed */
10096 p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1);
10098 return -TARGET_EFAULT
;
10101 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10102 unlock_user(p
, arg2
, 0);
10105 case TARGET_NR_getcwd
:
10106 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
10107 return -TARGET_EFAULT
;
10108 ret
= get_errno(sys_getcwd1(p
, arg2
));
10109 unlock_user(p
, arg1
, ret
);
10111 case TARGET_NR_capget
:
10112 case TARGET_NR_capset
:
10114 struct target_user_cap_header
*target_header
;
10115 struct target_user_cap_data
*target_data
= NULL
;
10116 struct __user_cap_header_struct header
;
10117 struct __user_cap_data_struct data
[2];
10118 struct __user_cap_data_struct
*dataptr
= NULL
;
10119 int i
, target_datalen
;
10120 int data_items
= 1;
10122 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
10123 return -TARGET_EFAULT
;
10125 header
.version
= tswap32(target_header
->version
);
10126 header
.pid
= tswap32(target_header
->pid
);
10128 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
10129 /* Version 2 and up takes pointer to two user_data structs */
10133 target_datalen
= sizeof(*target_data
) * data_items
;
10136 if (num
== TARGET_NR_capget
) {
10137 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
10139 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
10141 if (!target_data
) {
10142 unlock_user_struct(target_header
, arg1
, 0);
10143 return -TARGET_EFAULT
;
10146 if (num
== TARGET_NR_capset
) {
10147 for (i
= 0; i
< data_items
; i
++) {
10148 data
[i
].effective
= tswap32(target_data
[i
].effective
);
10149 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
10150 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
10157 if (num
== TARGET_NR_capget
) {
10158 ret
= get_errno(capget(&header
, dataptr
));
10160 ret
= get_errno(capset(&header
, dataptr
));
10163 /* The kernel always updates version for both capget and capset */
10164 target_header
->version
= tswap32(header
.version
);
10165 unlock_user_struct(target_header
, arg1
, 1);
10168 if (num
== TARGET_NR_capget
) {
10169 for (i
= 0; i
< data_items
; i
++) {
10170 target_data
[i
].effective
= tswap32(data
[i
].effective
);
10171 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
10172 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
10174 unlock_user(target_data
, arg2
, target_datalen
);
10176 unlock_user(target_data
, arg2
, 0);
10181 case TARGET_NR_sigaltstack
:
10182 return do_sigaltstack(arg1
, arg2
,
10183 get_sp_from_cpustate((CPUArchState
*)cpu_env
));
10185 #ifdef CONFIG_SENDFILE
10186 #ifdef TARGET_NR_sendfile
10187 case TARGET_NR_sendfile
:
10189 off_t
*offp
= NULL
;
10192 ret
= get_user_sal(off
, arg3
);
10193 if (is_error(ret
)) {
10198 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10199 if (!is_error(ret
) && arg3
) {
10200 abi_long ret2
= put_user_sal(off
, arg3
);
10201 if (is_error(ret2
)) {
10208 #ifdef TARGET_NR_sendfile64
10209 case TARGET_NR_sendfile64
:
10211 off_t
*offp
= NULL
;
10214 ret
= get_user_s64(off
, arg3
);
10215 if (is_error(ret
)) {
10220 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10221 if (!is_error(ret
) && arg3
) {
10222 abi_long ret2
= put_user_s64(off
, arg3
);
10223 if (is_error(ret2
)) {
10231 #ifdef TARGET_NR_vfork
10232 case TARGET_NR_vfork
:
10233 return get_errno(do_fork(cpu_env
,
10234 CLONE_VFORK
| CLONE_VM
| TARGET_SIGCHLD
,
10237 #ifdef TARGET_NR_ugetrlimit
10238 case TARGET_NR_ugetrlimit
:
10240 struct rlimit rlim
;
10241 int resource
= target_to_host_resource(arg1
);
10242 ret
= get_errno(getrlimit(resource
, &rlim
));
10243 if (!is_error(ret
)) {
10244 struct target_rlimit
*target_rlim
;
10245 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
10246 return -TARGET_EFAULT
;
10247 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
10248 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
10249 unlock_user_struct(target_rlim
, arg2
, 1);
10254 #ifdef TARGET_NR_truncate64
10255 case TARGET_NR_truncate64
:
10256 if (!(p
= lock_user_string(arg1
)))
10257 return -TARGET_EFAULT
;
10258 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
10259 unlock_user(p
, arg1
, 0);
10262 #ifdef TARGET_NR_ftruncate64
10263 case TARGET_NR_ftruncate64
:
10264 return target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
10266 #ifdef TARGET_NR_stat64
10267 case TARGET_NR_stat64
:
10268 if (!(p
= lock_user_string(arg1
))) {
10269 return -TARGET_EFAULT
;
10271 ret
= get_errno(stat(path(p
), &st
));
10272 unlock_user(p
, arg1
, 0);
10273 if (!is_error(ret
))
10274 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10277 #ifdef TARGET_NR_lstat64
10278 case TARGET_NR_lstat64
:
10279 if (!(p
= lock_user_string(arg1
))) {
10280 return -TARGET_EFAULT
;
10282 ret
= get_errno(lstat(path(p
), &st
));
10283 unlock_user(p
, arg1
, 0);
10284 if (!is_error(ret
))
10285 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10288 #ifdef TARGET_NR_fstat64
10289 case TARGET_NR_fstat64
:
10290 ret
= get_errno(fstat(arg1
, &st
));
10291 if (!is_error(ret
))
10292 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10295 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
10296 #ifdef TARGET_NR_fstatat64
10297 case TARGET_NR_fstatat64
:
10299 #ifdef TARGET_NR_newfstatat
10300 case TARGET_NR_newfstatat
:
10302 if (!(p
= lock_user_string(arg2
))) {
10303 return -TARGET_EFAULT
;
10305 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
10306 unlock_user(p
, arg2
, 0);
10307 if (!is_error(ret
))
10308 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
10311 #if defined(TARGET_NR_statx)
10312 case TARGET_NR_statx
:
10314 struct target_statx
*target_stx
;
10318 p
= lock_user_string(arg2
);
10320 return -TARGET_EFAULT
;
10322 #if defined(__NR_statx)
10325 * It is assumed that struct statx is architecture independent.
10327 struct target_statx host_stx
;
10330 ret
= get_errno(sys_statx(dirfd
, p
, flags
, mask
, &host_stx
));
10331 if (!is_error(ret
)) {
10332 if (host_to_target_statx(&host_stx
, arg5
) != 0) {
10333 unlock_user(p
, arg2
, 0);
10334 return -TARGET_EFAULT
;
10338 if (ret
!= -TARGET_ENOSYS
) {
10339 unlock_user(p
, arg2
, 0);
10344 ret
= get_errno(fstatat(dirfd
, path(p
), &st
, flags
));
10345 unlock_user(p
, arg2
, 0);
10347 if (!is_error(ret
)) {
10348 if (!lock_user_struct(VERIFY_WRITE
, target_stx
, arg5
, 0)) {
10349 return -TARGET_EFAULT
;
10351 memset(target_stx
, 0, sizeof(*target_stx
));
10352 __put_user(major(st
.st_dev
), &target_stx
->stx_dev_major
);
10353 __put_user(minor(st
.st_dev
), &target_stx
->stx_dev_minor
);
10354 __put_user(st
.st_ino
, &target_stx
->stx_ino
);
10355 __put_user(st
.st_mode
, &target_stx
->stx_mode
);
10356 __put_user(st
.st_uid
, &target_stx
->stx_uid
);
10357 __put_user(st
.st_gid
, &target_stx
->stx_gid
);
10358 __put_user(st
.st_nlink
, &target_stx
->stx_nlink
);
10359 __put_user(major(st
.st_rdev
), &target_stx
->stx_rdev_major
);
10360 __put_user(minor(st
.st_rdev
), &target_stx
->stx_rdev_minor
);
10361 __put_user(st
.st_size
, &target_stx
->stx_size
);
10362 __put_user(st
.st_blksize
, &target_stx
->stx_blksize
);
10363 __put_user(st
.st_blocks
, &target_stx
->stx_blocks
);
10364 __put_user(st
.st_atime
, &target_stx
->stx_atime
.tv_sec
);
10365 __put_user(st
.st_mtime
, &target_stx
->stx_mtime
.tv_sec
);
10366 __put_user(st
.st_ctime
, &target_stx
->stx_ctime
.tv_sec
);
10367 unlock_user_struct(target_stx
, arg5
, 1);
10372 #ifdef TARGET_NR_lchown
10373 case TARGET_NR_lchown
:
10374 if (!(p
= lock_user_string(arg1
)))
10375 return -TARGET_EFAULT
;
10376 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
10377 unlock_user(p
, arg1
, 0);
10380 #ifdef TARGET_NR_getuid
10381 case TARGET_NR_getuid
:
10382 return get_errno(high2lowuid(getuid()));
10384 #ifdef TARGET_NR_getgid
10385 case TARGET_NR_getgid
:
10386 return get_errno(high2lowgid(getgid()));
10388 #ifdef TARGET_NR_geteuid
10389 case TARGET_NR_geteuid
:
10390 return get_errno(high2lowuid(geteuid()));
10392 #ifdef TARGET_NR_getegid
10393 case TARGET_NR_getegid
:
10394 return get_errno(high2lowgid(getegid()));
10396 case TARGET_NR_setreuid
:
10397 return get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
10398 case TARGET_NR_setregid
:
10399 return get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
10400 case TARGET_NR_getgroups
:
10402 int gidsetsize
= arg1
;
10403 target_id
*target_grouplist
;
10407 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10408 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
10409 if (gidsetsize
== 0)
10411 if (!is_error(ret
)) {
10412 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* sizeof(target_id
), 0);
10413 if (!target_grouplist
)
10414 return -TARGET_EFAULT
;
10415 for(i
= 0;i
< ret
; i
++)
10416 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
10417 unlock_user(target_grouplist
, arg2
, gidsetsize
* sizeof(target_id
));
10421 case TARGET_NR_setgroups
:
10423 int gidsetsize
= arg1
;
10424 target_id
*target_grouplist
;
10425 gid_t
*grouplist
= NULL
;
10428 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10429 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* sizeof(target_id
), 1);
10430 if (!target_grouplist
) {
10431 return -TARGET_EFAULT
;
10433 for (i
= 0; i
< gidsetsize
; i
++) {
10434 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
10436 unlock_user(target_grouplist
, arg2
, 0);
10438 return get_errno(setgroups(gidsetsize
, grouplist
));
10440 case TARGET_NR_fchown
:
10441 return get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
10442 #if defined(TARGET_NR_fchownat)
10443 case TARGET_NR_fchownat
:
10444 if (!(p
= lock_user_string(arg2
)))
10445 return -TARGET_EFAULT
;
10446 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
10447 low2highgid(arg4
), arg5
));
10448 unlock_user(p
, arg2
, 0);
10451 #ifdef TARGET_NR_setresuid
10452 case TARGET_NR_setresuid
:
10453 return get_errno(sys_setresuid(low2highuid(arg1
),
10455 low2highuid(arg3
)));
10457 #ifdef TARGET_NR_getresuid
10458 case TARGET_NR_getresuid
:
10460 uid_t ruid
, euid
, suid
;
10461 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
10462 if (!is_error(ret
)) {
10463 if (put_user_id(high2lowuid(ruid
), arg1
)
10464 || put_user_id(high2lowuid(euid
), arg2
)
10465 || put_user_id(high2lowuid(suid
), arg3
))
10466 return -TARGET_EFAULT
;
10471 #ifdef TARGET_NR_getresgid
10472 case TARGET_NR_setresgid
:
10473 return get_errno(sys_setresgid(low2highgid(arg1
),
10475 low2highgid(arg3
)));
10477 #ifdef TARGET_NR_getresgid
10478 case TARGET_NR_getresgid
:
10480 gid_t rgid
, egid
, sgid
;
10481 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
10482 if (!is_error(ret
)) {
10483 if (put_user_id(high2lowgid(rgid
), arg1
)
10484 || put_user_id(high2lowgid(egid
), arg2
)
10485 || put_user_id(high2lowgid(sgid
), arg3
))
10486 return -TARGET_EFAULT
;
10491 #ifdef TARGET_NR_chown
10492 case TARGET_NR_chown
:
10493 if (!(p
= lock_user_string(arg1
)))
10494 return -TARGET_EFAULT
;
10495 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
10496 unlock_user(p
, arg1
, 0);
10499 case TARGET_NR_setuid
:
10500 return get_errno(sys_setuid(low2highuid(arg1
)));
10501 case TARGET_NR_setgid
:
10502 return get_errno(sys_setgid(low2highgid(arg1
)));
10503 case TARGET_NR_setfsuid
:
10504 return get_errno(setfsuid(arg1
));
10505 case TARGET_NR_setfsgid
:
10506 return get_errno(setfsgid(arg1
));
10508 #ifdef TARGET_NR_lchown32
10509 case TARGET_NR_lchown32
:
10510 if (!(p
= lock_user_string(arg1
)))
10511 return -TARGET_EFAULT
;
10512 ret
= get_errno(lchown(p
, arg2
, arg3
));
10513 unlock_user(p
, arg1
, 0);
10516 #ifdef TARGET_NR_getuid32
10517 case TARGET_NR_getuid32
:
10518 return get_errno(getuid());
10521 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
10522 /* Alpha specific */
10523 case TARGET_NR_getxuid
:
10527 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=euid
;
10529 return get_errno(getuid());
10531 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
10532 /* Alpha specific */
10533 case TARGET_NR_getxgid
:
10537 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=egid
;
10539 return get_errno(getgid());
10541 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
10542 /* Alpha specific */
10543 case TARGET_NR_osf_getsysinfo
:
10544 ret
= -TARGET_EOPNOTSUPP
;
10546 case TARGET_GSI_IEEE_FP_CONTROL
:
10548 uint64_t fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10549 uint64_t swcr
= ((CPUAlphaState
*)cpu_env
)->swcr
;
10551 swcr
&= ~SWCR_STATUS_MASK
;
10552 swcr
|= (fpcr
>> 35) & SWCR_STATUS_MASK
;
10554 if (put_user_u64 (swcr
, arg2
))
10555 return -TARGET_EFAULT
;
10560 /* case GSI_IEEE_STATE_AT_SIGNAL:
10561 -- Not implemented in linux kernel.
10563 -- Retrieves current unaligned access state; not much used.
10564 case GSI_PROC_TYPE:
10565 -- Retrieves implver information; surely not used.
10566 case GSI_GET_HWRPB:
10567 -- Grabs a copy of the HWRPB; surely not used.
10572 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
10573 /* Alpha specific */
10574 case TARGET_NR_osf_setsysinfo
:
10575 ret
= -TARGET_EOPNOTSUPP
;
10577 case TARGET_SSI_IEEE_FP_CONTROL
:
10579 uint64_t swcr
, fpcr
;
10581 if (get_user_u64 (swcr
, arg2
)) {
10582 return -TARGET_EFAULT
;
10586 * The kernel calls swcr_update_status to update the
10587 * status bits from the fpcr at every point that it
10588 * could be queried. Therefore, we store the status
10589 * bits only in FPCR.
10591 ((CPUAlphaState
*)cpu_env
)->swcr
10592 = swcr
& (SWCR_TRAP_ENABLE_MASK
| SWCR_MAP_MASK
);
10594 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10595 fpcr
&= ((uint64_t)FPCR_DYN_MASK
<< 32);
10596 fpcr
|= alpha_ieee_swcr_to_fpcr(swcr
);
10597 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
10602 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
10604 uint64_t exc
, fpcr
, fex
;
10606 if (get_user_u64(exc
, arg2
)) {
10607 return -TARGET_EFAULT
;
10609 exc
&= SWCR_STATUS_MASK
;
10610 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10612 /* Old exceptions are not signaled. */
10613 fex
= alpha_ieee_fpcr_to_swcr(fpcr
);
10615 fex
>>= SWCR_STATUS_TO_EXCSUM_SHIFT
;
10616 fex
&= ((CPUArchState
*)cpu_env
)->swcr
;
10618 /* Update the hardware fpcr. */
10619 fpcr
|= alpha_ieee_swcr_to_fpcr(exc
);
10620 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
10623 int si_code
= TARGET_FPE_FLTUNK
;
10624 target_siginfo_t info
;
10626 if (fex
& SWCR_TRAP_ENABLE_DNO
) {
10627 si_code
= TARGET_FPE_FLTUND
;
10629 if (fex
& SWCR_TRAP_ENABLE_INE
) {
10630 si_code
= TARGET_FPE_FLTRES
;
10632 if (fex
& SWCR_TRAP_ENABLE_UNF
) {
10633 si_code
= TARGET_FPE_FLTUND
;
10635 if (fex
& SWCR_TRAP_ENABLE_OVF
) {
10636 si_code
= TARGET_FPE_FLTOVF
;
10638 if (fex
& SWCR_TRAP_ENABLE_DZE
) {
10639 si_code
= TARGET_FPE_FLTDIV
;
10641 if (fex
& SWCR_TRAP_ENABLE_INV
) {
10642 si_code
= TARGET_FPE_FLTINV
;
10645 info
.si_signo
= SIGFPE
;
10647 info
.si_code
= si_code
;
10648 info
._sifields
._sigfault
._addr
10649 = ((CPUArchState
*)cpu_env
)->pc
;
10650 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
10651 QEMU_SI_FAULT
, &info
);
10657 /* case SSI_NVPAIRS:
10658 -- Used with SSIN_UACPROC to enable unaligned accesses.
10659 case SSI_IEEE_STATE_AT_SIGNAL:
10660 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
10661 -- Not implemented in linux kernel
10666 #ifdef TARGET_NR_osf_sigprocmask
10667 /* Alpha specific. */
10668 case TARGET_NR_osf_sigprocmask
:
10672 sigset_t set
, oldset
;
10675 case TARGET_SIG_BLOCK
:
10678 case TARGET_SIG_UNBLOCK
:
10681 case TARGET_SIG_SETMASK
:
10685 return -TARGET_EINVAL
;
10688 target_to_host_old_sigset(&set
, &mask
);
10689 ret
= do_sigprocmask(how
, &set
, &oldset
);
10691 host_to_target_old_sigset(&mask
, &oldset
);
10698 #ifdef TARGET_NR_getgid32
10699 case TARGET_NR_getgid32
:
10700 return get_errno(getgid());
10702 #ifdef TARGET_NR_geteuid32
10703 case TARGET_NR_geteuid32
:
10704 return get_errno(geteuid());
10706 #ifdef TARGET_NR_getegid32
10707 case TARGET_NR_getegid32
:
10708 return get_errno(getegid());
10710 #ifdef TARGET_NR_setreuid32
10711 case TARGET_NR_setreuid32
:
10712 return get_errno(setreuid(arg1
, arg2
));
10714 #ifdef TARGET_NR_setregid32
10715 case TARGET_NR_setregid32
:
10716 return get_errno(setregid(arg1
, arg2
));
10718 #ifdef TARGET_NR_getgroups32
10719 case TARGET_NR_getgroups32
:
10721 int gidsetsize
= arg1
;
10722 uint32_t *target_grouplist
;
10726 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10727 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
10728 if (gidsetsize
== 0)
10730 if (!is_error(ret
)) {
10731 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
10732 if (!target_grouplist
) {
10733 return -TARGET_EFAULT
;
10735 for(i
= 0;i
< ret
; i
++)
10736 target_grouplist
[i
] = tswap32(grouplist
[i
]);
10737 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
10742 #ifdef TARGET_NR_setgroups32
10743 case TARGET_NR_setgroups32
:
10745 int gidsetsize
= arg1
;
10746 uint32_t *target_grouplist
;
10750 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10751 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
10752 if (!target_grouplist
) {
10753 return -TARGET_EFAULT
;
10755 for(i
= 0;i
< gidsetsize
; i
++)
10756 grouplist
[i
] = tswap32(target_grouplist
[i
]);
10757 unlock_user(target_grouplist
, arg2
, 0);
10758 return get_errno(setgroups(gidsetsize
, grouplist
));
10761 #ifdef TARGET_NR_fchown32
10762 case TARGET_NR_fchown32
:
10763 return get_errno(fchown(arg1
, arg2
, arg3
));
10765 #ifdef TARGET_NR_setresuid32
10766 case TARGET_NR_setresuid32
:
10767 return get_errno(sys_setresuid(arg1
, arg2
, arg3
));
10769 #ifdef TARGET_NR_getresuid32
10770 case TARGET_NR_getresuid32
:
10772 uid_t ruid
, euid
, suid
;
10773 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
10774 if (!is_error(ret
)) {
10775 if (put_user_u32(ruid
, arg1
)
10776 || put_user_u32(euid
, arg2
)
10777 || put_user_u32(suid
, arg3
))
10778 return -TARGET_EFAULT
;
10783 #ifdef TARGET_NR_setresgid32
10784 case TARGET_NR_setresgid32
:
10785 return get_errno(sys_setresgid(arg1
, arg2
, arg3
));
10787 #ifdef TARGET_NR_getresgid32
10788 case TARGET_NR_getresgid32
:
10790 gid_t rgid
, egid
, sgid
;
10791 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
10792 if (!is_error(ret
)) {
10793 if (put_user_u32(rgid
, arg1
)
10794 || put_user_u32(egid
, arg2
)
10795 || put_user_u32(sgid
, arg3
))
10796 return -TARGET_EFAULT
;
10801 #ifdef TARGET_NR_chown32
10802 case TARGET_NR_chown32
:
10803 if (!(p
= lock_user_string(arg1
)))
10804 return -TARGET_EFAULT
;
10805 ret
= get_errno(chown(p
, arg2
, arg3
));
10806 unlock_user(p
, arg1
, 0);
10809 #ifdef TARGET_NR_setuid32
10810 case TARGET_NR_setuid32
:
10811 return get_errno(sys_setuid(arg1
));
10813 #ifdef TARGET_NR_setgid32
10814 case TARGET_NR_setgid32
:
10815 return get_errno(sys_setgid(arg1
));
10817 #ifdef TARGET_NR_setfsuid32
10818 case TARGET_NR_setfsuid32
:
10819 return get_errno(setfsuid(arg1
));
10821 #ifdef TARGET_NR_setfsgid32
10822 case TARGET_NR_setfsgid32
:
10823 return get_errno(setfsgid(arg1
));
10825 #ifdef TARGET_NR_mincore
10826 case TARGET_NR_mincore
:
10828 void *a
= lock_user(VERIFY_READ
, arg1
, arg2
, 0);
10830 return -TARGET_ENOMEM
;
10832 p
= lock_user_string(arg3
);
10834 ret
= -TARGET_EFAULT
;
10836 ret
= get_errno(mincore(a
, arg2
, p
));
10837 unlock_user(p
, arg3
, ret
);
10839 unlock_user(a
, arg1
, 0);
10843 #ifdef TARGET_NR_arm_fadvise64_64
10844 case TARGET_NR_arm_fadvise64_64
:
10845 /* arm_fadvise64_64 looks like fadvise64_64 but
10846 * with different argument order: fd, advice, offset, len
10847 * rather than the usual fd, offset, len, advice.
10848 * Note that offset and len are both 64-bit so appear as
10849 * pairs of 32-bit registers.
10851 ret
= posix_fadvise(arg1
, target_offset64(arg3
, arg4
),
10852 target_offset64(arg5
, arg6
), arg2
);
10853 return -host_to_target_errno(ret
);
10856 #if TARGET_ABI_BITS == 32
10858 #ifdef TARGET_NR_fadvise64_64
10859 case TARGET_NR_fadvise64_64
:
10860 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
10861 /* 6 args: fd, advice, offset (high, low), len (high, low) */
10869 /* 6 args: fd, offset (high, low), len (high, low), advice */
10870 if (regpairs_aligned(cpu_env
, num
)) {
10871 /* offset is in (3,4), len in (5,6) and advice in 7 */
10879 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
),
10880 target_offset64(arg4
, arg5
), arg6
);
10881 return -host_to_target_errno(ret
);
10884 #ifdef TARGET_NR_fadvise64
10885 case TARGET_NR_fadvise64
:
10886 /* 5 args: fd, offset (high, low), len, advice */
10887 if (regpairs_aligned(cpu_env
, num
)) {
10888 /* offset is in (3,4), len in 5 and advice in 6 */
10894 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
), arg4
, arg5
);
10895 return -host_to_target_errno(ret
);
10898 #else /* not a 32-bit ABI */
10899 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
10900 #ifdef TARGET_NR_fadvise64_64
10901 case TARGET_NR_fadvise64_64
:
10903 #ifdef TARGET_NR_fadvise64
10904 case TARGET_NR_fadvise64
:
10906 #ifdef TARGET_S390X
10908 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
10909 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
10910 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
10911 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
10915 return -host_to_target_errno(posix_fadvise(arg1
, arg2
, arg3
, arg4
));
10917 #endif /* end of 64-bit ABI fadvise handling */
10919 #ifdef TARGET_NR_madvise
10920 case TARGET_NR_madvise
:
10921 /* A straight passthrough may not be safe because qemu sometimes
10922 turns private file-backed mappings into anonymous mappings.
10923 This will break MADV_DONTNEED.
10924 This is a hint, so ignoring and returning success is ok. */
10927 #if TARGET_ABI_BITS == 32
10928 case TARGET_NR_fcntl64
:
10932 from_flock64_fn
*copyfrom
= copy_from_user_flock64
;
10933 to_flock64_fn
*copyto
= copy_to_user_flock64
;
10936 if (!((CPUARMState
*)cpu_env
)->eabi
) {
10937 copyfrom
= copy_from_user_oabi_flock64
;
10938 copyto
= copy_to_user_oabi_flock64
;
10942 cmd
= target_to_host_fcntl_cmd(arg2
);
10943 if (cmd
== -TARGET_EINVAL
) {
10948 case TARGET_F_GETLK64
:
10949 ret
= copyfrom(&fl
, arg3
);
10953 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
10955 ret
= copyto(arg3
, &fl
);
10959 case TARGET_F_SETLK64
:
10960 case TARGET_F_SETLKW64
:
10961 ret
= copyfrom(&fl
, arg3
);
10965 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
10968 ret
= do_fcntl(arg1
, arg2
, arg3
);
10974 #ifdef TARGET_NR_cacheflush
10975 case TARGET_NR_cacheflush
:
10976 /* self-modifying code is handled automatically, so nothing needed */
10979 #ifdef TARGET_NR_getpagesize
10980 case TARGET_NR_getpagesize
:
10981 return TARGET_PAGE_SIZE
;
10983 case TARGET_NR_gettid
:
10984 return get_errno(sys_gettid());
10985 #ifdef TARGET_NR_readahead
10986 case TARGET_NR_readahead
:
10987 #if TARGET_ABI_BITS == 32
10988 if (regpairs_aligned(cpu_env
, num
)) {
10993 ret
= get_errno(readahead(arg1
, target_offset64(arg2
, arg3
) , arg4
));
10995 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
11000 #ifdef TARGET_NR_setxattr
11001 case TARGET_NR_listxattr
:
11002 case TARGET_NR_llistxattr
:
11006 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11008 return -TARGET_EFAULT
;
11011 p
= lock_user_string(arg1
);
11013 if (num
== TARGET_NR_listxattr
) {
11014 ret
= get_errno(listxattr(p
, b
, arg3
));
11016 ret
= get_errno(llistxattr(p
, b
, arg3
));
11019 ret
= -TARGET_EFAULT
;
11021 unlock_user(p
, arg1
, 0);
11022 unlock_user(b
, arg2
, arg3
);
11025 case TARGET_NR_flistxattr
:
11029 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11031 return -TARGET_EFAULT
;
11034 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
11035 unlock_user(b
, arg2
, arg3
);
11038 case TARGET_NR_setxattr
:
11039 case TARGET_NR_lsetxattr
:
11041 void *p
, *n
, *v
= 0;
11043 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11045 return -TARGET_EFAULT
;
11048 p
= lock_user_string(arg1
);
11049 n
= lock_user_string(arg2
);
11051 if (num
== TARGET_NR_setxattr
) {
11052 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
11054 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
11057 ret
= -TARGET_EFAULT
;
11059 unlock_user(p
, arg1
, 0);
11060 unlock_user(n
, arg2
, 0);
11061 unlock_user(v
, arg3
, 0);
11064 case TARGET_NR_fsetxattr
:
11068 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11070 return -TARGET_EFAULT
;
11073 n
= lock_user_string(arg2
);
11075 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
11077 ret
= -TARGET_EFAULT
;
11079 unlock_user(n
, arg2
, 0);
11080 unlock_user(v
, arg3
, 0);
11083 case TARGET_NR_getxattr
:
11084 case TARGET_NR_lgetxattr
:
11086 void *p
, *n
, *v
= 0;
11088 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11090 return -TARGET_EFAULT
;
11093 p
= lock_user_string(arg1
);
11094 n
= lock_user_string(arg2
);
11096 if (num
== TARGET_NR_getxattr
) {
11097 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
11099 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
11102 ret
= -TARGET_EFAULT
;
11104 unlock_user(p
, arg1
, 0);
11105 unlock_user(n
, arg2
, 0);
11106 unlock_user(v
, arg3
, arg4
);
11109 case TARGET_NR_fgetxattr
:
11113 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11115 return -TARGET_EFAULT
;
11118 n
= lock_user_string(arg2
);
11120 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
11122 ret
= -TARGET_EFAULT
;
11124 unlock_user(n
, arg2
, 0);
11125 unlock_user(v
, arg3
, arg4
);
11128 case TARGET_NR_removexattr
:
11129 case TARGET_NR_lremovexattr
:
11132 p
= lock_user_string(arg1
);
11133 n
= lock_user_string(arg2
);
11135 if (num
== TARGET_NR_removexattr
) {
11136 ret
= get_errno(removexattr(p
, n
));
11138 ret
= get_errno(lremovexattr(p
, n
));
11141 ret
= -TARGET_EFAULT
;
11143 unlock_user(p
, arg1
, 0);
11144 unlock_user(n
, arg2
, 0);
11147 case TARGET_NR_fremovexattr
:
11150 n
= lock_user_string(arg2
);
11152 ret
= get_errno(fremovexattr(arg1
, n
));
11154 ret
= -TARGET_EFAULT
;
11156 unlock_user(n
, arg2
, 0);
11160 #endif /* CONFIG_ATTR */
11161 #ifdef TARGET_NR_set_thread_area
11162 case TARGET_NR_set_thread_area
:
11163 #if defined(TARGET_MIPS)
11164 ((CPUMIPSState
*) cpu_env
)->active_tc
.CP0_UserLocal
= arg1
;
11166 #elif defined(TARGET_CRIS)
11168 ret
= -TARGET_EINVAL
;
11170 ((CPUCRISState
*) cpu_env
)->pregs
[PR_PID
] = arg1
;
11174 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
11175 return do_set_thread_area(cpu_env
, arg1
);
11176 #elif defined(TARGET_M68K)
11178 TaskState
*ts
= cpu
->opaque
;
11179 ts
->tp_value
= arg1
;
11183 return -TARGET_ENOSYS
;
11186 #ifdef TARGET_NR_get_thread_area
11187 case TARGET_NR_get_thread_area
:
11188 #if defined(TARGET_I386) && defined(TARGET_ABI32)
11189 return do_get_thread_area(cpu_env
, arg1
);
11190 #elif defined(TARGET_M68K)
11192 TaskState
*ts
= cpu
->opaque
;
11193 return ts
->tp_value
;
11196 return -TARGET_ENOSYS
;
11199 #ifdef TARGET_NR_getdomainname
11200 case TARGET_NR_getdomainname
:
11201 return -TARGET_ENOSYS
;
11204 #ifdef TARGET_NR_clock_settime
11205 case TARGET_NR_clock_settime
:
11207 struct timespec ts
;
11209 ret
= target_to_host_timespec(&ts
, arg2
);
11210 if (!is_error(ret
)) {
11211 ret
= get_errno(clock_settime(arg1
, &ts
));
11216 #ifdef TARGET_NR_clock_gettime
11217 case TARGET_NR_clock_gettime
:
11219 struct timespec ts
;
11220 ret
= get_errno(clock_gettime(arg1
, &ts
));
11221 if (!is_error(ret
)) {
11222 ret
= host_to_target_timespec(arg2
, &ts
);
11227 #ifdef TARGET_NR_clock_getres
11228 case TARGET_NR_clock_getres
:
11230 struct timespec ts
;
11231 ret
= get_errno(clock_getres(arg1
, &ts
));
11232 if (!is_error(ret
)) {
11233 host_to_target_timespec(arg2
, &ts
);
11238 #ifdef TARGET_NR_clock_nanosleep
11239 case TARGET_NR_clock_nanosleep
:
11241 struct timespec ts
;
11242 target_to_host_timespec(&ts
, arg3
);
11243 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
11244 &ts
, arg4
? &ts
: NULL
));
11246 host_to_target_timespec(arg4
, &ts
);
11248 #if defined(TARGET_PPC)
11249 /* clock_nanosleep is odd in that it returns positive errno values.
11250 * On PPC, CR0 bit 3 should be set in such a situation. */
11251 if (ret
&& ret
!= -TARGET_ERESTARTSYS
) {
11252 ((CPUPPCState
*)cpu_env
)->crf
[0] |= 1;
11259 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11260 case TARGET_NR_set_tid_address
:
11261 return get_errno(set_tid_address((int *)g2h(arg1
)));
11264 case TARGET_NR_tkill
:
11265 return get_errno(safe_tkill((int)arg1
, target_to_host_signal(arg2
)));
11267 case TARGET_NR_tgkill
:
11268 return get_errno(safe_tgkill((int)arg1
, (int)arg2
,
11269 target_to_host_signal(arg3
)));
11271 #ifdef TARGET_NR_set_robust_list
11272 case TARGET_NR_set_robust_list
:
11273 case TARGET_NR_get_robust_list
:
11274 /* The ABI for supporting robust futexes has userspace pass
11275 * the kernel a pointer to a linked list which is updated by
11276 * userspace after the syscall; the list is walked by the kernel
11277 * when the thread exits. Since the linked list in QEMU guest
11278 * memory isn't a valid linked list for the host and we have
11279 * no way to reliably intercept the thread-death event, we can't
11280 * support these. Silently return ENOSYS so that guest userspace
11281 * falls back to a non-robust futex implementation (which should
11282 * be OK except in the corner case of the guest crashing while
11283 * holding a mutex that is shared with another process via
11286 return -TARGET_ENOSYS
;
11289 #if defined(TARGET_NR_utimensat)
11290 case TARGET_NR_utimensat
:
11292 struct timespec
*tsp
, ts
[2];
11296 target_to_host_timespec(ts
, arg3
);
11297 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
11301 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
11303 if (!(p
= lock_user_string(arg2
))) {
11304 return -TARGET_EFAULT
;
11306 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
11307 unlock_user(p
, arg2
, 0);
11312 case TARGET_NR_futex
:
11313 return do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
11314 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
11315 case TARGET_NR_inotify_init
:
11316 ret
= get_errno(sys_inotify_init());
11318 fd_trans_register(ret
, &target_inotify_trans
);
11322 #ifdef CONFIG_INOTIFY1
11323 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11324 case TARGET_NR_inotify_init1
:
11325 ret
= get_errno(sys_inotify_init1(target_to_host_bitmask(arg1
,
11326 fcntl_flags_tbl
)));
11328 fd_trans_register(ret
, &target_inotify_trans
);
11333 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
11334 case TARGET_NR_inotify_add_watch
:
11335 p
= lock_user_string(arg2
);
11336 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
11337 unlock_user(p
, arg2
, 0);
11340 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
11341 case TARGET_NR_inotify_rm_watch
:
11342 return get_errno(sys_inotify_rm_watch(arg1
, arg2
));
11345 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
11346 case TARGET_NR_mq_open
:
11348 struct mq_attr posix_mq_attr
;
11349 struct mq_attr
*pposix_mq_attr
;
11352 host_flags
= target_to_host_bitmask(arg2
, fcntl_flags_tbl
);
11353 pposix_mq_attr
= NULL
;
11355 if (copy_from_user_mq_attr(&posix_mq_attr
, arg4
) != 0) {
11356 return -TARGET_EFAULT
;
11358 pposix_mq_attr
= &posix_mq_attr
;
11360 p
= lock_user_string(arg1
- 1);
11362 return -TARGET_EFAULT
;
11364 ret
= get_errno(mq_open(p
, host_flags
, arg3
, pposix_mq_attr
));
11365 unlock_user (p
, arg1
, 0);
11369 case TARGET_NR_mq_unlink
:
11370 p
= lock_user_string(arg1
- 1);
11372 return -TARGET_EFAULT
;
11374 ret
= get_errno(mq_unlink(p
));
11375 unlock_user (p
, arg1
, 0);
11378 case TARGET_NR_mq_timedsend
:
11380 struct timespec ts
;
11382 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
11384 target_to_host_timespec(&ts
, arg5
);
11385 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
11386 host_to_target_timespec(arg5
, &ts
);
11388 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
11390 unlock_user (p
, arg2
, arg3
);
11394 case TARGET_NR_mq_timedreceive
:
11396 struct timespec ts
;
11399 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
11401 target_to_host_timespec(&ts
, arg5
);
11402 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
11404 host_to_target_timespec(arg5
, &ts
);
11406 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
11409 unlock_user (p
, arg2
, arg3
);
11411 put_user_u32(prio
, arg4
);
11415 /* Not implemented for now... */
11416 /* case TARGET_NR_mq_notify: */
11419 case TARGET_NR_mq_getsetattr
:
11421 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
11424 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
11425 ret
= get_errno(mq_setattr(arg1
, &posix_mq_attr_in
,
11426 &posix_mq_attr_out
));
11427 } else if (arg3
!= 0) {
11428 ret
= get_errno(mq_getattr(arg1
, &posix_mq_attr_out
));
11430 if (ret
== 0 && arg3
!= 0) {
11431 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
11437 #ifdef CONFIG_SPLICE
11438 #ifdef TARGET_NR_tee
11439 case TARGET_NR_tee
:
11441 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
11445 #ifdef TARGET_NR_splice
11446 case TARGET_NR_splice
:
11448 loff_t loff_in
, loff_out
;
11449 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
11451 if (get_user_u64(loff_in
, arg2
)) {
11452 return -TARGET_EFAULT
;
11454 ploff_in
= &loff_in
;
11457 if (get_user_u64(loff_out
, arg4
)) {
11458 return -TARGET_EFAULT
;
11460 ploff_out
= &loff_out
;
11462 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
11464 if (put_user_u64(loff_in
, arg2
)) {
11465 return -TARGET_EFAULT
;
11469 if (put_user_u64(loff_out
, arg4
)) {
11470 return -TARGET_EFAULT
;
11476 #ifdef TARGET_NR_vmsplice
11477 case TARGET_NR_vmsplice
:
11479 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
11481 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
11482 unlock_iovec(vec
, arg2
, arg3
, 0);
11484 ret
= -host_to_target_errno(errno
);
11489 #endif /* CONFIG_SPLICE */
11490 #ifdef CONFIG_EVENTFD
11491 #if defined(TARGET_NR_eventfd)
11492 case TARGET_NR_eventfd
:
11493 ret
= get_errno(eventfd(arg1
, 0));
11495 fd_trans_register(ret
, &target_eventfd_trans
);
11499 #if defined(TARGET_NR_eventfd2)
11500 case TARGET_NR_eventfd2
:
11502 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
));
11503 if (arg2
& TARGET_O_NONBLOCK
) {
11504 host_flags
|= O_NONBLOCK
;
11506 if (arg2
& TARGET_O_CLOEXEC
) {
11507 host_flags
|= O_CLOEXEC
;
11509 ret
= get_errno(eventfd(arg1
, host_flags
));
11511 fd_trans_register(ret
, &target_eventfd_trans
);
11516 #endif /* CONFIG_EVENTFD */
11517 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
11518 case TARGET_NR_fallocate
:
11519 #if TARGET_ABI_BITS == 32
11520 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
11521 target_offset64(arg5
, arg6
)));
11523 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
11527 #if defined(CONFIG_SYNC_FILE_RANGE)
11528 #if defined(TARGET_NR_sync_file_range)
11529 case TARGET_NR_sync_file_range
:
11530 #if TARGET_ABI_BITS == 32
11531 #if defined(TARGET_MIPS)
11532 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
11533 target_offset64(arg5
, arg6
), arg7
));
11535 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
11536 target_offset64(arg4
, arg5
), arg6
));
11537 #endif /* !TARGET_MIPS */
11539 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
11543 #if defined(TARGET_NR_sync_file_range2)
11544 case TARGET_NR_sync_file_range2
:
11545 /* This is like sync_file_range but the arguments are reordered */
11546 #if TARGET_ABI_BITS == 32
11547 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
11548 target_offset64(arg5
, arg6
), arg2
));
11550 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
11555 #if defined(TARGET_NR_signalfd4)
11556 case TARGET_NR_signalfd4
:
11557 return do_signalfd4(arg1
, arg2
, arg4
);
11559 #if defined(TARGET_NR_signalfd)
11560 case TARGET_NR_signalfd
:
11561 return do_signalfd4(arg1
, arg2
, 0);
11563 #if defined(CONFIG_EPOLL)
11564 #if defined(TARGET_NR_epoll_create)
11565 case TARGET_NR_epoll_create
:
11566 return get_errno(epoll_create(arg1
));
11568 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
11569 case TARGET_NR_epoll_create1
:
11570 return get_errno(epoll_create1(arg1
));
11572 #if defined(TARGET_NR_epoll_ctl)
11573 case TARGET_NR_epoll_ctl
:
11575 struct epoll_event ep
;
11576 struct epoll_event
*epp
= 0;
11578 struct target_epoll_event
*target_ep
;
11579 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
11580 return -TARGET_EFAULT
;
11582 ep
.events
= tswap32(target_ep
->events
);
11583 /* The epoll_data_t union is just opaque data to the kernel,
11584 * so we transfer all 64 bits across and need not worry what
11585 * actual data type it is.
11587 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
11588 unlock_user_struct(target_ep
, arg4
, 0);
11591 return get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
11595 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
11596 #if defined(TARGET_NR_epoll_wait)
11597 case TARGET_NR_epoll_wait
:
11599 #if defined(TARGET_NR_epoll_pwait)
11600 case TARGET_NR_epoll_pwait
:
11603 struct target_epoll_event
*target_ep
;
11604 struct epoll_event
*ep
;
11606 int maxevents
= arg3
;
11607 int timeout
= arg4
;
11609 if (maxevents
<= 0 || maxevents
> TARGET_EP_MAX_EVENTS
) {
11610 return -TARGET_EINVAL
;
11613 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
11614 maxevents
* sizeof(struct target_epoll_event
), 1);
11616 return -TARGET_EFAULT
;
11619 ep
= g_try_new(struct epoll_event
, maxevents
);
11621 unlock_user(target_ep
, arg2
, 0);
11622 return -TARGET_ENOMEM
;
11626 #if defined(TARGET_NR_epoll_pwait)
11627 case TARGET_NR_epoll_pwait
:
11629 target_sigset_t
*target_set
;
11630 sigset_t _set
, *set
= &_set
;
11633 if (arg6
!= sizeof(target_sigset_t
)) {
11634 ret
= -TARGET_EINVAL
;
11638 target_set
= lock_user(VERIFY_READ
, arg5
,
11639 sizeof(target_sigset_t
), 1);
11641 ret
= -TARGET_EFAULT
;
11644 target_to_host_sigset(set
, target_set
);
11645 unlock_user(target_set
, arg5
, 0);
11650 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
11651 set
, SIGSET_T_SIZE
));
11655 #if defined(TARGET_NR_epoll_wait)
11656 case TARGET_NR_epoll_wait
:
11657 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
11662 ret
= -TARGET_ENOSYS
;
11664 if (!is_error(ret
)) {
11666 for (i
= 0; i
< ret
; i
++) {
11667 target_ep
[i
].events
= tswap32(ep
[i
].events
);
11668 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
11670 unlock_user(target_ep
, arg2
,
11671 ret
* sizeof(struct target_epoll_event
));
11673 unlock_user(target_ep
, arg2
, 0);
11680 #ifdef TARGET_NR_prlimit64
11681 case TARGET_NR_prlimit64
:
11683 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
11684 struct target_rlimit64
*target_rnew
, *target_rold
;
11685 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
11686 int resource
= target_to_host_resource(arg2
);
11688 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
11689 return -TARGET_EFAULT
;
11691 rnew
.rlim_cur
= tswap64(target_rnew
->rlim_cur
);
11692 rnew
.rlim_max
= tswap64(target_rnew
->rlim_max
);
11693 unlock_user_struct(target_rnew
, arg3
, 0);
11697 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
11698 if (!is_error(ret
) && arg4
) {
11699 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
11700 return -TARGET_EFAULT
;
11702 target_rold
->rlim_cur
= tswap64(rold
.rlim_cur
);
11703 target_rold
->rlim_max
= tswap64(rold
.rlim_max
);
11704 unlock_user_struct(target_rold
, arg4
, 1);
11709 #ifdef TARGET_NR_gethostname
11710 case TARGET_NR_gethostname
:
11712 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
11714 ret
= get_errno(gethostname(name
, arg2
));
11715 unlock_user(name
, arg1
, arg2
);
11717 ret
= -TARGET_EFAULT
;
11722 #ifdef TARGET_NR_atomic_cmpxchg_32
11723 case TARGET_NR_atomic_cmpxchg_32
:
11725 /* should use start_exclusive from main.c */
11726 abi_ulong mem_value
;
11727 if (get_user_u32(mem_value
, arg6
)) {
11728 target_siginfo_t info
;
11729 info
.si_signo
= SIGSEGV
;
11731 info
.si_code
= TARGET_SEGV_MAPERR
;
11732 info
._sifields
._sigfault
._addr
= arg6
;
11733 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
11734 QEMU_SI_FAULT
, &info
);
11738 if (mem_value
== arg2
)
11739 put_user_u32(arg1
, arg6
);
11743 #ifdef TARGET_NR_atomic_barrier
11744 case TARGET_NR_atomic_barrier
:
11745 /* Like the kernel implementation and the
11746 qemu arm barrier, no-op this? */
11750 #ifdef TARGET_NR_timer_create
11751 case TARGET_NR_timer_create
:
11753 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
11755 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
11758 int timer_index
= next_free_host_timer();
11760 if (timer_index
< 0) {
11761 ret
= -TARGET_EAGAIN
;
11763 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
11766 phost_sevp
= &host_sevp
;
11767 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
11773 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
11777 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
11778 return -TARGET_EFAULT
;
11786 #ifdef TARGET_NR_timer_settime
11787 case TARGET_NR_timer_settime
:
11789 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
11790 * struct itimerspec * old_value */
11791 target_timer_t timerid
= get_timer_id(arg1
);
11795 } else if (arg3
== 0) {
11796 ret
= -TARGET_EINVAL
;
11798 timer_t htimer
= g_posix_timers
[timerid
];
11799 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
11801 if (target_to_host_itimerspec(&hspec_new
, arg3
)) {
11802 return -TARGET_EFAULT
;
11805 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
11806 if (arg4
&& host_to_target_itimerspec(arg4
, &hspec_old
)) {
11807 return -TARGET_EFAULT
;
11814 #ifdef TARGET_NR_timer_gettime
11815 case TARGET_NR_timer_gettime
:
11817 /* args: timer_t timerid, struct itimerspec *curr_value */
11818 target_timer_t timerid
= get_timer_id(arg1
);
11822 } else if (!arg2
) {
11823 ret
= -TARGET_EFAULT
;
11825 timer_t htimer
= g_posix_timers
[timerid
];
11826 struct itimerspec hspec
;
11827 ret
= get_errno(timer_gettime(htimer
, &hspec
));
11829 if (host_to_target_itimerspec(arg2
, &hspec
)) {
11830 ret
= -TARGET_EFAULT
;
11837 #ifdef TARGET_NR_timer_getoverrun
11838 case TARGET_NR_timer_getoverrun
:
11840 /* args: timer_t timerid */
11841 target_timer_t timerid
= get_timer_id(arg1
);
11846 timer_t htimer
= g_posix_timers
[timerid
];
11847 ret
= get_errno(timer_getoverrun(htimer
));
11849 fd_trans_unregister(ret
);
11854 #ifdef TARGET_NR_timer_delete
11855 case TARGET_NR_timer_delete
:
11857 /* args: timer_t timerid */
11858 target_timer_t timerid
= get_timer_id(arg1
);
11863 timer_t htimer
= g_posix_timers
[timerid
];
11864 ret
= get_errno(timer_delete(htimer
));
11865 g_posix_timers
[timerid
] = 0;
11871 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
11872 case TARGET_NR_timerfd_create
:
11873 return get_errno(timerfd_create(arg1
,
11874 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
11877 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
11878 case TARGET_NR_timerfd_gettime
:
11880 struct itimerspec its_curr
;
11882 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
11884 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
11885 return -TARGET_EFAULT
;
11891 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
11892 case TARGET_NR_timerfd_settime
:
11894 struct itimerspec its_new
, its_old
, *p_new
;
11897 if (target_to_host_itimerspec(&its_new
, arg3
)) {
11898 return -TARGET_EFAULT
;
11905 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
11907 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
11908 return -TARGET_EFAULT
;
11914 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
11915 case TARGET_NR_ioprio_get
:
11916 return get_errno(ioprio_get(arg1
, arg2
));
11919 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
11920 case TARGET_NR_ioprio_set
:
11921 return get_errno(ioprio_set(arg1
, arg2
, arg3
));
11924 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
11925 case TARGET_NR_setns
:
11926 return get_errno(setns(arg1
, arg2
));
11928 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
11929 case TARGET_NR_unshare
:
11930 return get_errno(unshare(arg1
));
11932 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
11933 case TARGET_NR_kcmp
:
11934 return get_errno(kcmp(arg1
, arg2
, arg3
, arg4
, arg5
));
11936 #ifdef TARGET_NR_swapcontext
11937 case TARGET_NR_swapcontext
:
11938 /* PowerPC specific. */
11939 return do_swapcontext(cpu_env
, arg1
, arg2
, arg3
);
11943 qemu_log_mask(LOG_UNIMP
, "Unsupported syscall: %d\n", num
);
11944 return -TARGET_ENOSYS
;
11949 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
11950 abi_long arg2
, abi_long arg3
, abi_long arg4
,
11951 abi_long arg5
, abi_long arg6
, abi_long arg7
,
11954 CPUState
*cpu
= env_cpu(cpu_env
);
11957 #ifdef DEBUG_ERESTARTSYS
11958 /* Debug-only code for exercising the syscall-restart code paths
11959 * in the per-architecture cpu main loops: restart every syscall
11960 * the guest makes once before letting it through.
11966 return -TARGET_ERESTARTSYS
;
11971 trace_guest_user_syscall(cpu
, num
, arg1
, arg2
, arg3
, arg4
,
11972 arg5
, arg6
, arg7
, arg8
);
11974 if (unlikely(do_strace
)) {
11975 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
11976 ret
= do_syscall1(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
,
11977 arg5
, arg6
, arg7
, arg8
);
11978 print_syscall_ret(num
, ret
);
11980 ret
= do_syscall1(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
,
11981 arg5
, arg6
, arg7
, arg8
);
11984 trace_guest_user_syscall_ret(cpu
, num
, ret
);