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>
43 #include <sys/times.h>
46 #include <sys/statfs.h>
48 #include <sys/sysinfo.h>
49 #include <sys/signalfd.h>
50 //#include <sys/user.h>
51 #include <netinet/ip.h>
52 #include <netinet/tcp.h>
53 #include <linux/wireless.h>
54 #include <linux/icmp.h>
55 #include <linux/icmpv6.h>
56 #include <linux/errqueue.h>
57 #include <linux/random.h>
59 #include <sys/timerfd.h>
62 #include <sys/eventfd.h>
65 #include <sys/epoll.h>
68 #include "qemu/xattr.h"
70 #ifdef CONFIG_SENDFILE
71 #include <sys/sendfile.h>
74 #define termios host_termios
75 #define winsize host_winsize
76 #define termio host_termio
77 #define sgttyb host_sgttyb /* same as target */
78 #define tchars host_tchars /* same as target */
79 #define ltchars host_ltchars /* same as target */
81 #include <linux/termios.h>
82 #include <linux/unistd.h>
83 #include <linux/cdrom.h>
84 #include <linux/hdreg.h>
85 #include <linux/soundcard.h>
87 #include <linux/mtio.h>
89 #if defined(CONFIG_FIEMAP)
90 #include <linux/fiemap.h>
93 #if defined(CONFIG_USBFS)
94 #include <linux/usbdevice_fs.h>
95 #include <linux/usb/ch9.h>
98 #include <linux/dm-ioctl.h>
99 #include <linux/reboot.h>
100 #include <linux/route.h>
101 #include <linux/filter.h>
102 #include <linux/blkpg.h>
103 #include <netpacket/packet.h>
104 #include <linux/netlink.h>
105 #include "linux_loop.h"
109 #include "qemu/guest-random.h"
110 #include "qapi/error.h"
111 #include "fd-trans.h"
114 #define CLONE_IO 0x80000000 /* Clone io context */
117 /* We can't directly call the host clone syscall, because this will
118 * badly confuse libc (breaking mutexes, for example). So we must
119 * divide clone flags into:
120 * * flag combinations that look like pthread_create()
121 * * flag combinations that look like fork()
122 * * flags we can implement within QEMU itself
123 * * flags we can't support and will return an error for
125 /* For thread creation, all these flags must be present; for
126 * fork, none must be present.
128 #define CLONE_THREAD_FLAGS \
129 (CLONE_VM | CLONE_FS | CLONE_FILES | \
130 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
132 /* These flags are ignored:
133 * CLONE_DETACHED is now ignored by the kernel;
134 * CLONE_IO is just an optimisation hint to the I/O scheduler
136 #define CLONE_IGNORED_FLAGS \
137 (CLONE_DETACHED | CLONE_IO)
139 /* Flags for fork which we can implement within QEMU itself */
140 #define CLONE_OPTIONAL_FORK_FLAGS \
141 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
142 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
144 /* Flags for thread creation which we can implement within QEMU itself */
145 #define CLONE_OPTIONAL_THREAD_FLAGS \
146 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
147 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
149 #define CLONE_INVALID_FORK_FLAGS \
150 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
152 #define CLONE_INVALID_THREAD_FLAGS \
153 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
154 CLONE_IGNORED_FLAGS))
156 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
157 * have almost all been allocated. We cannot support any of
158 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
159 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
160 * The checks against the invalid thread masks above will catch these.
161 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
164 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
165 * once. This exercises the codepaths for restart.
167 //#define DEBUG_ERESTARTSYS
169 //#include <linux/msdos_fs.h>
170 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
171 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
181 #define _syscall0(type,name) \
182 static type name (void) \
184 return syscall(__NR_##name); \
187 #define _syscall1(type,name,type1,arg1) \
188 static type name (type1 arg1) \
190 return syscall(__NR_##name, arg1); \
193 #define _syscall2(type,name,type1,arg1,type2,arg2) \
194 static type name (type1 arg1,type2 arg2) \
196 return syscall(__NR_##name, arg1, arg2); \
199 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
200 static type name (type1 arg1,type2 arg2,type3 arg3) \
202 return syscall(__NR_##name, arg1, arg2, arg3); \
205 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
206 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
208 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
211 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
213 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
215 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
219 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
220 type5,arg5,type6,arg6) \
221 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
224 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
228 #define __NR_sys_uname __NR_uname
229 #define __NR_sys_getcwd1 __NR_getcwd
230 #define __NR_sys_getdents __NR_getdents
231 #define __NR_sys_getdents64 __NR_getdents64
232 #define __NR_sys_getpriority __NR_getpriority
233 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
234 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
235 #define __NR_sys_syslog __NR_syslog
236 #define __NR_sys_futex __NR_futex
237 #define __NR_sys_inotify_init __NR_inotify_init
238 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
239 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
241 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
242 #define __NR__llseek __NR_lseek
245 /* Newer kernel ports have llseek() instead of _llseek() */
246 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
247 #define TARGET_NR__llseek TARGET_NR_llseek
250 #define __NR_sys_gettid __NR_gettid
251 _syscall0(int, sys_gettid
)
253 /* For the 64-bit guest on 32-bit host case we must emulate
254 * getdents using getdents64, because otherwise the host
255 * might hand us back more dirent records than we can fit
256 * into the guest buffer after structure format conversion.
257 * Otherwise we emulate getdents with getdents if the host has it.
259 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
260 #define EMULATE_GETDENTS_WITH_GETDENTS
263 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
264 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
266 #if (defined(TARGET_NR_getdents) && \
267 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
268 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
269 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
271 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
272 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
273 loff_t
*, res
, uint
, wh
);
275 _syscall3(int, sys_rt_sigqueueinfo
, pid_t
, pid
, int, sig
, siginfo_t
*, uinfo
)
276 _syscall4(int, sys_rt_tgsigqueueinfo
, pid_t
, pid
, pid_t
, tid
, int, sig
,
278 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
279 #ifdef __NR_exit_group
280 _syscall1(int,exit_group
,int,error_code
)
282 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
283 _syscall1(int,set_tid_address
,int *,tidptr
)
285 #if defined(TARGET_NR_futex) && defined(__NR_futex)
286 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
287 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
289 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
290 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
291 unsigned long *, user_mask_ptr
);
292 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
293 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
294 unsigned long *, user_mask_ptr
);
295 #define __NR_sys_getcpu __NR_getcpu
296 _syscall3(int, sys_getcpu
, unsigned *, cpu
, unsigned *, node
, void *, tcache
);
297 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
299 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
300 struct __user_cap_data_struct
*, data
);
301 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
302 struct __user_cap_data_struct
*, data
);
303 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
304 _syscall2(int, ioprio_get
, int, which
, int, who
)
306 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
307 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
309 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
310 _syscall3(int, getrandom
, void *, buf
, size_t, buflen
, unsigned int, flags
)
313 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
314 _syscall5(int, kcmp
, pid_t
, pid1
, pid_t
, pid2
, int, type
,
315 unsigned long, idx1
, unsigned long, idx2
)
318 static bitmask_transtbl fcntl_flags_tbl
[] = {
319 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
320 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
321 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
322 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
323 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
324 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
325 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
326 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
327 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
328 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
329 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
330 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
331 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
332 #if defined(O_DIRECT)
333 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
335 #if defined(O_NOATIME)
336 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
338 #if defined(O_CLOEXEC)
339 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
342 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
344 #if defined(O_TMPFILE)
345 { TARGET_O_TMPFILE
, TARGET_O_TMPFILE
, O_TMPFILE
, O_TMPFILE
},
347 /* Don't terminate the list prematurely on 64-bit host+guest. */
348 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
349 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
354 static int sys_getcwd1(char *buf
, size_t size
)
356 if (getcwd(buf
, size
) == NULL
) {
357 /* getcwd() sets errno */
360 return strlen(buf
)+1;
363 #ifdef TARGET_NR_utimensat
364 #if defined(__NR_utimensat)
365 #define __NR_sys_utimensat __NR_utimensat
366 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
367 const struct timespec
*,tsp
,int,flags
)
369 static int sys_utimensat(int dirfd
, const char *pathname
,
370 const struct timespec times
[2], int flags
)
376 #endif /* TARGET_NR_utimensat */
378 #ifdef TARGET_NR_renameat2
379 #if defined(__NR_renameat2)
380 #define __NR_sys_renameat2 __NR_renameat2
381 _syscall5(int, sys_renameat2
, int, oldfd
, const char *, old
, int, newfd
,
382 const char *, new, unsigned int, flags
)
384 static int sys_renameat2(int oldfd
, const char *old
,
385 int newfd
, const char *new, int flags
)
388 return renameat(oldfd
, old
, newfd
, new);
394 #endif /* TARGET_NR_renameat2 */
396 #ifdef CONFIG_INOTIFY
397 #include <sys/inotify.h>
399 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
400 static int sys_inotify_init(void)
402 return (inotify_init());
405 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
406 static int sys_inotify_add_watch(int fd
,const char *pathname
, int32_t mask
)
408 return (inotify_add_watch(fd
, pathname
, mask
));
411 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
412 static int sys_inotify_rm_watch(int fd
, int32_t wd
)
414 return (inotify_rm_watch(fd
, wd
));
417 #ifdef CONFIG_INOTIFY1
418 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
419 static int sys_inotify_init1(int flags
)
421 return (inotify_init1(flags
));
426 /* Userspace can usually survive runtime without inotify */
427 #undef TARGET_NR_inotify_init
428 #undef TARGET_NR_inotify_init1
429 #undef TARGET_NR_inotify_add_watch
430 #undef TARGET_NR_inotify_rm_watch
431 #endif /* CONFIG_INOTIFY */
433 #if defined(TARGET_NR_prlimit64)
434 #ifndef __NR_prlimit64
435 # define __NR_prlimit64 -1
437 #define __NR_sys_prlimit64 __NR_prlimit64
438 /* The glibc rlimit structure may not be that used by the underlying syscall */
439 struct host_rlimit64
{
443 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
444 const struct host_rlimit64
*, new_limit
,
445 struct host_rlimit64
*, old_limit
)
449 #if defined(TARGET_NR_timer_create)
450 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
451 static timer_t g_posix_timers
[32] = { 0, } ;
453 static inline int next_free_host_timer(void)
456 /* FIXME: Does finding the next free slot require a lock? */
457 for (k
= 0; k
< ARRAY_SIZE(g_posix_timers
); k
++) {
458 if (g_posix_timers
[k
] == 0) {
459 g_posix_timers
[k
] = (timer_t
) 1;
467 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
469 static inline int regpairs_aligned(void *cpu_env
, int num
)
471 return ((((CPUARMState
*)cpu_env
)->eabi
) == 1) ;
473 #elif defined(TARGET_MIPS) && (TARGET_ABI_BITS == 32)
474 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
475 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
476 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
477 * of registers which translates to the same as ARM/MIPS, because we start with
479 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
480 #elif defined(TARGET_SH4)
481 /* SH4 doesn't align register pairs, except for p{read,write}64 */
482 static inline int regpairs_aligned(void *cpu_env
, int num
)
485 case TARGET_NR_pread64
:
486 case TARGET_NR_pwrite64
:
493 #elif defined(TARGET_XTENSA)
494 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
496 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 0; }
499 #define ERRNO_TABLE_SIZE 1200
501 /* target_to_host_errno_table[] is initialized from
502 * host_to_target_errno_table[] in syscall_init(). */
503 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
507 * This list is the union of errno values overridden in asm-<arch>/errno.h
508 * minus the errnos that are not actually generic to all archs.
510 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
511 [EAGAIN
] = TARGET_EAGAIN
,
512 [EIDRM
] = TARGET_EIDRM
,
513 [ECHRNG
] = TARGET_ECHRNG
,
514 [EL2NSYNC
] = TARGET_EL2NSYNC
,
515 [EL3HLT
] = TARGET_EL3HLT
,
516 [EL3RST
] = TARGET_EL3RST
,
517 [ELNRNG
] = TARGET_ELNRNG
,
518 [EUNATCH
] = TARGET_EUNATCH
,
519 [ENOCSI
] = TARGET_ENOCSI
,
520 [EL2HLT
] = TARGET_EL2HLT
,
521 [EDEADLK
] = TARGET_EDEADLK
,
522 [ENOLCK
] = TARGET_ENOLCK
,
523 [EBADE
] = TARGET_EBADE
,
524 [EBADR
] = TARGET_EBADR
,
525 [EXFULL
] = TARGET_EXFULL
,
526 [ENOANO
] = TARGET_ENOANO
,
527 [EBADRQC
] = TARGET_EBADRQC
,
528 [EBADSLT
] = TARGET_EBADSLT
,
529 [EBFONT
] = TARGET_EBFONT
,
530 [ENOSTR
] = TARGET_ENOSTR
,
531 [ENODATA
] = TARGET_ENODATA
,
532 [ETIME
] = TARGET_ETIME
,
533 [ENOSR
] = TARGET_ENOSR
,
534 [ENONET
] = TARGET_ENONET
,
535 [ENOPKG
] = TARGET_ENOPKG
,
536 [EREMOTE
] = TARGET_EREMOTE
,
537 [ENOLINK
] = TARGET_ENOLINK
,
538 [EADV
] = TARGET_EADV
,
539 [ESRMNT
] = TARGET_ESRMNT
,
540 [ECOMM
] = TARGET_ECOMM
,
541 [EPROTO
] = TARGET_EPROTO
,
542 [EDOTDOT
] = TARGET_EDOTDOT
,
543 [EMULTIHOP
] = TARGET_EMULTIHOP
,
544 [EBADMSG
] = TARGET_EBADMSG
,
545 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
546 [EOVERFLOW
] = TARGET_EOVERFLOW
,
547 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
548 [EBADFD
] = TARGET_EBADFD
,
549 [EREMCHG
] = TARGET_EREMCHG
,
550 [ELIBACC
] = TARGET_ELIBACC
,
551 [ELIBBAD
] = TARGET_ELIBBAD
,
552 [ELIBSCN
] = TARGET_ELIBSCN
,
553 [ELIBMAX
] = TARGET_ELIBMAX
,
554 [ELIBEXEC
] = TARGET_ELIBEXEC
,
555 [EILSEQ
] = TARGET_EILSEQ
,
556 [ENOSYS
] = TARGET_ENOSYS
,
557 [ELOOP
] = TARGET_ELOOP
,
558 [ERESTART
] = TARGET_ERESTART
,
559 [ESTRPIPE
] = TARGET_ESTRPIPE
,
560 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
561 [EUSERS
] = TARGET_EUSERS
,
562 [ENOTSOCK
] = TARGET_ENOTSOCK
,
563 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
564 [EMSGSIZE
] = TARGET_EMSGSIZE
,
565 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
566 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
567 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
568 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
569 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
570 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
571 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
572 [EADDRINUSE
] = TARGET_EADDRINUSE
,
573 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
574 [ENETDOWN
] = TARGET_ENETDOWN
,
575 [ENETUNREACH
] = TARGET_ENETUNREACH
,
576 [ENETRESET
] = TARGET_ENETRESET
,
577 [ECONNABORTED
] = TARGET_ECONNABORTED
,
578 [ECONNRESET
] = TARGET_ECONNRESET
,
579 [ENOBUFS
] = TARGET_ENOBUFS
,
580 [EISCONN
] = TARGET_EISCONN
,
581 [ENOTCONN
] = TARGET_ENOTCONN
,
582 [EUCLEAN
] = TARGET_EUCLEAN
,
583 [ENOTNAM
] = TARGET_ENOTNAM
,
584 [ENAVAIL
] = TARGET_ENAVAIL
,
585 [EISNAM
] = TARGET_EISNAM
,
586 [EREMOTEIO
] = TARGET_EREMOTEIO
,
587 [EDQUOT
] = TARGET_EDQUOT
,
588 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
589 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
590 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
591 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
592 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
593 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
594 [EALREADY
] = TARGET_EALREADY
,
595 [EINPROGRESS
] = TARGET_EINPROGRESS
,
596 [ESTALE
] = TARGET_ESTALE
,
597 [ECANCELED
] = TARGET_ECANCELED
,
598 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
599 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
601 [ENOKEY
] = TARGET_ENOKEY
,
604 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
607 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
610 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
613 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
615 #ifdef ENOTRECOVERABLE
616 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
619 [ENOMSG
] = TARGET_ENOMSG
,
622 [ERFKILL
] = TARGET_ERFKILL
,
625 [EHWPOISON
] = TARGET_EHWPOISON
,
629 static inline int host_to_target_errno(int err
)
631 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
632 host_to_target_errno_table
[err
]) {
633 return host_to_target_errno_table
[err
];
638 static inline int target_to_host_errno(int err
)
640 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
641 target_to_host_errno_table
[err
]) {
642 return target_to_host_errno_table
[err
];
647 static inline abi_long
get_errno(abi_long ret
)
650 return -host_to_target_errno(errno
);
655 const char *target_strerror(int err
)
657 if (err
== TARGET_ERESTARTSYS
) {
658 return "To be restarted";
660 if (err
== TARGET_QEMU_ESIGRETURN
) {
661 return "Successful exit from sigreturn";
664 if ((err
>= ERRNO_TABLE_SIZE
) || (err
< 0)) {
667 return strerror(target_to_host_errno(err
));
670 #define safe_syscall0(type, name) \
671 static type safe_##name(void) \
673 return safe_syscall(__NR_##name); \
676 #define safe_syscall1(type, name, type1, arg1) \
677 static type safe_##name(type1 arg1) \
679 return safe_syscall(__NR_##name, arg1); \
682 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
683 static type safe_##name(type1 arg1, type2 arg2) \
685 return safe_syscall(__NR_##name, arg1, arg2); \
688 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
689 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
691 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
694 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
696 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
698 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
701 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
702 type4, arg4, type5, arg5) \
703 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
706 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
709 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
710 type4, arg4, type5, arg5, type6, arg6) \
711 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
712 type5 arg5, type6 arg6) \
714 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
717 safe_syscall3(ssize_t
, read
, int, fd
, void *, buff
, size_t, count
)
718 safe_syscall3(ssize_t
, write
, int, fd
, const void *, buff
, size_t, count
)
719 safe_syscall4(int, openat
, int, dirfd
, const char *, pathname
, \
720 int, flags
, mode_t
, mode
)
721 safe_syscall4(pid_t
, wait4
, pid_t
, pid
, int *, status
, int, options
, \
722 struct rusage
*, rusage
)
723 safe_syscall5(int, waitid
, idtype_t
, idtype
, id_t
, id
, siginfo_t
*, infop
, \
724 int, options
, struct rusage
*, rusage
)
725 safe_syscall3(int, execve
, const char *, filename
, char **, argv
, char **, envp
)
726 safe_syscall6(int, pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
, \
727 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
)
728 safe_syscall5(int, ppoll
, struct pollfd
*, ufds
, unsigned int, nfds
,
729 struct timespec
*, tsp
, const sigset_t
*, sigmask
,
731 safe_syscall6(int, epoll_pwait
, int, epfd
, struct epoll_event
*, events
,
732 int, maxevents
, int, timeout
, const sigset_t
*, sigmask
,
734 safe_syscall6(int,futex
,int *,uaddr
,int,op
,int,val
, \
735 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
736 safe_syscall2(int, rt_sigsuspend
, sigset_t
*, newset
, size_t, sigsetsize
)
737 safe_syscall2(int, kill
, pid_t
, pid
, int, sig
)
738 safe_syscall2(int, tkill
, int, tid
, int, sig
)
739 safe_syscall3(int, tgkill
, int, tgid
, int, pid
, int, sig
)
740 safe_syscall3(ssize_t
, readv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
741 safe_syscall3(ssize_t
, writev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
742 safe_syscall5(ssize_t
, preadv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
743 unsigned long, pos_l
, unsigned long, pos_h
)
744 safe_syscall5(ssize_t
, pwritev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
745 unsigned long, pos_l
, unsigned long, pos_h
)
746 safe_syscall3(int, connect
, int, fd
, const struct sockaddr
*, addr
,
748 safe_syscall6(ssize_t
, sendto
, int, fd
, const void *, buf
, size_t, len
,
749 int, flags
, const struct sockaddr
*, addr
, socklen_t
, addrlen
)
750 safe_syscall6(ssize_t
, recvfrom
, int, fd
, void *, buf
, size_t, len
,
751 int, flags
, struct sockaddr
*, addr
, socklen_t
*, addrlen
)
752 safe_syscall3(ssize_t
, sendmsg
, int, fd
, const struct msghdr
*, msg
, int, flags
)
753 safe_syscall3(ssize_t
, recvmsg
, int, fd
, struct msghdr
*, msg
, int, flags
)
754 safe_syscall2(int, flock
, int, fd
, int, operation
)
755 safe_syscall4(int, rt_sigtimedwait
, const sigset_t
*, these
, siginfo_t
*, uinfo
,
756 const struct timespec
*, uts
, size_t, sigsetsize
)
757 safe_syscall4(int, accept4
, int, fd
, struct sockaddr
*, addr
, socklen_t
*, len
,
759 safe_syscall2(int, nanosleep
, const struct timespec
*, req
,
760 struct timespec
*, rem
)
761 #ifdef TARGET_NR_clock_nanosleep
762 safe_syscall4(int, clock_nanosleep
, const clockid_t
, clock
, int, flags
,
763 const struct timespec
*, req
, struct timespec
*, rem
)
765 #if !defined(__NR_msgsnd) || !defined(__NR_msgrcv) || !defined(__NR_semtimedop)
766 /* This host kernel architecture uses a single ipc syscall; fake up
767 * wrappers for the sub-operations to hide this implementation detail.
768 * Annoyingly we can't include linux/ipc.h to get the constant definitions
769 * for the call parameter because some structs in there conflict with the
770 * sys/ipc.h ones. So we just define them here, and rely on them being
771 * the same for all host architectures.
773 #define Q_SEMTIMEDOP 4
776 #define Q_IPCCALL(VERSION, OP) ((VERSION) << 16 | (OP))
778 safe_syscall6(int, ipc
, int, call
, long, first
, long, second
, long, third
,
779 void *, ptr
, long, fifth
)
782 safe_syscall4(int, msgsnd
, int, msgid
, const void *, msgp
, size_t, sz
,
785 static int safe_msgsnd(int msgid
, const void *msgp
, size_t sz
, int flags
)
787 return safe_ipc(Q_IPCCALL(0, Q_MSGSND
), msgid
, sz
, flags
, (void *)msgp
, 0);
791 safe_syscall5(int, msgrcv
, int, msgid
, void *, msgp
, size_t, sz
,
792 long, msgtype
, int, flags
)
794 static int safe_msgrcv(int msgid
, void *msgp
, size_t sz
, long type
, int flags
)
796 return safe_ipc(Q_IPCCALL(1, Q_MSGRCV
), msgid
, sz
, flags
, msgp
, type
);
799 #ifdef __NR_semtimedop
800 safe_syscall4(int, semtimedop
, int, semid
, struct sembuf
*, tsops
,
801 unsigned, nsops
, const struct timespec
*, timeout
)
803 static int safe_semtimedop(int semid
, struct sembuf
*tsops
, unsigned nsops
,
804 const struct timespec
*timeout
)
806 return safe_ipc(Q_IPCCALL(0, Q_SEMTIMEDOP
), semid
, nsops
, 0, tsops
,
810 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
811 safe_syscall5(int, mq_timedsend
, int, mqdes
, const char *, msg_ptr
,
812 size_t, len
, unsigned, prio
, const struct timespec
*, timeout
)
813 safe_syscall5(int, mq_timedreceive
, int, mqdes
, char *, msg_ptr
,
814 size_t, len
, unsigned *, prio
, const struct timespec
*, timeout
)
816 /* We do ioctl like this rather than via safe_syscall3 to preserve the
817 * "third argument might be integer or pointer or not present" behaviour of
820 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
821 /* Similarly for fcntl. Note that callers must always:
822 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
823 * use the flock64 struct rather than unsuffixed flock
824 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
827 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
829 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
832 static inline int host_to_target_sock_type(int host_type
)
836 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
838 target_type
= TARGET_SOCK_DGRAM
;
841 target_type
= TARGET_SOCK_STREAM
;
844 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
848 #if defined(SOCK_CLOEXEC)
849 if (host_type
& SOCK_CLOEXEC
) {
850 target_type
|= TARGET_SOCK_CLOEXEC
;
854 #if defined(SOCK_NONBLOCK)
855 if (host_type
& SOCK_NONBLOCK
) {
856 target_type
|= TARGET_SOCK_NONBLOCK
;
863 static abi_ulong target_brk
;
864 static abi_ulong target_original_brk
;
865 static abi_ulong brk_page
;
867 void target_set_brk(abi_ulong new_brk
)
869 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
870 brk_page
= HOST_PAGE_ALIGN(target_brk
);
873 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
874 #define DEBUGF_BRK(message, args...)
876 /* do_brk() must return target values and target errnos. */
877 abi_long
do_brk(abi_ulong new_brk
)
879 abi_long mapped_addr
;
880 abi_ulong new_alloc_size
;
882 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx
") -> ", new_brk
);
885 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (!new_brk)\n", target_brk
);
888 if (new_brk
< target_original_brk
) {
889 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk < target_original_brk)\n",
894 /* If the new brk is less than the highest page reserved to the
895 * target heap allocation, set it and we're almost done... */
896 if (new_brk
<= brk_page
) {
897 /* Heap contents are initialized to zero, as for anonymous
899 if (new_brk
> target_brk
) {
900 memset(g2h(target_brk
), 0, new_brk
- target_brk
);
902 target_brk
= new_brk
;
903 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk <= brk_page)\n", target_brk
);
907 /* We need to allocate more memory after the brk... Note that
908 * we don't use MAP_FIXED because that will map over the top of
909 * any existing mapping (like the one with the host libc or qemu
910 * itself); instead we treat "mapped but at wrong address" as
911 * a failure and unmap again.
913 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
);
914 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
915 PROT_READ
|PROT_WRITE
,
916 MAP_ANON
|MAP_PRIVATE
, 0, 0));
918 if (mapped_addr
== brk_page
) {
919 /* Heap contents are initialized to zero, as for anonymous
920 * mapped pages. Technically the new pages are already
921 * initialized to zero since they *are* anonymous mapped
922 * pages, however we have to take care with the contents that
923 * come from the remaining part of the previous page: it may
924 * contains garbage data due to a previous heap usage (grown
926 memset(g2h(target_brk
), 0, brk_page
- target_brk
);
928 target_brk
= new_brk
;
929 brk_page
= HOST_PAGE_ALIGN(target_brk
);
930 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr == brk_page)\n",
933 } else if (mapped_addr
!= -1) {
934 /* Mapped but at wrong address, meaning there wasn't actually
935 * enough space for this brk.
937 target_munmap(mapped_addr
, new_alloc_size
);
939 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr != -1)\n", target_brk
);
942 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (otherwise)\n", target_brk
);
945 #if defined(TARGET_ALPHA)
946 /* We (partially) emulate OSF/1 on Alpha, which requires we
947 return a proper errno, not an unchanged brk value. */
948 return -TARGET_ENOMEM
;
950 /* For everything else, return the previous break. */
954 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
955 abi_ulong target_fds_addr
,
959 abi_ulong b
, *target_fds
;
961 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
962 if (!(target_fds
= lock_user(VERIFY_READ
,
964 sizeof(abi_ulong
) * nw
,
966 return -TARGET_EFAULT
;
970 for (i
= 0; i
< nw
; i
++) {
971 /* grab the abi_ulong */
972 __get_user(b
, &target_fds
[i
]);
973 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
974 /* check the bit inside the abi_ulong */
981 unlock_user(target_fds
, target_fds_addr
, 0);
986 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
987 abi_ulong target_fds_addr
,
990 if (target_fds_addr
) {
991 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
992 return -TARGET_EFAULT
;
1000 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
1006 abi_ulong
*target_fds
;
1008 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
1009 if (!(target_fds
= lock_user(VERIFY_WRITE
,
1011 sizeof(abi_ulong
) * nw
,
1013 return -TARGET_EFAULT
;
1016 for (i
= 0; i
< nw
; i
++) {
1018 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1019 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
1022 __put_user(v
, &target_fds
[i
]);
1025 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
1030 #if defined(__alpha__)
1031 #define HOST_HZ 1024
1036 static inline abi_long
host_to_target_clock_t(long ticks
)
1038 #if HOST_HZ == TARGET_HZ
1041 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
1045 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
1046 const struct rusage
*rusage
)
1048 struct target_rusage
*target_rusage
;
1050 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
1051 return -TARGET_EFAULT
;
1052 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
1053 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
1054 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
1055 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
1056 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
1057 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
1058 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
1059 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
1060 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
1061 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
1062 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
1063 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
1064 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
1065 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
1066 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
1067 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
1068 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
1069 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
1070 unlock_user_struct(target_rusage
, target_addr
, 1);
1075 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
1077 abi_ulong target_rlim_swap
;
1080 target_rlim_swap
= tswapal(target_rlim
);
1081 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
1082 return RLIM_INFINITY
;
1084 result
= target_rlim_swap
;
1085 if (target_rlim_swap
!= (rlim_t
)result
)
1086 return RLIM_INFINITY
;
1091 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
1093 abi_ulong target_rlim_swap
;
1096 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
1097 target_rlim_swap
= TARGET_RLIM_INFINITY
;
1099 target_rlim_swap
= rlim
;
1100 result
= tswapal(target_rlim_swap
);
1105 static inline int target_to_host_resource(int code
)
1108 case TARGET_RLIMIT_AS
:
1110 case TARGET_RLIMIT_CORE
:
1112 case TARGET_RLIMIT_CPU
:
1114 case TARGET_RLIMIT_DATA
:
1116 case TARGET_RLIMIT_FSIZE
:
1117 return RLIMIT_FSIZE
;
1118 case TARGET_RLIMIT_LOCKS
:
1119 return RLIMIT_LOCKS
;
1120 case TARGET_RLIMIT_MEMLOCK
:
1121 return RLIMIT_MEMLOCK
;
1122 case TARGET_RLIMIT_MSGQUEUE
:
1123 return RLIMIT_MSGQUEUE
;
1124 case TARGET_RLIMIT_NICE
:
1126 case TARGET_RLIMIT_NOFILE
:
1127 return RLIMIT_NOFILE
;
1128 case TARGET_RLIMIT_NPROC
:
1129 return RLIMIT_NPROC
;
1130 case TARGET_RLIMIT_RSS
:
1132 case TARGET_RLIMIT_RTPRIO
:
1133 return RLIMIT_RTPRIO
;
1134 case TARGET_RLIMIT_SIGPENDING
:
1135 return RLIMIT_SIGPENDING
;
1136 case TARGET_RLIMIT_STACK
:
1137 return RLIMIT_STACK
;
1143 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
1144 abi_ulong target_tv_addr
)
1146 struct target_timeval
*target_tv
;
1148 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
1149 return -TARGET_EFAULT
;
1151 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1152 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1154 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1159 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
1160 const struct timeval
*tv
)
1162 struct target_timeval
*target_tv
;
1164 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
1165 return -TARGET_EFAULT
;
1167 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1168 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1170 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1175 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
1176 abi_ulong target_tz_addr
)
1178 struct target_timezone
*target_tz
;
1180 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
1181 return -TARGET_EFAULT
;
1184 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1185 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1187 unlock_user_struct(target_tz
, target_tz_addr
, 0);
1192 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1195 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
1196 abi_ulong target_mq_attr_addr
)
1198 struct target_mq_attr
*target_mq_attr
;
1200 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
1201 target_mq_attr_addr
, 1))
1202 return -TARGET_EFAULT
;
1204 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1205 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1206 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1207 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1209 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
1214 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
1215 const struct mq_attr
*attr
)
1217 struct target_mq_attr
*target_mq_attr
;
1219 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
1220 target_mq_attr_addr
, 0))
1221 return -TARGET_EFAULT
;
1223 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1224 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1225 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1226 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1228 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1234 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1235 /* do_select() must return target values and target errnos. */
1236 static abi_long
do_select(int n
,
1237 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1238 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1240 fd_set rfds
, wfds
, efds
;
1241 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1243 struct timespec ts
, *ts_ptr
;
1246 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1250 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1254 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1259 if (target_tv_addr
) {
1260 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1261 return -TARGET_EFAULT
;
1262 ts
.tv_sec
= tv
.tv_sec
;
1263 ts
.tv_nsec
= tv
.tv_usec
* 1000;
1269 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1272 if (!is_error(ret
)) {
1273 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1274 return -TARGET_EFAULT
;
1275 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1276 return -TARGET_EFAULT
;
1277 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1278 return -TARGET_EFAULT
;
1280 if (target_tv_addr
) {
1281 tv
.tv_sec
= ts
.tv_sec
;
1282 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
1283 if (copy_to_user_timeval(target_tv_addr
, &tv
)) {
1284 return -TARGET_EFAULT
;
1292 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1293 static abi_long
do_old_select(abi_ulong arg1
)
1295 struct target_sel_arg_struct
*sel
;
1296 abi_ulong inp
, outp
, exp
, tvp
;
1299 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1)) {
1300 return -TARGET_EFAULT
;
1303 nsel
= tswapal(sel
->n
);
1304 inp
= tswapal(sel
->inp
);
1305 outp
= tswapal(sel
->outp
);
1306 exp
= tswapal(sel
->exp
);
1307 tvp
= tswapal(sel
->tvp
);
1309 unlock_user_struct(sel
, arg1
, 0);
1311 return do_select(nsel
, inp
, outp
, exp
, tvp
);
1316 static abi_long
do_pipe2(int host_pipe
[], int flags
)
1319 return pipe2(host_pipe
, flags
);
1325 static abi_long
do_pipe(void *cpu_env
, abi_ulong pipedes
,
1326 int flags
, int is_pipe2
)
1330 ret
= flags
? do_pipe2(host_pipe
, flags
) : pipe(host_pipe
);
1333 return get_errno(ret
);
1335 /* Several targets have special calling conventions for the original
1336 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1338 #if defined(TARGET_ALPHA)
1339 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = host_pipe
[1];
1340 return host_pipe
[0];
1341 #elif defined(TARGET_MIPS)
1342 ((CPUMIPSState
*)cpu_env
)->active_tc
.gpr
[3] = host_pipe
[1];
1343 return host_pipe
[0];
1344 #elif defined(TARGET_SH4)
1345 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
1346 return host_pipe
[0];
1347 #elif defined(TARGET_SPARC)
1348 ((CPUSPARCState
*)cpu_env
)->regwptr
[1] = host_pipe
[1];
1349 return host_pipe
[0];
1353 if (put_user_s32(host_pipe
[0], pipedes
)
1354 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(host_pipe
[0])))
1355 return -TARGET_EFAULT
;
1356 return get_errno(ret
);
1359 static inline abi_long
target_to_host_ip_mreq(struct ip_mreqn
*mreqn
,
1360 abi_ulong target_addr
,
1363 struct target_ip_mreqn
*target_smreqn
;
1365 target_smreqn
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1367 return -TARGET_EFAULT
;
1368 mreqn
->imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
1369 mreqn
->imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
1370 if (len
== sizeof(struct target_ip_mreqn
))
1371 mreqn
->imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
1372 unlock_user(target_smreqn
, target_addr
, 0);
1377 static inline abi_long
target_to_host_sockaddr(int fd
, struct sockaddr
*addr
,
1378 abi_ulong target_addr
,
1381 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1382 sa_family_t sa_family
;
1383 struct target_sockaddr
*target_saddr
;
1385 if (fd_trans_target_to_host_addr(fd
)) {
1386 return fd_trans_target_to_host_addr(fd
)(addr
, target_addr
, len
);
1389 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1391 return -TARGET_EFAULT
;
1393 sa_family
= tswap16(target_saddr
->sa_family
);
1395 /* Oops. The caller might send a incomplete sun_path; sun_path
1396 * must be terminated by \0 (see the manual page), but
1397 * unfortunately it is quite common to specify sockaddr_un
1398 * length as "strlen(x->sun_path)" while it should be
1399 * "strlen(...) + 1". We'll fix that here if needed.
1400 * Linux kernel has a similar feature.
1403 if (sa_family
== AF_UNIX
) {
1404 if (len
< unix_maxlen
&& len
> 0) {
1405 char *cp
= (char*)target_saddr
;
1407 if ( cp
[len
-1] && !cp
[len
] )
1410 if (len
> unix_maxlen
)
1414 memcpy(addr
, target_saddr
, len
);
1415 addr
->sa_family
= sa_family
;
1416 if (sa_family
== AF_NETLINK
) {
1417 struct sockaddr_nl
*nladdr
;
1419 nladdr
= (struct sockaddr_nl
*)addr
;
1420 nladdr
->nl_pid
= tswap32(nladdr
->nl_pid
);
1421 nladdr
->nl_groups
= tswap32(nladdr
->nl_groups
);
1422 } else if (sa_family
== AF_PACKET
) {
1423 struct target_sockaddr_ll
*lladdr
;
1425 lladdr
= (struct target_sockaddr_ll
*)addr
;
1426 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1427 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1429 unlock_user(target_saddr
, target_addr
, 0);
1434 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1435 struct sockaddr
*addr
,
1438 struct target_sockaddr
*target_saddr
;
1445 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1447 return -TARGET_EFAULT
;
1448 memcpy(target_saddr
, addr
, len
);
1449 if (len
>= offsetof(struct target_sockaddr
, sa_family
) +
1450 sizeof(target_saddr
->sa_family
)) {
1451 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1453 if (addr
->sa_family
== AF_NETLINK
&& len
>= sizeof(struct sockaddr_nl
)) {
1454 struct sockaddr_nl
*target_nl
= (struct sockaddr_nl
*)target_saddr
;
1455 target_nl
->nl_pid
= tswap32(target_nl
->nl_pid
);
1456 target_nl
->nl_groups
= tswap32(target_nl
->nl_groups
);
1457 } else if (addr
->sa_family
== AF_PACKET
) {
1458 struct sockaddr_ll
*target_ll
= (struct sockaddr_ll
*)target_saddr
;
1459 target_ll
->sll_ifindex
= tswap32(target_ll
->sll_ifindex
);
1460 target_ll
->sll_hatype
= tswap16(target_ll
->sll_hatype
);
1461 } else if (addr
->sa_family
== AF_INET6
&&
1462 len
>= sizeof(struct target_sockaddr_in6
)) {
1463 struct target_sockaddr_in6
*target_in6
=
1464 (struct target_sockaddr_in6
*)target_saddr
;
1465 target_in6
->sin6_scope_id
= tswap16(target_in6
->sin6_scope_id
);
1467 unlock_user(target_saddr
, target_addr
, len
);
1472 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1473 struct target_msghdr
*target_msgh
)
1475 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1476 abi_long msg_controllen
;
1477 abi_ulong target_cmsg_addr
;
1478 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1479 socklen_t space
= 0;
1481 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1482 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1484 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1485 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1486 target_cmsg_start
= target_cmsg
;
1488 return -TARGET_EFAULT
;
1490 while (cmsg
&& target_cmsg
) {
1491 void *data
= CMSG_DATA(cmsg
);
1492 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1494 int len
= tswapal(target_cmsg
->cmsg_len
)
1495 - sizeof(struct target_cmsghdr
);
1497 space
+= CMSG_SPACE(len
);
1498 if (space
> msgh
->msg_controllen
) {
1499 space
-= CMSG_SPACE(len
);
1500 /* This is a QEMU bug, since we allocated the payload
1501 * area ourselves (unlike overflow in host-to-target
1502 * conversion, which is just the guest giving us a buffer
1503 * that's too small). It can't happen for the payload types
1504 * we currently support; if it becomes an issue in future
1505 * we would need to improve our allocation strategy to
1506 * something more intelligent than "twice the size of the
1507 * target buffer we're reading from".
1509 gemu_log("Host cmsg overflow\n");
1513 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1514 cmsg
->cmsg_level
= SOL_SOCKET
;
1516 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1518 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1519 cmsg
->cmsg_len
= CMSG_LEN(len
);
1521 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1522 int *fd
= (int *)data
;
1523 int *target_fd
= (int *)target_data
;
1524 int i
, numfds
= len
/ sizeof(int);
1526 for (i
= 0; i
< numfds
; i
++) {
1527 __get_user(fd
[i
], target_fd
+ i
);
1529 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1530 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1531 struct ucred
*cred
= (struct ucred
*)data
;
1532 struct target_ucred
*target_cred
=
1533 (struct target_ucred
*)target_data
;
1535 __get_user(cred
->pid
, &target_cred
->pid
);
1536 __get_user(cred
->uid
, &target_cred
->uid
);
1537 __get_user(cred
->gid
, &target_cred
->gid
);
1539 gemu_log("Unsupported ancillary data: %d/%d\n",
1540 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1541 memcpy(data
, target_data
, len
);
1544 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1545 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1548 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1550 msgh
->msg_controllen
= space
;
1554 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1555 struct msghdr
*msgh
)
1557 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1558 abi_long msg_controllen
;
1559 abi_ulong target_cmsg_addr
;
1560 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1561 socklen_t space
= 0;
1563 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1564 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1566 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1567 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1568 target_cmsg_start
= target_cmsg
;
1570 return -TARGET_EFAULT
;
1572 while (cmsg
&& target_cmsg
) {
1573 void *data
= CMSG_DATA(cmsg
);
1574 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1576 int len
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1577 int tgt_len
, tgt_space
;
1579 /* We never copy a half-header but may copy half-data;
1580 * this is Linux's behaviour in put_cmsg(). Note that
1581 * truncation here is a guest problem (which we report
1582 * to the guest via the CTRUNC bit), unlike truncation
1583 * in target_to_host_cmsg, which is a QEMU bug.
1585 if (msg_controllen
< sizeof(struct target_cmsghdr
)) {
1586 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1590 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1591 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1593 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1595 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1597 /* Payload types which need a different size of payload on
1598 * the target must adjust tgt_len here.
1601 switch (cmsg
->cmsg_level
) {
1603 switch (cmsg
->cmsg_type
) {
1605 tgt_len
= sizeof(struct target_timeval
);
1615 if (msg_controllen
< TARGET_CMSG_LEN(tgt_len
)) {
1616 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1617 tgt_len
= msg_controllen
- sizeof(struct target_cmsghdr
);
1620 /* We must now copy-and-convert len bytes of payload
1621 * into tgt_len bytes of destination space. Bear in mind
1622 * that in both source and destination we may be dealing
1623 * with a truncated value!
1625 switch (cmsg
->cmsg_level
) {
1627 switch (cmsg
->cmsg_type
) {
1630 int *fd
= (int *)data
;
1631 int *target_fd
= (int *)target_data
;
1632 int i
, numfds
= tgt_len
/ sizeof(int);
1634 for (i
= 0; i
< numfds
; i
++) {
1635 __put_user(fd
[i
], target_fd
+ i
);
1641 struct timeval
*tv
= (struct timeval
*)data
;
1642 struct target_timeval
*target_tv
=
1643 (struct target_timeval
*)target_data
;
1645 if (len
!= sizeof(struct timeval
) ||
1646 tgt_len
!= sizeof(struct target_timeval
)) {
1650 /* copy struct timeval to target */
1651 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1652 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1655 case SCM_CREDENTIALS
:
1657 struct ucred
*cred
= (struct ucred
*)data
;
1658 struct target_ucred
*target_cred
=
1659 (struct target_ucred
*)target_data
;
1661 __put_user(cred
->pid
, &target_cred
->pid
);
1662 __put_user(cred
->uid
, &target_cred
->uid
);
1663 __put_user(cred
->gid
, &target_cred
->gid
);
1672 switch (cmsg
->cmsg_type
) {
1675 uint32_t *v
= (uint32_t *)data
;
1676 uint32_t *t_int
= (uint32_t *)target_data
;
1678 if (len
!= sizeof(uint32_t) ||
1679 tgt_len
!= sizeof(uint32_t)) {
1682 __put_user(*v
, t_int
);
1688 struct sock_extended_err ee
;
1689 struct sockaddr_in offender
;
1691 struct errhdr_t
*errh
= (struct errhdr_t
*)data
;
1692 struct errhdr_t
*target_errh
=
1693 (struct errhdr_t
*)target_data
;
1695 if (len
!= sizeof(struct errhdr_t
) ||
1696 tgt_len
!= sizeof(struct errhdr_t
)) {
1699 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1700 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1701 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1702 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1703 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1704 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1705 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1706 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1707 (void *) &errh
->offender
, sizeof(errh
->offender
));
1716 switch (cmsg
->cmsg_type
) {
1719 uint32_t *v
= (uint32_t *)data
;
1720 uint32_t *t_int
= (uint32_t *)target_data
;
1722 if (len
!= sizeof(uint32_t) ||
1723 tgt_len
!= sizeof(uint32_t)) {
1726 __put_user(*v
, t_int
);
1732 struct sock_extended_err ee
;
1733 struct sockaddr_in6 offender
;
1735 struct errhdr6_t
*errh
= (struct errhdr6_t
*)data
;
1736 struct errhdr6_t
*target_errh
=
1737 (struct errhdr6_t
*)target_data
;
1739 if (len
!= sizeof(struct errhdr6_t
) ||
1740 tgt_len
!= sizeof(struct errhdr6_t
)) {
1743 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1744 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1745 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1746 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1747 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1748 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1749 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1750 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1751 (void *) &errh
->offender
, sizeof(errh
->offender
));
1761 gemu_log("Unsupported ancillary data: %d/%d\n",
1762 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1763 memcpy(target_data
, data
, MIN(len
, tgt_len
));
1764 if (tgt_len
> len
) {
1765 memset(target_data
+ len
, 0, tgt_len
- len
);
1769 target_cmsg
->cmsg_len
= tswapal(TARGET_CMSG_LEN(tgt_len
));
1770 tgt_space
= TARGET_CMSG_SPACE(tgt_len
);
1771 if (msg_controllen
< tgt_space
) {
1772 tgt_space
= msg_controllen
;
1774 msg_controllen
-= tgt_space
;
1776 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1777 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1780 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
1782 target_msgh
->msg_controllen
= tswapal(space
);
1786 /* do_setsockopt() Must return target values and target errnos. */
1787 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
1788 abi_ulong optval_addr
, socklen_t optlen
)
1792 struct ip_mreqn
*ip_mreq
;
1793 struct ip_mreq_source
*ip_mreq_source
;
1797 /* TCP options all take an 'int' value. */
1798 if (optlen
< sizeof(uint32_t))
1799 return -TARGET_EINVAL
;
1801 if (get_user_u32(val
, optval_addr
))
1802 return -TARGET_EFAULT
;
1803 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1810 case IP_ROUTER_ALERT
:
1814 case IP_MTU_DISCOVER
:
1821 case IP_MULTICAST_TTL
:
1822 case IP_MULTICAST_LOOP
:
1824 if (optlen
>= sizeof(uint32_t)) {
1825 if (get_user_u32(val
, optval_addr
))
1826 return -TARGET_EFAULT
;
1827 } else if (optlen
>= 1) {
1828 if (get_user_u8(val
, optval_addr
))
1829 return -TARGET_EFAULT
;
1831 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1833 case IP_ADD_MEMBERSHIP
:
1834 case IP_DROP_MEMBERSHIP
:
1835 if (optlen
< sizeof (struct target_ip_mreq
) ||
1836 optlen
> sizeof (struct target_ip_mreqn
))
1837 return -TARGET_EINVAL
;
1839 ip_mreq
= (struct ip_mreqn
*) alloca(optlen
);
1840 target_to_host_ip_mreq(ip_mreq
, optval_addr
, optlen
);
1841 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq
, optlen
));
1844 case IP_BLOCK_SOURCE
:
1845 case IP_UNBLOCK_SOURCE
:
1846 case IP_ADD_SOURCE_MEMBERSHIP
:
1847 case IP_DROP_SOURCE_MEMBERSHIP
:
1848 if (optlen
!= sizeof (struct target_ip_mreq_source
))
1849 return -TARGET_EINVAL
;
1851 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
1852 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
1853 unlock_user (ip_mreq_source
, optval_addr
, 0);
1862 case IPV6_MTU_DISCOVER
:
1865 case IPV6_RECVPKTINFO
:
1866 case IPV6_UNICAST_HOPS
:
1867 case IPV6_MULTICAST_HOPS
:
1868 case IPV6_MULTICAST_LOOP
:
1870 case IPV6_RECVHOPLIMIT
:
1871 case IPV6_2292HOPLIMIT
:
1874 case IPV6_2292PKTINFO
:
1875 case IPV6_RECVTCLASS
:
1876 case IPV6_RECVRTHDR
:
1877 case IPV6_2292RTHDR
:
1878 case IPV6_RECVHOPOPTS
:
1879 case IPV6_2292HOPOPTS
:
1880 case IPV6_RECVDSTOPTS
:
1881 case IPV6_2292DSTOPTS
:
1883 #ifdef IPV6_RECVPATHMTU
1884 case IPV6_RECVPATHMTU
:
1886 #ifdef IPV6_TRANSPARENT
1887 case IPV6_TRANSPARENT
:
1889 #ifdef IPV6_FREEBIND
1892 #ifdef IPV6_RECVORIGDSTADDR
1893 case IPV6_RECVORIGDSTADDR
:
1896 if (optlen
< sizeof(uint32_t)) {
1897 return -TARGET_EINVAL
;
1899 if (get_user_u32(val
, optval_addr
)) {
1900 return -TARGET_EFAULT
;
1902 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1903 &val
, sizeof(val
)));
1907 struct in6_pktinfo pki
;
1909 if (optlen
< sizeof(pki
)) {
1910 return -TARGET_EINVAL
;
1913 if (copy_from_user(&pki
, optval_addr
, sizeof(pki
))) {
1914 return -TARGET_EFAULT
;
1917 pki
.ipi6_ifindex
= tswap32(pki
.ipi6_ifindex
);
1919 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1920 &pki
, sizeof(pki
)));
1931 struct icmp6_filter icmp6f
;
1933 if (optlen
> sizeof(icmp6f
)) {
1934 optlen
= sizeof(icmp6f
);
1937 if (copy_from_user(&icmp6f
, optval_addr
, optlen
)) {
1938 return -TARGET_EFAULT
;
1941 for (val
= 0; val
< 8; val
++) {
1942 icmp6f
.data
[val
] = tswap32(icmp6f
.data
[val
]);
1945 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1957 /* those take an u32 value */
1958 if (optlen
< sizeof(uint32_t)) {
1959 return -TARGET_EINVAL
;
1962 if (get_user_u32(val
, optval_addr
)) {
1963 return -TARGET_EFAULT
;
1965 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1966 &val
, sizeof(val
)));
1973 case TARGET_SOL_SOCKET
:
1975 case TARGET_SO_RCVTIMEO
:
1979 optname
= SO_RCVTIMEO
;
1982 if (optlen
!= sizeof(struct target_timeval
)) {
1983 return -TARGET_EINVAL
;
1986 if (copy_from_user_timeval(&tv
, optval_addr
)) {
1987 return -TARGET_EFAULT
;
1990 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
1994 case TARGET_SO_SNDTIMEO
:
1995 optname
= SO_SNDTIMEO
;
1997 case TARGET_SO_ATTACH_FILTER
:
1999 struct target_sock_fprog
*tfprog
;
2000 struct target_sock_filter
*tfilter
;
2001 struct sock_fprog fprog
;
2002 struct sock_filter
*filter
;
2005 if (optlen
!= sizeof(*tfprog
)) {
2006 return -TARGET_EINVAL
;
2008 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
2009 return -TARGET_EFAULT
;
2011 if (!lock_user_struct(VERIFY_READ
, tfilter
,
2012 tswapal(tfprog
->filter
), 0)) {
2013 unlock_user_struct(tfprog
, optval_addr
, 1);
2014 return -TARGET_EFAULT
;
2017 fprog
.len
= tswap16(tfprog
->len
);
2018 filter
= g_try_new(struct sock_filter
, fprog
.len
);
2019 if (filter
== NULL
) {
2020 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2021 unlock_user_struct(tfprog
, optval_addr
, 1);
2022 return -TARGET_ENOMEM
;
2024 for (i
= 0; i
< fprog
.len
; i
++) {
2025 filter
[i
].code
= tswap16(tfilter
[i
].code
);
2026 filter
[i
].jt
= tfilter
[i
].jt
;
2027 filter
[i
].jf
= tfilter
[i
].jf
;
2028 filter
[i
].k
= tswap32(tfilter
[i
].k
);
2030 fprog
.filter
= filter
;
2032 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
2033 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
2036 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
2037 unlock_user_struct(tfprog
, optval_addr
, 1);
2040 case TARGET_SO_BINDTODEVICE
:
2042 char *dev_ifname
, *addr_ifname
;
2044 if (optlen
> IFNAMSIZ
- 1) {
2045 optlen
= IFNAMSIZ
- 1;
2047 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2049 return -TARGET_EFAULT
;
2051 optname
= SO_BINDTODEVICE
;
2052 addr_ifname
= alloca(IFNAMSIZ
);
2053 memcpy(addr_ifname
, dev_ifname
, optlen
);
2054 addr_ifname
[optlen
] = 0;
2055 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
2056 addr_ifname
, optlen
));
2057 unlock_user (dev_ifname
, optval_addr
, 0);
2060 case TARGET_SO_LINGER
:
2063 struct target_linger
*tlg
;
2065 if (optlen
!= sizeof(struct target_linger
)) {
2066 return -TARGET_EINVAL
;
2068 if (!lock_user_struct(VERIFY_READ
, tlg
, optval_addr
, 1)) {
2069 return -TARGET_EFAULT
;
2071 __get_user(lg
.l_onoff
, &tlg
->l_onoff
);
2072 __get_user(lg
.l_linger
, &tlg
->l_linger
);
2073 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, SO_LINGER
,
2075 unlock_user_struct(tlg
, optval_addr
, 0);
2078 /* Options with 'int' argument. */
2079 case TARGET_SO_DEBUG
:
2082 case TARGET_SO_REUSEADDR
:
2083 optname
= SO_REUSEADDR
;
2086 case TARGET_SO_REUSEPORT
:
2087 optname
= SO_REUSEPORT
;
2090 case TARGET_SO_TYPE
:
2093 case TARGET_SO_ERROR
:
2096 case TARGET_SO_DONTROUTE
:
2097 optname
= SO_DONTROUTE
;
2099 case TARGET_SO_BROADCAST
:
2100 optname
= SO_BROADCAST
;
2102 case TARGET_SO_SNDBUF
:
2103 optname
= SO_SNDBUF
;
2105 case TARGET_SO_SNDBUFFORCE
:
2106 optname
= SO_SNDBUFFORCE
;
2108 case TARGET_SO_RCVBUF
:
2109 optname
= SO_RCVBUF
;
2111 case TARGET_SO_RCVBUFFORCE
:
2112 optname
= SO_RCVBUFFORCE
;
2114 case TARGET_SO_KEEPALIVE
:
2115 optname
= SO_KEEPALIVE
;
2117 case TARGET_SO_OOBINLINE
:
2118 optname
= SO_OOBINLINE
;
2120 case TARGET_SO_NO_CHECK
:
2121 optname
= SO_NO_CHECK
;
2123 case TARGET_SO_PRIORITY
:
2124 optname
= SO_PRIORITY
;
2127 case TARGET_SO_BSDCOMPAT
:
2128 optname
= SO_BSDCOMPAT
;
2131 case TARGET_SO_PASSCRED
:
2132 optname
= SO_PASSCRED
;
2134 case TARGET_SO_PASSSEC
:
2135 optname
= SO_PASSSEC
;
2137 case TARGET_SO_TIMESTAMP
:
2138 optname
= SO_TIMESTAMP
;
2140 case TARGET_SO_RCVLOWAT
:
2141 optname
= SO_RCVLOWAT
;
2146 if (optlen
< sizeof(uint32_t))
2147 return -TARGET_EINVAL
;
2149 if (get_user_u32(val
, optval_addr
))
2150 return -TARGET_EFAULT
;
2151 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
2155 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level
, optname
);
2156 ret
= -TARGET_ENOPROTOOPT
;
2161 /* do_getsockopt() Must return target values and target errnos. */
2162 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
2163 abi_ulong optval_addr
, abi_ulong optlen
)
2170 case TARGET_SOL_SOCKET
:
2173 /* These don't just return a single integer */
2174 case TARGET_SO_RCVTIMEO
:
2175 case TARGET_SO_SNDTIMEO
:
2176 case TARGET_SO_PEERNAME
:
2178 case TARGET_SO_PEERCRED
: {
2181 struct target_ucred
*tcr
;
2183 if (get_user_u32(len
, optlen
)) {
2184 return -TARGET_EFAULT
;
2187 return -TARGET_EINVAL
;
2191 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
2199 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
2200 return -TARGET_EFAULT
;
2202 __put_user(cr
.pid
, &tcr
->pid
);
2203 __put_user(cr
.uid
, &tcr
->uid
);
2204 __put_user(cr
.gid
, &tcr
->gid
);
2205 unlock_user_struct(tcr
, optval_addr
, 1);
2206 if (put_user_u32(len
, optlen
)) {
2207 return -TARGET_EFAULT
;
2211 case TARGET_SO_LINGER
:
2215 struct target_linger
*tlg
;
2217 if (get_user_u32(len
, optlen
)) {
2218 return -TARGET_EFAULT
;
2221 return -TARGET_EINVAL
;
2225 ret
= get_errno(getsockopt(sockfd
, level
, SO_LINGER
,
2233 if (!lock_user_struct(VERIFY_WRITE
, tlg
, optval_addr
, 0)) {
2234 return -TARGET_EFAULT
;
2236 __put_user(lg
.l_onoff
, &tlg
->l_onoff
);
2237 __put_user(lg
.l_linger
, &tlg
->l_linger
);
2238 unlock_user_struct(tlg
, optval_addr
, 1);
2239 if (put_user_u32(len
, optlen
)) {
2240 return -TARGET_EFAULT
;
2244 /* Options with 'int' argument. */
2245 case TARGET_SO_DEBUG
:
2248 case TARGET_SO_REUSEADDR
:
2249 optname
= SO_REUSEADDR
;
2252 case TARGET_SO_REUSEPORT
:
2253 optname
= SO_REUSEPORT
;
2256 case TARGET_SO_TYPE
:
2259 case TARGET_SO_ERROR
:
2262 case TARGET_SO_DONTROUTE
:
2263 optname
= SO_DONTROUTE
;
2265 case TARGET_SO_BROADCAST
:
2266 optname
= SO_BROADCAST
;
2268 case TARGET_SO_SNDBUF
:
2269 optname
= SO_SNDBUF
;
2271 case TARGET_SO_RCVBUF
:
2272 optname
= SO_RCVBUF
;
2274 case TARGET_SO_KEEPALIVE
:
2275 optname
= SO_KEEPALIVE
;
2277 case TARGET_SO_OOBINLINE
:
2278 optname
= SO_OOBINLINE
;
2280 case TARGET_SO_NO_CHECK
:
2281 optname
= SO_NO_CHECK
;
2283 case TARGET_SO_PRIORITY
:
2284 optname
= SO_PRIORITY
;
2287 case TARGET_SO_BSDCOMPAT
:
2288 optname
= SO_BSDCOMPAT
;
2291 case TARGET_SO_PASSCRED
:
2292 optname
= SO_PASSCRED
;
2294 case TARGET_SO_TIMESTAMP
:
2295 optname
= SO_TIMESTAMP
;
2297 case TARGET_SO_RCVLOWAT
:
2298 optname
= SO_RCVLOWAT
;
2300 case TARGET_SO_ACCEPTCONN
:
2301 optname
= SO_ACCEPTCONN
;
2308 /* TCP options all take an 'int' value. */
2310 if (get_user_u32(len
, optlen
))
2311 return -TARGET_EFAULT
;
2313 return -TARGET_EINVAL
;
2315 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2318 if (optname
== SO_TYPE
) {
2319 val
= host_to_target_sock_type(val
);
2324 if (put_user_u32(val
, optval_addr
))
2325 return -TARGET_EFAULT
;
2327 if (put_user_u8(val
, optval_addr
))
2328 return -TARGET_EFAULT
;
2330 if (put_user_u32(len
, optlen
))
2331 return -TARGET_EFAULT
;
2338 case IP_ROUTER_ALERT
:
2342 case IP_MTU_DISCOVER
:
2348 case IP_MULTICAST_TTL
:
2349 case IP_MULTICAST_LOOP
:
2350 if (get_user_u32(len
, optlen
))
2351 return -TARGET_EFAULT
;
2353 return -TARGET_EINVAL
;
2355 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2358 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2360 if (put_user_u32(len
, optlen
)
2361 || put_user_u8(val
, optval_addr
))
2362 return -TARGET_EFAULT
;
2364 if (len
> sizeof(int))
2366 if (put_user_u32(len
, optlen
)
2367 || put_user_u32(val
, optval_addr
))
2368 return -TARGET_EFAULT
;
2372 ret
= -TARGET_ENOPROTOOPT
;
2378 case IPV6_MTU_DISCOVER
:
2381 case IPV6_RECVPKTINFO
:
2382 case IPV6_UNICAST_HOPS
:
2383 case IPV6_MULTICAST_HOPS
:
2384 case IPV6_MULTICAST_LOOP
:
2386 case IPV6_RECVHOPLIMIT
:
2387 case IPV6_2292HOPLIMIT
:
2390 case IPV6_2292PKTINFO
:
2391 case IPV6_RECVTCLASS
:
2392 case IPV6_RECVRTHDR
:
2393 case IPV6_2292RTHDR
:
2394 case IPV6_RECVHOPOPTS
:
2395 case IPV6_2292HOPOPTS
:
2396 case IPV6_RECVDSTOPTS
:
2397 case IPV6_2292DSTOPTS
:
2399 #ifdef IPV6_RECVPATHMTU
2400 case IPV6_RECVPATHMTU
:
2402 #ifdef IPV6_TRANSPARENT
2403 case IPV6_TRANSPARENT
:
2405 #ifdef IPV6_FREEBIND
2408 #ifdef IPV6_RECVORIGDSTADDR
2409 case IPV6_RECVORIGDSTADDR
:
2411 if (get_user_u32(len
, optlen
))
2412 return -TARGET_EFAULT
;
2414 return -TARGET_EINVAL
;
2416 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
2419 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
2421 if (put_user_u32(len
, optlen
)
2422 || put_user_u8(val
, optval_addr
))
2423 return -TARGET_EFAULT
;
2425 if (len
> sizeof(int))
2427 if (put_user_u32(len
, optlen
)
2428 || put_user_u32(val
, optval_addr
))
2429 return -TARGET_EFAULT
;
2433 ret
= -TARGET_ENOPROTOOPT
;
2439 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
2441 ret
= -TARGET_EOPNOTSUPP
;
2447 /* Convert target low/high pair representing file offset into the host
2448 * low/high pair. This function doesn't handle offsets bigger than 64 bits
2449 * as the kernel doesn't handle them either.
2451 static void target_to_host_low_high(abi_ulong tlow
,
2453 unsigned long *hlow
,
2454 unsigned long *hhigh
)
2456 uint64_t off
= tlow
|
2457 ((unsigned long long)thigh
<< TARGET_LONG_BITS
/ 2) <<
2458 TARGET_LONG_BITS
/ 2;
2461 *hhigh
= (off
>> HOST_LONG_BITS
/ 2) >> HOST_LONG_BITS
/ 2;
2464 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
2465 abi_ulong count
, int copy
)
2467 struct target_iovec
*target_vec
;
2469 abi_ulong total_len
, max_len
;
2472 bool bad_address
= false;
2478 if (count
> IOV_MAX
) {
2483 vec
= g_try_new0(struct iovec
, count
);
2489 target_vec
= lock_user(VERIFY_READ
, target_addr
,
2490 count
* sizeof(struct target_iovec
), 1);
2491 if (target_vec
== NULL
) {
2496 /* ??? If host page size > target page size, this will result in a
2497 value larger than what we can actually support. */
2498 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
2501 for (i
= 0; i
< count
; i
++) {
2502 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
2503 abi_long len
= tswapal(target_vec
[i
].iov_len
);
2508 } else if (len
== 0) {
2509 /* Zero length pointer is ignored. */
2510 vec
[i
].iov_base
= 0;
2512 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
2513 /* If the first buffer pointer is bad, this is a fault. But
2514 * subsequent bad buffers will result in a partial write; this
2515 * is realized by filling the vector with null pointers and
2517 if (!vec
[i
].iov_base
) {
2528 if (len
> max_len
- total_len
) {
2529 len
= max_len
- total_len
;
2532 vec
[i
].iov_len
= len
;
2536 unlock_user(target_vec
, target_addr
, 0);
2541 if (tswapal(target_vec
[i
].iov_len
) > 0) {
2542 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
2545 unlock_user(target_vec
, target_addr
, 0);
2552 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
2553 abi_ulong count
, int copy
)
2555 struct target_iovec
*target_vec
;
2558 target_vec
= lock_user(VERIFY_READ
, target_addr
,
2559 count
* sizeof(struct target_iovec
), 1);
2561 for (i
= 0; i
< count
; i
++) {
2562 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
2563 abi_long len
= tswapal(target_vec
[i
].iov_len
);
2567 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
2569 unlock_user(target_vec
, target_addr
, 0);
2575 static inline int target_to_host_sock_type(int *type
)
2578 int target_type
= *type
;
2580 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
2581 case TARGET_SOCK_DGRAM
:
2582 host_type
= SOCK_DGRAM
;
2584 case TARGET_SOCK_STREAM
:
2585 host_type
= SOCK_STREAM
;
2588 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
2591 if (target_type
& TARGET_SOCK_CLOEXEC
) {
2592 #if defined(SOCK_CLOEXEC)
2593 host_type
|= SOCK_CLOEXEC
;
2595 return -TARGET_EINVAL
;
2598 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2599 #if defined(SOCK_NONBLOCK)
2600 host_type
|= SOCK_NONBLOCK
;
2601 #elif !defined(O_NONBLOCK)
2602 return -TARGET_EINVAL
;
2609 /* Try to emulate socket type flags after socket creation. */
2610 static int sock_flags_fixup(int fd
, int target_type
)
2612 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
2613 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2614 int flags
= fcntl(fd
, F_GETFL
);
2615 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
2617 return -TARGET_EINVAL
;
2624 /* do_socket() Must return target values and target errnos. */
2625 static abi_long
do_socket(int domain
, int type
, int protocol
)
2627 int target_type
= type
;
2630 ret
= target_to_host_sock_type(&type
);
2635 if (domain
== PF_NETLINK
&& !(
2636 #ifdef CONFIG_RTNETLINK
2637 protocol
== NETLINK_ROUTE
||
2639 protocol
== NETLINK_KOBJECT_UEVENT
||
2640 protocol
== NETLINK_AUDIT
)) {
2641 return -EPFNOSUPPORT
;
2644 if (domain
== AF_PACKET
||
2645 (domain
== AF_INET
&& type
== SOCK_PACKET
)) {
2646 protocol
= tswap16(protocol
);
2649 ret
= get_errno(socket(domain
, type
, protocol
));
2651 ret
= sock_flags_fixup(ret
, target_type
);
2652 if (type
== SOCK_PACKET
) {
2653 /* Manage an obsolete case :
2654 * if socket type is SOCK_PACKET, bind by name
2656 fd_trans_register(ret
, &target_packet_trans
);
2657 } else if (domain
== PF_NETLINK
) {
2659 #ifdef CONFIG_RTNETLINK
2661 fd_trans_register(ret
, &target_netlink_route_trans
);
2664 case NETLINK_KOBJECT_UEVENT
:
2665 /* nothing to do: messages are strings */
2668 fd_trans_register(ret
, &target_netlink_audit_trans
);
2671 g_assert_not_reached();
2678 /* do_bind() Must return target values and target errnos. */
2679 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
2685 if ((int)addrlen
< 0) {
2686 return -TARGET_EINVAL
;
2689 addr
= alloca(addrlen
+1);
2691 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
2695 return get_errno(bind(sockfd
, addr
, addrlen
));
2698 /* do_connect() Must return target values and target errnos. */
2699 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
2705 if ((int)addrlen
< 0) {
2706 return -TARGET_EINVAL
;
2709 addr
= alloca(addrlen
+1);
2711 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
2715 return get_errno(safe_connect(sockfd
, addr
, addrlen
));
2718 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
2719 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
2720 int flags
, int send
)
2726 abi_ulong target_vec
;
2728 if (msgp
->msg_name
) {
2729 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
2730 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
2731 ret
= target_to_host_sockaddr(fd
, msg
.msg_name
,
2732 tswapal(msgp
->msg_name
),
2734 if (ret
== -TARGET_EFAULT
) {
2735 /* For connected sockets msg_name and msg_namelen must
2736 * be ignored, so returning EFAULT immediately is wrong.
2737 * Instead, pass a bad msg_name to the host kernel, and
2738 * let it decide whether to return EFAULT or not.
2740 msg
.msg_name
= (void *)-1;
2745 msg
.msg_name
= NULL
;
2746 msg
.msg_namelen
= 0;
2748 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
2749 msg
.msg_control
= alloca(msg
.msg_controllen
);
2750 memset(msg
.msg_control
, 0, msg
.msg_controllen
);
2752 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
2754 count
= tswapal(msgp
->msg_iovlen
);
2755 target_vec
= tswapal(msgp
->msg_iov
);
2757 if (count
> IOV_MAX
) {
2758 /* sendrcvmsg returns a different errno for this condition than
2759 * readv/writev, so we must catch it here before lock_iovec() does.
2761 ret
= -TARGET_EMSGSIZE
;
2765 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
2766 target_vec
, count
, send
);
2768 ret
= -host_to_target_errno(errno
);
2771 msg
.msg_iovlen
= count
;
2775 if (fd_trans_target_to_host_data(fd
)) {
2778 host_msg
= g_malloc(msg
.msg_iov
->iov_len
);
2779 memcpy(host_msg
, msg
.msg_iov
->iov_base
, msg
.msg_iov
->iov_len
);
2780 ret
= fd_trans_target_to_host_data(fd
)(host_msg
,
2781 msg
.msg_iov
->iov_len
);
2783 msg
.msg_iov
->iov_base
= host_msg
;
2784 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
2788 ret
= target_to_host_cmsg(&msg
, msgp
);
2790 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
2794 ret
= get_errno(safe_recvmsg(fd
, &msg
, flags
));
2795 if (!is_error(ret
)) {
2797 if (fd_trans_host_to_target_data(fd
)) {
2798 ret
= fd_trans_host_to_target_data(fd
)(msg
.msg_iov
->iov_base
,
2799 MIN(msg
.msg_iov
->iov_len
, len
));
2801 ret
= host_to_target_cmsg(msgp
, &msg
);
2803 if (!is_error(ret
)) {
2804 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
2805 msgp
->msg_flags
= tswap32(msg
.msg_flags
);
2806 if (msg
.msg_name
!= NULL
&& msg
.msg_name
!= (void *)-1) {
2807 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
2808 msg
.msg_name
, msg
.msg_namelen
);
2820 unlock_iovec(vec
, target_vec
, count
, !send
);
2825 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
2826 int flags
, int send
)
2829 struct target_msghdr
*msgp
;
2831 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
2835 return -TARGET_EFAULT
;
2837 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
2838 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
2842 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
2843 * so it might not have this *mmsg-specific flag either.
2845 #ifndef MSG_WAITFORONE
2846 #define MSG_WAITFORONE 0x10000
2849 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
2850 unsigned int vlen
, unsigned int flags
,
2853 struct target_mmsghdr
*mmsgp
;
2857 if (vlen
> UIO_MAXIOV
) {
2861 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
2863 return -TARGET_EFAULT
;
2866 for (i
= 0; i
< vlen
; i
++) {
2867 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
2868 if (is_error(ret
)) {
2871 mmsgp
[i
].msg_len
= tswap32(ret
);
2872 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2873 if (flags
& MSG_WAITFORONE
) {
2874 flags
|= MSG_DONTWAIT
;
2878 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
2880 /* Return number of datagrams sent if we sent any at all;
2881 * otherwise return the error.
2889 /* do_accept4() Must return target values and target errnos. */
2890 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
2891 abi_ulong target_addrlen_addr
, int flags
)
2893 socklen_t addrlen
, ret_addrlen
;
2898 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
2900 if (target_addr
== 0) {
2901 return get_errno(safe_accept4(fd
, NULL
, NULL
, host_flags
));
2904 /* linux returns EINVAL if addrlen pointer is invalid */
2905 if (get_user_u32(addrlen
, target_addrlen_addr
))
2906 return -TARGET_EINVAL
;
2908 if ((int)addrlen
< 0) {
2909 return -TARGET_EINVAL
;
2912 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2913 return -TARGET_EINVAL
;
2915 addr
= alloca(addrlen
);
2917 ret_addrlen
= addrlen
;
2918 ret
= get_errno(safe_accept4(fd
, addr
, &ret_addrlen
, host_flags
));
2919 if (!is_error(ret
)) {
2920 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
2921 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
2922 ret
= -TARGET_EFAULT
;
2928 /* do_getpeername() Must return target values and target errnos. */
2929 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
2930 abi_ulong target_addrlen_addr
)
2932 socklen_t addrlen
, ret_addrlen
;
2936 if (get_user_u32(addrlen
, target_addrlen_addr
))
2937 return -TARGET_EFAULT
;
2939 if ((int)addrlen
< 0) {
2940 return -TARGET_EINVAL
;
2943 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2944 return -TARGET_EFAULT
;
2946 addr
= alloca(addrlen
);
2948 ret_addrlen
= addrlen
;
2949 ret
= get_errno(getpeername(fd
, addr
, &ret_addrlen
));
2950 if (!is_error(ret
)) {
2951 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
2952 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
2953 ret
= -TARGET_EFAULT
;
2959 /* do_getsockname() Must return target values and target errnos. */
2960 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
2961 abi_ulong target_addrlen_addr
)
2963 socklen_t addrlen
, ret_addrlen
;
2967 if (get_user_u32(addrlen
, target_addrlen_addr
))
2968 return -TARGET_EFAULT
;
2970 if ((int)addrlen
< 0) {
2971 return -TARGET_EINVAL
;
2974 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2975 return -TARGET_EFAULT
;
2977 addr
= alloca(addrlen
);
2979 ret_addrlen
= addrlen
;
2980 ret
= get_errno(getsockname(fd
, addr
, &ret_addrlen
));
2981 if (!is_error(ret
)) {
2982 host_to_target_sockaddr(target_addr
, addr
, MIN(addrlen
, ret_addrlen
));
2983 if (put_user_u32(ret_addrlen
, target_addrlen_addr
)) {
2984 ret
= -TARGET_EFAULT
;
2990 /* do_socketpair() Must return target values and target errnos. */
2991 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
2992 abi_ulong target_tab_addr
)
2997 target_to_host_sock_type(&type
);
2999 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
3000 if (!is_error(ret
)) {
3001 if (put_user_s32(tab
[0], target_tab_addr
)
3002 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
3003 ret
= -TARGET_EFAULT
;
3008 /* do_sendto() Must return target values and target errnos. */
3009 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
3010 abi_ulong target_addr
, socklen_t addrlen
)
3014 void *copy_msg
= NULL
;
3017 if ((int)addrlen
< 0) {
3018 return -TARGET_EINVAL
;
3021 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
3023 return -TARGET_EFAULT
;
3024 if (fd_trans_target_to_host_data(fd
)) {
3025 copy_msg
= host_msg
;
3026 host_msg
= g_malloc(len
);
3027 memcpy(host_msg
, copy_msg
, len
);
3028 ret
= fd_trans_target_to_host_data(fd
)(host_msg
, len
);
3034 addr
= alloca(addrlen
+1);
3035 ret
= target_to_host_sockaddr(fd
, addr
, target_addr
, addrlen
);
3039 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
3041 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, NULL
, 0));
3046 host_msg
= copy_msg
;
3048 unlock_user(host_msg
, msg
, 0);
3052 /* do_recvfrom() Must return target values and target errnos. */
3053 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
3054 abi_ulong target_addr
,
3055 abi_ulong target_addrlen
)
3057 socklen_t addrlen
, ret_addrlen
;
3062 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
3064 return -TARGET_EFAULT
;
3066 if (get_user_u32(addrlen
, target_addrlen
)) {
3067 ret
= -TARGET_EFAULT
;
3070 if ((int)addrlen
< 0) {
3071 ret
= -TARGET_EINVAL
;
3074 addr
= alloca(addrlen
);
3075 ret_addrlen
= addrlen
;
3076 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
,
3077 addr
, &ret_addrlen
));
3079 addr
= NULL
; /* To keep compiler quiet. */
3080 addrlen
= 0; /* To keep compiler quiet. */
3081 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
, NULL
, 0));
3083 if (!is_error(ret
)) {
3084 if (fd_trans_host_to_target_data(fd
)) {
3086 trans
= fd_trans_host_to_target_data(fd
)(host_msg
, MIN(ret
, len
));
3087 if (is_error(trans
)) {
3093 host_to_target_sockaddr(target_addr
, addr
,
3094 MIN(addrlen
, ret_addrlen
));
3095 if (put_user_u32(ret_addrlen
, target_addrlen
)) {
3096 ret
= -TARGET_EFAULT
;
3100 unlock_user(host_msg
, msg
, len
);
3103 unlock_user(host_msg
, msg
, 0);
3108 #ifdef TARGET_NR_socketcall
3109 /* do_socketcall() must return target values and target errnos. */
3110 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
3112 static const unsigned nargs
[] = { /* number of arguments per operation */
3113 [TARGET_SYS_SOCKET
] = 3, /* domain, type, protocol */
3114 [TARGET_SYS_BIND
] = 3, /* fd, addr, addrlen */
3115 [TARGET_SYS_CONNECT
] = 3, /* fd, addr, addrlen */
3116 [TARGET_SYS_LISTEN
] = 2, /* fd, backlog */
3117 [TARGET_SYS_ACCEPT
] = 3, /* fd, addr, addrlen */
3118 [TARGET_SYS_GETSOCKNAME
] = 3, /* fd, addr, addrlen */
3119 [TARGET_SYS_GETPEERNAME
] = 3, /* fd, addr, addrlen */
3120 [TARGET_SYS_SOCKETPAIR
] = 4, /* domain, type, protocol, tab */
3121 [TARGET_SYS_SEND
] = 4, /* fd, msg, len, flags */
3122 [TARGET_SYS_RECV
] = 4, /* fd, msg, len, flags */
3123 [TARGET_SYS_SENDTO
] = 6, /* fd, msg, len, flags, addr, addrlen */
3124 [TARGET_SYS_RECVFROM
] = 6, /* fd, msg, len, flags, addr, addrlen */
3125 [TARGET_SYS_SHUTDOWN
] = 2, /* fd, how */
3126 [TARGET_SYS_SETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3127 [TARGET_SYS_GETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
3128 [TARGET_SYS_SENDMSG
] = 3, /* fd, msg, flags */
3129 [TARGET_SYS_RECVMSG
] = 3, /* fd, msg, flags */
3130 [TARGET_SYS_ACCEPT4
] = 4, /* fd, addr, addrlen, flags */
3131 [TARGET_SYS_RECVMMSG
] = 4, /* fd, msgvec, vlen, flags */
3132 [TARGET_SYS_SENDMMSG
] = 4, /* fd, msgvec, vlen, flags */
3134 abi_long a
[6]; /* max 6 args */
3137 /* check the range of the first argument num */
3138 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
3139 if (num
< 1 || num
> TARGET_SYS_SENDMMSG
) {
3140 return -TARGET_EINVAL
;
3142 /* ensure we have space for args */
3143 if (nargs
[num
] > ARRAY_SIZE(a
)) {
3144 return -TARGET_EINVAL
;
3146 /* collect the arguments in a[] according to nargs[] */
3147 for (i
= 0; i
< nargs
[num
]; ++i
) {
3148 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
3149 return -TARGET_EFAULT
;
3152 /* now when we have the args, invoke the appropriate underlying function */
3154 case TARGET_SYS_SOCKET
: /* domain, type, protocol */
3155 return do_socket(a
[0], a
[1], a
[2]);
3156 case TARGET_SYS_BIND
: /* sockfd, addr, addrlen */
3157 return do_bind(a
[0], a
[1], a
[2]);
3158 case TARGET_SYS_CONNECT
: /* sockfd, addr, addrlen */
3159 return do_connect(a
[0], a
[1], a
[2]);
3160 case TARGET_SYS_LISTEN
: /* sockfd, backlog */
3161 return get_errno(listen(a
[0], a
[1]));
3162 case TARGET_SYS_ACCEPT
: /* sockfd, addr, addrlen */
3163 return do_accept4(a
[0], a
[1], a
[2], 0);
3164 case TARGET_SYS_GETSOCKNAME
: /* sockfd, addr, addrlen */
3165 return do_getsockname(a
[0], a
[1], a
[2]);
3166 case TARGET_SYS_GETPEERNAME
: /* sockfd, addr, addrlen */
3167 return do_getpeername(a
[0], a
[1], a
[2]);
3168 case TARGET_SYS_SOCKETPAIR
: /* domain, type, protocol, tab */
3169 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
3170 case TARGET_SYS_SEND
: /* sockfd, msg, len, flags */
3171 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
3172 case TARGET_SYS_RECV
: /* sockfd, msg, len, flags */
3173 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
3174 case TARGET_SYS_SENDTO
: /* sockfd, msg, len, flags, addr, addrlen */
3175 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3176 case TARGET_SYS_RECVFROM
: /* sockfd, msg, len, flags, addr, addrlen */
3177 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
3178 case TARGET_SYS_SHUTDOWN
: /* sockfd, how */
3179 return get_errno(shutdown(a
[0], a
[1]));
3180 case TARGET_SYS_SETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3181 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3182 case TARGET_SYS_GETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
3183 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
3184 case TARGET_SYS_SENDMSG
: /* sockfd, msg, flags */
3185 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
3186 case TARGET_SYS_RECVMSG
: /* sockfd, msg, flags */
3187 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
3188 case TARGET_SYS_ACCEPT4
: /* sockfd, addr, addrlen, flags */
3189 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
3190 case TARGET_SYS_RECVMMSG
: /* sockfd, msgvec, vlen, flags */
3191 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 0);
3192 case TARGET_SYS_SENDMMSG
: /* sockfd, msgvec, vlen, flags */
3193 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 1);
3195 gemu_log("Unsupported socketcall: %d\n", num
);
3196 return -TARGET_EINVAL
;
3201 #define N_SHM_REGIONS 32
3203 static struct shm_region
{
3207 } shm_regions
[N_SHM_REGIONS
];
3209 #ifndef TARGET_SEMID64_DS
3210 /* asm-generic version of this struct */
3211 struct target_semid64_ds
3213 struct target_ipc_perm sem_perm
;
3214 abi_ulong sem_otime
;
3215 #if TARGET_ABI_BITS == 32
3216 abi_ulong __unused1
;
3218 abi_ulong sem_ctime
;
3219 #if TARGET_ABI_BITS == 32
3220 abi_ulong __unused2
;
3222 abi_ulong sem_nsems
;
3223 abi_ulong __unused3
;
3224 abi_ulong __unused4
;
3228 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
3229 abi_ulong target_addr
)
3231 struct target_ipc_perm
*target_ip
;
3232 struct target_semid64_ds
*target_sd
;
3234 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3235 return -TARGET_EFAULT
;
3236 target_ip
= &(target_sd
->sem_perm
);
3237 host_ip
->__key
= tswap32(target_ip
->__key
);
3238 host_ip
->uid
= tswap32(target_ip
->uid
);
3239 host_ip
->gid
= tswap32(target_ip
->gid
);
3240 host_ip
->cuid
= tswap32(target_ip
->cuid
);
3241 host_ip
->cgid
= tswap32(target_ip
->cgid
);
3242 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3243 host_ip
->mode
= tswap32(target_ip
->mode
);
3245 host_ip
->mode
= tswap16(target_ip
->mode
);
3247 #if defined(TARGET_PPC)
3248 host_ip
->__seq
= tswap32(target_ip
->__seq
);
3250 host_ip
->__seq
= tswap16(target_ip
->__seq
);
3252 unlock_user_struct(target_sd
, target_addr
, 0);
3256 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
3257 struct ipc_perm
*host_ip
)
3259 struct target_ipc_perm
*target_ip
;
3260 struct target_semid64_ds
*target_sd
;
3262 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3263 return -TARGET_EFAULT
;
3264 target_ip
= &(target_sd
->sem_perm
);
3265 target_ip
->__key
= tswap32(host_ip
->__key
);
3266 target_ip
->uid
= tswap32(host_ip
->uid
);
3267 target_ip
->gid
= tswap32(host_ip
->gid
);
3268 target_ip
->cuid
= tswap32(host_ip
->cuid
);
3269 target_ip
->cgid
= tswap32(host_ip
->cgid
);
3270 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3271 target_ip
->mode
= tswap32(host_ip
->mode
);
3273 target_ip
->mode
= tswap16(host_ip
->mode
);
3275 #if defined(TARGET_PPC)
3276 target_ip
->__seq
= tswap32(host_ip
->__seq
);
3278 target_ip
->__seq
= tswap16(host_ip
->__seq
);
3280 unlock_user_struct(target_sd
, target_addr
, 1);
3284 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
3285 abi_ulong target_addr
)
3287 struct target_semid64_ds
*target_sd
;
3289 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3290 return -TARGET_EFAULT
;
3291 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
3292 return -TARGET_EFAULT
;
3293 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
3294 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
3295 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
3296 unlock_user_struct(target_sd
, target_addr
, 0);
3300 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
3301 struct semid_ds
*host_sd
)
3303 struct target_semid64_ds
*target_sd
;
3305 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3306 return -TARGET_EFAULT
;
3307 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
3308 return -TARGET_EFAULT
;
3309 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
3310 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
3311 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
3312 unlock_user_struct(target_sd
, target_addr
, 1);
3316 struct target_seminfo
{
3329 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
3330 struct seminfo
*host_seminfo
)
3332 struct target_seminfo
*target_seminfo
;
3333 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
3334 return -TARGET_EFAULT
;
3335 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
3336 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
3337 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
3338 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
3339 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
3340 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
3341 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
3342 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
3343 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
3344 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
3345 unlock_user_struct(target_seminfo
, target_addr
, 1);
3351 struct semid_ds
*buf
;
3352 unsigned short *array
;
3353 struct seminfo
*__buf
;
3356 union target_semun
{
3363 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
3364 abi_ulong target_addr
)
3367 unsigned short *array
;
3369 struct semid_ds semid_ds
;
3372 semun
.buf
= &semid_ds
;
3374 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3376 return get_errno(ret
);
3378 nsems
= semid_ds
.sem_nsems
;
3380 *host_array
= g_try_new(unsigned short, nsems
);
3382 return -TARGET_ENOMEM
;
3384 array
= lock_user(VERIFY_READ
, target_addr
,
3385 nsems
*sizeof(unsigned short), 1);
3387 g_free(*host_array
);
3388 return -TARGET_EFAULT
;
3391 for(i
=0; i
<nsems
; i
++) {
3392 __get_user((*host_array
)[i
], &array
[i
]);
3394 unlock_user(array
, target_addr
, 0);
3399 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
3400 unsigned short **host_array
)
3403 unsigned short *array
;
3405 struct semid_ds semid_ds
;
3408 semun
.buf
= &semid_ds
;
3410 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
3412 return get_errno(ret
);
3414 nsems
= semid_ds
.sem_nsems
;
3416 array
= lock_user(VERIFY_WRITE
, target_addr
,
3417 nsems
*sizeof(unsigned short), 0);
3419 return -TARGET_EFAULT
;
3421 for(i
=0; i
<nsems
; i
++) {
3422 __put_user((*host_array
)[i
], &array
[i
]);
3424 g_free(*host_array
);
3425 unlock_user(array
, target_addr
, 1);
3430 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
3431 abi_ulong target_arg
)
3433 union target_semun target_su
= { .buf
= target_arg
};
3435 struct semid_ds dsarg
;
3436 unsigned short *array
= NULL
;
3437 struct seminfo seminfo
;
3438 abi_long ret
= -TARGET_EINVAL
;
3445 /* In 64 bit cross-endian situations, we will erroneously pick up
3446 * the wrong half of the union for the "val" element. To rectify
3447 * this, the entire 8-byte structure is byteswapped, followed by
3448 * a swap of the 4 byte val field. In other cases, the data is
3449 * already in proper host byte order. */
3450 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
3451 target_su
.buf
= tswapal(target_su
.buf
);
3452 arg
.val
= tswap32(target_su
.val
);
3454 arg
.val
= target_su
.val
;
3456 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3460 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
3464 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3465 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
3472 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
3476 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3477 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
3483 arg
.__buf
= &seminfo
;
3484 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
3485 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
3493 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
3500 struct target_sembuf
{
3501 unsigned short sem_num
;
3506 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
3507 abi_ulong target_addr
,
3510 struct target_sembuf
*target_sembuf
;
3513 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
3514 nsops
*sizeof(struct target_sembuf
), 1);
3516 return -TARGET_EFAULT
;
3518 for(i
=0; i
<nsops
; i
++) {
3519 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
3520 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
3521 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
3524 unlock_user(target_sembuf
, target_addr
, 0);
3529 static inline abi_long
do_semop(int semid
, abi_long ptr
, unsigned nsops
)
3531 struct sembuf sops
[nsops
];
3533 if (target_to_host_sembuf(sops
, ptr
, nsops
))
3534 return -TARGET_EFAULT
;
3536 return get_errno(safe_semtimedop(semid
, sops
, nsops
, NULL
));
3539 struct target_msqid_ds
3541 struct target_ipc_perm msg_perm
;
3542 abi_ulong msg_stime
;
3543 #if TARGET_ABI_BITS == 32
3544 abi_ulong __unused1
;
3546 abi_ulong msg_rtime
;
3547 #if TARGET_ABI_BITS == 32
3548 abi_ulong __unused2
;
3550 abi_ulong msg_ctime
;
3551 #if TARGET_ABI_BITS == 32
3552 abi_ulong __unused3
;
3554 abi_ulong __msg_cbytes
;
3556 abi_ulong msg_qbytes
;
3557 abi_ulong msg_lspid
;
3558 abi_ulong msg_lrpid
;
3559 abi_ulong __unused4
;
3560 abi_ulong __unused5
;
3563 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
3564 abi_ulong target_addr
)
3566 struct target_msqid_ds
*target_md
;
3568 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
3569 return -TARGET_EFAULT
;
3570 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
3571 return -TARGET_EFAULT
;
3572 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
3573 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
3574 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
3575 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
3576 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
3577 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
3578 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
3579 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
3580 unlock_user_struct(target_md
, target_addr
, 0);
3584 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
3585 struct msqid_ds
*host_md
)
3587 struct target_msqid_ds
*target_md
;
3589 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
3590 return -TARGET_EFAULT
;
3591 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
3592 return -TARGET_EFAULT
;
3593 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
3594 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
3595 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
3596 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
3597 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
3598 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
3599 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
3600 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
3601 unlock_user_struct(target_md
, target_addr
, 1);
3605 struct target_msginfo
{
3613 unsigned short int msgseg
;
3616 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
3617 struct msginfo
*host_msginfo
)
3619 struct target_msginfo
*target_msginfo
;
3620 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
3621 return -TARGET_EFAULT
;
3622 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
3623 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
3624 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
3625 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
3626 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
3627 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
3628 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
3629 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
3630 unlock_user_struct(target_msginfo
, target_addr
, 1);
3634 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
3636 struct msqid_ds dsarg
;
3637 struct msginfo msginfo
;
3638 abi_long ret
= -TARGET_EINVAL
;
3646 if (target_to_host_msqid_ds(&dsarg
,ptr
))
3647 return -TARGET_EFAULT
;
3648 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
3649 if (host_to_target_msqid_ds(ptr
,&dsarg
))
3650 return -TARGET_EFAULT
;
3653 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
3657 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
3658 if (host_to_target_msginfo(ptr
, &msginfo
))
3659 return -TARGET_EFAULT
;
3666 struct target_msgbuf
{
3671 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
3672 ssize_t msgsz
, int msgflg
)
3674 struct target_msgbuf
*target_mb
;
3675 struct msgbuf
*host_mb
;
3679 return -TARGET_EINVAL
;
3682 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
3683 return -TARGET_EFAULT
;
3684 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
3686 unlock_user_struct(target_mb
, msgp
, 0);
3687 return -TARGET_ENOMEM
;
3689 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
3690 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
3691 ret
= get_errno(safe_msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
3693 unlock_user_struct(target_mb
, msgp
, 0);
3698 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
3699 ssize_t msgsz
, abi_long msgtyp
,
3702 struct target_msgbuf
*target_mb
;
3704 struct msgbuf
*host_mb
;
3708 return -TARGET_EINVAL
;
3711 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
3712 return -TARGET_EFAULT
;
3714 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
3716 ret
= -TARGET_ENOMEM
;
3719 ret
= get_errno(safe_msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
3722 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
3723 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
3724 if (!target_mtext
) {
3725 ret
= -TARGET_EFAULT
;
3728 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
3729 unlock_user(target_mtext
, target_mtext_addr
, ret
);
3732 target_mb
->mtype
= tswapal(host_mb
->mtype
);
3736 unlock_user_struct(target_mb
, msgp
, 1);
3741 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
3742 abi_ulong target_addr
)
3744 struct target_shmid_ds
*target_sd
;
3746 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3747 return -TARGET_EFAULT
;
3748 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
3749 return -TARGET_EFAULT
;
3750 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3751 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3752 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3753 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3754 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3755 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3756 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3757 unlock_user_struct(target_sd
, target_addr
, 0);
3761 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
3762 struct shmid_ds
*host_sd
)
3764 struct target_shmid_ds
*target_sd
;
3766 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3767 return -TARGET_EFAULT
;
3768 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
3769 return -TARGET_EFAULT
;
3770 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3771 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3772 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3773 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3774 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3775 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3776 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3777 unlock_user_struct(target_sd
, target_addr
, 1);
3781 struct target_shminfo
{
3789 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
3790 struct shminfo
*host_shminfo
)
3792 struct target_shminfo
*target_shminfo
;
3793 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
3794 return -TARGET_EFAULT
;
3795 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
3796 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
3797 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
3798 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
3799 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
3800 unlock_user_struct(target_shminfo
, target_addr
, 1);
3804 struct target_shm_info
{
3809 abi_ulong swap_attempts
;
3810 abi_ulong swap_successes
;
3813 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
3814 struct shm_info
*host_shm_info
)
3816 struct target_shm_info
*target_shm_info
;
3817 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
3818 return -TARGET_EFAULT
;
3819 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
3820 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
3821 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
3822 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
3823 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
3824 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
3825 unlock_user_struct(target_shm_info
, target_addr
, 1);
3829 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
3831 struct shmid_ds dsarg
;
3832 struct shminfo shminfo
;
3833 struct shm_info shm_info
;
3834 abi_long ret
= -TARGET_EINVAL
;
3842 if (target_to_host_shmid_ds(&dsarg
, buf
))
3843 return -TARGET_EFAULT
;
3844 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
3845 if (host_to_target_shmid_ds(buf
, &dsarg
))
3846 return -TARGET_EFAULT
;
3849 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
3850 if (host_to_target_shminfo(buf
, &shminfo
))
3851 return -TARGET_EFAULT
;
3854 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
3855 if (host_to_target_shm_info(buf
, &shm_info
))
3856 return -TARGET_EFAULT
;
3861 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
3868 #ifndef TARGET_FORCE_SHMLBA
3869 /* For most architectures, SHMLBA is the same as the page size;
3870 * some architectures have larger values, in which case they should
3871 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
3872 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
3873 * and defining its own value for SHMLBA.
3875 * The kernel also permits SHMLBA to be set by the architecture to a
3876 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
3877 * this means that addresses are rounded to the large size if
3878 * SHM_RND is set but addresses not aligned to that size are not rejected
3879 * as long as they are at least page-aligned. Since the only architecture
3880 * which uses this is ia64 this code doesn't provide for that oddity.
3882 static inline abi_ulong
target_shmlba(CPUArchState
*cpu_env
)
3884 return TARGET_PAGE_SIZE
;
3888 static inline abi_ulong
do_shmat(CPUArchState
*cpu_env
,
3889 int shmid
, abi_ulong shmaddr
, int shmflg
)
3893 struct shmid_ds shm_info
;
3897 /* find out the length of the shared memory segment */
3898 ret
= get_errno(shmctl(shmid
, IPC_STAT
, &shm_info
));
3899 if (is_error(ret
)) {
3900 /* can't get length, bail out */
3904 shmlba
= target_shmlba(cpu_env
);
3906 if (shmaddr
& (shmlba
- 1)) {
3907 if (shmflg
& SHM_RND
) {
3908 shmaddr
&= ~(shmlba
- 1);
3910 return -TARGET_EINVAL
;
3913 if (!guest_range_valid(shmaddr
, shm_info
.shm_segsz
)) {
3914 return -TARGET_EINVAL
;
3920 host_raddr
= shmat(shmid
, (void *)g2h(shmaddr
), shmflg
);
3922 abi_ulong mmap_start
;
3924 /* In order to use the host shmat, we need to honor host SHMLBA. */
3925 mmap_start
= mmap_find_vma(0, shm_info
.shm_segsz
, MAX(SHMLBA
, shmlba
));
3927 if (mmap_start
== -1) {
3929 host_raddr
= (void *)-1;
3931 host_raddr
= shmat(shmid
, g2h(mmap_start
), shmflg
| SHM_REMAP
);
3934 if (host_raddr
== (void *)-1) {
3936 return get_errno((long)host_raddr
);
3938 raddr
=h2g((unsigned long)host_raddr
);
3940 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
3941 PAGE_VALID
| PAGE_READ
|
3942 ((shmflg
& SHM_RDONLY
)? 0 : PAGE_WRITE
));
3944 for (i
= 0; i
< N_SHM_REGIONS
; i
++) {
3945 if (!shm_regions
[i
].in_use
) {
3946 shm_regions
[i
].in_use
= true;
3947 shm_regions
[i
].start
= raddr
;
3948 shm_regions
[i
].size
= shm_info
.shm_segsz
;
3958 static inline abi_long
do_shmdt(abi_ulong shmaddr
)
3965 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
3966 if (shm_regions
[i
].in_use
&& shm_regions
[i
].start
== shmaddr
) {
3967 shm_regions
[i
].in_use
= false;
3968 page_set_flags(shmaddr
, shmaddr
+ shm_regions
[i
].size
, 0);
3972 rv
= get_errno(shmdt(g2h(shmaddr
)));
3979 #ifdef TARGET_NR_ipc
3980 /* ??? This only works with linear mappings. */
3981 /* do_ipc() must return target values and target errnos. */
3982 static abi_long
do_ipc(CPUArchState
*cpu_env
,
3983 unsigned int call
, abi_long first
,
3984 abi_long second
, abi_long third
,
3985 abi_long ptr
, abi_long fifth
)
3990 version
= call
>> 16;
3995 ret
= do_semop(first
, ptr
, second
);
3999 ret
= get_errno(semget(first
, second
, third
));
4002 case IPCOP_semctl
: {
4003 /* The semun argument to semctl is passed by value, so dereference the
4006 get_user_ual(atptr
, ptr
);
4007 ret
= do_semctl(first
, second
, third
, atptr
);
4012 ret
= get_errno(msgget(first
, second
));
4016 ret
= do_msgsnd(first
, ptr
, second
, third
);
4020 ret
= do_msgctl(first
, second
, ptr
);
4027 struct target_ipc_kludge
{
4032 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
4033 ret
= -TARGET_EFAULT
;
4037 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
4039 unlock_user_struct(tmp
, ptr
, 0);
4043 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
4052 raddr
= do_shmat(cpu_env
, first
, ptr
, second
);
4053 if (is_error(raddr
))
4054 return get_errno(raddr
);
4055 if (put_user_ual(raddr
, third
))
4056 return -TARGET_EFAULT
;
4060 ret
= -TARGET_EINVAL
;
4065 ret
= do_shmdt(ptr
);
4069 /* IPC_* flag values are the same on all linux platforms */
4070 ret
= get_errno(shmget(first
, second
, third
));
4073 /* IPC_* and SHM_* command values are the same on all linux platforms */
4075 ret
= do_shmctl(first
, second
, ptr
);
4078 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
4079 ret
= -TARGET_ENOSYS
;
4086 /* kernel structure types definitions */
4088 #define STRUCT(name, ...) STRUCT_ ## name,
4089 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
4091 #include "syscall_types.h"
4095 #undef STRUCT_SPECIAL
4097 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
4098 #define STRUCT_SPECIAL(name)
4099 #include "syscall_types.h"
4101 #undef STRUCT_SPECIAL
4103 typedef struct IOCTLEntry IOCTLEntry
;
4105 typedef abi_long
do_ioctl_fn(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4106 int fd
, int cmd
, abi_long arg
);
4110 unsigned int host_cmd
;
4113 do_ioctl_fn
*do_ioctl
;
4114 const argtype arg_type
[5];
4117 #define IOC_R 0x0001
4118 #define IOC_W 0x0002
4119 #define IOC_RW (IOC_R | IOC_W)
4121 #define MAX_STRUCT_SIZE 4096
4123 #ifdef CONFIG_FIEMAP
4124 /* So fiemap access checks don't overflow on 32 bit systems.
4125 * This is very slightly smaller than the limit imposed by
4126 * the underlying kernel.
4128 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
4129 / sizeof(struct fiemap_extent))
4131 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4132 int fd
, int cmd
, abi_long arg
)
4134 /* The parameter for this ioctl is a struct fiemap followed
4135 * by an array of struct fiemap_extent whose size is set
4136 * in fiemap->fm_extent_count. The array is filled in by the
4139 int target_size_in
, target_size_out
;
4141 const argtype
*arg_type
= ie
->arg_type
;
4142 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
4145 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
4149 assert(arg_type
[0] == TYPE_PTR
);
4150 assert(ie
->access
== IOC_RW
);
4152 target_size_in
= thunk_type_size(arg_type
, 0);
4153 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
4155 return -TARGET_EFAULT
;
4157 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4158 unlock_user(argptr
, arg
, 0);
4159 fm
= (struct fiemap
*)buf_temp
;
4160 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
4161 return -TARGET_EINVAL
;
4164 outbufsz
= sizeof (*fm
) +
4165 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
4167 if (outbufsz
> MAX_STRUCT_SIZE
) {
4168 /* We can't fit all the extents into the fixed size buffer.
4169 * Allocate one that is large enough and use it instead.
4171 fm
= g_try_malloc(outbufsz
);
4173 return -TARGET_ENOMEM
;
4175 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
4178 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, fm
));
4179 if (!is_error(ret
)) {
4180 target_size_out
= target_size_in
;
4181 /* An extent_count of 0 means we were only counting the extents
4182 * so there are no structs to copy
4184 if (fm
->fm_extent_count
!= 0) {
4185 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
4187 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
4189 ret
= -TARGET_EFAULT
;
4191 /* Convert the struct fiemap */
4192 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
4193 if (fm
->fm_extent_count
!= 0) {
4194 p
= argptr
+ target_size_in
;
4195 /* ...and then all the struct fiemap_extents */
4196 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
4197 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
4202 unlock_user(argptr
, arg
, target_size_out
);
4212 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4213 int fd
, int cmd
, abi_long arg
)
4215 const argtype
*arg_type
= ie
->arg_type
;
4219 struct ifconf
*host_ifconf
;
4221 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
4222 int target_ifreq_size
;
4227 abi_long target_ifc_buf
;
4231 assert(arg_type
[0] == TYPE_PTR
);
4232 assert(ie
->access
== IOC_RW
);
4235 target_size
= thunk_type_size(arg_type
, 0);
4237 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4239 return -TARGET_EFAULT
;
4240 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4241 unlock_user(argptr
, arg
, 0);
4243 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
4244 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
4245 target_ifreq_size
= thunk_type_size(ifreq_arg_type
, 0);
4247 if (target_ifc_buf
!= 0) {
4248 target_ifc_len
= host_ifconf
->ifc_len
;
4249 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
4250 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
4252 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
4253 if (outbufsz
> MAX_STRUCT_SIZE
) {
4255 * We can't fit all the extents into the fixed size buffer.
4256 * Allocate one that is large enough and use it instead.
4258 host_ifconf
= malloc(outbufsz
);
4260 return -TARGET_ENOMEM
;
4262 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
4265 host_ifc_buf
= (char *)host_ifconf
+ sizeof(*host_ifconf
);
4267 host_ifconf
->ifc_len
= host_ifc_len
;
4269 host_ifc_buf
= NULL
;
4271 host_ifconf
->ifc_buf
= host_ifc_buf
;
4273 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_ifconf
));
4274 if (!is_error(ret
)) {
4275 /* convert host ifc_len to target ifc_len */
4277 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
4278 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
4279 host_ifconf
->ifc_len
= target_ifc_len
;
4281 /* restore target ifc_buf */
4283 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
4285 /* copy struct ifconf to target user */
4287 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4289 return -TARGET_EFAULT
;
4290 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
4291 unlock_user(argptr
, arg
, target_size
);
4293 if (target_ifc_buf
!= 0) {
4294 /* copy ifreq[] to target user */
4295 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
4296 for (i
= 0; i
< nb_ifreq
; i
++) {
4297 thunk_convert(argptr
+ i
* target_ifreq_size
,
4298 host_ifc_buf
+ i
* sizeof(struct ifreq
),
4299 ifreq_arg_type
, THUNK_TARGET
);
4301 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
4312 #if defined(CONFIG_USBFS)
4313 #if HOST_LONG_BITS > 64
4314 #error USBDEVFS thunks do not support >64 bit hosts yet.
4317 uint64_t target_urb_adr
;
4318 uint64_t target_buf_adr
;
4319 char *target_buf_ptr
;
4320 struct usbdevfs_urb host_urb
;
4323 static GHashTable
*usbdevfs_urb_hashtable(void)
4325 static GHashTable
*urb_hashtable
;
4327 if (!urb_hashtable
) {
4328 urb_hashtable
= g_hash_table_new(g_int64_hash
, g_int64_equal
);
4330 return urb_hashtable
;
4333 static void urb_hashtable_insert(struct live_urb
*urb
)
4335 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4336 g_hash_table_insert(urb_hashtable
, urb
, urb
);
4339 static struct live_urb
*urb_hashtable_lookup(uint64_t target_urb_adr
)
4341 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4342 return g_hash_table_lookup(urb_hashtable
, &target_urb_adr
);
4345 static void urb_hashtable_remove(struct live_urb
*urb
)
4347 GHashTable
*urb_hashtable
= usbdevfs_urb_hashtable();
4348 g_hash_table_remove(urb_hashtable
, urb
);
4352 do_ioctl_usbdevfs_reapurb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4353 int fd
, int cmd
, abi_long arg
)
4355 const argtype usbfsurb_arg_type
[] = { MK_STRUCT(STRUCT_usbdevfs_urb
) };
4356 const argtype ptrvoid_arg_type
[] = { TYPE_PTRVOID
, 0, 0 };
4357 struct live_urb
*lurb
;
4361 uintptr_t target_urb_adr
;
4364 target_size
= thunk_type_size(usbfsurb_arg_type
, THUNK_TARGET
);
4366 memset(buf_temp
, 0, sizeof(uint64_t));
4367 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4368 if (is_error(ret
)) {
4372 memcpy(&hurb
, buf_temp
, sizeof(uint64_t));
4373 lurb
= (void *)((uintptr_t)hurb
- offsetof(struct live_urb
, host_urb
));
4374 if (!lurb
->target_urb_adr
) {
4375 return -TARGET_EFAULT
;
4377 urb_hashtable_remove(lurb
);
4378 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
,
4379 lurb
->host_urb
.buffer_length
);
4380 lurb
->target_buf_ptr
= NULL
;
4382 /* restore the guest buffer pointer */
4383 lurb
->host_urb
.buffer
= (void *)(uintptr_t)lurb
->target_buf_adr
;
4385 /* update the guest urb struct */
4386 argptr
= lock_user(VERIFY_WRITE
, lurb
->target_urb_adr
, target_size
, 0);
4389 return -TARGET_EFAULT
;
4391 thunk_convert(argptr
, &lurb
->host_urb
, usbfsurb_arg_type
, THUNK_TARGET
);
4392 unlock_user(argptr
, lurb
->target_urb_adr
, target_size
);
4394 target_size
= thunk_type_size(ptrvoid_arg_type
, THUNK_TARGET
);
4395 /* write back the urb handle */
4396 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4399 return -TARGET_EFAULT
;
4402 /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */
4403 target_urb_adr
= lurb
->target_urb_adr
;
4404 thunk_convert(argptr
, &target_urb_adr
, ptrvoid_arg_type
, THUNK_TARGET
);
4405 unlock_user(argptr
, arg
, target_size
);
4412 do_ioctl_usbdevfs_discardurb(const IOCTLEntry
*ie
,
4413 uint8_t *buf_temp
__attribute__((unused
)),
4414 int fd
, int cmd
, abi_long arg
)
4416 struct live_urb
*lurb
;
4418 /* map target address back to host URB with metadata. */
4419 lurb
= urb_hashtable_lookup(arg
);
4421 return -TARGET_EFAULT
;
4423 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4427 do_ioctl_usbdevfs_submiturb(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4428 int fd
, int cmd
, abi_long arg
)
4430 const argtype
*arg_type
= ie
->arg_type
;
4435 struct live_urb
*lurb
;
4438 * each submitted URB needs to map to a unique ID for the
4439 * kernel, and that unique ID needs to be a pointer to
4440 * host memory. hence, we need to malloc for each URB.
4441 * isochronous transfers have a variable length struct.
4444 target_size
= thunk_type_size(arg_type
, THUNK_TARGET
);
4446 /* construct host copy of urb and metadata */
4447 lurb
= g_try_malloc0(sizeof(struct live_urb
));
4449 return -TARGET_ENOMEM
;
4452 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4455 return -TARGET_EFAULT
;
4457 thunk_convert(&lurb
->host_urb
, argptr
, arg_type
, THUNK_HOST
);
4458 unlock_user(argptr
, arg
, 0);
4460 lurb
->target_urb_adr
= arg
;
4461 lurb
->target_buf_adr
= (uintptr_t)lurb
->host_urb
.buffer
;
4463 /* buffer space used depends on endpoint type so lock the entire buffer */
4464 /* control type urbs should check the buffer contents for true direction */
4465 rw_dir
= lurb
->host_urb
.endpoint
& USB_DIR_IN
? VERIFY_WRITE
: VERIFY_READ
;
4466 lurb
->target_buf_ptr
= lock_user(rw_dir
, lurb
->target_buf_adr
,
4467 lurb
->host_urb
.buffer_length
, 1);
4468 if (lurb
->target_buf_ptr
== NULL
) {
4470 return -TARGET_EFAULT
;
4473 /* update buffer pointer in host copy */
4474 lurb
->host_urb
.buffer
= lurb
->target_buf_ptr
;
4476 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, &lurb
->host_urb
));
4477 if (is_error(ret
)) {
4478 unlock_user(lurb
->target_buf_ptr
, lurb
->target_buf_adr
, 0);
4481 urb_hashtable_insert(lurb
);
4486 #endif /* CONFIG_USBFS */
4488 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
4489 int cmd
, abi_long arg
)
4492 struct dm_ioctl
*host_dm
;
4493 abi_long guest_data
;
4494 uint32_t guest_data_size
;
4496 const argtype
*arg_type
= ie
->arg_type
;
4498 void *big_buf
= NULL
;
4502 target_size
= thunk_type_size(arg_type
, 0);
4503 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4505 ret
= -TARGET_EFAULT
;
4508 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4509 unlock_user(argptr
, arg
, 0);
4511 /* buf_temp is too small, so fetch things into a bigger buffer */
4512 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
4513 memcpy(big_buf
, buf_temp
, target_size
);
4517 guest_data
= arg
+ host_dm
->data_start
;
4518 if ((guest_data
- arg
) < 0) {
4519 ret
= -TARGET_EINVAL
;
4522 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
4523 host_data
= (char*)host_dm
+ host_dm
->data_start
;
4525 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
4527 ret
= -TARGET_EFAULT
;
4531 switch (ie
->host_cmd
) {
4533 case DM_LIST_DEVICES
:
4536 case DM_DEV_SUSPEND
:
4539 case DM_TABLE_STATUS
:
4540 case DM_TABLE_CLEAR
:
4542 case DM_LIST_VERSIONS
:
4546 case DM_DEV_SET_GEOMETRY
:
4547 /* data contains only strings */
4548 memcpy(host_data
, argptr
, guest_data_size
);
4551 memcpy(host_data
, argptr
, guest_data_size
);
4552 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
4556 void *gspec
= argptr
;
4557 void *cur_data
= host_data
;
4558 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
4559 int spec_size
= thunk_type_size(arg_type
, 0);
4562 for (i
= 0; i
< host_dm
->target_count
; i
++) {
4563 struct dm_target_spec
*spec
= cur_data
;
4567 thunk_convert(spec
, gspec
, arg_type
, THUNK_HOST
);
4568 slen
= strlen((char*)gspec
+ spec_size
) + 1;
4570 spec
->next
= sizeof(*spec
) + slen
;
4571 strcpy((char*)&spec
[1], gspec
+ spec_size
);
4573 cur_data
+= spec
->next
;
4578 ret
= -TARGET_EINVAL
;
4579 unlock_user(argptr
, guest_data
, 0);
4582 unlock_user(argptr
, guest_data
, 0);
4584 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4585 if (!is_error(ret
)) {
4586 guest_data
= arg
+ host_dm
->data_start
;
4587 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
4588 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
4589 switch (ie
->host_cmd
) {
4594 case DM_DEV_SUSPEND
:
4597 case DM_TABLE_CLEAR
:
4599 case DM_DEV_SET_GEOMETRY
:
4600 /* no return data */
4602 case DM_LIST_DEVICES
:
4604 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
4605 uint32_t remaining_data
= guest_data_size
;
4606 void *cur_data
= argptr
;
4607 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
4608 int nl_size
= 12; /* can't use thunk_size due to alignment */
4611 uint32_t next
= nl
->next
;
4613 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
4615 if (remaining_data
< nl
->next
) {
4616 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4619 thunk_convert(cur_data
, nl
, arg_type
, THUNK_TARGET
);
4620 strcpy(cur_data
+ nl_size
, nl
->name
);
4621 cur_data
+= nl
->next
;
4622 remaining_data
-= nl
->next
;
4626 nl
= (void*)nl
+ next
;
4631 case DM_TABLE_STATUS
:
4633 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
4634 void *cur_data
= argptr
;
4635 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
4636 int spec_size
= thunk_type_size(arg_type
, 0);
4639 for (i
= 0; i
< host_dm
->target_count
; i
++) {
4640 uint32_t next
= spec
->next
;
4641 int slen
= strlen((char*)&spec
[1]) + 1;
4642 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
4643 if (guest_data_size
< spec
->next
) {
4644 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4647 thunk_convert(cur_data
, spec
, arg_type
, THUNK_TARGET
);
4648 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
4649 cur_data
= argptr
+ spec
->next
;
4650 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
4656 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
4657 int count
= *(uint32_t*)hdata
;
4658 uint64_t *hdev
= hdata
+ 8;
4659 uint64_t *gdev
= argptr
+ 8;
4662 *(uint32_t*)argptr
= tswap32(count
);
4663 for (i
= 0; i
< count
; i
++) {
4664 *gdev
= tswap64(*hdev
);
4670 case DM_LIST_VERSIONS
:
4672 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
4673 uint32_t remaining_data
= guest_data_size
;
4674 void *cur_data
= argptr
;
4675 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
4676 int vers_size
= thunk_type_size(arg_type
, 0);
4679 uint32_t next
= vers
->next
;
4681 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
4683 if (remaining_data
< vers
->next
) {
4684 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
4687 thunk_convert(cur_data
, vers
, arg_type
, THUNK_TARGET
);
4688 strcpy(cur_data
+ vers_size
, vers
->name
);
4689 cur_data
+= vers
->next
;
4690 remaining_data
-= vers
->next
;
4694 vers
= (void*)vers
+ next
;
4699 unlock_user(argptr
, guest_data
, 0);
4700 ret
= -TARGET_EINVAL
;
4703 unlock_user(argptr
, guest_data
, guest_data_size
);
4705 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4707 ret
= -TARGET_EFAULT
;
4710 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
4711 unlock_user(argptr
, arg
, target_size
);
4718 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
4719 int cmd
, abi_long arg
)
4723 const argtype
*arg_type
= ie
->arg_type
;
4724 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
4727 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
4728 struct blkpg_partition host_part
;
4730 /* Read and convert blkpg */
4732 target_size
= thunk_type_size(arg_type
, 0);
4733 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4735 ret
= -TARGET_EFAULT
;
4738 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4739 unlock_user(argptr
, arg
, 0);
4741 switch (host_blkpg
->op
) {
4742 case BLKPG_ADD_PARTITION
:
4743 case BLKPG_DEL_PARTITION
:
4744 /* payload is struct blkpg_partition */
4747 /* Unknown opcode */
4748 ret
= -TARGET_EINVAL
;
4752 /* Read and convert blkpg->data */
4753 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
4754 target_size
= thunk_type_size(part_arg_type
, 0);
4755 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4757 ret
= -TARGET_EFAULT
;
4760 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
4761 unlock_user(argptr
, arg
, 0);
4763 /* Swizzle the data pointer to our local copy and call! */
4764 host_blkpg
->data
= &host_part
;
4765 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_blkpg
));
4771 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4772 int fd
, int cmd
, abi_long arg
)
4774 const argtype
*arg_type
= ie
->arg_type
;
4775 const StructEntry
*se
;
4776 const argtype
*field_types
;
4777 const int *dst_offsets
, *src_offsets
;
4780 abi_ulong
*target_rt_dev_ptr
= NULL
;
4781 unsigned long *host_rt_dev_ptr
= NULL
;
4785 assert(ie
->access
== IOC_W
);
4786 assert(*arg_type
== TYPE_PTR
);
4788 assert(*arg_type
== TYPE_STRUCT
);
4789 target_size
= thunk_type_size(arg_type
, 0);
4790 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4792 return -TARGET_EFAULT
;
4795 assert(*arg_type
== (int)STRUCT_rtentry
);
4796 se
= struct_entries
+ *arg_type
++;
4797 assert(se
->convert
[0] == NULL
);
4798 /* convert struct here to be able to catch rt_dev string */
4799 field_types
= se
->field_types
;
4800 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
4801 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
4802 for (i
= 0; i
< se
->nb_fields
; i
++) {
4803 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
4804 assert(*field_types
== TYPE_PTRVOID
);
4805 target_rt_dev_ptr
= (abi_ulong
*)(argptr
+ src_offsets
[i
]);
4806 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
4807 if (*target_rt_dev_ptr
!= 0) {
4808 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
4809 tswapal(*target_rt_dev_ptr
));
4810 if (!*host_rt_dev_ptr
) {
4811 unlock_user(argptr
, arg
, 0);
4812 return -TARGET_EFAULT
;
4815 *host_rt_dev_ptr
= 0;
4820 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
4821 argptr
+ src_offsets
[i
],
4822 field_types
, THUNK_HOST
);
4824 unlock_user(argptr
, arg
, 0);
4826 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4828 assert(host_rt_dev_ptr
!= NULL
);
4829 assert(target_rt_dev_ptr
!= NULL
);
4830 if (*host_rt_dev_ptr
!= 0) {
4831 unlock_user((void *)*host_rt_dev_ptr
,
4832 *target_rt_dev_ptr
, 0);
4837 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4838 int fd
, int cmd
, abi_long arg
)
4840 int sig
= target_to_host_signal(arg
);
4841 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, sig
));
4845 static abi_long
do_ioctl_tiocgptpeer(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
4846 int fd
, int cmd
, abi_long arg
)
4848 int flags
= target_to_host_bitmask(arg
, fcntl_flags_tbl
);
4849 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, flags
));
4853 static IOCTLEntry ioctl_entries
[] = {
4854 #define IOCTL(cmd, access, ...) \
4855 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
4856 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
4857 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
4858 #define IOCTL_IGNORE(cmd) \
4859 { TARGET_ ## cmd, 0, #cmd },
4864 /* ??? Implement proper locking for ioctls. */
4865 /* do_ioctl() Must return target values and target errnos. */
4866 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
4868 const IOCTLEntry
*ie
;
4869 const argtype
*arg_type
;
4871 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
4877 if (ie
->target_cmd
== 0) {
4878 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
4879 return -TARGET_ENOSYS
;
4881 if (ie
->target_cmd
== cmd
)
4885 arg_type
= ie
->arg_type
;
4887 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
4888 } else if (!ie
->host_cmd
) {
4889 /* Some architectures define BSD ioctls in their headers
4890 that are not implemented in Linux. */
4891 return -TARGET_ENOSYS
;
4894 switch(arg_type
[0]) {
4897 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
));
4901 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, arg
));
4905 target_size
= thunk_type_size(arg_type
, 0);
4906 switch(ie
->access
) {
4908 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4909 if (!is_error(ret
)) {
4910 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4912 return -TARGET_EFAULT
;
4913 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
4914 unlock_user(argptr
, arg
, target_size
);
4918 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4920 return -TARGET_EFAULT
;
4921 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4922 unlock_user(argptr
, arg
, 0);
4923 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4927 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
4929 return -TARGET_EFAULT
;
4930 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
4931 unlock_user(argptr
, arg
, 0);
4932 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
4933 if (!is_error(ret
)) {
4934 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
4936 return -TARGET_EFAULT
;
4937 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
4938 unlock_user(argptr
, arg
, target_size
);
4944 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
4945 (long)cmd
, arg_type
[0]);
4946 ret
= -TARGET_ENOSYS
;
4952 static const bitmask_transtbl iflag_tbl
[] = {
4953 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
4954 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
4955 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
4956 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
4957 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
4958 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
4959 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
4960 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
4961 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
4962 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
4963 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
4964 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
4965 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
4966 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
4970 static const bitmask_transtbl oflag_tbl
[] = {
4971 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
4972 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
4973 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
4974 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
4975 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
4976 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
4977 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
4978 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
4979 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
4980 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
4981 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
4982 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
4983 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
4984 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
4985 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
4986 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
4987 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
4988 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
4989 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
4990 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
4991 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
4992 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
4993 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
4994 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
4998 static const bitmask_transtbl cflag_tbl
[] = {
4999 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
5000 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
5001 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
5002 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
5003 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
5004 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
5005 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
5006 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
5007 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
5008 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
5009 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
5010 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
5011 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
5012 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
5013 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
5014 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
5015 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
5016 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
5017 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
5018 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
5019 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
5020 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
5021 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
5022 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
5023 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
5024 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
5025 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
5026 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
5027 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
5028 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
5029 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
5033 static const bitmask_transtbl lflag_tbl
[] = {
5034 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
5035 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
5036 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
5037 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
5038 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
5039 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
5040 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
5041 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
5042 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
5043 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
5044 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
5045 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
5046 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
5047 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
5048 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
5052 static void target_to_host_termios (void *dst
, const void *src
)
5054 struct host_termios
*host
= dst
;
5055 const struct target_termios
*target
= src
;
5058 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
5060 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
5062 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
5064 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
5065 host
->c_line
= target
->c_line
;
5067 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
5068 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
5069 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
5070 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
5071 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
5072 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
5073 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
5074 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
5075 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
5076 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
5077 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
5078 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
5079 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
5080 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
5081 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
5082 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
5083 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
5084 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
5087 static void host_to_target_termios (void *dst
, const void *src
)
5089 struct target_termios
*target
= dst
;
5090 const struct host_termios
*host
= src
;
5093 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
5095 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
5097 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
5099 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
5100 target
->c_line
= host
->c_line
;
5102 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
5103 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
5104 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
5105 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
5106 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
5107 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
5108 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
5109 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
5110 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
5111 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
5112 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
5113 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
5114 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
5115 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
5116 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
5117 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
5118 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
5119 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
5122 static const StructEntry struct_termios_def
= {
5123 .convert
= { host_to_target_termios
, target_to_host_termios
},
5124 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
5125 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
5128 static bitmask_transtbl mmap_flags_tbl
[] = {
5129 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
5130 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
5131 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
5132 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
,
5133 MAP_ANONYMOUS
, MAP_ANONYMOUS
},
5134 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
,
5135 MAP_GROWSDOWN
, MAP_GROWSDOWN
},
5136 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
,
5137 MAP_DENYWRITE
, MAP_DENYWRITE
},
5138 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
,
5139 MAP_EXECUTABLE
, MAP_EXECUTABLE
},
5140 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
5141 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
,
5142 MAP_NORESERVE
, MAP_NORESERVE
},
5143 { TARGET_MAP_HUGETLB
, TARGET_MAP_HUGETLB
, MAP_HUGETLB
, MAP_HUGETLB
},
5144 /* MAP_STACK had been ignored by the kernel for quite some time.
5145 Recognize it for the target insofar as we do not want to pass
5146 it through to the host. */
5147 { TARGET_MAP_STACK
, TARGET_MAP_STACK
, 0, 0 },
5151 #if defined(TARGET_I386)
5153 /* NOTE: there is really one LDT for all the threads */
5154 static uint8_t *ldt_table
;
5156 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
5163 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
5164 if (size
> bytecount
)
5166 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
5168 return -TARGET_EFAULT
;
5169 /* ??? Should this by byteswapped? */
5170 memcpy(p
, ldt_table
, size
);
5171 unlock_user(p
, ptr
, size
);
5175 /* XXX: add locking support */
5176 static abi_long
write_ldt(CPUX86State
*env
,
5177 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
5179 struct target_modify_ldt_ldt_s ldt_info
;
5180 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5181 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5182 int seg_not_present
, useable
, lm
;
5183 uint32_t *lp
, entry_1
, entry_2
;
5185 if (bytecount
!= sizeof(ldt_info
))
5186 return -TARGET_EINVAL
;
5187 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
5188 return -TARGET_EFAULT
;
5189 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5190 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5191 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5192 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5193 unlock_user_struct(target_ldt_info
, ptr
, 0);
5195 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
5196 return -TARGET_EINVAL
;
5197 seg_32bit
= ldt_info
.flags
& 1;
5198 contents
= (ldt_info
.flags
>> 1) & 3;
5199 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5200 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5201 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5202 useable
= (ldt_info
.flags
>> 6) & 1;
5206 lm
= (ldt_info
.flags
>> 7) & 1;
5208 if (contents
== 3) {
5210 return -TARGET_EINVAL
;
5211 if (seg_not_present
== 0)
5212 return -TARGET_EINVAL
;
5214 /* allocate the LDT */
5216 env
->ldt
.base
= target_mmap(0,
5217 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
5218 PROT_READ
|PROT_WRITE
,
5219 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
5220 if (env
->ldt
.base
== -1)
5221 return -TARGET_ENOMEM
;
5222 memset(g2h(env
->ldt
.base
), 0,
5223 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
5224 env
->ldt
.limit
= 0xffff;
5225 ldt_table
= g2h(env
->ldt
.base
);
5228 /* NOTE: same code as Linux kernel */
5229 /* Allow LDTs to be cleared by the user. */
5230 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
5233 read_exec_only
== 1 &&
5235 limit_in_pages
== 0 &&
5236 seg_not_present
== 1 &&
5244 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
5245 (ldt_info
.limit
& 0x0ffff);
5246 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
5247 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
5248 (ldt_info
.limit
& 0xf0000) |
5249 ((read_exec_only
^ 1) << 9) |
5251 ((seg_not_present
^ 1) << 15) |
5253 (limit_in_pages
<< 23) |
5257 entry_2
|= (useable
<< 20);
5259 /* Install the new entry ... */
5261 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
5262 lp
[0] = tswap32(entry_1
);
5263 lp
[1] = tswap32(entry_2
);
5267 /* specific and weird i386 syscalls */
5268 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
5269 unsigned long bytecount
)
5275 ret
= read_ldt(ptr
, bytecount
);
5278 ret
= write_ldt(env
, ptr
, bytecount
, 1);
5281 ret
= write_ldt(env
, ptr
, bytecount
, 0);
5284 ret
= -TARGET_ENOSYS
;
5290 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5291 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
5293 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
5294 struct target_modify_ldt_ldt_s ldt_info
;
5295 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5296 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5297 int seg_not_present
, useable
, lm
;
5298 uint32_t *lp
, entry_1
, entry_2
;
5301 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
5302 if (!target_ldt_info
)
5303 return -TARGET_EFAULT
;
5304 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5305 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5306 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5307 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5308 if (ldt_info
.entry_number
== -1) {
5309 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
5310 if (gdt_table
[i
] == 0) {
5311 ldt_info
.entry_number
= i
;
5312 target_ldt_info
->entry_number
= tswap32(i
);
5317 unlock_user_struct(target_ldt_info
, ptr
, 1);
5319 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
5320 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
5321 return -TARGET_EINVAL
;
5322 seg_32bit
= ldt_info
.flags
& 1;
5323 contents
= (ldt_info
.flags
>> 1) & 3;
5324 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5325 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5326 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5327 useable
= (ldt_info
.flags
>> 6) & 1;
5331 lm
= (ldt_info
.flags
>> 7) & 1;
5334 if (contents
== 3) {
5335 if (seg_not_present
== 0)
5336 return -TARGET_EINVAL
;
5339 /* NOTE: same code as Linux kernel */
5340 /* Allow LDTs to be cleared by the user. */
5341 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
5342 if ((contents
== 0 &&
5343 read_exec_only
== 1 &&
5345 limit_in_pages
== 0 &&
5346 seg_not_present
== 1 &&
5354 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
5355 (ldt_info
.limit
& 0x0ffff);
5356 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
5357 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
5358 (ldt_info
.limit
& 0xf0000) |
5359 ((read_exec_only
^ 1) << 9) |
5361 ((seg_not_present
^ 1) << 15) |
5363 (limit_in_pages
<< 23) |
5368 /* Install the new entry ... */
5370 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
5371 lp
[0] = tswap32(entry_1
);
5372 lp
[1] = tswap32(entry_2
);
5376 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
5378 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5379 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
5380 uint32_t base_addr
, limit
, flags
;
5381 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
5382 int seg_not_present
, useable
, lm
;
5383 uint32_t *lp
, entry_1
, entry_2
;
5385 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
5386 if (!target_ldt_info
)
5387 return -TARGET_EFAULT
;
5388 idx
= tswap32(target_ldt_info
->entry_number
);
5389 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
5390 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
5391 unlock_user_struct(target_ldt_info
, ptr
, 1);
5392 return -TARGET_EINVAL
;
5394 lp
= (uint32_t *)(gdt_table
+ idx
);
5395 entry_1
= tswap32(lp
[0]);
5396 entry_2
= tswap32(lp
[1]);
5398 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
5399 contents
= (entry_2
>> 10) & 3;
5400 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
5401 seg_32bit
= (entry_2
>> 22) & 1;
5402 limit_in_pages
= (entry_2
>> 23) & 1;
5403 useable
= (entry_2
>> 20) & 1;
5407 lm
= (entry_2
>> 21) & 1;
5409 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
5410 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
5411 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
5412 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
5413 base_addr
= (entry_1
>> 16) |
5414 (entry_2
& 0xff000000) |
5415 ((entry_2
& 0xff) << 16);
5416 target_ldt_info
->base_addr
= tswapal(base_addr
);
5417 target_ldt_info
->limit
= tswap32(limit
);
5418 target_ldt_info
->flags
= tswap32(flags
);
5419 unlock_user_struct(target_ldt_info
, ptr
, 1);
5422 #endif /* TARGET_I386 && TARGET_ABI32 */
5424 #ifndef TARGET_ABI32
5425 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
5432 case TARGET_ARCH_SET_GS
:
5433 case TARGET_ARCH_SET_FS
:
5434 if (code
== TARGET_ARCH_SET_GS
)
5438 cpu_x86_load_seg(env
, idx
, 0);
5439 env
->segs
[idx
].base
= addr
;
5441 case TARGET_ARCH_GET_GS
:
5442 case TARGET_ARCH_GET_FS
:
5443 if (code
== TARGET_ARCH_GET_GS
)
5447 val
= env
->segs
[idx
].base
;
5448 if (put_user(val
, addr
, abi_ulong
))
5449 ret
= -TARGET_EFAULT
;
5452 ret
= -TARGET_EINVAL
;
5459 #endif /* defined(TARGET_I386) */
5461 #define NEW_STACK_SIZE 0x40000
5464 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
5467 pthread_mutex_t mutex
;
5468 pthread_cond_t cond
;
5471 abi_ulong child_tidptr
;
5472 abi_ulong parent_tidptr
;
5476 static void *clone_func(void *arg
)
5478 new_thread_info
*info
= arg
;
5483 rcu_register_thread();
5484 tcg_register_thread();
5488 ts
= (TaskState
*)cpu
->opaque
;
5489 info
->tid
= sys_gettid();
5491 if (info
->child_tidptr
)
5492 put_user_u32(info
->tid
, info
->child_tidptr
);
5493 if (info
->parent_tidptr
)
5494 put_user_u32(info
->tid
, info
->parent_tidptr
);
5495 qemu_guest_random_seed_thread_part2(cpu
->random_seed
);
5496 /* Enable signals. */
5497 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
5498 /* Signal to the parent that we're ready. */
5499 pthread_mutex_lock(&info
->mutex
);
5500 pthread_cond_broadcast(&info
->cond
);
5501 pthread_mutex_unlock(&info
->mutex
);
5502 /* Wait until the parent has finished initializing the tls state. */
5503 pthread_mutex_lock(&clone_lock
);
5504 pthread_mutex_unlock(&clone_lock
);
5510 /* do_fork() Must return host values and target errnos (unlike most
5511 do_*() functions). */
5512 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
5513 abi_ulong parent_tidptr
, target_ulong newtls
,
5514 abi_ulong child_tidptr
)
5516 CPUState
*cpu
= env_cpu(env
);
5520 CPUArchState
*new_env
;
5523 flags
&= ~CLONE_IGNORED_FLAGS
;
5525 /* Emulate vfork() with fork() */
5526 if (flags
& CLONE_VFORK
)
5527 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
5529 if (flags
& CLONE_VM
) {
5530 TaskState
*parent_ts
= (TaskState
*)cpu
->opaque
;
5531 new_thread_info info
;
5532 pthread_attr_t attr
;
5534 if (((flags
& CLONE_THREAD_FLAGS
) != CLONE_THREAD_FLAGS
) ||
5535 (flags
& CLONE_INVALID_THREAD_FLAGS
)) {
5536 return -TARGET_EINVAL
;
5539 ts
= g_new0(TaskState
, 1);
5540 init_task_state(ts
);
5542 /* Grab a mutex so that thread setup appears atomic. */
5543 pthread_mutex_lock(&clone_lock
);
5545 /* we create a new CPU instance. */
5546 new_env
= cpu_copy(env
);
5547 /* Init regs that differ from the parent. */
5548 cpu_clone_regs(new_env
, newsp
);
5549 new_cpu
= env_cpu(new_env
);
5550 new_cpu
->opaque
= ts
;
5551 ts
->bprm
= parent_ts
->bprm
;
5552 ts
->info
= parent_ts
->info
;
5553 ts
->signal_mask
= parent_ts
->signal_mask
;
5555 if (flags
& CLONE_CHILD_CLEARTID
) {
5556 ts
->child_tidptr
= child_tidptr
;
5559 if (flags
& CLONE_SETTLS
) {
5560 cpu_set_tls (new_env
, newtls
);
5563 memset(&info
, 0, sizeof(info
));
5564 pthread_mutex_init(&info
.mutex
, NULL
);
5565 pthread_mutex_lock(&info
.mutex
);
5566 pthread_cond_init(&info
.cond
, NULL
);
5568 if (flags
& CLONE_CHILD_SETTID
) {
5569 info
.child_tidptr
= child_tidptr
;
5571 if (flags
& CLONE_PARENT_SETTID
) {
5572 info
.parent_tidptr
= parent_tidptr
;
5575 ret
= pthread_attr_init(&attr
);
5576 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
5577 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
5578 /* It is not safe to deliver signals until the child has finished
5579 initializing, so temporarily block all signals. */
5580 sigfillset(&sigmask
);
5581 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
5582 cpu
->random_seed
= qemu_guest_random_seed_thread_part1();
5584 /* If this is our first additional thread, we need to ensure we
5585 * generate code for parallel execution and flush old translations.
5587 if (!parallel_cpus
) {
5588 parallel_cpus
= true;
5592 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
5593 /* TODO: Free new CPU state if thread creation failed. */
5595 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
5596 pthread_attr_destroy(&attr
);
5598 /* Wait for the child to initialize. */
5599 pthread_cond_wait(&info
.cond
, &info
.mutex
);
5604 pthread_mutex_unlock(&info
.mutex
);
5605 pthread_cond_destroy(&info
.cond
);
5606 pthread_mutex_destroy(&info
.mutex
);
5607 pthread_mutex_unlock(&clone_lock
);
5609 /* if no CLONE_VM, we consider it is a fork */
5610 if (flags
& CLONE_INVALID_FORK_FLAGS
) {
5611 return -TARGET_EINVAL
;
5614 /* We can't support custom termination signals */
5615 if ((flags
& CSIGNAL
) != TARGET_SIGCHLD
) {
5616 return -TARGET_EINVAL
;
5619 if (block_signals()) {
5620 return -TARGET_ERESTARTSYS
;
5626 /* Child Process. */
5627 cpu_clone_regs(env
, newsp
);
5629 /* There is a race condition here. The parent process could
5630 theoretically read the TID in the child process before the child
5631 tid is set. This would require using either ptrace
5632 (not implemented) or having *_tidptr to point at a shared memory
5633 mapping. We can't repeat the spinlock hack used above because
5634 the child process gets its own copy of the lock. */
5635 if (flags
& CLONE_CHILD_SETTID
)
5636 put_user_u32(sys_gettid(), child_tidptr
);
5637 if (flags
& CLONE_PARENT_SETTID
)
5638 put_user_u32(sys_gettid(), parent_tidptr
);
5639 ts
= (TaskState
*)cpu
->opaque
;
5640 if (flags
& CLONE_SETTLS
)
5641 cpu_set_tls (env
, newtls
);
5642 if (flags
& CLONE_CHILD_CLEARTID
)
5643 ts
->child_tidptr
= child_tidptr
;
5651 /* warning : doesn't handle linux specific flags... */
5652 static int target_to_host_fcntl_cmd(int cmd
)
5657 case TARGET_F_DUPFD
:
5658 case TARGET_F_GETFD
:
5659 case TARGET_F_SETFD
:
5660 case TARGET_F_GETFL
:
5661 case TARGET_F_SETFL
:
5664 case TARGET_F_GETLK
:
5667 case TARGET_F_SETLK
:
5670 case TARGET_F_SETLKW
:
5673 case TARGET_F_GETOWN
:
5676 case TARGET_F_SETOWN
:
5679 case TARGET_F_GETSIG
:
5682 case TARGET_F_SETSIG
:
5685 #if TARGET_ABI_BITS == 32
5686 case TARGET_F_GETLK64
:
5689 case TARGET_F_SETLK64
:
5692 case TARGET_F_SETLKW64
:
5696 case TARGET_F_SETLEASE
:
5699 case TARGET_F_GETLEASE
:
5702 #ifdef F_DUPFD_CLOEXEC
5703 case TARGET_F_DUPFD_CLOEXEC
:
5704 ret
= F_DUPFD_CLOEXEC
;
5707 case TARGET_F_NOTIFY
:
5711 case TARGET_F_GETOWN_EX
:
5716 case TARGET_F_SETOWN_EX
:
5721 case TARGET_F_SETPIPE_SZ
:
5724 case TARGET_F_GETPIPE_SZ
:
5729 ret
= -TARGET_EINVAL
;
5733 #if defined(__powerpc64__)
5734 /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and
5735 * is not supported by kernel. The glibc fcntl call actually adjusts
5736 * them to 5, 6 and 7 before making the syscall(). Since we make the
5737 * syscall directly, adjust to what is supported by the kernel.
5739 if (ret
>= F_GETLK64
&& ret
<= F_SETLKW64
) {
5740 ret
-= F_GETLK64
- 5;
5747 #define FLOCK_TRANSTBL \
5749 TRANSTBL_CONVERT(F_RDLCK); \
5750 TRANSTBL_CONVERT(F_WRLCK); \
5751 TRANSTBL_CONVERT(F_UNLCK); \
5752 TRANSTBL_CONVERT(F_EXLCK); \
5753 TRANSTBL_CONVERT(F_SHLCK); \
5756 static int target_to_host_flock(int type
)
5758 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
5760 #undef TRANSTBL_CONVERT
5761 return -TARGET_EINVAL
;
5764 static int host_to_target_flock(int type
)
5766 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
5768 #undef TRANSTBL_CONVERT
5769 /* if we don't know how to convert the value coming
5770 * from the host we copy to the target field as-is
5775 static inline abi_long
copy_from_user_flock(struct flock64
*fl
,
5776 abi_ulong target_flock_addr
)
5778 struct target_flock
*target_fl
;
5781 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
5782 return -TARGET_EFAULT
;
5785 __get_user(l_type
, &target_fl
->l_type
);
5786 l_type
= target_to_host_flock(l_type
);
5790 fl
->l_type
= l_type
;
5791 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
5792 __get_user(fl
->l_start
, &target_fl
->l_start
);
5793 __get_user(fl
->l_len
, &target_fl
->l_len
);
5794 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
5795 unlock_user_struct(target_fl
, target_flock_addr
, 0);
5799 static inline abi_long
copy_to_user_flock(abi_ulong target_flock_addr
,
5800 const struct flock64
*fl
)
5802 struct target_flock
*target_fl
;
5805 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
5806 return -TARGET_EFAULT
;
5809 l_type
= host_to_target_flock(fl
->l_type
);
5810 __put_user(l_type
, &target_fl
->l_type
);
5811 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
5812 __put_user(fl
->l_start
, &target_fl
->l_start
);
5813 __put_user(fl
->l_len
, &target_fl
->l_len
);
5814 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
5815 unlock_user_struct(target_fl
, target_flock_addr
, 1);
5819 typedef abi_long
from_flock64_fn(struct flock64
*fl
, abi_ulong target_addr
);
5820 typedef abi_long
to_flock64_fn(abi_ulong target_addr
, const struct flock64
*fl
);
5822 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
5823 static inline abi_long
copy_from_user_oabi_flock64(struct flock64
*fl
,
5824 abi_ulong target_flock_addr
)
5826 struct target_oabi_flock64
*target_fl
;
5829 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
5830 return -TARGET_EFAULT
;
5833 __get_user(l_type
, &target_fl
->l_type
);
5834 l_type
= target_to_host_flock(l_type
);
5838 fl
->l_type
= l_type
;
5839 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
5840 __get_user(fl
->l_start
, &target_fl
->l_start
);
5841 __get_user(fl
->l_len
, &target_fl
->l_len
);
5842 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
5843 unlock_user_struct(target_fl
, target_flock_addr
, 0);
5847 static inline abi_long
copy_to_user_oabi_flock64(abi_ulong target_flock_addr
,
5848 const struct flock64
*fl
)
5850 struct target_oabi_flock64
*target_fl
;
5853 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
5854 return -TARGET_EFAULT
;
5857 l_type
= host_to_target_flock(fl
->l_type
);
5858 __put_user(l_type
, &target_fl
->l_type
);
5859 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
5860 __put_user(fl
->l_start
, &target_fl
->l_start
);
5861 __put_user(fl
->l_len
, &target_fl
->l_len
);
5862 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
5863 unlock_user_struct(target_fl
, target_flock_addr
, 1);
5868 static inline abi_long
copy_from_user_flock64(struct flock64
*fl
,
5869 abi_ulong target_flock_addr
)
5871 struct target_flock64
*target_fl
;
5874 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
5875 return -TARGET_EFAULT
;
5878 __get_user(l_type
, &target_fl
->l_type
);
5879 l_type
= target_to_host_flock(l_type
);
5883 fl
->l_type
= l_type
;
5884 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
5885 __get_user(fl
->l_start
, &target_fl
->l_start
);
5886 __get_user(fl
->l_len
, &target_fl
->l_len
);
5887 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
5888 unlock_user_struct(target_fl
, target_flock_addr
, 0);
5892 static inline abi_long
copy_to_user_flock64(abi_ulong target_flock_addr
,
5893 const struct flock64
*fl
)
5895 struct target_flock64
*target_fl
;
5898 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
5899 return -TARGET_EFAULT
;
5902 l_type
= host_to_target_flock(fl
->l_type
);
5903 __put_user(l_type
, &target_fl
->l_type
);
5904 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
5905 __put_user(fl
->l_start
, &target_fl
->l_start
);
5906 __put_user(fl
->l_len
, &target_fl
->l_len
);
5907 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
5908 unlock_user_struct(target_fl
, target_flock_addr
, 1);
5912 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
5914 struct flock64 fl64
;
5916 struct f_owner_ex fox
;
5917 struct target_f_owner_ex
*target_fox
;
5920 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
5922 if (host_cmd
== -TARGET_EINVAL
)
5926 case TARGET_F_GETLK
:
5927 ret
= copy_from_user_flock(&fl64
, arg
);
5931 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
5933 ret
= copy_to_user_flock(arg
, &fl64
);
5937 case TARGET_F_SETLK
:
5938 case TARGET_F_SETLKW
:
5939 ret
= copy_from_user_flock(&fl64
, arg
);
5943 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
5946 case TARGET_F_GETLK64
:
5947 ret
= copy_from_user_flock64(&fl64
, arg
);
5951 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
5953 ret
= copy_to_user_flock64(arg
, &fl64
);
5956 case TARGET_F_SETLK64
:
5957 case TARGET_F_SETLKW64
:
5958 ret
= copy_from_user_flock64(&fl64
, arg
);
5962 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
5965 case TARGET_F_GETFL
:
5966 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
5968 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
5972 case TARGET_F_SETFL
:
5973 ret
= get_errno(safe_fcntl(fd
, host_cmd
,
5974 target_to_host_bitmask(arg
,
5979 case TARGET_F_GETOWN_EX
:
5980 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
5982 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
5983 return -TARGET_EFAULT
;
5984 target_fox
->type
= tswap32(fox
.type
);
5985 target_fox
->pid
= tswap32(fox
.pid
);
5986 unlock_user_struct(target_fox
, arg
, 1);
5992 case TARGET_F_SETOWN_EX
:
5993 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
5994 return -TARGET_EFAULT
;
5995 fox
.type
= tswap32(target_fox
->type
);
5996 fox
.pid
= tswap32(target_fox
->pid
);
5997 unlock_user_struct(target_fox
, arg
, 0);
5998 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6002 case TARGET_F_SETOWN
:
6003 case TARGET_F_GETOWN
:
6004 case TARGET_F_SETSIG
:
6005 case TARGET_F_GETSIG
:
6006 case TARGET_F_SETLEASE
:
6007 case TARGET_F_GETLEASE
:
6008 case TARGET_F_SETPIPE_SZ
:
6009 case TARGET_F_GETPIPE_SZ
:
6010 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6014 ret
= get_errno(safe_fcntl(fd
, cmd
, arg
));
6022 static inline int high2lowuid(int uid
)
6030 static inline int high2lowgid(int gid
)
6038 static inline int low2highuid(int uid
)
6040 if ((int16_t)uid
== -1)
6046 static inline int low2highgid(int gid
)
6048 if ((int16_t)gid
== -1)
6053 static inline int tswapid(int id
)
6058 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6060 #else /* !USE_UID16 */
6061 static inline int high2lowuid(int uid
)
6065 static inline int high2lowgid(int gid
)
6069 static inline int low2highuid(int uid
)
6073 static inline int low2highgid(int gid
)
6077 static inline int tswapid(int id
)
6082 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6084 #endif /* USE_UID16 */
6086 /* We must do direct syscalls for setting UID/GID, because we want to
6087 * implement the Linux system call semantics of "change only for this thread",
6088 * not the libc/POSIX semantics of "change for all threads in process".
6089 * (See http://ewontfix.com/17/ for more details.)
6090 * We use the 32-bit version of the syscalls if present; if it is not
6091 * then either the host architecture supports 32-bit UIDs natively with
6092 * the standard syscall, or the 16-bit UID is the best we can do.
6094 #ifdef __NR_setuid32
6095 #define __NR_sys_setuid __NR_setuid32
6097 #define __NR_sys_setuid __NR_setuid
6099 #ifdef __NR_setgid32
6100 #define __NR_sys_setgid __NR_setgid32
6102 #define __NR_sys_setgid __NR_setgid
6104 #ifdef __NR_setresuid32
6105 #define __NR_sys_setresuid __NR_setresuid32
6107 #define __NR_sys_setresuid __NR_setresuid
6109 #ifdef __NR_setresgid32
6110 #define __NR_sys_setresgid __NR_setresgid32
6112 #define __NR_sys_setresgid __NR_setresgid
6115 _syscall1(int, sys_setuid
, uid_t
, uid
)
6116 _syscall1(int, sys_setgid
, gid_t
, gid
)
6117 _syscall3(int, sys_setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
6118 _syscall3(int, sys_setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
6120 void syscall_init(void)
6123 const argtype
*arg_type
;
6127 thunk_init(STRUCT_MAX
);
6129 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
6130 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
6131 #include "syscall_types.h"
6133 #undef STRUCT_SPECIAL
6135 /* Build target_to_host_errno_table[] table from
6136 * host_to_target_errno_table[]. */
6137 for (i
= 0; i
< ERRNO_TABLE_SIZE
; i
++) {
6138 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
6141 /* we patch the ioctl size if necessary. We rely on the fact that
6142 no ioctl has all the bits at '1' in the size field */
6144 while (ie
->target_cmd
!= 0) {
6145 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
6146 TARGET_IOC_SIZEMASK
) {
6147 arg_type
= ie
->arg_type
;
6148 if (arg_type
[0] != TYPE_PTR
) {
6149 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
6154 size
= thunk_type_size(arg_type
, 0);
6155 ie
->target_cmd
= (ie
->target_cmd
&
6156 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
6157 (size
<< TARGET_IOC_SIZESHIFT
);
6160 /* automatic consistency check if same arch */
6161 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6162 (defined(__x86_64__) && defined(TARGET_X86_64))
6163 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
6164 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6165 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
6172 #if TARGET_ABI_BITS == 32
6173 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
6175 #ifdef TARGET_WORDS_BIGENDIAN
6176 return ((uint64_t)word0
<< 32) | word1
;
6178 return ((uint64_t)word1
<< 32) | word0
;
6181 #else /* TARGET_ABI_BITS == 32 */
6182 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
6186 #endif /* TARGET_ABI_BITS != 32 */
6188 #ifdef TARGET_NR_truncate64
6189 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
6194 if (regpairs_aligned(cpu_env
, TARGET_NR_truncate64
)) {
6198 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
6202 #ifdef TARGET_NR_ftruncate64
6203 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
6208 if (regpairs_aligned(cpu_env
, TARGET_NR_ftruncate64
)) {
6212 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
6216 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
6217 abi_ulong target_addr
)
6219 struct target_timespec
*target_ts
;
6221 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
6222 return -TARGET_EFAULT
;
6223 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
6224 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
6225 unlock_user_struct(target_ts
, target_addr
, 0);
6229 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
6230 struct timespec
*host_ts
)
6232 struct target_timespec
*target_ts
;
6234 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
6235 return -TARGET_EFAULT
;
6236 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
6237 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
6238 unlock_user_struct(target_ts
, target_addr
, 1);
6242 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_itspec
,
6243 abi_ulong target_addr
)
6245 struct target_itimerspec
*target_itspec
;
6247 if (!lock_user_struct(VERIFY_READ
, target_itspec
, target_addr
, 1)) {
6248 return -TARGET_EFAULT
;
6251 host_itspec
->it_interval
.tv_sec
=
6252 tswapal(target_itspec
->it_interval
.tv_sec
);
6253 host_itspec
->it_interval
.tv_nsec
=
6254 tswapal(target_itspec
->it_interval
.tv_nsec
);
6255 host_itspec
->it_value
.tv_sec
= tswapal(target_itspec
->it_value
.tv_sec
);
6256 host_itspec
->it_value
.tv_nsec
= tswapal(target_itspec
->it_value
.tv_nsec
);
6258 unlock_user_struct(target_itspec
, target_addr
, 1);
6262 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
6263 struct itimerspec
*host_its
)
6265 struct target_itimerspec
*target_itspec
;
6267 if (!lock_user_struct(VERIFY_WRITE
, target_itspec
, target_addr
, 0)) {
6268 return -TARGET_EFAULT
;
6271 target_itspec
->it_interval
.tv_sec
= tswapal(host_its
->it_interval
.tv_sec
);
6272 target_itspec
->it_interval
.tv_nsec
= tswapal(host_its
->it_interval
.tv_nsec
);
6274 target_itspec
->it_value
.tv_sec
= tswapal(host_its
->it_value
.tv_sec
);
6275 target_itspec
->it_value
.tv_nsec
= tswapal(host_its
->it_value
.tv_nsec
);
6277 unlock_user_struct(target_itspec
, target_addr
, 0);
6281 static inline abi_long
target_to_host_timex(struct timex
*host_tx
,
6282 abi_long target_addr
)
6284 struct target_timex
*target_tx
;
6286 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
6287 return -TARGET_EFAULT
;
6290 __get_user(host_tx
->modes
, &target_tx
->modes
);
6291 __get_user(host_tx
->offset
, &target_tx
->offset
);
6292 __get_user(host_tx
->freq
, &target_tx
->freq
);
6293 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
6294 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
6295 __get_user(host_tx
->status
, &target_tx
->status
);
6296 __get_user(host_tx
->constant
, &target_tx
->constant
);
6297 __get_user(host_tx
->precision
, &target_tx
->precision
);
6298 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
6299 __get_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
6300 __get_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
6301 __get_user(host_tx
->tick
, &target_tx
->tick
);
6302 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
6303 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
6304 __get_user(host_tx
->shift
, &target_tx
->shift
);
6305 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
6306 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
6307 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
6308 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
6309 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
6310 __get_user(host_tx
->tai
, &target_tx
->tai
);
6312 unlock_user_struct(target_tx
, target_addr
, 0);
6316 static inline abi_long
host_to_target_timex(abi_long target_addr
,
6317 struct timex
*host_tx
)
6319 struct target_timex
*target_tx
;
6321 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
6322 return -TARGET_EFAULT
;
6325 __put_user(host_tx
->modes
, &target_tx
->modes
);
6326 __put_user(host_tx
->offset
, &target_tx
->offset
);
6327 __put_user(host_tx
->freq
, &target_tx
->freq
);
6328 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
6329 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
6330 __put_user(host_tx
->status
, &target_tx
->status
);
6331 __put_user(host_tx
->constant
, &target_tx
->constant
);
6332 __put_user(host_tx
->precision
, &target_tx
->precision
);
6333 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
6334 __put_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
6335 __put_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
6336 __put_user(host_tx
->tick
, &target_tx
->tick
);
6337 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
6338 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
6339 __put_user(host_tx
->shift
, &target_tx
->shift
);
6340 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
6341 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
6342 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
6343 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
6344 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
6345 __put_user(host_tx
->tai
, &target_tx
->tai
);
6347 unlock_user_struct(target_tx
, target_addr
, 1);
6352 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
6353 abi_ulong target_addr
)
6355 struct target_sigevent
*target_sevp
;
6357 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
6358 return -TARGET_EFAULT
;
6361 /* This union is awkward on 64 bit systems because it has a 32 bit
6362 * integer and a pointer in it; we follow the conversion approach
6363 * used for handling sigval types in signal.c so the guest should get
6364 * the correct value back even if we did a 64 bit byteswap and it's
6365 * using the 32 bit integer.
6367 host_sevp
->sigev_value
.sival_ptr
=
6368 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
6369 host_sevp
->sigev_signo
=
6370 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
6371 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
6372 host_sevp
->_sigev_un
._tid
= tswap32(target_sevp
->_sigev_un
._tid
);
6374 unlock_user_struct(target_sevp
, target_addr
, 1);
6378 #if defined(TARGET_NR_mlockall)
6379 static inline int target_to_host_mlockall_arg(int arg
)
6383 if (arg
& TARGET_MLOCKALL_MCL_CURRENT
) {
6384 result
|= MCL_CURRENT
;
6386 if (arg
& TARGET_MLOCKALL_MCL_FUTURE
) {
6387 result
|= MCL_FUTURE
;
6393 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) || \
6394 defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) || \
6395 defined(TARGET_NR_newfstatat))
6396 static inline abi_long
host_to_target_stat64(void *cpu_env
,
6397 abi_ulong target_addr
,
6398 struct stat
*host_st
)
6400 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
6401 if (((CPUARMState
*)cpu_env
)->eabi
) {
6402 struct target_eabi_stat64
*target_st
;
6404 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
6405 return -TARGET_EFAULT
;
6406 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
6407 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
6408 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
6409 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6410 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
6412 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
6413 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
6414 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
6415 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
6416 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
6417 __put_user(host_st
->st_size
, &target_st
->st_size
);
6418 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
6419 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
6420 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
6421 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
6422 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
6423 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
6424 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
6425 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
6426 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
6428 unlock_user_struct(target_st
, target_addr
, 1);
6432 #if defined(TARGET_HAS_STRUCT_STAT64)
6433 struct target_stat64
*target_st
;
6435 struct target_stat
*target_st
;
6438 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
6439 return -TARGET_EFAULT
;
6440 memset(target_st
, 0, sizeof(*target_st
));
6441 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
6442 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
6443 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6444 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
6446 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
6447 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
6448 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
6449 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
6450 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
6451 /* XXX: better use of kernel struct */
6452 __put_user(host_st
->st_size
, &target_st
->st_size
);
6453 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
6454 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
6455 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
6456 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
6457 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
6458 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
6459 __put_user(host_st
->st_atim
.tv_nsec
, &target_st
->target_st_atime_nsec
);
6460 __put_user(host_st
->st_mtim
.tv_nsec
, &target_st
->target_st_mtime_nsec
);
6461 __put_user(host_st
->st_ctim
.tv_nsec
, &target_st
->target_st_ctime_nsec
);
6463 unlock_user_struct(target_st
, target_addr
, 1);
6470 /* ??? Using host futex calls even when target atomic operations
6471 are not really atomic probably breaks things. However implementing
6472 futexes locally would make futexes shared between multiple processes
6473 tricky. However they're probably useless because guest atomic
6474 operations won't work either. */
6475 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
6476 target_ulong uaddr2
, int val3
)
6478 struct timespec ts
, *pts
;
6481 /* ??? We assume FUTEX_* constants are the same on both host
6483 #ifdef FUTEX_CMD_MASK
6484 base_op
= op
& FUTEX_CMD_MASK
;
6490 case FUTEX_WAIT_BITSET
:
6493 target_to_host_timespec(pts
, timeout
);
6497 return get_errno(safe_futex(g2h(uaddr
), op
, tswap32(val
),
6500 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
6502 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
6504 case FUTEX_CMP_REQUEUE
:
6506 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
6507 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
6508 But the prototype takes a `struct timespec *'; insert casts
6509 to satisfy the compiler. We do not need to tswap TIMEOUT
6510 since it's not compared to guest memory. */
6511 pts
= (struct timespec
*)(uintptr_t) timeout
;
6512 return get_errno(safe_futex(g2h(uaddr
), op
, val
, pts
,
6514 (base_op
== FUTEX_CMP_REQUEUE
6518 return -TARGET_ENOSYS
;
6521 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6522 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
6523 abi_long handle
, abi_long mount_id
,
6526 struct file_handle
*target_fh
;
6527 struct file_handle
*fh
;
6531 unsigned int size
, total_size
;
6533 if (get_user_s32(size
, handle
)) {
6534 return -TARGET_EFAULT
;
6537 name
= lock_user_string(pathname
);
6539 return -TARGET_EFAULT
;
6542 total_size
= sizeof(struct file_handle
) + size
;
6543 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
6545 unlock_user(name
, pathname
, 0);
6546 return -TARGET_EFAULT
;
6549 fh
= g_malloc0(total_size
);
6550 fh
->handle_bytes
= size
;
6552 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
6553 unlock_user(name
, pathname
, 0);
6555 /* man name_to_handle_at(2):
6556 * Other than the use of the handle_bytes field, the caller should treat
6557 * the file_handle structure as an opaque data type
6560 memcpy(target_fh
, fh
, total_size
);
6561 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
6562 target_fh
->handle_type
= tswap32(fh
->handle_type
);
6564 unlock_user(target_fh
, handle
, total_size
);
6566 if (put_user_s32(mid
, mount_id
)) {
6567 return -TARGET_EFAULT
;
6575 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6576 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
6579 struct file_handle
*target_fh
;
6580 struct file_handle
*fh
;
6581 unsigned int size
, total_size
;
6584 if (get_user_s32(size
, handle
)) {
6585 return -TARGET_EFAULT
;
6588 total_size
= sizeof(struct file_handle
) + size
;
6589 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
6591 return -TARGET_EFAULT
;
6594 fh
= g_memdup(target_fh
, total_size
);
6595 fh
->handle_bytes
= size
;
6596 fh
->handle_type
= tswap32(target_fh
->handle_type
);
6598 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
6599 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
6603 unlock_user(target_fh
, handle
, total_size
);
6609 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
6611 static abi_long
do_signalfd4(int fd
, abi_long mask
, int flags
)
6614 target_sigset_t
*target_mask
;
6618 if (flags
& ~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
)) {
6619 return -TARGET_EINVAL
;
6621 if (!lock_user_struct(VERIFY_READ
, target_mask
, mask
, 1)) {
6622 return -TARGET_EFAULT
;
6625 target_to_host_sigset(&host_mask
, target_mask
);
6627 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
6629 ret
= get_errno(signalfd(fd
, &host_mask
, host_flags
));
6631 fd_trans_register(ret
, &target_signalfd_trans
);
6634 unlock_user_struct(target_mask
, mask
, 0);
6640 /* Map host to target signal numbers for the wait family of syscalls.
6641 Assume all other status bits are the same. */
6642 int host_to_target_waitstatus(int status
)
6644 if (WIFSIGNALED(status
)) {
6645 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
6647 if (WIFSTOPPED(status
)) {
6648 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
6654 static int open_self_cmdline(void *cpu_env
, int fd
)
6656 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6657 struct linux_binprm
*bprm
= ((TaskState
*)cpu
->opaque
)->bprm
;
6660 for (i
= 0; i
< bprm
->argc
; i
++) {
6661 size_t len
= strlen(bprm
->argv
[i
]) + 1;
6663 if (write(fd
, bprm
->argv
[i
], len
) != len
) {
6671 static int open_self_maps(void *cpu_env
, int fd
)
6673 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6674 TaskState
*ts
= cpu
->opaque
;
6680 fp
= fopen("/proc/self/maps", "r");
6685 while ((read
= getline(&line
, &len
, fp
)) != -1) {
6686 int fields
, dev_maj
, dev_min
, inode
;
6687 uint64_t min
, max
, offset
;
6688 char flag_r
, flag_w
, flag_x
, flag_p
;
6689 char path
[512] = "";
6690 fields
= sscanf(line
, "%"PRIx64
"-%"PRIx64
" %c%c%c%c %"PRIx64
" %x:%x %d"
6691 " %512s", &min
, &max
, &flag_r
, &flag_w
, &flag_x
,
6692 &flag_p
, &offset
, &dev_maj
, &dev_min
, &inode
, path
);
6694 if ((fields
< 10) || (fields
> 11)) {
6697 if (h2g_valid(min
)) {
6698 int flags
= page_get_flags(h2g(min
));
6699 max
= h2g_valid(max
- 1) ? max
: (uintptr_t)g2h(GUEST_ADDR_MAX
) + 1;
6700 if (page_check_range(h2g(min
), max
- min
, flags
) == -1) {
6703 if (h2g(min
) == ts
->info
->stack_limit
) {
6704 pstrcpy(path
, sizeof(path
), " [stack]");
6706 dprintf(fd
, TARGET_ABI_FMT_ptr
"-" TARGET_ABI_FMT_ptr
6707 " %c%c%c%c %08" PRIx64
" %02x:%02x %d %s%s\n",
6708 h2g(min
), h2g(max
- 1) + 1, flag_r
, flag_w
,
6709 flag_x
, flag_p
, offset
, dev_maj
, dev_min
, inode
,
6710 path
[0] ? " " : "", path
);
6720 static int open_self_stat(void *cpu_env
, int fd
)
6722 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6723 TaskState
*ts
= cpu
->opaque
;
6724 abi_ulong start_stack
= ts
->info
->start_stack
;
6727 for (i
= 0; i
< 44; i
++) {
6735 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
6736 } else if (i
== 1) {
6738 snprintf(buf
, sizeof(buf
), "(%s) ", ts
->bprm
->argv
[0]);
6739 } else if (i
== 27) {
6742 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
6744 /* for the rest, there is MasterCard */
6745 snprintf(buf
, sizeof(buf
), "0%c", i
== 43 ? '\n' : ' ');
6749 if (write(fd
, buf
, len
) != len
) {
6757 static int open_self_auxv(void *cpu_env
, int fd
)
6759 CPUState
*cpu
= env_cpu((CPUArchState
*)cpu_env
);
6760 TaskState
*ts
= cpu
->opaque
;
6761 abi_ulong auxv
= ts
->info
->saved_auxv
;
6762 abi_ulong len
= ts
->info
->auxv_len
;
6766 * Auxiliary vector is stored in target process stack.
6767 * read in whole auxv vector and copy it to file
6769 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
6773 r
= write(fd
, ptr
, len
);
6780 lseek(fd
, 0, SEEK_SET
);
6781 unlock_user(ptr
, auxv
, len
);
6787 static int is_proc_myself(const char *filename
, const char *entry
)
6789 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
6790 filename
+= strlen("/proc/");
6791 if (!strncmp(filename
, "self/", strlen("self/"))) {
6792 filename
+= strlen("self/");
6793 } else if (*filename
>= '1' && *filename
<= '9') {
6795 snprintf(myself
, sizeof(myself
), "%d/", getpid());
6796 if (!strncmp(filename
, myself
, strlen(myself
))) {
6797 filename
+= strlen(myself
);
6804 if (!strcmp(filename
, entry
)) {
6811 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) || \
6812 defined(TARGET_SPARC) || defined(TARGET_M68K)
6813 static int is_proc(const char *filename
, const char *entry
)
6815 return strcmp(filename
, entry
) == 0;
6819 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
6820 static int open_net_route(void *cpu_env
, int fd
)
6827 fp
= fopen("/proc/net/route", "r");
6834 read
= getline(&line
, &len
, fp
);
6835 dprintf(fd
, "%s", line
);
6839 while ((read
= getline(&line
, &len
, fp
)) != -1) {
6841 uint32_t dest
, gw
, mask
;
6842 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
6845 fields
= sscanf(line
,
6846 "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
6847 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
6848 &mask
, &mtu
, &window
, &irtt
);
6852 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
6853 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
6854 metric
, tswap32(mask
), mtu
, window
, irtt
);
6864 #if defined(TARGET_SPARC)
6865 static int open_cpuinfo(void *cpu_env
, int fd
)
6867 dprintf(fd
, "type\t\t: sun4u\n");
6872 #if defined(TARGET_M68K)
6873 static int open_hardware(void *cpu_env
, int fd
)
6875 dprintf(fd
, "Model:\t\tqemu-m68k\n");
6880 static int do_openat(void *cpu_env
, int dirfd
, const char *pathname
, int flags
, mode_t mode
)
6883 const char *filename
;
6884 int (*fill
)(void *cpu_env
, int fd
);
6885 int (*cmp
)(const char *s1
, const char *s2
);
6887 const struct fake_open
*fake_open
;
6888 static const struct fake_open fakes
[] = {
6889 { "maps", open_self_maps
, is_proc_myself
},
6890 { "stat", open_self_stat
, is_proc_myself
},
6891 { "auxv", open_self_auxv
, is_proc_myself
},
6892 { "cmdline", open_self_cmdline
, is_proc_myself
},
6893 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
6894 { "/proc/net/route", open_net_route
, is_proc
},
6896 #if defined(TARGET_SPARC)
6897 { "/proc/cpuinfo", open_cpuinfo
, is_proc
},
6899 #if defined(TARGET_M68K)
6900 { "/proc/hardware", open_hardware
, is_proc
},
6902 { NULL
, NULL
, NULL
}
6905 if (is_proc_myself(pathname
, "exe")) {
6906 int execfd
= qemu_getauxval(AT_EXECFD
);
6907 return execfd
? execfd
: safe_openat(dirfd
, exec_path
, flags
, mode
);
6910 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
6911 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
6916 if (fake_open
->filename
) {
6918 char filename
[PATH_MAX
];
6921 /* create temporary file to map stat to */
6922 tmpdir
= getenv("TMPDIR");
6925 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
6926 fd
= mkstemp(filename
);
6932 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
6938 lseek(fd
, 0, SEEK_SET
);
6943 return safe_openat(dirfd
, path(pathname
), flags
, mode
);
6946 #define TIMER_MAGIC 0x0caf0000
6947 #define TIMER_MAGIC_MASK 0xffff0000
6949 /* Convert QEMU provided timer ID back to internal 16bit index format */
6950 static target_timer_t
get_timer_id(abi_long arg
)
6952 target_timer_t timerid
= arg
;
6954 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
6955 return -TARGET_EINVAL
;
6960 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
6961 return -TARGET_EINVAL
;
6967 static int target_to_host_cpu_mask(unsigned long *host_mask
,
6969 abi_ulong target_addr
,
6972 unsigned target_bits
= sizeof(abi_ulong
) * 8;
6973 unsigned host_bits
= sizeof(*host_mask
) * 8;
6974 abi_ulong
*target_mask
;
6977 assert(host_size
>= target_size
);
6979 target_mask
= lock_user(VERIFY_READ
, target_addr
, target_size
, 1);
6981 return -TARGET_EFAULT
;
6983 memset(host_mask
, 0, host_size
);
6985 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
6986 unsigned bit
= i
* target_bits
;
6989 __get_user(val
, &target_mask
[i
]);
6990 for (j
= 0; j
< target_bits
; j
++, bit
++) {
6991 if (val
& (1UL << j
)) {
6992 host_mask
[bit
/ host_bits
] |= 1UL << (bit
% host_bits
);
6997 unlock_user(target_mask
, target_addr
, 0);
7001 static int host_to_target_cpu_mask(const unsigned long *host_mask
,
7003 abi_ulong target_addr
,
7006 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7007 unsigned host_bits
= sizeof(*host_mask
) * 8;
7008 abi_ulong
*target_mask
;
7011 assert(host_size
>= target_size
);
7013 target_mask
= lock_user(VERIFY_WRITE
, target_addr
, target_size
, 0);
7015 return -TARGET_EFAULT
;
7018 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7019 unsigned bit
= i
* target_bits
;
7022 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7023 if (host_mask
[bit
/ host_bits
] & (1UL << (bit
% host_bits
))) {
7027 __put_user(val
, &target_mask
[i
]);
7030 unlock_user(target_mask
, target_addr
, target_size
);
7034 /* This is an internal helper for do_syscall so that it is easier
7035 * to have a single return point, so that actions, such as logging
7036 * of syscall results, can be performed.
7037 * All errnos that do_syscall() returns must be -TARGET_<errcode>.
7039 static abi_long
do_syscall1(void *cpu_env
, int num
, abi_long arg1
,
7040 abi_long arg2
, abi_long arg3
, abi_long arg4
,
7041 abi_long arg5
, abi_long arg6
, abi_long arg7
,
7044 CPUState
*cpu
= env_cpu(cpu_env
);
7046 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \
7047 || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \
7048 || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
7051 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \
7052 || defined(TARGET_NR_fstatfs)
7058 case TARGET_NR_exit
:
7059 /* In old applications this may be used to implement _exit(2).
7060 However in threaded applictions it is used for thread termination,
7061 and _exit_group is used for application termination.
7062 Do thread termination if we have more then one thread. */
7064 if (block_signals()) {
7065 return -TARGET_ERESTARTSYS
;
7070 if (CPU_NEXT(first_cpu
)) {
7073 /* Remove the CPU from the list. */
7074 QTAILQ_REMOVE_RCU(&cpus
, cpu
, node
);
7079 if (ts
->child_tidptr
) {
7080 put_user_u32(0, ts
->child_tidptr
);
7081 sys_futex(g2h(ts
->child_tidptr
), FUTEX_WAKE
, INT_MAX
,
7085 object_unref(OBJECT(cpu
));
7087 rcu_unregister_thread();
7092 preexit_cleanup(cpu_env
, arg1
);
7094 return 0; /* avoid warning */
7095 case TARGET_NR_read
:
7096 if (arg2
== 0 && arg3
== 0) {
7097 return get_errno(safe_read(arg1
, 0, 0));
7099 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
7100 return -TARGET_EFAULT
;
7101 ret
= get_errno(safe_read(arg1
, p
, arg3
));
7103 fd_trans_host_to_target_data(arg1
)) {
7104 ret
= fd_trans_host_to_target_data(arg1
)(p
, ret
);
7106 unlock_user(p
, arg2
, ret
);
7109 case TARGET_NR_write
:
7110 if (arg2
== 0 && arg3
== 0) {
7111 return get_errno(safe_write(arg1
, 0, 0));
7113 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
7114 return -TARGET_EFAULT
;
7115 if (fd_trans_target_to_host_data(arg1
)) {
7116 void *copy
= g_malloc(arg3
);
7117 memcpy(copy
, p
, arg3
);
7118 ret
= fd_trans_target_to_host_data(arg1
)(copy
, arg3
);
7120 ret
= get_errno(safe_write(arg1
, copy
, ret
));
7124 ret
= get_errno(safe_write(arg1
, p
, arg3
));
7126 unlock_user(p
, arg2
, 0);
7129 #ifdef TARGET_NR_open
7130 case TARGET_NR_open
:
7131 if (!(p
= lock_user_string(arg1
)))
7132 return -TARGET_EFAULT
;
7133 ret
= get_errno(do_openat(cpu_env
, AT_FDCWD
, p
,
7134 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
7136 fd_trans_unregister(ret
);
7137 unlock_user(p
, arg1
, 0);
7140 case TARGET_NR_openat
:
7141 if (!(p
= lock_user_string(arg2
)))
7142 return -TARGET_EFAULT
;
7143 ret
= get_errno(do_openat(cpu_env
, arg1
, p
,
7144 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
7146 fd_trans_unregister(ret
);
7147 unlock_user(p
, arg2
, 0);
7149 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7150 case TARGET_NR_name_to_handle_at
:
7151 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
7154 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7155 case TARGET_NR_open_by_handle_at
:
7156 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
7157 fd_trans_unregister(ret
);
7160 case TARGET_NR_close
:
7161 fd_trans_unregister(arg1
);
7162 return get_errno(close(arg1
));
7165 return do_brk(arg1
);
7166 #ifdef TARGET_NR_fork
7167 case TARGET_NR_fork
:
7168 return get_errno(do_fork(cpu_env
, TARGET_SIGCHLD
, 0, 0, 0, 0));
7170 #ifdef TARGET_NR_waitpid
7171 case TARGET_NR_waitpid
:
7174 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, 0));
7175 if (!is_error(ret
) && arg2
&& ret
7176 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
7177 return -TARGET_EFAULT
;
7181 #ifdef TARGET_NR_waitid
7182 case TARGET_NR_waitid
:
7186 ret
= get_errno(safe_waitid(arg1
, arg2
, &info
, arg4
, NULL
));
7187 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
7188 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
7189 return -TARGET_EFAULT
;
7190 host_to_target_siginfo(p
, &info
);
7191 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
7196 #ifdef TARGET_NR_creat /* not on alpha */
7197 case TARGET_NR_creat
:
7198 if (!(p
= lock_user_string(arg1
)))
7199 return -TARGET_EFAULT
;
7200 ret
= get_errno(creat(p
, arg2
));
7201 fd_trans_unregister(ret
);
7202 unlock_user(p
, arg1
, 0);
7205 #ifdef TARGET_NR_link
7206 case TARGET_NR_link
:
7209 p
= lock_user_string(arg1
);
7210 p2
= lock_user_string(arg2
);
7212 ret
= -TARGET_EFAULT
;
7214 ret
= get_errno(link(p
, p2
));
7215 unlock_user(p2
, arg2
, 0);
7216 unlock_user(p
, arg1
, 0);
7220 #if defined(TARGET_NR_linkat)
7221 case TARGET_NR_linkat
:
7225 return -TARGET_EFAULT
;
7226 p
= lock_user_string(arg2
);
7227 p2
= lock_user_string(arg4
);
7229 ret
= -TARGET_EFAULT
;
7231 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
7232 unlock_user(p
, arg2
, 0);
7233 unlock_user(p2
, arg4
, 0);
7237 #ifdef TARGET_NR_unlink
7238 case TARGET_NR_unlink
:
7239 if (!(p
= lock_user_string(arg1
)))
7240 return -TARGET_EFAULT
;
7241 ret
= get_errno(unlink(p
));
7242 unlock_user(p
, arg1
, 0);
7245 #if defined(TARGET_NR_unlinkat)
7246 case TARGET_NR_unlinkat
:
7247 if (!(p
= lock_user_string(arg2
)))
7248 return -TARGET_EFAULT
;
7249 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
7250 unlock_user(p
, arg2
, 0);
7253 case TARGET_NR_execve
:
7255 char **argp
, **envp
;
7258 abi_ulong guest_argp
;
7259 abi_ulong guest_envp
;
7266 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
7267 if (get_user_ual(addr
, gp
))
7268 return -TARGET_EFAULT
;
7275 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
7276 if (get_user_ual(addr
, gp
))
7277 return -TARGET_EFAULT
;
7283 argp
= g_new0(char *, argc
+ 1);
7284 envp
= g_new0(char *, envc
+ 1);
7286 for (gp
= guest_argp
, q
= argp
; gp
;
7287 gp
+= sizeof(abi_ulong
), q
++) {
7288 if (get_user_ual(addr
, gp
))
7292 if (!(*q
= lock_user_string(addr
)))
7294 total_size
+= strlen(*q
) + 1;
7298 for (gp
= guest_envp
, q
= envp
; gp
;
7299 gp
+= sizeof(abi_ulong
), q
++) {
7300 if (get_user_ual(addr
, gp
))
7304 if (!(*q
= lock_user_string(addr
)))
7306 total_size
+= strlen(*q
) + 1;
7310 if (!(p
= lock_user_string(arg1
)))
7312 /* Although execve() is not an interruptible syscall it is
7313 * a special case where we must use the safe_syscall wrapper:
7314 * if we allow a signal to happen before we make the host
7315 * syscall then we will 'lose' it, because at the point of
7316 * execve the process leaves QEMU's control. So we use the
7317 * safe syscall wrapper to ensure that we either take the
7318 * signal as a guest signal, or else it does not happen
7319 * before the execve completes and makes it the other
7320 * program's problem.
7322 ret
= get_errno(safe_execve(p
, argp
, envp
));
7323 unlock_user(p
, arg1
, 0);
7328 ret
= -TARGET_EFAULT
;
7331 for (gp
= guest_argp
, q
= argp
; *q
;
7332 gp
+= sizeof(abi_ulong
), q
++) {
7333 if (get_user_ual(addr
, gp
)
7336 unlock_user(*q
, addr
, 0);
7338 for (gp
= guest_envp
, q
= envp
; *q
;
7339 gp
+= sizeof(abi_ulong
), q
++) {
7340 if (get_user_ual(addr
, gp
)
7343 unlock_user(*q
, addr
, 0);
7350 case TARGET_NR_chdir
:
7351 if (!(p
= lock_user_string(arg1
)))
7352 return -TARGET_EFAULT
;
7353 ret
= get_errno(chdir(p
));
7354 unlock_user(p
, arg1
, 0);
7356 #ifdef TARGET_NR_time
7357 case TARGET_NR_time
:
7360 ret
= get_errno(time(&host_time
));
7363 && put_user_sal(host_time
, arg1
))
7364 return -TARGET_EFAULT
;
7368 #ifdef TARGET_NR_mknod
7369 case TARGET_NR_mknod
:
7370 if (!(p
= lock_user_string(arg1
)))
7371 return -TARGET_EFAULT
;
7372 ret
= get_errno(mknod(p
, arg2
, arg3
));
7373 unlock_user(p
, arg1
, 0);
7376 #if defined(TARGET_NR_mknodat)
7377 case TARGET_NR_mknodat
:
7378 if (!(p
= lock_user_string(arg2
)))
7379 return -TARGET_EFAULT
;
7380 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
7381 unlock_user(p
, arg2
, 0);
7384 #ifdef TARGET_NR_chmod
7385 case TARGET_NR_chmod
:
7386 if (!(p
= lock_user_string(arg1
)))
7387 return -TARGET_EFAULT
;
7388 ret
= get_errno(chmod(p
, arg2
));
7389 unlock_user(p
, arg1
, 0);
7392 #ifdef TARGET_NR_lseek
7393 case TARGET_NR_lseek
:
7394 return get_errno(lseek(arg1
, arg2
, arg3
));
7396 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
7397 /* Alpha specific */
7398 case TARGET_NR_getxpid
:
7399 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = getppid();
7400 return get_errno(getpid());
7402 #ifdef TARGET_NR_getpid
7403 case TARGET_NR_getpid
:
7404 return get_errno(getpid());
7406 case TARGET_NR_mount
:
7408 /* need to look at the data field */
7412 p
= lock_user_string(arg1
);
7414 return -TARGET_EFAULT
;
7420 p2
= lock_user_string(arg2
);
7423 unlock_user(p
, arg1
, 0);
7425 return -TARGET_EFAULT
;
7429 p3
= lock_user_string(arg3
);
7432 unlock_user(p
, arg1
, 0);
7434 unlock_user(p2
, arg2
, 0);
7435 return -TARGET_EFAULT
;
7441 /* FIXME - arg5 should be locked, but it isn't clear how to
7442 * do that since it's not guaranteed to be a NULL-terminated
7446 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
7448 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
));
7450 ret
= get_errno(ret
);
7453 unlock_user(p
, arg1
, 0);
7455 unlock_user(p2
, arg2
, 0);
7457 unlock_user(p3
, arg3
, 0);
7461 #ifdef TARGET_NR_umount
7462 case TARGET_NR_umount
:
7463 if (!(p
= lock_user_string(arg1
)))
7464 return -TARGET_EFAULT
;
7465 ret
= get_errno(umount(p
));
7466 unlock_user(p
, arg1
, 0);
7469 #ifdef TARGET_NR_stime /* not on alpha */
7470 case TARGET_NR_stime
:
7473 if (get_user_sal(host_time
, arg1
))
7474 return -TARGET_EFAULT
;
7475 return get_errno(stime(&host_time
));
7478 #ifdef TARGET_NR_alarm /* not on alpha */
7479 case TARGET_NR_alarm
:
7482 #ifdef TARGET_NR_pause /* not on alpha */
7483 case TARGET_NR_pause
:
7484 if (!block_signals()) {
7485 sigsuspend(&((TaskState
*)cpu
->opaque
)->signal_mask
);
7487 return -TARGET_EINTR
;
7489 #ifdef TARGET_NR_utime
7490 case TARGET_NR_utime
:
7492 struct utimbuf tbuf
, *host_tbuf
;
7493 struct target_utimbuf
*target_tbuf
;
7495 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
7496 return -TARGET_EFAULT
;
7497 tbuf
.actime
= tswapal(target_tbuf
->actime
);
7498 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
7499 unlock_user_struct(target_tbuf
, arg2
, 0);
7504 if (!(p
= lock_user_string(arg1
)))
7505 return -TARGET_EFAULT
;
7506 ret
= get_errno(utime(p
, host_tbuf
));
7507 unlock_user(p
, arg1
, 0);
7511 #ifdef TARGET_NR_utimes
7512 case TARGET_NR_utimes
:
7514 struct timeval
*tvp
, tv
[2];
7516 if (copy_from_user_timeval(&tv
[0], arg2
)
7517 || copy_from_user_timeval(&tv
[1],
7518 arg2
+ sizeof(struct target_timeval
)))
7519 return -TARGET_EFAULT
;
7524 if (!(p
= lock_user_string(arg1
)))
7525 return -TARGET_EFAULT
;
7526 ret
= get_errno(utimes(p
, tvp
));
7527 unlock_user(p
, arg1
, 0);
7531 #if defined(TARGET_NR_futimesat)
7532 case TARGET_NR_futimesat
:
7534 struct timeval
*tvp
, tv
[2];
7536 if (copy_from_user_timeval(&tv
[0], arg3
)
7537 || copy_from_user_timeval(&tv
[1],
7538 arg3
+ sizeof(struct target_timeval
)))
7539 return -TARGET_EFAULT
;
7544 if (!(p
= lock_user_string(arg2
))) {
7545 return -TARGET_EFAULT
;
7547 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
7548 unlock_user(p
, arg2
, 0);
7552 #ifdef TARGET_NR_access
7553 case TARGET_NR_access
:
7554 if (!(p
= lock_user_string(arg1
))) {
7555 return -TARGET_EFAULT
;
7557 ret
= get_errno(access(path(p
), arg2
));
7558 unlock_user(p
, arg1
, 0);
7561 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
7562 case TARGET_NR_faccessat
:
7563 if (!(p
= lock_user_string(arg2
))) {
7564 return -TARGET_EFAULT
;
7566 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
7567 unlock_user(p
, arg2
, 0);
7570 #ifdef TARGET_NR_nice /* not on alpha */
7571 case TARGET_NR_nice
:
7572 return get_errno(nice(arg1
));
7574 case TARGET_NR_sync
:
7577 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
7578 case TARGET_NR_syncfs
:
7579 return get_errno(syncfs(arg1
));
7581 case TARGET_NR_kill
:
7582 return get_errno(safe_kill(arg1
, target_to_host_signal(arg2
)));
7583 #ifdef TARGET_NR_rename
7584 case TARGET_NR_rename
:
7587 p
= lock_user_string(arg1
);
7588 p2
= lock_user_string(arg2
);
7590 ret
= -TARGET_EFAULT
;
7592 ret
= get_errno(rename(p
, p2
));
7593 unlock_user(p2
, arg2
, 0);
7594 unlock_user(p
, arg1
, 0);
7598 #if defined(TARGET_NR_renameat)
7599 case TARGET_NR_renameat
:
7602 p
= lock_user_string(arg2
);
7603 p2
= lock_user_string(arg4
);
7605 ret
= -TARGET_EFAULT
;
7607 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
7608 unlock_user(p2
, arg4
, 0);
7609 unlock_user(p
, arg2
, 0);
7613 #if defined(TARGET_NR_renameat2)
7614 case TARGET_NR_renameat2
:
7617 p
= lock_user_string(arg2
);
7618 p2
= lock_user_string(arg4
);
7620 ret
= -TARGET_EFAULT
;
7622 ret
= get_errno(sys_renameat2(arg1
, p
, arg3
, p2
, arg5
));
7624 unlock_user(p2
, arg4
, 0);
7625 unlock_user(p
, arg2
, 0);
7629 #ifdef TARGET_NR_mkdir
7630 case TARGET_NR_mkdir
:
7631 if (!(p
= lock_user_string(arg1
)))
7632 return -TARGET_EFAULT
;
7633 ret
= get_errno(mkdir(p
, arg2
));
7634 unlock_user(p
, arg1
, 0);
7637 #if defined(TARGET_NR_mkdirat)
7638 case TARGET_NR_mkdirat
:
7639 if (!(p
= lock_user_string(arg2
)))
7640 return -TARGET_EFAULT
;
7641 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
7642 unlock_user(p
, arg2
, 0);
7645 #ifdef TARGET_NR_rmdir
7646 case TARGET_NR_rmdir
:
7647 if (!(p
= lock_user_string(arg1
)))
7648 return -TARGET_EFAULT
;
7649 ret
= get_errno(rmdir(p
));
7650 unlock_user(p
, arg1
, 0);
7654 ret
= get_errno(dup(arg1
));
7656 fd_trans_dup(arg1
, ret
);
7659 #ifdef TARGET_NR_pipe
7660 case TARGET_NR_pipe
:
7661 return do_pipe(cpu_env
, arg1
, 0, 0);
7663 #ifdef TARGET_NR_pipe2
7664 case TARGET_NR_pipe2
:
7665 return do_pipe(cpu_env
, arg1
,
7666 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
7668 case TARGET_NR_times
:
7670 struct target_tms
*tmsp
;
7672 ret
= get_errno(times(&tms
));
7674 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
7676 return -TARGET_EFAULT
;
7677 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
7678 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
7679 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
7680 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
7683 ret
= host_to_target_clock_t(ret
);
7686 case TARGET_NR_acct
:
7688 ret
= get_errno(acct(NULL
));
7690 if (!(p
= lock_user_string(arg1
))) {
7691 return -TARGET_EFAULT
;
7693 ret
= get_errno(acct(path(p
)));
7694 unlock_user(p
, arg1
, 0);
7697 #ifdef TARGET_NR_umount2
7698 case TARGET_NR_umount2
:
7699 if (!(p
= lock_user_string(arg1
)))
7700 return -TARGET_EFAULT
;
7701 ret
= get_errno(umount2(p
, arg2
));
7702 unlock_user(p
, arg1
, 0);
7705 case TARGET_NR_ioctl
:
7706 return do_ioctl(arg1
, arg2
, arg3
);
7707 #ifdef TARGET_NR_fcntl
7708 case TARGET_NR_fcntl
:
7709 return do_fcntl(arg1
, arg2
, arg3
);
7711 case TARGET_NR_setpgid
:
7712 return get_errno(setpgid(arg1
, arg2
));
7713 case TARGET_NR_umask
:
7714 return get_errno(umask(arg1
));
7715 case TARGET_NR_chroot
:
7716 if (!(p
= lock_user_string(arg1
)))
7717 return -TARGET_EFAULT
;
7718 ret
= get_errno(chroot(p
));
7719 unlock_user(p
, arg1
, 0);
7721 #ifdef TARGET_NR_dup2
7722 case TARGET_NR_dup2
:
7723 ret
= get_errno(dup2(arg1
, arg2
));
7725 fd_trans_dup(arg1
, arg2
);
7729 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
7730 case TARGET_NR_dup3
:
7734 if ((arg3
& ~TARGET_O_CLOEXEC
) != 0) {
7737 host_flags
= target_to_host_bitmask(arg3
, fcntl_flags_tbl
);
7738 ret
= get_errno(dup3(arg1
, arg2
, host_flags
));
7740 fd_trans_dup(arg1
, arg2
);
7745 #ifdef TARGET_NR_getppid /* not on alpha */
7746 case TARGET_NR_getppid
:
7747 return get_errno(getppid());
7749 #ifdef TARGET_NR_getpgrp
7750 case TARGET_NR_getpgrp
:
7751 return get_errno(getpgrp());
7753 case TARGET_NR_setsid
:
7754 return get_errno(setsid());
7755 #ifdef TARGET_NR_sigaction
7756 case TARGET_NR_sigaction
:
7758 #if defined(TARGET_ALPHA)
7759 struct target_sigaction act
, oact
, *pact
= 0;
7760 struct target_old_sigaction
*old_act
;
7762 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7763 return -TARGET_EFAULT
;
7764 act
._sa_handler
= old_act
->_sa_handler
;
7765 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
7766 act
.sa_flags
= old_act
->sa_flags
;
7767 act
.sa_restorer
= 0;
7768 unlock_user_struct(old_act
, arg2
, 0);
7771 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7772 if (!is_error(ret
) && arg3
) {
7773 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
7774 return -TARGET_EFAULT
;
7775 old_act
->_sa_handler
= oact
._sa_handler
;
7776 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
7777 old_act
->sa_flags
= oact
.sa_flags
;
7778 unlock_user_struct(old_act
, arg3
, 1);
7780 #elif defined(TARGET_MIPS)
7781 struct target_sigaction act
, oact
, *pact
, *old_act
;
7784 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7785 return -TARGET_EFAULT
;
7786 act
._sa_handler
= old_act
->_sa_handler
;
7787 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
7788 act
.sa_flags
= old_act
->sa_flags
;
7789 unlock_user_struct(old_act
, arg2
, 0);
7795 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7797 if (!is_error(ret
) && arg3
) {
7798 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
7799 return -TARGET_EFAULT
;
7800 old_act
->_sa_handler
= oact
._sa_handler
;
7801 old_act
->sa_flags
= oact
.sa_flags
;
7802 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
7803 old_act
->sa_mask
.sig
[1] = 0;
7804 old_act
->sa_mask
.sig
[2] = 0;
7805 old_act
->sa_mask
.sig
[3] = 0;
7806 unlock_user_struct(old_act
, arg3
, 1);
7809 struct target_old_sigaction
*old_act
;
7810 struct target_sigaction act
, oact
, *pact
;
7812 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
7813 return -TARGET_EFAULT
;
7814 act
._sa_handler
= old_act
->_sa_handler
;
7815 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
7816 act
.sa_flags
= old_act
->sa_flags
;
7817 act
.sa_restorer
= old_act
->sa_restorer
;
7818 #ifdef TARGET_ARCH_HAS_KA_RESTORER
7819 act
.ka_restorer
= 0;
7821 unlock_user_struct(old_act
, arg2
, 0);
7826 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7827 if (!is_error(ret
) && arg3
) {
7828 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
7829 return -TARGET_EFAULT
;
7830 old_act
->_sa_handler
= oact
._sa_handler
;
7831 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
7832 old_act
->sa_flags
= oact
.sa_flags
;
7833 old_act
->sa_restorer
= oact
.sa_restorer
;
7834 unlock_user_struct(old_act
, arg3
, 1);
7840 case TARGET_NR_rt_sigaction
:
7842 #if defined(TARGET_ALPHA)
7843 /* For Alpha and SPARC this is a 5 argument syscall, with
7844 * a 'restorer' parameter which must be copied into the
7845 * sa_restorer field of the sigaction struct.
7846 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
7847 * and arg5 is the sigsetsize.
7848 * Alpha also has a separate rt_sigaction struct that it uses
7849 * here; SPARC uses the usual sigaction struct.
7851 struct target_rt_sigaction
*rt_act
;
7852 struct target_sigaction act
, oact
, *pact
= 0;
7854 if (arg4
!= sizeof(target_sigset_t
)) {
7855 return -TARGET_EINVAL
;
7858 if (!lock_user_struct(VERIFY_READ
, rt_act
, arg2
, 1))
7859 return -TARGET_EFAULT
;
7860 act
._sa_handler
= rt_act
->_sa_handler
;
7861 act
.sa_mask
= rt_act
->sa_mask
;
7862 act
.sa_flags
= rt_act
->sa_flags
;
7863 act
.sa_restorer
= arg5
;
7864 unlock_user_struct(rt_act
, arg2
, 0);
7867 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
7868 if (!is_error(ret
) && arg3
) {
7869 if (!lock_user_struct(VERIFY_WRITE
, rt_act
, arg3
, 0))
7870 return -TARGET_EFAULT
;
7871 rt_act
->_sa_handler
= oact
._sa_handler
;
7872 rt_act
->sa_mask
= oact
.sa_mask
;
7873 rt_act
->sa_flags
= oact
.sa_flags
;
7874 unlock_user_struct(rt_act
, arg3
, 1);
7878 target_ulong restorer
= arg4
;
7879 target_ulong sigsetsize
= arg5
;
7881 target_ulong sigsetsize
= arg4
;
7883 struct target_sigaction
*act
;
7884 struct target_sigaction
*oact
;
7886 if (sigsetsize
!= sizeof(target_sigset_t
)) {
7887 return -TARGET_EINVAL
;
7890 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1)) {
7891 return -TARGET_EFAULT
;
7893 #ifdef TARGET_ARCH_HAS_KA_RESTORER
7894 act
->ka_restorer
= restorer
;
7900 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
7901 ret
= -TARGET_EFAULT
;
7902 goto rt_sigaction_fail
;
7906 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
7909 unlock_user_struct(act
, arg2
, 0);
7911 unlock_user_struct(oact
, arg3
, 1);
7915 #ifdef TARGET_NR_sgetmask /* not on alpha */
7916 case TARGET_NR_sgetmask
:
7919 abi_ulong target_set
;
7920 ret
= do_sigprocmask(0, NULL
, &cur_set
);
7922 host_to_target_old_sigset(&target_set
, &cur_set
);
7928 #ifdef TARGET_NR_ssetmask /* not on alpha */
7929 case TARGET_NR_ssetmask
:
7932 abi_ulong target_set
= arg1
;
7933 target_to_host_old_sigset(&set
, &target_set
);
7934 ret
= do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
7936 host_to_target_old_sigset(&target_set
, &oset
);
7942 #ifdef TARGET_NR_sigprocmask
7943 case TARGET_NR_sigprocmask
:
7945 #if defined(TARGET_ALPHA)
7946 sigset_t set
, oldset
;
7951 case TARGET_SIG_BLOCK
:
7954 case TARGET_SIG_UNBLOCK
:
7957 case TARGET_SIG_SETMASK
:
7961 return -TARGET_EINVAL
;
7964 target_to_host_old_sigset(&set
, &mask
);
7966 ret
= do_sigprocmask(how
, &set
, &oldset
);
7967 if (!is_error(ret
)) {
7968 host_to_target_old_sigset(&mask
, &oldset
);
7970 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0; /* force no error */
7973 sigset_t set
, oldset
, *set_ptr
;
7978 case TARGET_SIG_BLOCK
:
7981 case TARGET_SIG_UNBLOCK
:
7984 case TARGET_SIG_SETMASK
:
7988 return -TARGET_EINVAL
;
7990 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
7991 return -TARGET_EFAULT
;
7992 target_to_host_old_sigset(&set
, p
);
7993 unlock_user(p
, arg2
, 0);
7999 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8000 if (!is_error(ret
) && arg3
) {
8001 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8002 return -TARGET_EFAULT
;
8003 host_to_target_old_sigset(p
, &oldset
);
8004 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8010 case TARGET_NR_rt_sigprocmask
:
8013 sigset_t set
, oldset
, *set_ptr
;
8015 if (arg4
!= sizeof(target_sigset_t
)) {
8016 return -TARGET_EINVAL
;
8021 case TARGET_SIG_BLOCK
:
8024 case TARGET_SIG_UNBLOCK
:
8027 case TARGET_SIG_SETMASK
:
8031 return -TARGET_EINVAL
;
8033 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8034 return -TARGET_EFAULT
;
8035 target_to_host_sigset(&set
, p
);
8036 unlock_user(p
, arg2
, 0);
8042 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8043 if (!is_error(ret
) && arg3
) {
8044 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8045 return -TARGET_EFAULT
;
8046 host_to_target_sigset(p
, &oldset
);
8047 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8051 #ifdef TARGET_NR_sigpending
8052 case TARGET_NR_sigpending
:
8055 ret
= get_errno(sigpending(&set
));
8056 if (!is_error(ret
)) {
8057 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8058 return -TARGET_EFAULT
;
8059 host_to_target_old_sigset(p
, &set
);
8060 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8065 case TARGET_NR_rt_sigpending
:
8069 /* Yes, this check is >, not != like most. We follow the kernel's
8070 * logic and it does it like this because it implements
8071 * NR_sigpending through the same code path, and in that case
8072 * the old_sigset_t is smaller in size.
8074 if (arg2
> sizeof(target_sigset_t
)) {
8075 return -TARGET_EINVAL
;
8078 ret
= get_errno(sigpending(&set
));
8079 if (!is_error(ret
)) {
8080 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8081 return -TARGET_EFAULT
;
8082 host_to_target_sigset(p
, &set
);
8083 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8087 #ifdef TARGET_NR_sigsuspend
8088 case TARGET_NR_sigsuspend
:
8090 TaskState
*ts
= cpu
->opaque
;
8091 #if defined(TARGET_ALPHA)
8092 abi_ulong mask
= arg1
;
8093 target_to_host_old_sigset(&ts
->sigsuspend_mask
, &mask
);
8095 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8096 return -TARGET_EFAULT
;
8097 target_to_host_old_sigset(&ts
->sigsuspend_mask
, p
);
8098 unlock_user(p
, arg1
, 0);
8100 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8102 if (ret
!= -TARGET_ERESTARTSYS
) {
8103 ts
->in_sigsuspend
= 1;
8108 case TARGET_NR_rt_sigsuspend
:
8110 TaskState
*ts
= cpu
->opaque
;
8112 if (arg2
!= sizeof(target_sigset_t
)) {
8113 return -TARGET_EINVAL
;
8115 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8116 return -TARGET_EFAULT
;
8117 target_to_host_sigset(&ts
->sigsuspend_mask
, p
);
8118 unlock_user(p
, arg1
, 0);
8119 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8121 if (ret
!= -TARGET_ERESTARTSYS
) {
8122 ts
->in_sigsuspend
= 1;
8126 case TARGET_NR_rt_sigtimedwait
:
8129 struct timespec uts
, *puts
;
8132 if (arg4
!= sizeof(target_sigset_t
)) {
8133 return -TARGET_EINVAL
;
8136 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8137 return -TARGET_EFAULT
;
8138 target_to_host_sigset(&set
, p
);
8139 unlock_user(p
, arg1
, 0);
8142 target_to_host_timespec(puts
, arg3
);
8146 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
8148 if (!is_error(ret
)) {
8150 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
8153 return -TARGET_EFAULT
;
8155 host_to_target_siginfo(p
, &uinfo
);
8156 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
8158 ret
= host_to_target_signal(ret
);
8162 case TARGET_NR_rt_sigqueueinfo
:
8166 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
8168 return -TARGET_EFAULT
;
8170 target_to_host_siginfo(&uinfo
, p
);
8171 unlock_user(p
, arg3
, 0);
8172 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
8175 case TARGET_NR_rt_tgsigqueueinfo
:
8179 p
= lock_user(VERIFY_READ
, arg4
, sizeof(target_siginfo_t
), 1);
8181 return -TARGET_EFAULT
;
8183 target_to_host_siginfo(&uinfo
, p
);
8184 unlock_user(p
, arg4
, 0);
8185 ret
= get_errno(sys_rt_tgsigqueueinfo(arg1
, arg2
, arg3
, &uinfo
));
8188 #ifdef TARGET_NR_sigreturn
8189 case TARGET_NR_sigreturn
:
8190 if (block_signals()) {
8191 return -TARGET_ERESTARTSYS
;
8193 return do_sigreturn(cpu_env
);
8195 case TARGET_NR_rt_sigreturn
:
8196 if (block_signals()) {
8197 return -TARGET_ERESTARTSYS
;
8199 return do_rt_sigreturn(cpu_env
);
8200 case TARGET_NR_sethostname
:
8201 if (!(p
= lock_user_string(arg1
)))
8202 return -TARGET_EFAULT
;
8203 ret
= get_errno(sethostname(p
, arg2
));
8204 unlock_user(p
, arg1
, 0);
8206 #ifdef TARGET_NR_setrlimit
8207 case TARGET_NR_setrlimit
:
8209 int resource
= target_to_host_resource(arg1
);
8210 struct target_rlimit
*target_rlim
;
8212 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
8213 return -TARGET_EFAULT
;
8214 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
8215 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
8216 unlock_user_struct(target_rlim
, arg2
, 0);
8218 * If we just passed through resource limit settings for memory then
8219 * they would also apply to QEMU's own allocations, and QEMU will
8220 * crash or hang or die if its allocations fail. Ideally we would
8221 * track the guest allocations in QEMU and apply the limits ourselves.
8222 * For now, just tell the guest the call succeeded but don't actually
8225 if (resource
!= RLIMIT_AS
&&
8226 resource
!= RLIMIT_DATA
&&
8227 resource
!= RLIMIT_STACK
) {
8228 return get_errno(setrlimit(resource
, &rlim
));
8234 #ifdef TARGET_NR_getrlimit
8235 case TARGET_NR_getrlimit
:
8237 int resource
= target_to_host_resource(arg1
);
8238 struct target_rlimit
*target_rlim
;
8241 ret
= get_errno(getrlimit(resource
, &rlim
));
8242 if (!is_error(ret
)) {
8243 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
8244 return -TARGET_EFAULT
;
8245 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
8246 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
8247 unlock_user_struct(target_rlim
, arg2
, 1);
8252 case TARGET_NR_getrusage
:
8254 struct rusage rusage
;
8255 ret
= get_errno(getrusage(arg1
, &rusage
));
8256 if (!is_error(ret
)) {
8257 ret
= host_to_target_rusage(arg2
, &rusage
);
8261 case TARGET_NR_gettimeofday
:
8264 ret
= get_errno(gettimeofday(&tv
, NULL
));
8265 if (!is_error(ret
)) {
8266 if (copy_to_user_timeval(arg1
, &tv
))
8267 return -TARGET_EFAULT
;
8271 case TARGET_NR_settimeofday
:
8273 struct timeval tv
, *ptv
= NULL
;
8274 struct timezone tz
, *ptz
= NULL
;
8277 if (copy_from_user_timeval(&tv
, arg1
)) {
8278 return -TARGET_EFAULT
;
8284 if (copy_from_user_timezone(&tz
, arg2
)) {
8285 return -TARGET_EFAULT
;
8290 return get_errno(settimeofday(ptv
, ptz
));
8292 #if defined(TARGET_NR_select)
8293 case TARGET_NR_select
:
8294 #if defined(TARGET_WANT_NI_OLD_SELECT)
8295 /* some architectures used to have old_select here
8296 * but now ENOSYS it.
8298 ret
= -TARGET_ENOSYS
;
8299 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
8300 ret
= do_old_select(arg1
);
8302 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
8306 #ifdef TARGET_NR_pselect6
8307 case TARGET_NR_pselect6
:
8309 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
8310 fd_set rfds
, wfds
, efds
;
8311 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
8312 struct timespec ts
, *ts_ptr
;
8315 * The 6th arg is actually two args smashed together,
8316 * so we cannot use the C library.
8324 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
8325 target_sigset_t
*target_sigset
;
8333 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
8337 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
8341 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
8347 * This takes a timespec, and not a timeval, so we cannot
8348 * use the do_select() helper ...
8351 if (target_to_host_timespec(&ts
, ts_addr
)) {
8352 return -TARGET_EFAULT
;
8359 /* Extract the two packed args for the sigset */
8362 sig
.size
= SIGSET_T_SIZE
;
8364 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
8366 return -TARGET_EFAULT
;
8368 arg_sigset
= tswapal(arg7
[0]);
8369 arg_sigsize
= tswapal(arg7
[1]);
8370 unlock_user(arg7
, arg6
, 0);
8374 if (arg_sigsize
!= sizeof(*target_sigset
)) {
8375 /* Like the kernel, we enforce correct size sigsets */
8376 return -TARGET_EINVAL
;
8378 target_sigset
= lock_user(VERIFY_READ
, arg_sigset
,
8379 sizeof(*target_sigset
), 1);
8380 if (!target_sigset
) {
8381 return -TARGET_EFAULT
;
8383 target_to_host_sigset(&set
, target_sigset
);
8384 unlock_user(target_sigset
, arg_sigset
, 0);
8392 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
8395 if (!is_error(ret
)) {
8396 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
8397 return -TARGET_EFAULT
;
8398 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
8399 return -TARGET_EFAULT
;
8400 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
8401 return -TARGET_EFAULT
;
8403 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
))
8404 return -TARGET_EFAULT
;
8409 #ifdef TARGET_NR_symlink
8410 case TARGET_NR_symlink
:
8413 p
= lock_user_string(arg1
);
8414 p2
= lock_user_string(arg2
);
8416 ret
= -TARGET_EFAULT
;
8418 ret
= get_errno(symlink(p
, p2
));
8419 unlock_user(p2
, arg2
, 0);
8420 unlock_user(p
, arg1
, 0);
8424 #if defined(TARGET_NR_symlinkat)
8425 case TARGET_NR_symlinkat
:
8428 p
= lock_user_string(arg1
);
8429 p2
= lock_user_string(arg3
);
8431 ret
= -TARGET_EFAULT
;
8433 ret
= get_errno(symlinkat(p
, arg2
, p2
));
8434 unlock_user(p2
, arg3
, 0);
8435 unlock_user(p
, arg1
, 0);
8439 #ifdef TARGET_NR_readlink
8440 case TARGET_NR_readlink
:
8443 p
= lock_user_string(arg1
);
8444 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
8446 ret
= -TARGET_EFAULT
;
8448 /* Short circuit this for the magic exe check. */
8449 ret
= -TARGET_EINVAL
;
8450 } else if (is_proc_myself((const char *)p
, "exe")) {
8451 char real
[PATH_MAX
], *temp
;
8452 temp
= realpath(exec_path
, real
);
8453 /* Return value is # of bytes that we wrote to the buffer. */
8455 ret
= get_errno(-1);
8457 /* Don't worry about sign mismatch as earlier mapping
8458 * logic would have thrown a bad address error. */
8459 ret
= MIN(strlen(real
), arg3
);
8460 /* We cannot NUL terminate the string. */
8461 memcpy(p2
, real
, ret
);
8464 ret
= get_errno(readlink(path(p
), p2
, arg3
));
8466 unlock_user(p2
, arg2
, ret
);
8467 unlock_user(p
, arg1
, 0);
8471 #if defined(TARGET_NR_readlinkat)
8472 case TARGET_NR_readlinkat
:
8475 p
= lock_user_string(arg2
);
8476 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
8478 ret
= -TARGET_EFAULT
;
8479 } else if (is_proc_myself((const char *)p
, "exe")) {
8480 char real
[PATH_MAX
], *temp
;
8481 temp
= realpath(exec_path
, real
);
8482 ret
= temp
== NULL
? get_errno(-1) : strlen(real
) ;
8483 snprintf((char *)p2
, arg4
, "%s", real
);
8485 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
8487 unlock_user(p2
, arg3
, ret
);
8488 unlock_user(p
, arg2
, 0);
8492 #ifdef TARGET_NR_swapon
8493 case TARGET_NR_swapon
:
8494 if (!(p
= lock_user_string(arg1
)))
8495 return -TARGET_EFAULT
;
8496 ret
= get_errno(swapon(p
, arg2
));
8497 unlock_user(p
, arg1
, 0);
8500 case TARGET_NR_reboot
:
8501 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
8502 /* arg4 must be ignored in all other cases */
8503 p
= lock_user_string(arg4
);
8505 return -TARGET_EFAULT
;
8507 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
8508 unlock_user(p
, arg4
, 0);
8510 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
8513 #ifdef TARGET_NR_mmap
8514 case TARGET_NR_mmap
:
8515 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
8516 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
8517 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
8518 || defined(TARGET_S390X)
8521 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
8522 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
8523 return -TARGET_EFAULT
;
8530 unlock_user(v
, arg1
, 0);
8531 ret
= get_errno(target_mmap(v1
, v2
, v3
,
8532 target_to_host_bitmask(v4
, mmap_flags_tbl
),
8536 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
8537 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
8543 #ifdef TARGET_NR_mmap2
8544 case TARGET_NR_mmap2
:
8546 #define MMAP_SHIFT 12
8548 ret
= target_mmap(arg1
, arg2
, arg3
,
8549 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
8550 arg5
, arg6
<< MMAP_SHIFT
);
8551 return get_errno(ret
);
8553 case TARGET_NR_munmap
:
8554 return get_errno(target_munmap(arg1
, arg2
));
8555 case TARGET_NR_mprotect
:
8557 TaskState
*ts
= cpu
->opaque
;
8558 /* Special hack to detect libc making the stack executable. */
8559 if ((arg3
& PROT_GROWSDOWN
)
8560 && arg1
>= ts
->info
->stack_limit
8561 && arg1
<= ts
->info
->start_stack
) {
8562 arg3
&= ~PROT_GROWSDOWN
;
8563 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
8564 arg1
= ts
->info
->stack_limit
;
8567 return get_errno(target_mprotect(arg1
, arg2
, arg3
));
8568 #ifdef TARGET_NR_mremap
8569 case TARGET_NR_mremap
:
8570 return get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
8572 /* ??? msync/mlock/munlock are broken for softmmu. */
8573 #ifdef TARGET_NR_msync
8574 case TARGET_NR_msync
:
8575 return get_errno(msync(g2h(arg1
), arg2
, arg3
));
8577 #ifdef TARGET_NR_mlock
8578 case TARGET_NR_mlock
:
8579 return get_errno(mlock(g2h(arg1
), arg2
));
8581 #ifdef TARGET_NR_munlock
8582 case TARGET_NR_munlock
:
8583 return get_errno(munlock(g2h(arg1
), arg2
));
8585 #ifdef TARGET_NR_mlockall
8586 case TARGET_NR_mlockall
:
8587 return get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
8589 #ifdef TARGET_NR_munlockall
8590 case TARGET_NR_munlockall
:
8591 return get_errno(munlockall());
8593 #ifdef TARGET_NR_truncate
8594 case TARGET_NR_truncate
:
8595 if (!(p
= lock_user_string(arg1
)))
8596 return -TARGET_EFAULT
;
8597 ret
= get_errno(truncate(p
, arg2
));
8598 unlock_user(p
, arg1
, 0);
8601 #ifdef TARGET_NR_ftruncate
8602 case TARGET_NR_ftruncate
:
8603 return get_errno(ftruncate(arg1
, arg2
));
8605 case TARGET_NR_fchmod
:
8606 return get_errno(fchmod(arg1
, arg2
));
8607 #if defined(TARGET_NR_fchmodat)
8608 case TARGET_NR_fchmodat
:
8609 if (!(p
= lock_user_string(arg2
)))
8610 return -TARGET_EFAULT
;
8611 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
8612 unlock_user(p
, arg2
, 0);
8615 case TARGET_NR_getpriority
:
8616 /* Note that negative values are valid for getpriority, so we must
8617 differentiate based on errno settings. */
8619 ret
= getpriority(arg1
, arg2
);
8620 if (ret
== -1 && errno
!= 0) {
8621 return -host_to_target_errno(errno
);
8624 /* Return value is the unbiased priority. Signal no error. */
8625 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0;
8627 /* Return value is a biased priority to avoid negative numbers. */
8631 case TARGET_NR_setpriority
:
8632 return get_errno(setpriority(arg1
, arg2
, arg3
));
8633 #ifdef TARGET_NR_statfs
8634 case TARGET_NR_statfs
:
8635 if (!(p
= lock_user_string(arg1
))) {
8636 return -TARGET_EFAULT
;
8638 ret
= get_errno(statfs(path(p
), &stfs
));
8639 unlock_user(p
, arg1
, 0);
8641 if (!is_error(ret
)) {
8642 struct target_statfs
*target_stfs
;
8644 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
8645 return -TARGET_EFAULT
;
8646 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
8647 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
8648 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
8649 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
8650 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
8651 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
8652 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
8653 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
8654 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
8655 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
8656 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
8657 #ifdef _STATFS_F_FLAGS
8658 __put_user(stfs
.f_flags
, &target_stfs
->f_flags
);
8660 __put_user(0, &target_stfs
->f_flags
);
8662 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
8663 unlock_user_struct(target_stfs
, arg2
, 1);
8667 #ifdef TARGET_NR_fstatfs
8668 case TARGET_NR_fstatfs
:
8669 ret
= get_errno(fstatfs(arg1
, &stfs
));
8670 goto convert_statfs
;
8672 #ifdef TARGET_NR_statfs64
8673 case TARGET_NR_statfs64
:
8674 if (!(p
= lock_user_string(arg1
))) {
8675 return -TARGET_EFAULT
;
8677 ret
= get_errno(statfs(path(p
), &stfs
));
8678 unlock_user(p
, arg1
, 0);
8680 if (!is_error(ret
)) {
8681 struct target_statfs64
*target_stfs
;
8683 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
8684 return -TARGET_EFAULT
;
8685 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
8686 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
8687 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
8688 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
8689 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
8690 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
8691 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
8692 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
8693 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
8694 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
8695 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
8696 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
8697 unlock_user_struct(target_stfs
, arg3
, 1);
8700 case TARGET_NR_fstatfs64
:
8701 ret
= get_errno(fstatfs(arg1
, &stfs
));
8702 goto convert_statfs64
;
8704 #ifdef TARGET_NR_socketcall
8705 case TARGET_NR_socketcall
:
8706 return do_socketcall(arg1
, arg2
);
8708 #ifdef TARGET_NR_accept
8709 case TARGET_NR_accept
:
8710 return do_accept4(arg1
, arg2
, arg3
, 0);
8712 #ifdef TARGET_NR_accept4
8713 case TARGET_NR_accept4
:
8714 return do_accept4(arg1
, arg2
, arg3
, arg4
);
8716 #ifdef TARGET_NR_bind
8717 case TARGET_NR_bind
:
8718 return do_bind(arg1
, arg2
, arg3
);
8720 #ifdef TARGET_NR_connect
8721 case TARGET_NR_connect
:
8722 return do_connect(arg1
, arg2
, arg3
);
8724 #ifdef TARGET_NR_getpeername
8725 case TARGET_NR_getpeername
:
8726 return do_getpeername(arg1
, arg2
, arg3
);
8728 #ifdef TARGET_NR_getsockname
8729 case TARGET_NR_getsockname
:
8730 return do_getsockname(arg1
, arg2
, arg3
);
8732 #ifdef TARGET_NR_getsockopt
8733 case TARGET_NR_getsockopt
:
8734 return do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
8736 #ifdef TARGET_NR_listen
8737 case TARGET_NR_listen
:
8738 return get_errno(listen(arg1
, arg2
));
8740 #ifdef TARGET_NR_recv
8741 case TARGET_NR_recv
:
8742 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
8744 #ifdef TARGET_NR_recvfrom
8745 case TARGET_NR_recvfrom
:
8746 return do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
8748 #ifdef TARGET_NR_recvmsg
8749 case TARGET_NR_recvmsg
:
8750 return do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
8752 #ifdef TARGET_NR_send
8753 case TARGET_NR_send
:
8754 return do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
8756 #ifdef TARGET_NR_sendmsg
8757 case TARGET_NR_sendmsg
:
8758 return do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
8760 #ifdef TARGET_NR_sendmmsg
8761 case TARGET_NR_sendmmsg
:
8762 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
8763 case TARGET_NR_recvmmsg
:
8764 return do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
8766 #ifdef TARGET_NR_sendto
8767 case TARGET_NR_sendto
:
8768 return do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
8770 #ifdef TARGET_NR_shutdown
8771 case TARGET_NR_shutdown
:
8772 return get_errno(shutdown(arg1
, arg2
));
8774 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
8775 case TARGET_NR_getrandom
:
8776 p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
8778 return -TARGET_EFAULT
;
8780 ret
= get_errno(getrandom(p
, arg2
, arg3
));
8781 unlock_user(p
, arg1
, ret
);
8784 #ifdef TARGET_NR_socket
8785 case TARGET_NR_socket
:
8786 return do_socket(arg1
, arg2
, arg3
);
8788 #ifdef TARGET_NR_socketpair
8789 case TARGET_NR_socketpair
:
8790 return do_socketpair(arg1
, arg2
, arg3
, arg4
);
8792 #ifdef TARGET_NR_setsockopt
8793 case TARGET_NR_setsockopt
:
8794 return do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
8796 #if defined(TARGET_NR_syslog)
8797 case TARGET_NR_syslog
:
8802 case TARGET_SYSLOG_ACTION_CLOSE
: /* Close log */
8803 case TARGET_SYSLOG_ACTION_OPEN
: /* Open log */
8804 case TARGET_SYSLOG_ACTION_CLEAR
: /* Clear ring buffer */
8805 case TARGET_SYSLOG_ACTION_CONSOLE_OFF
: /* Disable logging */
8806 case TARGET_SYSLOG_ACTION_CONSOLE_ON
: /* Enable logging */
8807 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL
: /* Set messages level */
8808 case TARGET_SYSLOG_ACTION_SIZE_UNREAD
: /* Number of chars */
8809 case TARGET_SYSLOG_ACTION_SIZE_BUFFER
: /* Size of the buffer */
8810 return get_errno(sys_syslog((int)arg1
, NULL
, (int)arg3
));
8811 case TARGET_SYSLOG_ACTION_READ
: /* Read from log */
8812 case TARGET_SYSLOG_ACTION_READ_CLEAR
: /* Read/clear msgs */
8813 case TARGET_SYSLOG_ACTION_READ_ALL
: /* Read last messages */
8816 return -TARGET_EINVAL
;
8821 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
8823 return -TARGET_EFAULT
;
8825 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
8826 unlock_user(p
, arg2
, arg3
);
8830 return -TARGET_EINVAL
;
8835 case TARGET_NR_setitimer
:
8837 struct itimerval value
, ovalue
, *pvalue
;
8841 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
8842 || copy_from_user_timeval(&pvalue
->it_value
,
8843 arg2
+ sizeof(struct target_timeval
)))
8844 return -TARGET_EFAULT
;
8848 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
8849 if (!is_error(ret
) && arg3
) {
8850 if (copy_to_user_timeval(arg3
,
8851 &ovalue
.it_interval
)
8852 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
8854 return -TARGET_EFAULT
;
8858 case TARGET_NR_getitimer
:
8860 struct itimerval value
;
8862 ret
= get_errno(getitimer(arg1
, &value
));
8863 if (!is_error(ret
) && arg2
) {
8864 if (copy_to_user_timeval(arg2
,
8866 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
8868 return -TARGET_EFAULT
;
8872 #ifdef TARGET_NR_stat
8873 case TARGET_NR_stat
:
8874 if (!(p
= lock_user_string(arg1
))) {
8875 return -TARGET_EFAULT
;
8877 ret
= get_errno(stat(path(p
), &st
));
8878 unlock_user(p
, arg1
, 0);
8881 #ifdef TARGET_NR_lstat
8882 case TARGET_NR_lstat
:
8883 if (!(p
= lock_user_string(arg1
))) {
8884 return -TARGET_EFAULT
;
8886 ret
= get_errno(lstat(path(p
), &st
));
8887 unlock_user(p
, arg1
, 0);
8890 #ifdef TARGET_NR_fstat
8891 case TARGET_NR_fstat
:
8893 ret
= get_errno(fstat(arg1
, &st
));
8894 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
8897 if (!is_error(ret
)) {
8898 struct target_stat
*target_st
;
8900 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
8901 return -TARGET_EFAULT
;
8902 memset(target_st
, 0, sizeof(*target_st
));
8903 __put_user(st
.st_dev
, &target_st
->st_dev
);
8904 __put_user(st
.st_ino
, &target_st
->st_ino
);
8905 __put_user(st
.st_mode
, &target_st
->st_mode
);
8906 __put_user(st
.st_uid
, &target_st
->st_uid
);
8907 __put_user(st
.st_gid
, &target_st
->st_gid
);
8908 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
8909 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
8910 __put_user(st
.st_size
, &target_st
->st_size
);
8911 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
8912 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
8913 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
8914 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
8915 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
8916 #if (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700) && \
8917 defined(TARGET_STAT_HAVE_NSEC)
8918 __put_user(st
.st_atim
.tv_nsec
,
8919 &target_st
->target_st_atime_nsec
);
8920 __put_user(st
.st_mtim
.tv_nsec
,
8921 &target_st
->target_st_mtime_nsec
);
8922 __put_user(st
.st_ctim
.tv_nsec
,
8923 &target_st
->target_st_ctime_nsec
);
8925 unlock_user_struct(target_st
, arg2
, 1);
8930 case TARGET_NR_vhangup
:
8931 return get_errno(vhangup());
8932 #ifdef TARGET_NR_syscall
8933 case TARGET_NR_syscall
:
8934 return do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
8935 arg6
, arg7
, arg8
, 0);
8937 case TARGET_NR_wait4
:
8940 abi_long status_ptr
= arg2
;
8941 struct rusage rusage
, *rusage_ptr
;
8942 abi_ulong target_rusage
= arg4
;
8943 abi_long rusage_err
;
8945 rusage_ptr
= &rusage
;
8948 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, rusage_ptr
));
8949 if (!is_error(ret
)) {
8950 if (status_ptr
&& ret
) {
8951 status
= host_to_target_waitstatus(status
);
8952 if (put_user_s32(status
, status_ptr
))
8953 return -TARGET_EFAULT
;
8955 if (target_rusage
) {
8956 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
8964 #ifdef TARGET_NR_swapoff
8965 case TARGET_NR_swapoff
:
8966 if (!(p
= lock_user_string(arg1
)))
8967 return -TARGET_EFAULT
;
8968 ret
= get_errno(swapoff(p
));
8969 unlock_user(p
, arg1
, 0);
8972 case TARGET_NR_sysinfo
:
8974 struct target_sysinfo
*target_value
;
8975 struct sysinfo value
;
8976 ret
= get_errno(sysinfo(&value
));
8977 if (!is_error(ret
) && arg1
)
8979 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
8980 return -TARGET_EFAULT
;
8981 __put_user(value
.uptime
, &target_value
->uptime
);
8982 __put_user(value
.loads
[0], &target_value
->loads
[0]);
8983 __put_user(value
.loads
[1], &target_value
->loads
[1]);
8984 __put_user(value
.loads
[2], &target_value
->loads
[2]);
8985 __put_user(value
.totalram
, &target_value
->totalram
);
8986 __put_user(value
.freeram
, &target_value
->freeram
);
8987 __put_user(value
.sharedram
, &target_value
->sharedram
);
8988 __put_user(value
.bufferram
, &target_value
->bufferram
);
8989 __put_user(value
.totalswap
, &target_value
->totalswap
);
8990 __put_user(value
.freeswap
, &target_value
->freeswap
);
8991 __put_user(value
.procs
, &target_value
->procs
);
8992 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
8993 __put_user(value
.freehigh
, &target_value
->freehigh
);
8994 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
8995 unlock_user_struct(target_value
, arg1
, 1);
8999 #ifdef TARGET_NR_ipc
9001 return do_ipc(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9003 #ifdef TARGET_NR_semget
9004 case TARGET_NR_semget
:
9005 return get_errno(semget(arg1
, arg2
, arg3
));
9007 #ifdef TARGET_NR_semop
9008 case TARGET_NR_semop
:
9009 return do_semop(arg1
, arg2
, arg3
);
9011 #ifdef TARGET_NR_semctl
9012 case TARGET_NR_semctl
:
9013 return do_semctl(arg1
, arg2
, arg3
, arg4
);
9015 #ifdef TARGET_NR_msgctl
9016 case TARGET_NR_msgctl
:
9017 return do_msgctl(arg1
, arg2
, arg3
);
9019 #ifdef TARGET_NR_msgget
9020 case TARGET_NR_msgget
:
9021 return get_errno(msgget(arg1
, arg2
));
9023 #ifdef TARGET_NR_msgrcv
9024 case TARGET_NR_msgrcv
:
9025 return do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
9027 #ifdef TARGET_NR_msgsnd
9028 case TARGET_NR_msgsnd
:
9029 return do_msgsnd(arg1
, arg2
, arg3
, arg4
);
9031 #ifdef TARGET_NR_shmget
9032 case TARGET_NR_shmget
:
9033 return get_errno(shmget(arg1
, arg2
, arg3
));
9035 #ifdef TARGET_NR_shmctl
9036 case TARGET_NR_shmctl
:
9037 return do_shmctl(arg1
, arg2
, arg3
);
9039 #ifdef TARGET_NR_shmat
9040 case TARGET_NR_shmat
:
9041 return do_shmat(cpu_env
, arg1
, arg2
, arg3
);
9043 #ifdef TARGET_NR_shmdt
9044 case TARGET_NR_shmdt
:
9045 return do_shmdt(arg1
);
9047 case TARGET_NR_fsync
:
9048 return get_errno(fsync(arg1
));
9049 case TARGET_NR_clone
:
9050 /* Linux manages to have three different orderings for its
9051 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
9052 * match the kernel's CONFIG_CLONE_* settings.
9053 * Microblaze is further special in that it uses a sixth
9054 * implicit argument to clone for the TLS pointer.
9056 #if defined(TARGET_MICROBLAZE)
9057 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
9058 #elif defined(TARGET_CLONE_BACKWARDS)
9059 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
9060 #elif defined(TARGET_CLONE_BACKWARDS2)
9061 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
9063 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
9066 #ifdef __NR_exit_group
9067 /* new thread calls */
9068 case TARGET_NR_exit_group
:
9069 preexit_cleanup(cpu_env
, arg1
);
9070 return get_errno(exit_group(arg1
));
9072 case TARGET_NR_setdomainname
:
9073 if (!(p
= lock_user_string(arg1
)))
9074 return -TARGET_EFAULT
;
9075 ret
= get_errno(setdomainname(p
, arg2
));
9076 unlock_user(p
, arg1
, 0);
9078 case TARGET_NR_uname
:
9079 /* no need to transcode because we use the linux syscall */
9081 struct new_utsname
* buf
;
9083 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
9084 return -TARGET_EFAULT
;
9085 ret
= get_errno(sys_uname(buf
));
9086 if (!is_error(ret
)) {
9087 /* Overwrite the native machine name with whatever is being
9089 g_strlcpy(buf
->machine
, cpu_to_uname_machine(cpu_env
),
9090 sizeof(buf
->machine
));
9091 /* Allow the user to override the reported release. */
9092 if (qemu_uname_release
&& *qemu_uname_release
) {
9093 g_strlcpy(buf
->release
, qemu_uname_release
,
9094 sizeof(buf
->release
));
9097 unlock_user_struct(buf
, arg1
, 1);
9101 case TARGET_NR_modify_ldt
:
9102 return do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
9103 #if !defined(TARGET_X86_64)
9104 case TARGET_NR_vm86
:
9105 return do_vm86(cpu_env
, arg1
, arg2
);
9108 case TARGET_NR_adjtimex
:
9110 struct timex host_buf
;
9112 if (target_to_host_timex(&host_buf
, arg1
) != 0) {
9113 return -TARGET_EFAULT
;
9115 ret
= get_errno(adjtimex(&host_buf
));
9116 if (!is_error(ret
)) {
9117 if (host_to_target_timex(arg1
, &host_buf
) != 0) {
9118 return -TARGET_EFAULT
;
9123 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
9124 case TARGET_NR_clock_adjtime
:
9126 struct timex htx
, *phtx
= &htx
;
9128 if (target_to_host_timex(phtx
, arg2
) != 0) {
9129 return -TARGET_EFAULT
;
9131 ret
= get_errno(clock_adjtime(arg1
, phtx
));
9132 if (!is_error(ret
) && phtx
) {
9133 if (host_to_target_timex(arg2
, phtx
) != 0) {
9134 return -TARGET_EFAULT
;
9140 case TARGET_NR_getpgid
:
9141 return get_errno(getpgid(arg1
));
9142 case TARGET_NR_fchdir
:
9143 return get_errno(fchdir(arg1
));
9144 case TARGET_NR_personality
:
9145 return get_errno(personality(arg1
));
9146 #ifdef TARGET_NR__llseek /* Not on alpha */
9147 case TARGET_NR__llseek
:
9150 #if !defined(__NR_llseek)
9151 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | (abi_ulong
)arg3
, arg5
);
9153 ret
= get_errno(res
);
9158 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
9160 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
9161 return -TARGET_EFAULT
;
9166 #ifdef TARGET_NR_getdents
9167 case TARGET_NR_getdents
:
9168 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
9169 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
9171 struct target_dirent
*target_dirp
;
9172 struct linux_dirent
*dirp
;
9173 abi_long count
= arg3
;
9175 dirp
= g_try_malloc(count
);
9177 return -TARGET_ENOMEM
;
9180 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
9181 if (!is_error(ret
)) {
9182 struct linux_dirent
*de
;
9183 struct target_dirent
*tde
;
9185 int reclen
, treclen
;
9186 int count1
, tnamelen
;
9190 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9191 return -TARGET_EFAULT
;
9194 reclen
= de
->d_reclen
;
9195 tnamelen
= reclen
- offsetof(struct linux_dirent
, d_name
);
9196 assert(tnamelen
>= 0);
9197 treclen
= tnamelen
+ offsetof(struct target_dirent
, d_name
);
9198 assert(count1
+ treclen
<= count
);
9199 tde
->d_reclen
= tswap16(treclen
);
9200 tde
->d_ino
= tswapal(de
->d_ino
);
9201 tde
->d_off
= tswapal(de
->d_off
);
9202 memcpy(tde
->d_name
, de
->d_name
, tnamelen
);
9203 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
9205 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
9209 unlock_user(target_dirp
, arg2
, ret
);
9215 struct linux_dirent
*dirp
;
9216 abi_long count
= arg3
;
9218 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9219 return -TARGET_EFAULT
;
9220 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
9221 if (!is_error(ret
)) {
9222 struct linux_dirent
*de
;
9227 reclen
= de
->d_reclen
;
9230 de
->d_reclen
= tswap16(reclen
);
9231 tswapls(&de
->d_ino
);
9232 tswapls(&de
->d_off
);
9233 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
9237 unlock_user(dirp
, arg2
, ret
);
9241 /* Implement getdents in terms of getdents64 */
9243 struct linux_dirent64
*dirp
;
9244 abi_long count
= arg3
;
9246 dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
9248 return -TARGET_EFAULT
;
9250 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
9251 if (!is_error(ret
)) {
9252 /* Convert the dirent64 structs to target dirent. We do this
9253 * in-place, since we can guarantee that a target_dirent is no
9254 * larger than a dirent64; however this means we have to be
9255 * careful to read everything before writing in the new format.
9257 struct linux_dirent64
*de
;
9258 struct target_dirent
*tde
;
9263 tde
= (struct target_dirent
*)dirp
;
9265 int namelen
, treclen
;
9266 int reclen
= de
->d_reclen
;
9267 uint64_t ino
= de
->d_ino
;
9268 int64_t off
= de
->d_off
;
9269 uint8_t type
= de
->d_type
;
9271 namelen
= strlen(de
->d_name
);
9272 treclen
= offsetof(struct target_dirent
, d_name
)
9274 treclen
= QEMU_ALIGN_UP(treclen
, sizeof(abi_long
));
9276 memmove(tde
->d_name
, de
->d_name
, namelen
+ 1);
9277 tde
->d_ino
= tswapal(ino
);
9278 tde
->d_off
= tswapal(off
);
9279 tde
->d_reclen
= tswap16(treclen
);
9280 /* The target_dirent type is in what was formerly a padding
9281 * byte at the end of the structure:
9283 *(((char *)tde
) + treclen
- 1) = type
;
9285 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
9286 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
9292 unlock_user(dirp
, arg2
, ret
);
9296 #endif /* TARGET_NR_getdents */
9297 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
9298 case TARGET_NR_getdents64
:
9300 struct linux_dirent64
*dirp
;
9301 abi_long count
= arg3
;
9302 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
9303 return -TARGET_EFAULT
;
9304 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
9305 if (!is_error(ret
)) {
9306 struct linux_dirent64
*de
;
9311 reclen
= de
->d_reclen
;
9314 de
->d_reclen
= tswap16(reclen
);
9315 tswap64s((uint64_t *)&de
->d_ino
);
9316 tswap64s((uint64_t *)&de
->d_off
);
9317 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
9321 unlock_user(dirp
, arg2
, ret
);
9324 #endif /* TARGET_NR_getdents64 */
9325 #if defined(TARGET_NR__newselect)
9326 case TARGET_NR__newselect
:
9327 return do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
9329 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
9330 # ifdef TARGET_NR_poll
9331 case TARGET_NR_poll
:
9333 # ifdef TARGET_NR_ppoll
9334 case TARGET_NR_ppoll
:
9337 struct target_pollfd
*target_pfd
;
9338 unsigned int nfds
= arg2
;
9345 if (nfds
> (INT_MAX
/ sizeof(struct target_pollfd
))) {
9346 return -TARGET_EINVAL
;
9349 target_pfd
= lock_user(VERIFY_WRITE
, arg1
,
9350 sizeof(struct target_pollfd
) * nfds
, 1);
9352 return -TARGET_EFAULT
;
9355 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
9356 for (i
= 0; i
< nfds
; i
++) {
9357 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
9358 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
9363 # ifdef TARGET_NR_ppoll
9364 case TARGET_NR_ppoll
:
9366 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
9367 target_sigset_t
*target_set
;
9368 sigset_t _set
, *set
= &_set
;
9371 if (target_to_host_timespec(timeout_ts
, arg3
)) {
9372 unlock_user(target_pfd
, arg1
, 0);
9373 return -TARGET_EFAULT
;
9380 if (arg5
!= sizeof(target_sigset_t
)) {
9381 unlock_user(target_pfd
, arg1
, 0);
9382 return -TARGET_EINVAL
;
9385 target_set
= lock_user(VERIFY_READ
, arg4
, sizeof(target_sigset_t
), 1);
9387 unlock_user(target_pfd
, arg1
, 0);
9388 return -TARGET_EFAULT
;
9390 target_to_host_sigset(set
, target_set
);
9395 ret
= get_errno(safe_ppoll(pfd
, nfds
, timeout_ts
,
9396 set
, SIGSET_T_SIZE
));
9398 if (!is_error(ret
) && arg3
) {
9399 host_to_target_timespec(arg3
, timeout_ts
);
9402 unlock_user(target_set
, arg4
, 0);
9407 # ifdef TARGET_NR_poll
9408 case TARGET_NR_poll
:
9410 struct timespec ts
, *pts
;
9413 /* Convert ms to secs, ns */
9414 ts
.tv_sec
= arg3
/ 1000;
9415 ts
.tv_nsec
= (arg3
% 1000) * 1000000LL;
9418 /* -ve poll() timeout means "infinite" */
9421 ret
= get_errno(safe_ppoll(pfd
, nfds
, pts
, NULL
, 0));
9426 g_assert_not_reached();
9429 if (!is_error(ret
)) {
9430 for(i
= 0; i
< nfds
; i
++) {
9431 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
9434 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
9438 case TARGET_NR_flock
:
9439 /* NOTE: the flock constant seems to be the same for every
9441 return get_errno(safe_flock(arg1
, arg2
));
9442 case TARGET_NR_readv
:
9444 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
9446 ret
= get_errno(safe_readv(arg1
, vec
, arg3
));
9447 unlock_iovec(vec
, arg2
, arg3
, 1);
9449 ret
= -host_to_target_errno(errno
);
9453 case TARGET_NR_writev
:
9455 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
9457 ret
= get_errno(safe_writev(arg1
, vec
, arg3
));
9458 unlock_iovec(vec
, arg2
, arg3
, 0);
9460 ret
= -host_to_target_errno(errno
);
9464 #if defined(TARGET_NR_preadv)
9465 case TARGET_NR_preadv
:
9467 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
9469 unsigned long low
, high
;
9471 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
9472 ret
= get_errno(safe_preadv(arg1
, vec
, arg3
, low
, high
));
9473 unlock_iovec(vec
, arg2
, arg3
, 1);
9475 ret
= -host_to_target_errno(errno
);
9480 #if defined(TARGET_NR_pwritev)
9481 case TARGET_NR_pwritev
:
9483 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
9485 unsigned long low
, high
;
9487 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
9488 ret
= get_errno(safe_pwritev(arg1
, vec
, arg3
, low
, high
));
9489 unlock_iovec(vec
, arg2
, arg3
, 0);
9491 ret
= -host_to_target_errno(errno
);
9496 case TARGET_NR_getsid
:
9497 return get_errno(getsid(arg1
));
9498 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
9499 case TARGET_NR_fdatasync
:
9500 return get_errno(fdatasync(arg1
));
9502 #ifdef TARGET_NR__sysctl
9503 case TARGET_NR__sysctl
:
9504 /* We don't implement this, but ENOTDIR is always a safe
9506 return -TARGET_ENOTDIR
;
9508 case TARGET_NR_sched_getaffinity
:
9510 unsigned int mask_size
;
9511 unsigned long *mask
;
9514 * sched_getaffinity needs multiples of ulong, so need to take
9515 * care of mismatches between target ulong and host ulong sizes.
9517 if (arg2
& (sizeof(abi_ulong
) - 1)) {
9518 return -TARGET_EINVAL
;
9520 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
9522 mask
= alloca(mask_size
);
9523 memset(mask
, 0, mask_size
);
9524 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
9526 if (!is_error(ret
)) {
9528 /* More data returned than the caller's buffer will fit.
9529 * This only happens if sizeof(abi_long) < sizeof(long)
9530 * and the caller passed us a buffer holding an odd number
9531 * of abi_longs. If the host kernel is actually using the
9532 * extra 4 bytes then fail EINVAL; otherwise we can just
9533 * ignore them and only copy the interesting part.
9535 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
9536 if (numcpus
> arg2
* 8) {
9537 return -TARGET_EINVAL
;
9542 if (host_to_target_cpu_mask(mask
, mask_size
, arg3
, ret
)) {
9543 return -TARGET_EFAULT
;
9548 case TARGET_NR_sched_setaffinity
:
9550 unsigned int mask_size
;
9551 unsigned long *mask
;
9554 * sched_setaffinity needs multiples of ulong, so need to take
9555 * care of mismatches between target ulong and host ulong sizes.
9557 if (arg2
& (sizeof(abi_ulong
) - 1)) {
9558 return -TARGET_EINVAL
;
9560 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
9561 mask
= alloca(mask_size
);
9563 ret
= target_to_host_cpu_mask(mask
, mask_size
, arg3
, arg2
);
9568 return get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
9570 case TARGET_NR_getcpu
:
9573 ret
= get_errno(sys_getcpu(arg1
? &cpu
: NULL
,
9574 arg2
? &node
: NULL
,
9576 if (is_error(ret
)) {
9579 if (arg1
&& put_user_u32(cpu
, arg1
)) {
9580 return -TARGET_EFAULT
;
9582 if (arg2
&& put_user_u32(node
, arg2
)) {
9583 return -TARGET_EFAULT
;
9587 case TARGET_NR_sched_setparam
:
9589 struct sched_param
*target_schp
;
9590 struct sched_param schp
;
9593 return -TARGET_EINVAL
;
9595 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
9596 return -TARGET_EFAULT
;
9597 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
9598 unlock_user_struct(target_schp
, arg2
, 0);
9599 return get_errno(sched_setparam(arg1
, &schp
));
9601 case TARGET_NR_sched_getparam
:
9603 struct sched_param
*target_schp
;
9604 struct sched_param schp
;
9607 return -TARGET_EINVAL
;
9609 ret
= get_errno(sched_getparam(arg1
, &schp
));
9610 if (!is_error(ret
)) {
9611 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
9612 return -TARGET_EFAULT
;
9613 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
9614 unlock_user_struct(target_schp
, arg2
, 1);
9618 case TARGET_NR_sched_setscheduler
:
9620 struct sched_param
*target_schp
;
9621 struct sched_param schp
;
9623 return -TARGET_EINVAL
;
9625 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
9626 return -TARGET_EFAULT
;
9627 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
9628 unlock_user_struct(target_schp
, arg3
, 0);
9629 return get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
9631 case TARGET_NR_sched_getscheduler
:
9632 return get_errno(sched_getscheduler(arg1
));
9633 case TARGET_NR_sched_yield
:
9634 return get_errno(sched_yield());
9635 case TARGET_NR_sched_get_priority_max
:
9636 return get_errno(sched_get_priority_max(arg1
));
9637 case TARGET_NR_sched_get_priority_min
:
9638 return get_errno(sched_get_priority_min(arg1
));
9639 case TARGET_NR_sched_rr_get_interval
:
9642 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
9643 if (!is_error(ret
)) {
9644 ret
= host_to_target_timespec(arg2
, &ts
);
9648 case TARGET_NR_nanosleep
:
9650 struct timespec req
, rem
;
9651 target_to_host_timespec(&req
, arg1
);
9652 ret
= get_errno(safe_nanosleep(&req
, &rem
));
9653 if (is_error(ret
) && arg2
) {
9654 host_to_target_timespec(arg2
, &rem
);
9658 case TARGET_NR_prctl
:
9660 case PR_GET_PDEATHSIG
:
9663 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
9664 if (!is_error(ret
) && arg2
9665 && put_user_ual(deathsig
, arg2
)) {
9666 return -TARGET_EFAULT
;
9673 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
9675 return -TARGET_EFAULT
;
9677 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
9679 unlock_user(name
, arg2
, 16);
9684 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
9686 return -TARGET_EFAULT
;
9688 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
9690 unlock_user(name
, arg2
, 0);
9695 case TARGET_PR_GET_FP_MODE
:
9697 CPUMIPSState
*env
= ((CPUMIPSState
*)cpu_env
);
9699 if (env
->CP0_Status
& (1 << CP0St_FR
)) {
9700 ret
|= TARGET_PR_FP_MODE_FR
;
9702 if (env
->CP0_Config5
& (1 << CP0C5_FRE
)) {
9703 ret
|= TARGET_PR_FP_MODE_FRE
;
9707 case TARGET_PR_SET_FP_MODE
:
9709 CPUMIPSState
*env
= ((CPUMIPSState
*)cpu_env
);
9710 bool old_fr
= env
->CP0_Status
& (1 << CP0St_FR
);
9711 bool old_fre
= env
->CP0_Config5
& (1 << CP0C5_FRE
);
9712 bool new_fr
= arg2
& TARGET_PR_FP_MODE_FR
;
9713 bool new_fre
= arg2
& TARGET_PR_FP_MODE_FRE
;
9715 const unsigned int known_bits
= TARGET_PR_FP_MODE_FR
|
9716 TARGET_PR_FP_MODE_FRE
;
9718 /* If nothing to change, return right away, successfully. */
9719 if (old_fr
== new_fr
&& old_fre
== new_fre
) {
9722 /* Check the value is valid */
9723 if (arg2
& ~known_bits
) {
9724 return -TARGET_EOPNOTSUPP
;
9726 /* Setting FRE without FR is not supported. */
9727 if (new_fre
&& !new_fr
) {
9728 return -TARGET_EOPNOTSUPP
;
9730 if (new_fr
&& !(env
->active_fpu
.fcr0
& (1 << FCR0_F64
))) {
9731 /* FR1 is not supported */
9732 return -TARGET_EOPNOTSUPP
;
9734 if (!new_fr
&& (env
->active_fpu
.fcr0
& (1 << FCR0_F64
))
9735 && !(env
->CP0_Status_rw_bitmask
& (1 << CP0St_FR
))) {
9736 /* cannot set FR=0 */
9737 return -TARGET_EOPNOTSUPP
;
9739 if (new_fre
&& !(env
->active_fpu
.fcr0
& (1 << FCR0_FREP
))) {
9740 /* Cannot set FRE=1 */
9741 return -TARGET_EOPNOTSUPP
;
9745 fpr_t
*fpr
= env
->active_fpu
.fpr
;
9746 for (i
= 0; i
< 32 ; i
+= 2) {
9747 if (!old_fr
&& new_fr
) {
9748 fpr
[i
].w
[!FP_ENDIAN_IDX
] = fpr
[i
+ 1].w
[FP_ENDIAN_IDX
];
9749 } else if (old_fr
&& !new_fr
) {
9750 fpr
[i
+ 1].w
[FP_ENDIAN_IDX
] = fpr
[i
].w
[!FP_ENDIAN_IDX
];
9755 env
->CP0_Status
|= (1 << CP0St_FR
);
9756 env
->hflags
|= MIPS_HFLAG_F64
;
9758 env
->CP0_Status
&= ~(1 << CP0St_FR
);
9759 env
->hflags
&= ~MIPS_HFLAG_F64
;
9762 env
->CP0_Config5
|= (1 << CP0C5_FRE
);
9763 if (env
->active_fpu
.fcr0
& (1 << FCR0_FREP
)) {
9764 env
->hflags
|= MIPS_HFLAG_FRE
;
9767 env
->CP0_Config5
&= ~(1 << CP0C5_FRE
);
9768 env
->hflags
&= ~MIPS_HFLAG_FRE
;
9774 #ifdef TARGET_AARCH64
9775 case TARGET_PR_SVE_SET_VL
:
9777 * We cannot support either PR_SVE_SET_VL_ONEXEC or
9778 * PR_SVE_VL_INHERIT. Note the kernel definition
9779 * of sve_vl_valid allows for VQ=512, i.e. VL=8192,
9780 * even though the current architectural maximum is VQ=16.
9782 ret
= -TARGET_EINVAL
;
9783 if (cpu_isar_feature(aa64_sve
, env_archcpu(cpu_env
))
9784 && arg2
>= 0 && arg2
<= 512 * 16 && !(arg2
& 15)) {
9785 CPUARMState
*env
= cpu_env
;
9786 ARMCPU
*cpu
= env_archcpu(env
);
9787 uint32_t vq
, old_vq
;
9789 old_vq
= (env
->vfp
.zcr_el
[1] & 0xf) + 1;
9790 vq
= MAX(arg2
/ 16, 1);
9791 vq
= MIN(vq
, cpu
->sve_max_vq
);
9794 aarch64_sve_narrow_vq(env
, vq
);
9796 env
->vfp
.zcr_el
[1] = vq
- 1;
9800 case TARGET_PR_SVE_GET_VL
:
9801 ret
= -TARGET_EINVAL
;
9803 ARMCPU
*cpu
= env_archcpu(cpu_env
);
9804 if (cpu_isar_feature(aa64_sve
, cpu
)) {
9805 ret
= ((cpu
->env
.vfp
.zcr_el
[1] & 0xf) + 1) * 16;
9809 case TARGET_PR_PAC_RESET_KEYS
:
9811 CPUARMState
*env
= cpu_env
;
9812 ARMCPU
*cpu
= env_archcpu(env
);
9814 if (arg3
|| arg4
|| arg5
) {
9815 return -TARGET_EINVAL
;
9817 if (cpu_isar_feature(aa64_pauth
, cpu
)) {
9818 int all
= (TARGET_PR_PAC_APIAKEY
| TARGET_PR_PAC_APIBKEY
|
9819 TARGET_PR_PAC_APDAKEY
| TARGET_PR_PAC_APDBKEY
|
9820 TARGET_PR_PAC_APGAKEY
);
9826 } else if (arg2
& ~all
) {
9827 return -TARGET_EINVAL
;
9829 if (arg2
& TARGET_PR_PAC_APIAKEY
) {
9830 ret
|= qemu_guest_getrandom(&env
->keys
.apia
,
9831 sizeof(ARMPACKey
), &err
);
9833 if (arg2
& TARGET_PR_PAC_APIBKEY
) {
9834 ret
|= qemu_guest_getrandom(&env
->keys
.apib
,
9835 sizeof(ARMPACKey
), &err
);
9837 if (arg2
& TARGET_PR_PAC_APDAKEY
) {
9838 ret
|= qemu_guest_getrandom(&env
->keys
.apda
,
9839 sizeof(ARMPACKey
), &err
);
9841 if (arg2
& TARGET_PR_PAC_APDBKEY
) {
9842 ret
|= qemu_guest_getrandom(&env
->keys
.apdb
,
9843 sizeof(ARMPACKey
), &err
);
9845 if (arg2
& TARGET_PR_PAC_APGAKEY
) {
9846 ret
|= qemu_guest_getrandom(&env
->keys
.apga
,
9847 sizeof(ARMPACKey
), &err
);
9851 * Some unknown failure in the crypto. The best
9852 * we can do is log it and fail the syscall.
9853 * The real syscall cannot fail this way.
9855 qemu_log_mask(LOG_UNIMP
,
9856 "PR_PAC_RESET_KEYS: Crypto failure: %s",
9857 error_get_pretty(err
));
9864 return -TARGET_EINVAL
;
9865 #endif /* AARCH64 */
9866 case PR_GET_SECCOMP
:
9867 case PR_SET_SECCOMP
:
9868 /* Disable seccomp to prevent the target disabling syscalls we
9870 return -TARGET_EINVAL
;
9872 /* Most prctl options have no pointer arguments */
9873 return get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
9876 #ifdef TARGET_NR_arch_prctl
9877 case TARGET_NR_arch_prctl
:
9878 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
9879 return do_arch_prctl(cpu_env
, arg1
, arg2
);
9884 #ifdef TARGET_NR_pread64
9885 case TARGET_NR_pread64
:
9886 if (regpairs_aligned(cpu_env
, num
)) {
9890 if (arg2
== 0 && arg3
== 0) {
9891 /* Special-case NULL buffer and zero length, which should succeed */
9894 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9896 return -TARGET_EFAULT
;
9899 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
9900 unlock_user(p
, arg2
, ret
);
9902 case TARGET_NR_pwrite64
:
9903 if (regpairs_aligned(cpu_env
, num
)) {
9907 if (arg2
== 0 && arg3
== 0) {
9908 /* Special-case NULL buffer and zero length, which should succeed */
9911 p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1);
9913 return -TARGET_EFAULT
;
9916 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
9917 unlock_user(p
, arg2
, 0);
9920 case TARGET_NR_getcwd
:
9921 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
9922 return -TARGET_EFAULT
;
9923 ret
= get_errno(sys_getcwd1(p
, arg2
));
9924 unlock_user(p
, arg1
, ret
);
9926 case TARGET_NR_capget
:
9927 case TARGET_NR_capset
:
9929 struct target_user_cap_header
*target_header
;
9930 struct target_user_cap_data
*target_data
= NULL
;
9931 struct __user_cap_header_struct header
;
9932 struct __user_cap_data_struct data
[2];
9933 struct __user_cap_data_struct
*dataptr
= NULL
;
9934 int i
, target_datalen
;
9937 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
9938 return -TARGET_EFAULT
;
9940 header
.version
= tswap32(target_header
->version
);
9941 header
.pid
= tswap32(target_header
->pid
);
9943 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
9944 /* Version 2 and up takes pointer to two user_data structs */
9948 target_datalen
= sizeof(*target_data
) * data_items
;
9951 if (num
== TARGET_NR_capget
) {
9952 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
9954 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
9957 unlock_user_struct(target_header
, arg1
, 0);
9958 return -TARGET_EFAULT
;
9961 if (num
== TARGET_NR_capset
) {
9962 for (i
= 0; i
< data_items
; i
++) {
9963 data
[i
].effective
= tswap32(target_data
[i
].effective
);
9964 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
9965 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
9972 if (num
== TARGET_NR_capget
) {
9973 ret
= get_errno(capget(&header
, dataptr
));
9975 ret
= get_errno(capset(&header
, dataptr
));
9978 /* The kernel always updates version for both capget and capset */
9979 target_header
->version
= tswap32(header
.version
);
9980 unlock_user_struct(target_header
, arg1
, 1);
9983 if (num
== TARGET_NR_capget
) {
9984 for (i
= 0; i
< data_items
; i
++) {
9985 target_data
[i
].effective
= tswap32(data
[i
].effective
);
9986 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
9987 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
9989 unlock_user(target_data
, arg2
, target_datalen
);
9991 unlock_user(target_data
, arg2
, 0);
9996 case TARGET_NR_sigaltstack
:
9997 return do_sigaltstack(arg1
, arg2
,
9998 get_sp_from_cpustate((CPUArchState
*)cpu_env
));
10000 #ifdef CONFIG_SENDFILE
10001 #ifdef TARGET_NR_sendfile
10002 case TARGET_NR_sendfile
:
10004 off_t
*offp
= NULL
;
10007 ret
= get_user_sal(off
, arg3
);
10008 if (is_error(ret
)) {
10013 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10014 if (!is_error(ret
) && arg3
) {
10015 abi_long ret2
= put_user_sal(off
, arg3
);
10016 if (is_error(ret2
)) {
10023 #ifdef TARGET_NR_sendfile64
10024 case TARGET_NR_sendfile64
:
10026 off_t
*offp
= NULL
;
10029 ret
= get_user_s64(off
, arg3
);
10030 if (is_error(ret
)) {
10035 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10036 if (!is_error(ret
) && arg3
) {
10037 abi_long ret2
= put_user_s64(off
, arg3
);
10038 if (is_error(ret2
)) {
10046 #ifdef TARGET_NR_vfork
10047 case TARGET_NR_vfork
:
10048 return get_errno(do_fork(cpu_env
,
10049 CLONE_VFORK
| CLONE_VM
| TARGET_SIGCHLD
,
10052 #ifdef TARGET_NR_ugetrlimit
10053 case TARGET_NR_ugetrlimit
:
10055 struct rlimit rlim
;
10056 int resource
= target_to_host_resource(arg1
);
10057 ret
= get_errno(getrlimit(resource
, &rlim
));
10058 if (!is_error(ret
)) {
10059 struct target_rlimit
*target_rlim
;
10060 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
10061 return -TARGET_EFAULT
;
10062 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
10063 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
10064 unlock_user_struct(target_rlim
, arg2
, 1);
10069 #ifdef TARGET_NR_truncate64
10070 case TARGET_NR_truncate64
:
10071 if (!(p
= lock_user_string(arg1
)))
10072 return -TARGET_EFAULT
;
10073 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
10074 unlock_user(p
, arg1
, 0);
10077 #ifdef TARGET_NR_ftruncate64
10078 case TARGET_NR_ftruncate64
:
10079 return target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
10081 #ifdef TARGET_NR_stat64
10082 case TARGET_NR_stat64
:
10083 if (!(p
= lock_user_string(arg1
))) {
10084 return -TARGET_EFAULT
;
10086 ret
= get_errno(stat(path(p
), &st
));
10087 unlock_user(p
, arg1
, 0);
10088 if (!is_error(ret
))
10089 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10092 #ifdef TARGET_NR_lstat64
10093 case TARGET_NR_lstat64
:
10094 if (!(p
= lock_user_string(arg1
))) {
10095 return -TARGET_EFAULT
;
10097 ret
= get_errno(lstat(path(p
), &st
));
10098 unlock_user(p
, arg1
, 0);
10099 if (!is_error(ret
))
10100 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10103 #ifdef TARGET_NR_fstat64
10104 case TARGET_NR_fstat64
:
10105 ret
= get_errno(fstat(arg1
, &st
));
10106 if (!is_error(ret
))
10107 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10110 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
10111 #ifdef TARGET_NR_fstatat64
10112 case TARGET_NR_fstatat64
:
10114 #ifdef TARGET_NR_newfstatat
10115 case TARGET_NR_newfstatat
:
10117 if (!(p
= lock_user_string(arg2
))) {
10118 return -TARGET_EFAULT
;
10120 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
10121 unlock_user(p
, arg2
, 0);
10122 if (!is_error(ret
))
10123 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
10126 #ifdef TARGET_NR_lchown
10127 case TARGET_NR_lchown
:
10128 if (!(p
= lock_user_string(arg1
)))
10129 return -TARGET_EFAULT
;
10130 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
10131 unlock_user(p
, arg1
, 0);
10134 #ifdef TARGET_NR_getuid
10135 case TARGET_NR_getuid
:
10136 return get_errno(high2lowuid(getuid()));
10138 #ifdef TARGET_NR_getgid
10139 case TARGET_NR_getgid
:
10140 return get_errno(high2lowgid(getgid()));
10142 #ifdef TARGET_NR_geteuid
10143 case TARGET_NR_geteuid
:
10144 return get_errno(high2lowuid(geteuid()));
10146 #ifdef TARGET_NR_getegid
10147 case TARGET_NR_getegid
:
10148 return get_errno(high2lowgid(getegid()));
10150 case TARGET_NR_setreuid
:
10151 return get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
10152 case TARGET_NR_setregid
:
10153 return get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
10154 case TARGET_NR_getgroups
:
10156 int gidsetsize
= arg1
;
10157 target_id
*target_grouplist
;
10161 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10162 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
10163 if (gidsetsize
== 0)
10165 if (!is_error(ret
)) {
10166 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* sizeof(target_id
), 0);
10167 if (!target_grouplist
)
10168 return -TARGET_EFAULT
;
10169 for(i
= 0;i
< ret
; i
++)
10170 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
10171 unlock_user(target_grouplist
, arg2
, gidsetsize
* sizeof(target_id
));
10175 case TARGET_NR_setgroups
:
10177 int gidsetsize
= arg1
;
10178 target_id
*target_grouplist
;
10179 gid_t
*grouplist
= NULL
;
10182 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10183 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* sizeof(target_id
), 1);
10184 if (!target_grouplist
) {
10185 return -TARGET_EFAULT
;
10187 for (i
= 0; i
< gidsetsize
; i
++) {
10188 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
10190 unlock_user(target_grouplist
, arg2
, 0);
10192 return get_errno(setgroups(gidsetsize
, grouplist
));
10194 case TARGET_NR_fchown
:
10195 return get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
10196 #if defined(TARGET_NR_fchownat)
10197 case TARGET_NR_fchownat
:
10198 if (!(p
= lock_user_string(arg2
)))
10199 return -TARGET_EFAULT
;
10200 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
10201 low2highgid(arg4
), arg5
));
10202 unlock_user(p
, arg2
, 0);
10205 #ifdef TARGET_NR_setresuid
10206 case TARGET_NR_setresuid
:
10207 return get_errno(sys_setresuid(low2highuid(arg1
),
10209 low2highuid(arg3
)));
10211 #ifdef TARGET_NR_getresuid
10212 case TARGET_NR_getresuid
:
10214 uid_t ruid
, euid
, suid
;
10215 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
10216 if (!is_error(ret
)) {
10217 if (put_user_id(high2lowuid(ruid
), arg1
)
10218 || put_user_id(high2lowuid(euid
), arg2
)
10219 || put_user_id(high2lowuid(suid
), arg3
))
10220 return -TARGET_EFAULT
;
10225 #ifdef TARGET_NR_getresgid
10226 case TARGET_NR_setresgid
:
10227 return get_errno(sys_setresgid(low2highgid(arg1
),
10229 low2highgid(arg3
)));
10231 #ifdef TARGET_NR_getresgid
10232 case TARGET_NR_getresgid
:
10234 gid_t rgid
, egid
, sgid
;
10235 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
10236 if (!is_error(ret
)) {
10237 if (put_user_id(high2lowgid(rgid
), arg1
)
10238 || put_user_id(high2lowgid(egid
), arg2
)
10239 || put_user_id(high2lowgid(sgid
), arg3
))
10240 return -TARGET_EFAULT
;
10245 #ifdef TARGET_NR_chown
10246 case TARGET_NR_chown
:
10247 if (!(p
= lock_user_string(arg1
)))
10248 return -TARGET_EFAULT
;
10249 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
10250 unlock_user(p
, arg1
, 0);
10253 case TARGET_NR_setuid
:
10254 return get_errno(sys_setuid(low2highuid(arg1
)));
10255 case TARGET_NR_setgid
:
10256 return get_errno(sys_setgid(low2highgid(arg1
)));
10257 case TARGET_NR_setfsuid
:
10258 return get_errno(setfsuid(arg1
));
10259 case TARGET_NR_setfsgid
:
10260 return get_errno(setfsgid(arg1
));
10262 #ifdef TARGET_NR_lchown32
10263 case TARGET_NR_lchown32
:
10264 if (!(p
= lock_user_string(arg1
)))
10265 return -TARGET_EFAULT
;
10266 ret
= get_errno(lchown(p
, arg2
, arg3
));
10267 unlock_user(p
, arg1
, 0);
10270 #ifdef TARGET_NR_getuid32
10271 case TARGET_NR_getuid32
:
10272 return get_errno(getuid());
10275 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
10276 /* Alpha specific */
10277 case TARGET_NR_getxuid
:
10281 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=euid
;
10283 return get_errno(getuid());
10285 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
10286 /* Alpha specific */
10287 case TARGET_NR_getxgid
:
10291 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=egid
;
10293 return get_errno(getgid());
10295 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
10296 /* Alpha specific */
10297 case TARGET_NR_osf_getsysinfo
:
10298 ret
= -TARGET_EOPNOTSUPP
;
10300 case TARGET_GSI_IEEE_FP_CONTROL
:
10302 uint64_t fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10303 uint64_t swcr
= ((CPUAlphaState
*)cpu_env
)->swcr
;
10305 swcr
&= ~SWCR_STATUS_MASK
;
10306 swcr
|= (fpcr
>> 35) & SWCR_STATUS_MASK
;
10308 if (put_user_u64 (swcr
, arg2
))
10309 return -TARGET_EFAULT
;
10314 /* case GSI_IEEE_STATE_AT_SIGNAL:
10315 -- Not implemented in linux kernel.
10317 -- Retrieves current unaligned access state; not much used.
10318 case GSI_PROC_TYPE:
10319 -- Retrieves implver information; surely not used.
10320 case GSI_GET_HWRPB:
10321 -- Grabs a copy of the HWRPB; surely not used.
10326 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
10327 /* Alpha specific */
10328 case TARGET_NR_osf_setsysinfo
:
10329 ret
= -TARGET_EOPNOTSUPP
;
10331 case TARGET_SSI_IEEE_FP_CONTROL
:
10333 uint64_t swcr
, fpcr
;
10335 if (get_user_u64 (swcr
, arg2
)) {
10336 return -TARGET_EFAULT
;
10340 * The kernel calls swcr_update_status to update the
10341 * status bits from the fpcr at every point that it
10342 * could be queried. Therefore, we store the status
10343 * bits only in FPCR.
10345 ((CPUAlphaState
*)cpu_env
)->swcr
10346 = swcr
& (SWCR_TRAP_ENABLE_MASK
| SWCR_MAP_MASK
);
10348 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10349 fpcr
&= ((uint64_t)FPCR_DYN_MASK
<< 32);
10350 fpcr
|= alpha_ieee_swcr_to_fpcr(swcr
);
10351 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
10356 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
10358 uint64_t exc
, fpcr
, fex
;
10360 if (get_user_u64(exc
, arg2
)) {
10361 return -TARGET_EFAULT
;
10363 exc
&= SWCR_STATUS_MASK
;
10364 fpcr
= cpu_alpha_load_fpcr(cpu_env
);
10366 /* Old exceptions are not signaled. */
10367 fex
= alpha_ieee_fpcr_to_swcr(fpcr
);
10369 fex
>>= SWCR_STATUS_TO_EXCSUM_SHIFT
;
10370 fex
&= ((CPUArchState
*)cpu_env
)->swcr
;
10372 /* Update the hardware fpcr. */
10373 fpcr
|= alpha_ieee_swcr_to_fpcr(exc
);
10374 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
10377 int si_code
= TARGET_FPE_FLTUNK
;
10378 target_siginfo_t info
;
10380 if (fex
& SWCR_TRAP_ENABLE_DNO
) {
10381 si_code
= TARGET_FPE_FLTUND
;
10383 if (fex
& SWCR_TRAP_ENABLE_INE
) {
10384 si_code
= TARGET_FPE_FLTRES
;
10386 if (fex
& SWCR_TRAP_ENABLE_UNF
) {
10387 si_code
= TARGET_FPE_FLTUND
;
10389 if (fex
& SWCR_TRAP_ENABLE_OVF
) {
10390 si_code
= TARGET_FPE_FLTOVF
;
10392 if (fex
& SWCR_TRAP_ENABLE_DZE
) {
10393 si_code
= TARGET_FPE_FLTDIV
;
10395 if (fex
& SWCR_TRAP_ENABLE_INV
) {
10396 si_code
= TARGET_FPE_FLTINV
;
10399 info
.si_signo
= SIGFPE
;
10401 info
.si_code
= si_code
;
10402 info
._sifields
._sigfault
._addr
10403 = ((CPUArchState
*)cpu_env
)->pc
;
10404 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
10405 QEMU_SI_FAULT
, &info
);
10411 /* case SSI_NVPAIRS:
10412 -- Used with SSIN_UACPROC to enable unaligned accesses.
10413 case SSI_IEEE_STATE_AT_SIGNAL:
10414 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
10415 -- Not implemented in linux kernel
10420 #ifdef TARGET_NR_osf_sigprocmask
10421 /* Alpha specific. */
10422 case TARGET_NR_osf_sigprocmask
:
10426 sigset_t set
, oldset
;
10429 case TARGET_SIG_BLOCK
:
10432 case TARGET_SIG_UNBLOCK
:
10435 case TARGET_SIG_SETMASK
:
10439 return -TARGET_EINVAL
;
10442 target_to_host_old_sigset(&set
, &mask
);
10443 ret
= do_sigprocmask(how
, &set
, &oldset
);
10445 host_to_target_old_sigset(&mask
, &oldset
);
10452 #ifdef TARGET_NR_getgid32
10453 case TARGET_NR_getgid32
:
10454 return get_errno(getgid());
10456 #ifdef TARGET_NR_geteuid32
10457 case TARGET_NR_geteuid32
:
10458 return get_errno(geteuid());
10460 #ifdef TARGET_NR_getegid32
10461 case TARGET_NR_getegid32
:
10462 return get_errno(getegid());
10464 #ifdef TARGET_NR_setreuid32
10465 case TARGET_NR_setreuid32
:
10466 return get_errno(setreuid(arg1
, arg2
));
10468 #ifdef TARGET_NR_setregid32
10469 case TARGET_NR_setregid32
:
10470 return get_errno(setregid(arg1
, arg2
));
10472 #ifdef TARGET_NR_getgroups32
10473 case TARGET_NR_getgroups32
:
10475 int gidsetsize
= arg1
;
10476 uint32_t *target_grouplist
;
10480 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10481 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
10482 if (gidsetsize
== 0)
10484 if (!is_error(ret
)) {
10485 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
10486 if (!target_grouplist
) {
10487 return -TARGET_EFAULT
;
10489 for(i
= 0;i
< ret
; i
++)
10490 target_grouplist
[i
] = tswap32(grouplist
[i
]);
10491 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
10496 #ifdef TARGET_NR_setgroups32
10497 case TARGET_NR_setgroups32
:
10499 int gidsetsize
= arg1
;
10500 uint32_t *target_grouplist
;
10504 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10505 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
10506 if (!target_grouplist
) {
10507 return -TARGET_EFAULT
;
10509 for(i
= 0;i
< gidsetsize
; i
++)
10510 grouplist
[i
] = tswap32(target_grouplist
[i
]);
10511 unlock_user(target_grouplist
, arg2
, 0);
10512 return get_errno(setgroups(gidsetsize
, grouplist
));
10515 #ifdef TARGET_NR_fchown32
10516 case TARGET_NR_fchown32
:
10517 return get_errno(fchown(arg1
, arg2
, arg3
));
10519 #ifdef TARGET_NR_setresuid32
10520 case TARGET_NR_setresuid32
:
10521 return get_errno(sys_setresuid(arg1
, arg2
, arg3
));
10523 #ifdef TARGET_NR_getresuid32
10524 case TARGET_NR_getresuid32
:
10526 uid_t ruid
, euid
, suid
;
10527 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
10528 if (!is_error(ret
)) {
10529 if (put_user_u32(ruid
, arg1
)
10530 || put_user_u32(euid
, arg2
)
10531 || put_user_u32(suid
, arg3
))
10532 return -TARGET_EFAULT
;
10537 #ifdef TARGET_NR_setresgid32
10538 case TARGET_NR_setresgid32
:
10539 return get_errno(sys_setresgid(arg1
, arg2
, arg3
));
10541 #ifdef TARGET_NR_getresgid32
10542 case TARGET_NR_getresgid32
:
10544 gid_t rgid
, egid
, sgid
;
10545 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
10546 if (!is_error(ret
)) {
10547 if (put_user_u32(rgid
, arg1
)
10548 || put_user_u32(egid
, arg2
)
10549 || put_user_u32(sgid
, arg3
))
10550 return -TARGET_EFAULT
;
10555 #ifdef TARGET_NR_chown32
10556 case TARGET_NR_chown32
:
10557 if (!(p
= lock_user_string(arg1
)))
10558 return -TARGET_EFAULT
;
10559 ret
= get_errno(chown(p
, arg2
, arg3
));
10560 unlock_user(p
, arg1
, 0);
10563 #ifdef TARGET_NR_setuid32
10564 case TARGET_NR_setuid32
:
10565 return get_errno(sys_setuid(arg1
));
10567 #ifdef TARGET_NR_setgid32
10568 case TARGET_NR_setgid32
:
10569 return get_errno(sys_setgid(arg1
));
10571 #ifdef TARGET_NR_setfsuid32
10572 case TARGET_NR_setfsuid32
:
10573 return get_errno(setfsuid(arg1
));
10575 #ifdef TARGET_NR_setfsgid32
10576 case TARGET_NR_setfsgid32
:
10577 return get_errno(setfsgid(arg1
));
10579 #ifdef TARGET_NR_mincore
10580 case TARGET_NR_mincore
:
10582 void *a
= lock_user(VERIFY_READ
, arg1
, arg2
, 0);
10584 return -TARGET_ENOMEM
;
10586 p
= lock_user_string(arg3
);
10588 ret
= -TARGET_EFAULT
;
10590 ret
= get_errno(mincore(a
, arg2
, p
));
10591 unlock_user(p
, arg3
, ret
);
10593 unlock_user(a
, arg1
, 0);
10597 #ifdef TARGET_NR_arm_fadvise64_64
10598 case TARGET_NR_arm_fadvise64_64
:
10599 /* arm_fadvise64_64 looks like fadvise64_64 but
10600 * with different argument order: fd, advice, offset, len
10601 * rather than the usual fd, offset, len, advice.
10602 * Note that offset and len are both 64-bit so appear as
10603 * pairs of 32-bit registers.
10605 ret
= posix_fadvise(arg1
, target_offset64(arg3
, arg4
),
10606 target_offset64(arg5
, arg6
), arg2
);
10607 return -host_to_target_errno(ret
);
10610 #if TARGET_ABI_BITS == 32
10612 #ifdef TARGET_NR_fadvise64_64
10613 case TARGET_NR_fadvise64_64
:
10614 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
10615 /* 6 args: fd, advice, offset (high, low), len (high, low) */
10623 /* 6 args: fd, offset (high, low), len (high, low), advice */
10624 if (regpairs_aligned(cpu_env
, num
)) {
10625 /* offset is in (3,4), len in (5,6) and advice in 7 */
10633 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
),
10634 target_offset64(arg4
, arg5
), arg6
);
10635 return -host_to_target_errno(ret
);
10638 #ifdef TARGET_NR_fadvise64
10639 case TARGET_NR_fadvise64
:
10640 /* 5 args: fd, offset (high, low), len, advice */
10641 if (regpairs_aligned(cpu_env
, num
)) {
10642 /* offset is in (3,4), len in 5 and advice in 6 */
10648 ret
= posix_fadvise(arg1
, target_offset64(arg2
, arg3
), arg4
, arg5
);
10649 return -host_to_target_errno(ret
);
10652 #else /* not a 32-bit ABI */
10653 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
10654 #ifdef TARGET_NR_fadvise64_64
10655 case TARGET_NR_fadvise64_64
:
10657 #ifdef TARGET_NR_fadvise64
10658 case TARGET_NR_fadvise64
:
10660 #ifdef TARGET_S390X
10662 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
10663 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
10664 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
10665 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
10669 return -host_to_target_errno(posix_fadvise(arg1
, arg2
, arg3
, arg4
));
10671 #endif /* end of 64-bit ABI fadvise handling */
10673 #ifdef TARGET_NR_madvise
10674 case TARGET_NR_madvise
:
10675 /* A straight passthrough may not be safe because qemu sometimes
10676 turns private file-backed mappings into anonymous mappings.
10677 This will break MADV_DONTNEED.
10678 This is a hint, so ignoring and returning success is ok. */
10681 #if TARGET_ABI_BITS == 32
10682 case TARGET_NR_fcntl64
:
10686 from_flock64_fn
*copyfrom
= copy_from_user_flock64
;
10687 to_flock64_fn
*copyto
= copy_to_user_flock64
;
10690 if (!((CPUARMState
*)cpu_env
)->eabi
) {
10691 copyfrom
= copy_from_user_oabi_flock64
;
10692 copyto
= copy_to_user_oabi_flock64
;
10696 cmd
= target_to_host_fcntl_cmd(arg2
);
10697 if (cmd
== -TARGET_EINVAL
) {
10702 case TARGET_F_GETLK64
:
10703 ret
= copyfrom(&fl
, arg3
);
10707 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
10709 ret
= copyto(arg3
, &fl
);
10713 case TARGET_F_SETLK64
:
10714 case TARGET_F_SETLKW64
:
10715 ret
= copyfrom(&fl
, arg3
);
10719 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
10722 ret
= do_fcntl(arg1
, arg2
, arg3
);
10728 #ifdef TARGET_NR_cacheflush
10729 case TARGET_NR_cacheflush
:
10730 /* self-modifying code is handled automatically, so nothing needed */
10733 #ifdef TARGET_NR_getpagesize
10734 case TARGET_NR_getpagesize
:
10735 return TARGET_PAGE_SIZE
;
10737 case TARGET_NR_gettid
:
10738 return get_errno(sys_gettid());
10739 #ifdef TARGET_NR_readahead
10740 case TARGET_NR_readahead
:
10741 #if TARGET_ABI_BITS == 32
10742 if (regpairs_aligned(cpu_env
, num
)) {
10747 ret
= get_errno(readahead(arg1
, target_offset64(arg2
, arg3
) , arg4
));
10749 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
10754 #ifdef TARGET_NR_setxattr
10755 case TARGET_NR_listxattr
:
10756 case TARGET_NR_llistxattr
:
10760 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
10762 return -TARGET_EFAULT
;
10765 p
= lock_user_string(arg1
);
10767 if (num
== TARGET_NR_listxattr
) {
10768 ret
= get_errno(listxattr(p
, b
, arg3
));
10770 ret
= get_errno(llistxattr(p
, b
, arg3
));
10773 ret
= -TARGET_EFAULT
;
10775 unlock_user(p
, arg1
, 0);
10776 unlock_user(b
, arg2
, arg3
);
10779 case TARGET_NR_flistxattr
:
10783 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
10785 return -TARGET_EFAULT
;
10788 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
10789 unlock_user(b
, arg2
, arg3
);
10792 case TARGET_NR_setxattr
:
10793 case TARGET_NR_lsetxattr
:
10795 void *p
, *n
, *v
= 0;
10797 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
10799 return -TARGET_EFAULT
;
10802 p
= lock_user_string(arg1
);
10803 n
= lock_user_string(arg2
);
10805 if (num
== TARGET_NR_setxattr
) {
10806 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
10808 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
10811 ret
= -TARGET_EFAULT
;
10813 unlock_user(p
, arg1
, 0);
10814 unlock_user(n
, arg2
, 0);
10815 unlock_user(v
, arg3
, 0);
10818 case TARGET_NR_fsetxattr
:
10822 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
10824 return -TARGET_EFAULT
;
10827 n
= lock_user_string(arg2
);
10829 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
10831 ret
= -TARGET_EFAULT
;
10833 unlock_user(n
, arg2
, 0);
10834 unlock_user(v
, arg3
, 0);
10837 case TARGET_NR_getxattr
:
10838 case TARGET_NR_lgetxattr
:
10840 void *p
, *n
, *v
= 0;
10842 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
10844 return -TARGET_EFAULT
;
10847 p
= lock_user_string(arg1
);
10848 n
= lock_user_string(arg2
);
10850 if (num
== TARGET_NR_getxattr
) {
10851 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
10853 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
10856 ret
= -TARGET_EFAULT
;
10858 unlock_user(p
, arg1
, 0);
10859 unlock_user(n
, arg2
, 0);
10860 unlock_user(v
, arg3
, arg4
);
10863 case TARGET_NR_fgetxattr
:
10867 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
10869 return -TARGET_EFAULT
;
10872 n
= lock_user_string(arg2
);
10874 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
10876 ret
= -TARGET_EFAULT
;
10878 unlock_user(n
, arg2
, 0);
10879 unlock_user(v
, arg3
, arg4
);
10882 case TARGET_NR_removexattr
:
10883 case TARGET_NR_lremovexattr
:
10886 p
= lock_user_string(arg1
);
10887 n
= lock_user_string(arg2
);
10889 if (num
== TARGET_NR_removexattr
) {
10890 ret
= get_errno(removexattr(p
, n
));
10892 ret
= get_errno(lremovexattr(p
, n
));
10895 ret
= -TARGET_EFAULT
;
10897 unlock_user(p
, arg1
, 0);
10898 unlock_user(n
, arg2
, 0);
10901 case TARGET_NR_fremovexattr
:
10904 n
= lock_user_string(arg2
);
10906 ret
= get_errno(fremovexattr(arg1
, n
));
10908 ret
= -TARGET_EFAULT
;
10910 unlock_user(n
, arg2
, 0);
10914 #endif /* CONFIG_ATTR */
10915 #ifdef TARGET_NR_set_thread_area
10916 case TARGET_NR_set_thread_area
:
10917 #if defined(TARGET_MIPS)
10918 ((CPUMIPSState
*) cpu_env
)->active_tc
.CP0_UserLocal
= arg1
;
10920 #elif defined(TARGET_CRIS)
10922 ret
= -TARGET_EINVAL
;
10924 ((CPUCRISState
*) cpu_env
)->pregs
[PR_PID
] = arg1
;
10928 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
10929 return do_set_thread_area(cpu_env
, arg1
);
10930 #elif defined(TARGET_M68K)
10932 TaskState
*ts
= cpu
->opaque
;
10933 ts
->tp_value
= arg1
;
10937 return -TARGET_ENOSYS
;
10940 #ifdef TARGET_NR_get_thread_area
10941 case TARGET_NR_get_thread_area
:
10942 #if defined(TARGET_I386) && defined(TARGET_ABI32)
10943 return do_get_thread_area(cpu_env
, arg1
);
10944 #elif defined(TARGET_M68K)
10946 TaskState
*ts
= cpu
->opaque
;
10947 return ts
->tp_value
;
10950 return -TARGET_ENOSYS
;
10953 #ifdef TARGET_NR_getdomainname
10954 case TARGET_NR_getdomainname
:
10955 return -TARGET_ENOSYS
;
10958 #ifdef TARGET_NR_clock_settime
10959 case TARGET_NR_clock_settime
:
10961 struct timespec ts
;
10963 ret
= target_to_host_timespec(&ts
, arg2
);
10964 if (!is_error(ret
)) {
10965 ret
= get_errno(clock_settime(arg1
, &ts
));
10970 #ifdef TARGET_NR_clock_gettime
10971 case TARGET_NR_clock_gettime
:
10973 struct timespec ts
;
10974 ret
= get_errno(clock_gettime(arg1
, &ts
));
10975 if (!is_error(ret
)) {
10976 ret
= host_to_target_timespec(arg2
, &ts
);
10981 #ifdef TARGET_NR_clock_getres
10982 case TARGET_NR_clock_getres
:
10984 struct timespec ts
;
10985 ret
= get_errno(clock_getres(arg1
, &ts
));
10986 if (!is_error(ret
)) {
10987 host_to_target_timespec(arg2
, &ts
);
10992 #ifdef TARGET_NR_clock_nanosleep
10993 case TARGET_NR_clock_nanosleep
:
10995 struct timespec ts
;
10996 target_to_host_timespec(&ts
, arg3
);
10997 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
10998 &ts
, arg4
? &ts
: NULL
));
11000 host_to_target_timespec(arg4
, &ts
);
11002 #if defined(TARGET_PPC)
11003 /* clock_nanosleep is odd in that it returns positive errno values.
11004 * On PPC, CR0 bit 3 should be set in such a situation. */
11005 if (ret
&& ret
!= -TARGET_ERESTARTSYS
) {
11006 ((CPUPPCState
*)cpu_env
)->crf
[0] |= 1;
11013 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11014 case TARGET_NR_set_tid_address
:
11015 return get_errno(set_tid_address((int *)g2h(arg1
)));
11018 case TARGET_NR_tkill
:
11019 return get_errno(safe_tkill((int)arg1
, target_to_host_signal(arg2
)));
11021 case TARGET_NR_tgkill
:
11022 return get_errno(safe_tgkill((int)arg1
, (int)arg2
,
11023 target_to_host_signal(arg3
)));
11025 #ifdef TARGET_NR_set_robust_list
11026 case TARGET_NR_set_robust_list
:
11027 case TARGET_NR_get_robust_list
:
11028 /* The ABI for supporting robust futexes has userspace pass
11029 * the kernel a pointer to a linked list which is updated by
11030 * userspace after the syscall; the list is walked by the kernel
11031 * when the thread exits. Since the linked list in QEMU guest
11032 * memory isn't a valid linked list for the host and we have
11033 * no way to reliably intercept the thread-death event, we can't
11034 * support these. Silently return ENOSYS so that guest userspace
11035 * falls back to a non-robust futex implementation (which should
11036 * be OK except in the corner case of the guest crashing while
11037 * holding a mutex that is shared with another process via
11040 return -TARGET_ENOSYS
;
11043 #if defined(TARGET_NR_utimensat)
11044 case TARGET_NR_utimensat
:
11046 struct timespec
*tsp
, ts
[2];
11050 target_to_host_timespec(ts
, arg3
);
11051 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
11055 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
11057 if (!(p
= lock_user_string(arg2
))) {
11058 return -TARGET_EFAULT
;
11060 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
11061 unlock_user(p
, arg2
, 0);
11066 case TARGET_NR_futex
:
11067 return do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
11068 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
11069 case TARGET_NR_inotify_init
:
11070 ret
= get_errno(sys_inotify_init());
11072 fd_trans_register(ret
, &target_inotify_trans
);
11076 #ifdef CONFIG_INOTIFY1
11077 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11078 case TARGET_NR_inotify_init1
:
11079 ret
= get_errno(sys_inotify_init1(target_to_host_bitmask(arg1
,
11080 fcntl_flags_tbl
)));
11082 fd_trans_register(ret
, &target_inotify_trans
);
11087 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
11088 case TARGET_NR_inotify_add_watch
:
11089 p
= lock_user_string(arg2
);
11090 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
11091 unlock_user(p
, arg2
, 0);
11094 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
11095 case TARGET_NR_inotify_rm_watch
:
11096 return get_errno(sys_inotify_rm_watch(arg1
, arg2
));
11099 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
11100 case TARGET_NR_mq_open
:
11102 struct mq_attr posix_mq_attr
;
11103 struct mq_attr
*pposix_mq_attr
;
11106 host_flags
= target_to_host_bitmask(arg2
, fcntl_flags_tbl
);
11107 pposix_mq_attr
= NULL
;
11109 if (copy_from_user_mq_attr(&posix_mq_attr
, arg4
) != 0) {
11110 return -TARGET_EFAULT
;
11112 pposix_mq_attr
= &posix_mq_attr
;
11114 p
= lock_user_string(arg1
- 1);
11116 return -TARGET_EFAULT
;
11118 ret
= get_errno(mq_open(p
, host_flags
, arg3
, pposix_mq_attr
));
11119 unlock_user (p
, arg1
, 0);
11123 case TARGET_NR_mq_unlink
:
11124 p
= lock_user_string(arg1
- 1);
11126 return -TARGET_EFAULT
;
11128 ret
= get_errno(mq_unlink(p
));
11129 unlock_user (p
, arg1
, 0);
11132 case TARGET_NR_mq_timedsend
:
11134 struct timespec ts
;
11136 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
11138 target_to_host_timespec(&ts
, arg5
);
11139 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
11140 host_to_target_timespec(arg5
, &ts
);
11142 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
11144 unlock_user (p
, arg2
, arg3
);
11148 case TARGET_NR_mq_timedreceive
:
11150 struct timespec ts
;
11153 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
11155 target_to_host_timespec(&ts
, arg5
);
11156 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
11158 host_to_target_timespec(arg5
, &ts
);
11160 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
11163 unlock_user (p
, arg2
, arg3
);
11165 put_user_u32(prio
, arg4
);
11169 /* Not implemented for now... */
11170 /* case TARGET_NR_mq_notify: */
11173 case TARGET_NR_mq_getsetattr
:
11175 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
11178 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
11179 ret
= get_errno(mq_setattr(arg1
, &posix_mq_attr_in
,
11180 &posix_mq_attr_out
));
11181 } else if (arg3
!= 0) {
11182 ret
= get_errno(mq_getattr(arg1
, &posix_mq_attr_out
));
11184 if (ret
== 0 && arg3
!= 0) {
11185 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
11191 #ifdef CONFIG_SPLICE
11192 #ifdef TARGET_NR_tee
11193 case TARGET_NR_tee
:
11195 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
11199 #ifdef TARGET_NR_splice
11200 case TARGET_NR_splice
:
11202 loff_t loff_in
, loff_out
;
11203 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
11205 if (get_user_u64(loff_in
, arg2
)) {
11206 return -TARGET_EFAULT
;
11208 ploff_in
= &loff_in
;
11211 if (get_user_u64(loff_out
, arg4
)) {
11212 return -TARGET_EFAULT
;
11214 ploff_out
= &loff_out
;
11216 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
11218 if (put_user_u64(loff_in
, arg2
)) {
11219 return -TARGET_EFAULT
;
11223 if (put_user_u64(loff_out
, arg4
)) {
11224 return -TARGET_EFAULT
;
11230 #ifdef TARGET_NR_vmsplice
11231 case TARGET_NR_vmsplice
:
11233 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
11235 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
11236 unlock_iovec(vec
, arg2
, arg3
, 0);
11238 ret
= -host_to_target_errno(errno
);
11243 #endif /* CONFIG_SPLICE */
11244 #ifdef CONFIG_EVENTFD
11245 #if defined(TARGET_NR_eventfd)
11246 case TARGET_NR_eventfd
:
11247 ret
= get_errno(eventfd(arg1
, 0));
11249 fd_trans_register(ret
, &target_eventfd_trans
);
11253 #if defined(TARGET_NR_eventfd2)
11254 case TARGET_NR_eventfd2
:
11256 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
));
11257 if (arg2
& TARGET_O_NONBLOCK
) {
11258 host_flags
|= O_NONBLOCK
;
11260 if (arg2
& TARGET_O_CLOEXEC
) {
11261 host_flags
|= O_CLOEXEC
;
11263 ret
= get_errno(eventfd(arg1
, host_flags
));
11265 fd_trans_register(ret
, &target_eventfd_trans
);
11270 #endif /* CONFIG_EVENTFD */
11271 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
11272 case TARGET_NR_fallocate
:
11273 #if TARGET_ABI_BITS == 32
11274 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
11275 target_offset64(arg5
, arg6
)));
11277 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
11281 #if defined(CONFIG_SYNC_FILE_RANGE)
11282 #if defined(TARGET_NR_sync_file_range)
11283 case TARGET_NR_sync_file_range
:
11284 #if TARGET_ABI_BITS == 32
11285 #if defined(TARGET_MIPS)
11286 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
11287 target_offset64(arg5
, arg6
), arg7
));
11289 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
11290 target_offset64(arg4
, arg5
), arg6
));
11291 #endif /* !TARGET_MIPS */
11293 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
11297 #if defined(TARGET_NR_sync_file_range2)
11298 case TARGET_NR_sync_file_range2
:
11299 /* This is like sync_file_range but the arguments are reordered */
11300 #if TARGET_ABI_BITS == 32
11301 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
11302 target_offset64(arg5
, arg6
), arg2
));
11304 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
11309 #if defined(TARGET_NR_signalfd4)
11310 case TARGET_NR_signalfd4
:
11311 return do_signalfd4(arg1
, arg2
, arg4
);
11313 #if defined(TARGET_NR_signalfd)
11314 case TARGET_NR_signalfd
:
11315 return do_signalfd4(arg1
, arg2
, 0);
11317 #if defined(CONFIG_EPOLL)
11318 #if defined(TARGET_NR_epoll_create)
11319 case TARGET_NR_epoll_create
:
11320 return get_errno(epoll_create(arg1
));
11322 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
11323 case TARGET_NR_epoll_create1
:
11324 return get_errno(epoll_create1(arg1
));
11326 #if defined(TARGET_NR_epoll_ctl)
11327 case TARGET_NR_epoll_ctl
:
11329 struct epoll_event ep
;
11330 struct epoll_event
*epp
= 0;
11332 struct target_epoll_event
*target_ep
;
11333 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
11334 return -TARGET_EFAULT
;
11336 ep
.events
= tswap32(target_ep
->events
);
11337 /* The epoll_data_t union is just opaque data to the kernel,
11338 * so we transfer all 64 bits across and need not worry what
11339 * actual data type it is.
11341 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
11342 unlock_user_struct(target_ep
, arg4
, 0);
11345 return get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
11349 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
11350 #if defined(TARGET_NR_epoll_wait)
11351 case TARGET_NR_epoll_wait
:
11353 #if defined(TARGET_NR_epoll_pwait)
11354 case TARGET_NR_epoll_pwait
:
11357 struct target_epoll_event
*target_ep
;
11358 struct epoll_event
*ep
;
11360 int maxevents
= arg3
;
11361 int timeout
= arg4
;
11363 if (maxevents
<= 0 || maxevents
> TARGET_EP_MAX_EVENTS
) {
11364 return -TARGET_EINVAL
;
11367 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
11368 maxevents
* sizeof(struct target_epoll_event
), 1);
11370 return -TARGET_EFAULT
;
11373 ep
= g_try_new(struct epoll_event
, maxevents
);
11375 unlock_user(target_ep
, arg2
, 0);
11376 return -TARGET_ENOMEM
;
11380 #if defined(TARGET_NR_epoll_pwait)
11381 case TARGET_NR_epoll_pwait
:
11383 target_sigset_t
*target_set
;
11384 sigset_t _set
, *set
= &_set
;
11387 if (arg6
!= sizeof(target_sigset_t
)) {
11388 ret
= -TARGET_EINVAL
;
11392 target_set
= lock_user(VERIFY_READ
, arg5
,
11393 sizeof(target_sigset_t
), 1);
11395 ret
= -TARGET_EFAULT
;
11398 target_to_host_sigset(set
, target_set
);
11399 unlock_user(target_set
, arg5
, 0);
11404 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
11405 set
, SIGSET_T_SIZE
));
11409 #if defined(TARGET_NR_epoll_wait)
11410 case TARGET_NR_epoll_wait
:
11411 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
11416 ret
= -TARGET_ENOSYS
;
11418 if (!is_error(ret
)) {
11420 for (i
= 0; i
< ret
; i
++) {
11421 target_ep
[i
].events
= tswap32(ep
[i
].events
);
11422 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
11424 unlock_user(target_ep
, arg2
,
11425 ret
* sizeof(struct target_epoll_event
));
11427 unlock_user(target_ep
, arg2
, 0);
11434 #ifdef TARGET_NR_prlimit64
11435 case TARGET_NR_prlimit64
:
11437 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
11438 struct target_rlimit64
*target_rnew
, *target_rold
;
11439 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
11440 int resource
= target_to_host_resource(arg2
);
11442 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
11443 return -TARGET_EFAULT
;
11445 rnew
.rlim_cur
= tswap64(target_rnew
->rlim_cur
);
11446 rnew
.rlim_max
= tswap64(target_rnew
->rlim_max
);
11447 unlock_user_struct(target_rnew
, arg3
, 0);
11451 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
11452 if (!is_error(ret
) && arg4
) {
11453 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
11454 return -TARGET_EFAULT
;
11456 target_rold
->rlim_cur
= tswap64(rold
.rlim_cur
);
11457 target_rold
->rlim_max
= tswap64(rold
.rlim_max
);
11458 unlock_user_struct(target_rold
, arg4
, 1);
11463 #ifdef TARGET_NR_gethostname
11464 case TARGET_NR_gethostname
:
11466 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
11468 ret
= get_errno(gethostname(name
, arg2
));
11469 unlock_user(name
, arg1
, arg2
);
11471 ret
= -TARGET_EFAULT
;
11476 #ifdef TARGET_NR_atomic_cmpxchg_32
11477 case TARGET_NR_atomic_cmpxchg_32
:
11479 /* should use start_exclusive from main.c */
11480 abi_ulong mem_value
;
11481 if (get_user_u32(mem_value
, arg6
)) {
11482 target_siginfo_t info
;
11483 info
.si_signo
= SIGSEGV
;
11485 info
.si_code
= TARGET_SEGV_MAPERR
;
11486 info
._sifields
._sigfault
._addr
= arg6
;
11487 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
11488 QEMU_SI_FAULT
, &info
);
11492 if (mem_value
== arg2
)
11493 put_user_u32(arg1
, arg6
);
11497 #ifdef TARGET_NR_atomic_barrier
11498 case TARGET_NR_atomic_barrier
:
11499 /* Like the kernel implementation and the
11500 qemu arm barrier, no-op this? */
11504 #ifdef TARGET_NR_timer_create
11505 case TARGET_NR_timer_create
:
11507 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
11509 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
11512 int timer_index
= next_free_host_timer();
11514 if (timer_index
< 0) {
11515 ret
= -TARGET_EAGAIN
;
11517 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
11520 phost_sevp
= &host_sevp
;
11521 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
11527 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
11531 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
11532 return -TARGET_EFAULT
;
11540 #ifdef TARGET_NR_timer_settime
11541 case TARGET_NR_timer_settime
:
11543 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
11544 * struct itimerspec * old_value */
11545 target_timer_t timerid
= get_timer_id(arg1
);
11549 } else if (arg3
== 0) {
11550 ret
= -TARGET_EINVAL
;
11552 timer_t htimer
= g_posix_timers
[timerid
];
11553 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
11555 if (target_to_host_itimerspec(&hspec_new
, arg3
)) {
11556 return -TARGET_EFAULT
;
11559 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
11560 if (arg4
&& host_to_target_itimerspec(arg4
, &hspec_old
)) {
11561 return -TARGET_EFAULT
;
11568 #ifdef TARGET_NR_timer_gettime
11569 case TARGET_NR_timer_gettime
:
11571 /* args: timer_t timerid, struct itimerspec *curr_value */
11572 target_timer_t timerid
= get_timer_id(arg1
);
11576 } else if (!arg2
) {
11577 ret
= -TARGET_EFAULT
;
11579 timer_t htimer
= g_posix_timers
[timerid
];
11580 struct itimerspec hspec
;
11581 ret
= get_errno(timer_gettime(htimer
, &hspec
));
11583 if (host_to_target_itimerspec(arg2
, &hspec
)) {
11584 ret
= -TARGET_EFAULT
;
11591 #ifdef TARGET_NR_timer_getoverrun
11592 case TARGET_NR_timer_getoverrun
:
11594 /* args: timer_t timerid */
11595 target_timer_t timerid
= get_timer_id(arg1
);
11600 timer_t htimer
= g_posix_timers
[timerid
];
11601 ret
= get_errno(timer_getoverrun(htimer
));
11603 fd_trans_unregister(ret
);
11608 #ifdef TARGET_NR_timer_delete
11609 case TARGET_NR_timer_delete
:
11611 /* args: timer_t timerid */
11612 target_timer_t timerid
= get_timer_id(arg1
);
11617 timer_t htimer
= g_posix_timers
[timerid
];
11618 ret
= get_errno(timer_delete(htimer
));
11619 g_posix_timers
[timerid
] = 0;
11625 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
11626 case TARGET_NR_timerfd_create
:
11627 return get_errno(timerfd_create(arg1
,
11628 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
11631 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
11632 case TARGET_NR_timerfd_gettime
:
11634 struct itimerspec its_curr
;
11636 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
11638 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
11639 return -TARGET_EFAULT
;
11645 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
11646 case TARGET_NR_timerfd_settime
:
11648 struct itimerspec its_new
, its_old
, *p_new
;
11651 if (target_to_host_itimerspec(&its_new
, arg3
)) {
11652 return -TARGET_EFAULT
;
11659 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
11661 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
11662 return -TARGET_EFAULT
;
11668 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
11669 case TARGET_NR_ioprio_get
:
11670 return get_errno(ioprio_get(arg1
, arg2
));
11673 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
11674 case TARGET_NR_ioprio_set
:
11675 return get_errno(ioprio_set(arg1
, arg2
, arg3
));
11678 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
11679 case TARGET_NR_setns
:
11680 return get_errno(setns(arg1
, arg2
));
11682 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
11683 case TARGET_NR_unshare
:
11684 return get_errno(unshare(arg1
));
11686 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
11687 case TARGET_NR_kcmp
:
11688 return get_errno(kcmp(arg1
, arg2
, arg3
, arg4
, arg5
));
11690 #ifdef TARGET_NR_swapcontext
11691 case TARGET_NR_swapcontext
:
11692 /* PowerPC specific. */
11693 return do_swapcontext(cpu_env
, arg1
, arg2
, arg3
);
11697 qemu_log_mask(LOG_UNIMP
, "Unsupported syscall: %d\n", num
);
11698 return -TARGET_ENOSYS
;
11703 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
11704 abi_long arg2
, abi_long arg3
, abi_long arg4
,
11705 abi_long arg5
, abi_long arg6
, abi_long arg7
,
11708 CPUState
*cpu
= env_cpu(cpu_env
);
11711 #ifdef DEBUG_ERESTARTSYS
11712 /* Debug-only code for exercising the syscall-restart code paths
11713 * in the per-architecture cpu main loops: restart every syscall
11714 * the guest makes once before letting it through.
11720 return -TARGET_ERESTARTSYS
;
11725 trace_guest_user_syscall(cpu
, num
, arg1
, arg2
, arg3
, arg4
,
11726 arg5
, arg6
, arg7
, arg8
);
11728 if (unlikely(do_strace
)) {
11729 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
11730 ret
= do_syscall1(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
,
11731 arg5
, arg6
, arg7
, arg8
);
11732 print_syscall_ret(num
, ret
);
11734 ret
= do_syscall1(cpu_env
, num
, arg1
, arg2
, arg3
, arg4
,
11735 arg5
, arg6
, arg7
, arg8
);
11738 trace_guest_user_syscall_ret(cpu
, num
, ret
);