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
32 #include <sys/types.h>
38 #include <sys/mount.h>
40 #include <sys/fsuid.h>
41 #include <sys/personality.h>
42 #include <sys/prctl.h>
43 #include <sys/resource.h>
46 #include <linux/capability.h>
50 int __clone2(int (*fn
)(void *), void *child_stack_base
,
51 size_t stack_size
, int flags
, void *arg
, ...);
53 #include <sys/socket.h>
57 #include <sys/times.h>
60 #include <sys/statfs.h>
62 #include <sys/sysinfo.h>
63 //#include <sys/user.h>
64 #include <netinet/ip.h>
65 #include <netinet/tcp.h>
66 #include <linux/wireless.h>
67 #include <linux/icmp.h>
68 #include "qemu-common.h"
70 #include <sys/timerfd.h>
76 #include <sys/eventfd.h>
79 #include <sys/epoll.h>
82 #include "qemu/xattr.h"
84 #ifdef CONFIG_SENDFILE
85 #include <sys/sendfile.h>
88 #define termios host_termios
89 #define winsize host_winsize
90 #define termio host_termio
91 #define sgttyb host_sgttyb /* same as target */
92 #define tchars host_tchars /* same as target */
93 #define ltchars host_ltchars /* same as target */
95 #include <linux/termios.h>
96 #include <linux/unistd.h>
97 #include <linux/cdrom.h>
98 #include <linux/hdreg.h>
99 #include <linux/soundcard.h>
100 #include <linux/kd.h>
101 #include <linux/mtio.h>
102 #include <linux/fs.h>
103 #if defined(CONFIG_FIEMAP)
104 #include <linux/fiemap.h>
106 #include <linux/fb.h>
107 #include <linux/vt.h>
108 #include <linux/dm-ioctl.h>
109 #include <linux/reboot.h>
110 #include <linux/route.h>
111 #include <linux/filter.h>
112 #include <linux/blkpg.h>
113 #include "linux_loop.h"
118 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
119 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
123 //#include <linux/msdos_fs.h>
124 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
125 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
136 #define _syscall0(type,name) \
137 static type name (void) \
139 return syscall(__NR_##name); \
142 #define _syscall1(type,name,type1,arg1) \
143 static type name (type1 arg1) \
145 return syscall(__NR_##name, arg1); \
148 #define _syscall2(type,name,type1,arg1,type2,arg2) \
149 static type name (type1 arg1,type2 arg2) \
151 return syscall(__NR_##name, arg1, arg2); \
154 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
155 static type name (type1 arg1,type2 arg2,type3 arg3) \
157 return syscall(__NR_##name, arg1, arg2, arg3); \
160 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
161 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
163 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
166 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
168 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
170 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
174 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
175 type5,arg5,type6,arg6) \
176 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
179 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
183 #define __NR_sys_uname __NR_uname
184 #define __NR_sys_getcwd1 __NR_getcwd
185 #define __NR_sys_getdents __NR_getdents
186 #define __NR_sys_getdents64 __NR_getdents64
187 #define __NR_sys_getpriority __NR_getpriority
188 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
189 #define __NR_sys_syslog __NR_syslog
190 #define __NR_sys_tgkill __NR_tgkill
191 #define __NR_sys_tkill __NR_tkill
192 #define __NR_sys_futex __NR_futex
193 #define __NR_sys_inotify_init __NR_inotify_init
194 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
195 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
197 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__) || \
199 #define __NR__llseek __NR_lseek
202 /* Newer kernel ports have llseek() instead of _llseek() */
203 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
204 #define TARGET_NR__llseek TARGET_NR_llseek
208 _syscall0(int, gettid
)
210 /* This is a replacement for the host gettid() and must return a host
212 static int gettid(void) {
216 #if defined(TARGET_NR_getdents) && defined(__NR_getdents)
217 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
219 #if !defined(__NR_getdents) || \
220 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
221 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
223 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
224 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
225 loff_t
*, res
, uint
, wh
);
227 _syscall3(int,sys_rt_sigqueueinfo
,int,pid
,int,sig
,siginfo_t
*,uinfo
)
228 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
229 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
230 _syscall3(int,sys_tgkill
,int,tgid
,int,pid
,int,sig
)
232 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
233 _syscall2(int,sys_tkill
,int,tid
,int,sig
)
235 #ifdef __NR_exit_group
236 _syscall1(int,exit_group
,int,error_code
)
238 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
239 _syscall1(int,set_tid_address
,int *,tidptr
)
241 #if defined(TARGET_NR_futex) && defined(__NR_futex)
242 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
243 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
245 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
246 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
247 unsigned long *, user_mask_ptr
);
248 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
249 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
250 unsigned long *, user_mask_ptr
);
251 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
253 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
254 struct __user_cap_data_struct
*, data
);
255 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
256 struct __user_cap_data_struct
*, data
);
257 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
258 _syscall2(int, ioprio_get
, int, which
, int, who
)
260 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
261 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
264 static bitmask_transtbl fcntl_flags_tbl
[] = {
265 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
266 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
267 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
268 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
269 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
270 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
271 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
272 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
273 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
274 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
275 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
276 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
277 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
278 #if defined(O_DIRECT)
279 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
281 #if defined(O_NOATIME)
282 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
284 #if defined(O_CLOEXEC)
285 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
288 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
290 /* Don't terminate the list prematurely on 64-bit host+guest. */
291 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
292 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
297 static int sys_getcwd1(char *buf
, size_t size
)
299 if (getcwd(buf
, size
) == NULL
) {
300 /* getcwd() sets errno */
303 return strlen(buf
)+1;
306 static int sys_openat(int dirfd
, const char *pathname
, int flags
, mode_t mode
)
309 * open(2) has extra parameter 'mode' when called with
312 if ((flags
& O_CREAT
) != 0) {
313 return (openat(dirfd
, pathname
, flags
, mode
));
315 return (openat(dirfd
, pathname
, flags
));
318 #ifdef TARGET_NR_utimensat
319 #ifdef CONFIG_UTIMENSAT
320 static int sys_utimensat(int dirfd
, const char *pathname
,
321 const struct timespec times
[2], int flags
)
323 if (pathname
== NULL
)
324 return futimens(dirfd
, times
);
326 return utimensat(dirfd
, pathname
, times
, flags
);
328 #elif defined(__NR_utimensat)
329 #define __NR_sys_utimensat __NR_utimensat
330 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
331 const struct timespec
*,tsp
,int,flags
)
333 static int sys_utimensat(int dirfd
, const char *pathname
,
334 const struct timespec times
[2], int flags
)
340 #endif /* TARGET_NR_utimensat */
342 #ifdef CONFIG_INOTIFY
343 #include <sys/inotify.h>
345 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
346 static int sys_inotify_init(void)
348 return (inotify_init());
351 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
352 static int sys_inotify_add_watch(int fd
,const char *pathname
, int32_t mask
)
354 return (inotify_add_watch(fd
, pathname
, mask
));
357 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
358 static int sys_inotify_rm_watch(int fd
, int32_t wd
)
360 return (inotify_rm_watch(fd
, wd
));
363 #ifdef CONFIG_INOTIFY1
364 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
365 static int sys_inotify_init1(int flags
)
367 return (inotify_init1(flags
));
372 /* Userspace can usually survive runtime without inotify */
373 #undef TARGET_NR_inotify_init
374 #undef TARGET_NR_inotify_init1
375 #undef TARGET_NR_inotify_add_watch
376 #undef TARGET_NR_inotify_rm_watch
377 #endif /* CONFIG_INOTIFY */
379 #if defined(TARGET_NR_ppoll)
381 # define __NR_ppoll -1
383 #define __NR_sys_ppoll __NR_ppoll
384 _syscall5(int, sys_ppoll
, struct pollfd
*, fds
, nfds_t
, nfds
,
385 struct timespec
*, timeout
, const sigset_t
*, sigmask
,
389 #if defined(TARGET_NR_pselect6)
390 #ifndef __NR_pselect6
391 # define __NR_pselect6 -1
393 #define __NR_sys_pselect6 __NR_pselect6
394 _syscall6(int, sys_pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
,
395 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
);
398 #if defined(TARGET_NR_prlimit64)
399 #ifndef __NR_prlimit64
400 # define __NR_prlimit64 -1
402 #define __NR_sys_prlimit64 __NR_prlimit64
403 /* The glibc rlimit structure may not be that used by the underlying syscall */
404 struct host_rlimit64
{
408 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
409 const struct host_rlimit64
*, new_limit
,
410 struct host_rlimit64
*, old_limit
)
414 #if defined(TARGET_NR_timer_create)
415 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
416 static timer_t g_posix_timers
[32] = { 0, } ;
418 static inline int next_free_host_timer(void)
421 /* FIXME: Does finding the next free slot require a lock? */
422 for (k
= 0; k
< ARRAY_SIZE(g_posix_timers
); k
++) {
423 if (g_posix_timers
[k
] == 0) {
424 g_posix_timers
[k
] = (timer_t
) 1;
432 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
434 static inline int regpairs_aligned(void *cpu_env
) {
435 return ((((CPUARMState
*)cpu_env
)->eabi
) == 1) ;
437 #elif defined(TARGET_MIPS)
438 static inline int regpairs_aligned(void *cpu_env
) { return 1; }
439 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
440 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
441 * of registers which translates to the same as ARM/MIPS, because we start with
443 static inline int regpairs_aligned(void *cpu_env
) { return 1; }
445 static inline int regpairs_aligned(void *cpu_env
) { return 0; }
448 #define ERRNO_TABLE_SIZE 1200
450 /* target_to_host_errno_table[] is initialized from
451 * host_to_target_errno_table[] in syscall_init(). */
452 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
456 * This list is the union of errno values overridden in asm-<arch>/errno.h
457 * minus the errnos that are not actually generic to all archs.
459 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
460 [EIDRM
] = TARGET_EIDRM
,
461 [ECHRNG
] = TARGET_ECHRNG
,
462 [EL2NSYNC
] = TARGET_EL2NSYNC
,
463 [EL3HLT
] = TARGET_EL3HLT
,
464 [EL3RST
] = TARGET_EL3RST
,
465 [ELNRNG
] = TARGET_ELNRNG
,
466 [EUNATCH
] = TARGET_EUNATCH
,
467 [ENOCSI
] = TARGET_ENOCSI
,
468 [EL2HLT
] = TARGET_EL2HLT
,
469 [EDEADLK
] = TARGET_EDEADLK
,
470 [ENOLCK
] = TARGET_ENOLCK
,
471 [EBADE
] = TARGET_EBADE
,
472 [EBADR
] = TARGET_EBADR
,
473 [EXFULL
] = TARGET_EXFULL
,
474 [ENOANO
] = TARGET_ENOANO
,
475 [EBADRQC
] = TARGET_EBADRQC
,
476 [EBADSLT
] = TARGET_EBADSLT
,
477 [EBFONT
] = TARGET_EBFONT
,
478 [ENOSTR
] = TARGET_ENOSTR
,
479 [ENODATA
] = TARGET_ENODATA
,
480 [ETIME
] = TARGET_ETIME
,
481 [ENOSR
] = TARGET_ENOSR
,
482 [ENONET
] = TARGET_ENONET
,
483 [ENOPKG
] = TARGET_ENOPKG
,
484 [EREMOTE
] = TARGET_EREMOTE
,
485 [ENOLINK
] = TARGET_ENOLINK
,
486 [EADV
] = TARGET_EADV
,
487 [ESRMNT
] = TARGET_ESRMNT
,
488 [ECOMM
] = TARGET_ECOMM
,
489 [EPROTO
] = TARGET_EPROTO
,
490 [EDOTDOT
] = TARGET_EDOTDOT
,
491 [EMULTIHOP
] = TARGET_EMULTIHOP
,
492 [EBADMSG
] = TARGET_EBADMSG
,
493 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
494 [EOVERFLOW
] = TARGET_EOVERFLOW
,
495 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
496 [EBADFD
] = TARGET_EBADFD
,
497 [EREMCHG
] = TARGET_EREMCHG
,
498 [ELIBACC
] = TARGET_ELIBACC
,
499 [ELIBBAD
] = TARGET_ELIBBAD
,
500 [ELIBSCN
] = TARGET_ELIBSCN
,
501 [ELIBMAX
] = TARGET_ELIBMAX
,
502 [ELIBEXEC
] = TARGET_ELIBEXEC
,
503 [EILSEQ
] = TARGET_EILSEQ
,
504 [ENOSYS
] = TARGET_ENOSYS
,
505 [ELOOP
] = TARGET_ELOOP
,
506 [ERESTART
] = TARGET_ERESTART
,
507 [ESTRPIPE
] = TARGET_ESTRPIPE
,
508 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
509 [EUSERS
] = TARGET_EUSERS
,
510 [ENOTSOCK
] = TARGET_ENOTSOCK
,
511 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
512 [EMSGSIZE
] = TARGET_EMSGSIZE
,
513 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
514 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
515 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
516 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
517 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
518 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
519 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
520 [EADDRINUSE
] = TARGET_EADDRINUSE
,
521 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
522 [ENETDOWN
] = TARGET_ENETDOWN
,
523 [ENETUNREACH
] = TARGET_ENETUNREACH
,
524 [ENETRESET
] = TARGET_ENETRESET
,
525 [ECONNABORTED
] = TARGET_ECONNABORTED
,
526 [ECONNRESET
] = TARGET_ECONNRESET
,
527 [ENOBUFS
] = TARGET_ENOBUFS
,
528 [EISCONN
] = TARGET_EISCONN
,
529 [ENOTCONN
] = TARGET_ENOTCONN
,
530 [EUCLEAN
] = TARGET_EUCLEAN
,
531 [ENOTNAM
] = TARGET_ENOTNAM
,
532 [ENAVAIL
] = TARGET_ENAVAIL
,
533 [EISNAM
] = TARGET_EISNAM
,
534 [EREMOTEIO
] = TARGET_EREMOTEIO
,
535 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
536 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
537 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
538 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
539 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
540 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
541 [EALREADY
] = TARGET_EALREADY
,
542 [EINPROGRESS
] = TARGET_EINPROGRESS
,
543 [ESTALE
] = TARGET_ESTALE
,
544 [ECANCELED
] = TARGET_ECANCELED
,
545 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
546 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
548 [ENOKEY
] = TARGET_ENOKEY
,
551 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
554 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
557 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
560 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
562 #ifdef ENOTRECOVERABLE
563 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
567 static inline int host_to_target_errno(int err
)
569 if(host_to_target_errno_table
[err
])
570 return host_to_target_errno_table
[err
];
574 static inline int target_to_host_errno(int err
)
576 if (target_to_host_errno_table
[err
])
577 return target_to_host_errno_table
[err
];
581 static inline abi_long
get_errno(abi_long ret
)
584 return -host_to_target_errno(errno
);
589 static inline int is_error(abi_long ret
)
591 return (abi_ulong
)ret
>= (abi_ulong
)(-4096);
594 char *target_strerror(int err
)
596 if ((err
>= ERRNO_TABLE_SIZE
) || (err
< 0)) {
599 return strerror(target_to_host_errno(err
));
602 static inline int host_to_target_sock_type(int host_type
)
606 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
608 target_type
= TARGET_SOCK_DGRAM
;
611 target_type
= TARGET_SOCK_STREAM
;
614 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
618 #if defined(SOCK_CLOEXEC)
619 if (host_type
& SOCK_CLOEXEC
) {
620 target_type
|= TARGET_SOCK_CLOEXEC
;
624 #if defined(SOCK_NONBLOCK)
625 if (host_type
& SOCK_NONBLOCK
) {
626 target_type
|= TARGET_SOCK_NONBLOCK
;
633 static abi_ulong target_brk
;
634 static abi_ulong target_original_brk
;
635 static abi_ulong brk_page
;
637 void target_set_brk(abi_ulong new_brk
)
639 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
640 brk_page
= HOST_PAGE_ALIGN(target_brk
);
643 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
644 #define DEBUGF_BRK(message, args...)
646 /* do_brk() must return target values and target errnos. */
647 abi_long
do_brk(abi_ulong new_brk
)
649 abi_long mapped_addr
;
652 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx
") -> ", new_brk
);
655 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (!new_brk)\n", target_brk
);
658 if (new_brk
< target_original_brk
) {
659 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk < target_original_brk)\n",
664 /* If the new brk is less than the highest page reserved to the
665 * target heap allocation, set it and we're almost done... */
666 if (new_brk
<= brk_page
) {
667 /* Heap contents are initialized to zero, as for anonymous
669 if (new_brk
> target_brk
) {
670 memset(g2h(target_brk
), 0, new_brk
- target_brk
);
672 target_brk
= new_brk
;
673 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk <= brk_page)\n", target_brk
);
677 /* We need to allocate more memory after the brk... Note that
678 * we don't use MAP_FIXED because that will map over the top of
679 * any existing mapping (like the one with the host libc or qemu
680 * itself); instead we treat "mapped but at wrong address" as
681 * a failure and unmap again.
683 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
);
684 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
685 PROT_READ
|PROT_WRITE
,
686 MAP_ANON
|MAP_PRIVATE
, 0, 0));
688 if (mapped_addr
== brk_page
) {
689 /* Heap contents are initialized to zero, as for anonymous
690 * mapped pages. Technically the new pages are already
691 * initialized to zero since they *are* anonymous mapped
692 * pages, however we have to take care with the contents that
693 * come from the remaining part of the previous page: it may
694 * contains garbage data due to a previous heap usage (grown
696 memset(g2h(target_brk
), 0, brk_page
- target_brk
);
698 target_brk
= new_brk
;
699 brk_page
= HOST_PAGE_ALIGN(target_brk
);
700 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr == brk_page)\n",
703 } else if (mapped_addr
!= -1) {
704 /* Mapped but at wrong address, meaning there wasn't actually
705 * enough space for this brk.
707 target_munmap(mapped_addr
, new_alloc_size
);
709 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr != -1)\n", target_brk
);
712 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (otherwise)\n", target_brk
);
715 #if defined(TARGET_ALPHA)
716 /* We (partially) emulate OSF/1 on Alpha, which requires we
717 return a proper errno, not an unchanged brk value. */
718 return -TARGET_ENOMEM
;
720 /* For everything else, return the previous break. */
724 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
725 abi_ulong target_fds_addr
,
729 abi_ulong b
, *target_fds
;
731 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
732 if (!(target_fds
= lock_user(VERIFY_READ
,
734 sizeof(abi_ulong
) * nw
,
736 return -TARGET_EFAULT
;
740 for (i
= 0; i
< nw
; i
++) {
741 /* grab the abi_ulong */
742 __get_user(b
, &target_fds
[i
]);
743 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
744 /* check the bit inside the abi_ulong */
751 unlock_user(target_fds
, target_fds_addr
, 0);
756 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
757 abi_ulong target_fds_addr
,
760 if (target_fds_addr
) {
761 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
762 return -TARGET_EFAULT
;
770 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
776 abi_ulong
*target_fds
;
778 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
779 if (!(target_fds
= lock_user(VERIFY_WRITE
,
781 sizeof(abi_ulong
) * nw
,
783 return -TARGET_EFAULT
;
786 for (i
= 0; i
< nw
; i
++) {
788 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
789 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
792 __put_user(v
, &target_fds
[i
]);
795 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
800 #if defined(__alpha__)
806 static inline abi_long
host_to_target_clock_t(long ticks
)
808 #if HOST_HZ == TARGET_HZ
811 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
815 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
816 const struct rusage
*rusage
)
818 struct target_rusage
*target_rusage
;
820 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
821 return -TARGET_EFAULT
;
822 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
823 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
824 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
825 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
826 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
827 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
828 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
829 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
830 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
831 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
832 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
833 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
834 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
835 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
836 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
837 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
838 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
839 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
840 unlock_user_struct(target_rusage
, target_addr
, 1);
845 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
847 abi_ulong target_rlim_swap
;
850 target_rlim_swap
= tswapal(target_rlim
);
851 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
852 return RLIM_INFINITY
;
854 result
= target_rlim_swap
;
855 if (target_rlim_swap
!= (rlim_t
)result
)
856 return RLIM_INFINITY
;
861 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
863 abi_ulong target_rlim_swap
;
866 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
867 target_rlim_swap
= TARGET_RLIM_INFINITY
;
869 target_rlim_swap
= rlim
;
870 result
= tswapal(target_rlim_swap
);
875 static inline int target_to_host_resource(int code
)
878 case TARGET_RLIMIT_AS
:
880 case TARGET_RLIMIT_CORE
:
882 case TARGET_RLIMIT_CPU
:
884 case TARGET_RLIMIT_DATA
:
886 case TARGET_RLIMIT_FSIZE
:
888 case TARGET_RLIMIT_LOCKS
:
890 case TARGET_RLIMIT_MEMLOCK
:
891 return RLIMIT_MEMLOCK
;
892 case TARGET_RLIMIT_MSGQUEUE
:
893 return RLIMIT_MSGQUEUE
;
894 case TARGET_RLIMIT_NICE
:
896 case TARGET_RLIMIT_NOFILE
:
897 return RLIMIT_NOFILE
;
898 case TARGET_RLIMIT_NPROC
:
900 case TARGET_RLIMIT_RSS
:
902 case TARGET_RLIMIT_RTPRIO
:
903 return RLIMIT_RTPRIO
;
904 case TARGET_RLIMIT_SIGPENDING
:
905 return RLIMIT_SIGPENDING
;
906 case TARGET_RLIMIT_STACK
:
913 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
914 abi_ulong target_tv_addr
)
916 struct target_timeval
*target_tv
;
918 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
919 return -TARGET_EFAULT
;
921 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
922 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
924 unlock_user_struct(target_tv
, target_tv_addr
, 0);
929 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
930 const struct timeval
*tv
)
932 struct target_timeval
*target_tv
;
934 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
935 return -TARGET_EFAULT
;
937 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
938 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
940 unlock_user_struct(target_tv
, target_tv_addr
, 1);
945 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
946 abi_ulong target_tz_addr
)
948 struct target_timezone
*target_tz
;
950 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
951 return -TARGET_EFAULT
;
954 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
955 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
957 unlock_user_struct(target_tz
, target_tz_addr
, 0);
962 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
965 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
966 abi_ulong target_mq_attr_addr
)
968 struct target_mq_attr
*target_mq_attr
;
970 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
971 target_mq_attr_addr
, 1))
972 return -TARGET_EFAULT
;
974 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
975 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
976 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
977 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
979 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
984 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
985 const struct mq_attr
*attr
)
987 struct target_mq_attr
*target_mq_attr
;
989 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
990 target_mq_attr_addr
, 0))
991 return -TARGET_EFAULT
;
993 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
994 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
995 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
996 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
998 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1004 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1005 /* do_select() must return target values and target errnos. */
1006 static abi_long
do_select(int n
,
1007 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1008 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1010 fd_set rfds
, wfds
, efds
;
1011 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1012 struct timeval tv
, *tv_ptr
;
1015 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1019 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1023 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1028 if (target_tv_addr
) {
1029 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1030 return -TARGET_EFAULT
;
1036 ret
= get_errno(select(n
, rfds_ptr
, wfds_ptr
, efds_ptr
, tv_ptr
));
1038 if (!is_error(ret
)) {
1039 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1040 return -TARGET_EFAULT
;
1041 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1042 return -TARGET_EFAULT
;
1043 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1044 return -TARGET_EFAULT
;
1046 if (target_tv_addr
&& copy_to_user_timeval(target_tv_addr
, &tv
))
1047 return -TARGET_EFAULT
;
1054 static abi_long
do_pipe2(int host_pipe
[], int flags
)
1057 return pipe2(host_pipe
, flags
);
1063 static abi_long
do_pipe(void *cpu_env
, abi_ulong pipedes
,
1064 int flags
, int is_pipe2
)
1068 ret
= flags
? do_pipe2(host_pipe
, flags
) : pipe(host_pipe
);
1071 return get_errno(ret
);
1073 /* Several targets have special calling conventions for the original
1074 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1076 #if defined(TARGET_ALPHA)
1077 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = host_pipe
[1];
1078 return host_pipe
[0];
1079 #elif defined(TARGET_MIPS)
1080 ((CPUMIPSState
*)cpu_env
)->active_tc
.gpr
[3] = host_pipe
[1];
1081 return host_pipe
[0];
1082 #elif defined(TARGET_SH4)
1083 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
1084 return host_pipe
[0];
1085 #elif defined(TARGET_SPARC)
1086 ((CPUSPARCState
*)cpu_env
)->regwptr
[1] = host_pipe
[1];
1087 return host_pipe
[0];
1091 if (put_user_s32(host_pipe
[0], pipedes
)
1092 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(host_pipe
[0])))
1093 return -TARGET_EFAULT
;
1094 return get_errno(ret
);
1097 static inline abi_long
target_to_host_ip_mreq(struct ip_mreqn
*mreqn
,
1098 abi_ulong target_addr
,
1101 struct target_ip_mreqn
*target_smreqn
;
1103 target_smreqn
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1105 return -TARGET_EFAULT
;
1106 mreqn
->imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
1107 mreqn
->imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
1108 if (len
== sizeof(struct target_ip_mreqn
))
1109 mreqn
->imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
1110 unlock_user(target_smreqn
, target_addr
, 0);
1115 static inline abi_long
target_to_host_sockaddr(struct sockaddr
*addr
,
1116 abi_ulong target_addr
,
1119 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1120 sa_family_t sa_family
;
1121 struct target_sockaddr
*target_saddr
;
1123 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1125 return -TARGET_EFAULT
;
1127 sa_family
= tswap16(target_saddr
->sa_family
);
1129 /* Oops. The caller might send a incomplete sun_path; sun_path
1130 * must be terminated by \0 (see the manual page), but
1131 * unfortunately it is quite common to specify sockaddr_un
1132 * length as "strlen(x->sun_path)" while it should be
1133 * "strlen(...) + 1". We'll fix that here if needed.
1134 * Linux kernel has a similar feature.
1137 if (sa_family
== AF_UNIX
) {
1138 if (len
< unix_maxlen
&& len
> 0) {
1139 char *cp
= (char*)target_saddr
;
1141 if ( cp
[len
-1] && !cp
[len
] )
1144 if (len
> unix_maxlen
)
1148 memcpy(addr
, target_saddr
, len
);
1149 addr
->sa_family
= sa_family
;
1150 if (sa_family
== AF_PACKET
) {
1151 struct target_sockaddr_ll
*lladdr
;
1153 lladdr
= (struct target_sockaddr_ll
*)addr
;
1154 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1155 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1157 unlock_user(target_saddr
, target_addr
, 0);
1162 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1163 struct sockaddr
*addr
,
1166 struct target_sockaddr
*target_saddr
;
1168 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1170 return -TARGET_EFAULT
;
1171 memcpy(target_saddr
, addr
, len
);
1172 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1173 unlock_user(target_saddr
, target_addr
, len
);
1178 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1179 struct target_msghdr
*target_msgh
)
1181 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1182 abi_long msg_controllen
;
1183 abi_ulong target_cmsg_addr
;
1184 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1185 socklen_t space
= 0;
1187 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1188 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1190 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1191 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1192 target_cmsg_start
= target_cmsg
;
1194 return -TARGET_EFAULT
;
1196 while (cmsg
&& target_cmsg
) {
1197 void *data
= CMSG_DATA(cmsg
);
1198 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1200 int len
= tswapal(target_cmsg
->cmsg_len
)
1201 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr
));
1203 space
+= CMSG_SPACE(len
);
1204 if (space
> msgh
->msg_controllen
) {
1205 space
-= CMSG_SPACE(len
);
1206 /* This is a QEMU bug, since we allocated the payload
1207 * area ourselves (unlike overflow in host-to-target
1208 * conversion, which is just the guest giving us a buffer
1209 * that's too small). It can't happen for the payload types
1210 * we currently support; if it becomes an issue in future
1211 * we would need to improve our allocation strategy to
1212 * something more intelligent than "twice the size of the
1213 * target buffer we're reading from".
1215 gemu_log("Host cmsg overflow\n");
1219 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1220 cmsg
->cmsg_level
= SOL_SOCKET
;
1222 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1224 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1225 cmsg
->cmsg_len
= CMSG_LEN(len
);
1227 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1228 int *fd
= (int *)data
;
1229 int *target_fd
= (int *)target_data
;
1230 int i
, numfds
= len
/ sizeof(int);
1232 for (i
= 0; i
< numfds
; i
++) {
1233 __get_user(fd
[i
], target_fd
+ i
);
1235 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1236 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1237 struct ucred
*cred
= (struct ucred
*)data
;
1238 struct target_ucred
*target_cred
=
1239 (struct target_ucred
*)target_data
;
1241 __get_user(cred
->pid
, &target_cred
->pid
);
1242 __get_user(cred
->uid
, &target_cred
->uid
);
1243 __get_user(cred
->gid
, &target_cred
->gid
);
1245 gemu_log("Unsupported ancillary data: %d/%d\n",
1246 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1247 memcpy(data
, target_data
, len
);
1250 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1251 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1254 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1256 msgh
->msg_controllen
= space
;
1260 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1261 struct msghdr
*msgh
)
1263 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1264 abi_long msg_controllen
;
1265 abi_ulong target_cmsg_addr
;
1266 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1267 socklen_t space
= 0;
1269 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1270 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1272 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1273 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1274 target_cmsg_start
= target_cmsg
;
1276 return -TARGET_EFAULT
;
1278 while (cmsg
&& target_cmsg
) {
1279 void *data
= CMSG_DATA(cmsg
);
1280 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1282 int len
= cmsg
->cmsg_len
- CMSG_ALIGN(sizeof (struct cmsghdr
));
1283 int tgt_len
, tgt_space
;
1285 /* We never copy a half-header but may copy half-data;
1286 * this is Linux's behaviour in put_cmsg(). Note that
1287 * truncation here is a guest problem (which we report
1288 * to the guest via the CTRUNC bit), unlike truncation
1289 * in target_to_host_cmsg, which is a QEMU bug.
1291 if (msg_controllen
< sizeof(struct cmsghdr
)) {
1292 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1296 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1297 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1299 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1301 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1303 tgt_len
= TARGET_CMSG_LEN(len
);
1305 /* Payload types which need a different size of payload on
1306 * the target must adjust tgt_len here.
1308 switch (cmsg
->cmsg_level
) {
1310 switch (cmsg
->cmsg_type
) {
1312 tgt_len
= sizeof(struct target_timeval
);
1321 if (msg_controllen
< tgt_len
) {
1322 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1323 tgt_len
= msg_controllen
;
1326 /* We must now copy-and-convert len bytes of payload
1327 * into tgt_len bytes of destination space. Bear in mind
1328 * that in both source and destination we may be dealing
1329 * with a truncated value!
1331 switch (cmsg
->cmsg_level
) {
1333 switch (cmsg
->cmsg_type
) {
1336 int *fd
= (int *)data
;
1337 int *target_fd
= (int *)target_data
;
1338 int i
, numfds
= tgt_len
/ sizeof(int);
1340 for (i
= 0; i
< numfds
; i
++) {
1341 __put_user(fd
[i
], target_fd
+ i
);
1347 struct timeval
*tv
= (struct timeval
*)data
;
1348 struct target_timeval
*target_tv
=
1349 (struct target_timeval
*)target_data
;
1351 if (len
!= sizeof(struct timeval
) ||
1352 tgt_len
!= sizeof(struct target_timeval
)) {
1356 /* copy struct timeval to target */
1357 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1358 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1361 case SCM_CREDENTIALS
:
1363 struct ucred
*cred
= (struct ucred
*)data
;
1364 struct target_ucred
*target_cred
=
1365 (struct target_ucred
*)target_data
;
1367 __put_user(cred
->pid
, &target_cred
->pid
);
1368 __put_user(cred
->uid
, &target_cred
->uid
);
1369 __put_user(cred
->gid
, &target_cred
->gid
);
1379 gemu_log("Unsupported ancillary data: %d/%d\n",
1380 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1381 memcpy(target_data
, data
, MIN(len
, tgt_len
));
1382 if (tgt_len
> len
) {
1383 memset(target_data
+ len
, 0, tgt_len
- len
);
1387 target_cmsg
->cmsg_len
= tswapal(tgt_len
);
1388 tgt_space
= TARGET_CMSG_SPACE(len
);
1389 if (msg_controllen
< tgt_space
) {
1390 tgt_space
= msg_controllen
;
1392 msg_controllen
-= tgt_space
;
1394 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1395 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1398 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
1400 target_msgh
->msg_controllen
= tswapal(space
);
1404 /* do_setsockopt() Must return target values and target errnos. */
1405 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
1406 abi_ulong optval_addr
, socklen_t optlen
)
1410 struct ip_mreqn
*ip_mreq
;
1411 struct ip_mreq_source
*ip_mreq_source
;
1415 /* TCP options all take an 'int' value. */
1416 if (optlen
< sizeof(uint32_t))
1417 return -TARGET_EINVAL
;
1419 if (get_user_u32(val
, optval_addr
))
1420 return -TARGET_EFAULT
;
1421 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1428 case IP_ROUTER_ALERT
:
1432 case IP_MTU_DISCOVER
:
1438 case IP_MULTICAST_TTL
:
1439 case IP_MULTICAST_LOOP
:
1441 if (optlen
>= sizeof(uint32_t)) {
1442 if (get_user_u32(val
, optval_addr
))
1443 return -TARGET_EFAULT
;
1444 } else if (optlen
>= 1) {
1445 if (get_user_u8(val
, optval_addr
))
1446 return -TARGET_EFAULT
;
1448 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
1450 case IP_ADD_MEMBERSHIP
:
1451 case IP_DROP_MEMBERSHIP
:
1452 if (optlen
< sizeof (struct target_ip_mreq
) ||
1453 optlen
> sizeof (struct target_ip_mreqn
))
1454 return -TARGET_EINVAL
;
1456 ip_mreq
= (struct ip_mreqn
*) alloca(optlen
);
1457 target_to_host_ip_mreq(ip_mreq
, optval_addr
, optlen
);
1458 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq
, optlen
));
1461 case IP_BLOCK_SOURCE
:
1462 case IP_UNBLOCK_SOURCE
:
1463 case IP_ADD_SOURCE_MEMBERSHIP
:
1464 case IP_DROP_SOURCE_MEMBERSHIP
:
1465 if (optlen
!= sizeof (struct target_ip_mreq_source
))
1466 return -TARGET_EINVAL
;
1468 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
1469 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
1470 unlock_user (ip_mreq_source
, optval_addr
, 0);
1479 case IPV6_MTU_DISCOVER
:
1482 case IPV6_RECVPKTINFO
:
1484 if (optlen
< sizeof(uint32_t)) {
1485 return -TARGET_EINVAL
;
1487 if (get_user_u32(val
, optval_addr
)) {
1488 return -TARGET_EFAULT
;
1490 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1491 &val
, sizeof(val
)));
1500 /* struct icmp_filter takes an u32 value */
1501 if (optlen
< sizeof(uint32_t)) {
1502 return -TARGET_EINVAL
;
1505 if (get_user_u32(val
, optval_addr
)) {
1506 return -TARGET_EFAULT
;
1508 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
1509 &val
, sizeof(val
)));
1516 case TARGET_SOL_SOCKET
:
1518 case TARGET_SO_RCVTIMEO
:
1522 optname
= SO_RCVTIMEO
;
1525 if (optlen
!= sizeof(struct target_timeval
)) {
1526 return -TARGET_EINVAL
;
1529 if (copy_from_user_timeval(&tv
, optval_addr
)) {
1530 return -TARGET_EFAULT
;
1533 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
1537 case TARGET_SO_SNDTIMEO
:
1538 optname
= SO_SNDTIMEO
;
1540 case TARGET_SO_ATTACH_FILTER
:
1542 struct target_sock_fprog
*tfprog
;
1543 struct target_sock_filter
*tfilter
;
1544 struct sock_fprog fprog
;
1545 struct sock_filter
*filter
;
1548 if (optlen
!= sizeof(*tfprog
)) {
1549 return -TARGET_EINVAL
;
1551 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
1552 return -TARGET_EFAULT
;
1554 if (!lock_user_struct(VERIFY_READ
, tfilter
,
1555 tswapal(tfprog
->filter
), 0)) {
1556 unlock_user_struct(tfprog
, optval_addr
, 1);
1557 return -TARGET_EFAULT
;
1560 fprog
.len
= tswap16(tfprog
->len
);
1561 filter
= malloc(fprog
.len
* sizeof(*filter
));
1562 if (filter
== NULL
) {
1563 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
1564 unlock_user_struct(tfprog
, optval_addr
, 1);
1565 return -TARGET_ENOMEM
;
1567 for (i
= 0; i
< fprog
.len
; i
++) {
1568 filter
[i
].code
= tswap16(tfilter
[i
].code
);
1569 filter
[i
].jt
= tfilter
[i
].jt
;
1570 filter
[i
].jf
= tfilter
[i
].jf
;
1571 filter
[i
].k
= tswap32(tfilter
[i
].k
);
1573 fprog
.filter
= filter
;
1575 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
1576 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
1579 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
1580 unlock_user_struct(tfprog
, optval_addr
, 1);
1583 case TARGET_SO_BINDTODEVICE
:
1585 char *dev_ifname
, *addr_ifname
;
1587 if (optlen
> IFNAMSIZ
- 1) {
1588 optlen
= IFNAMSIZ
- 1;
1590 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
1592 return -TARGET_EFAULT
;
1594 optname
= SO_BINDTODEVICE
;
1595 addr_ifname
= alloca(IFNAMSIZ
);
1596 memcpy(addr_ifname
, dev_ifname
, optlen
);
1597 addr_ifname
[optlen
] = 0;
1598 ret
= get_errno(setsockopt(sockfd
, level
, optname
, addr_ifname
, optlen
));
1599 unlock_user (dev_ifname
, optval_addr
, 0);
1602 /* Options with 'int' argument. */
1603 case TARGET_SO_DEBUG
:
1606 case TARGET_SO_REUSEADDR
:
1607 optname
= SO_REUSEADDR
;
1609 case TARGET_SO_TYPE
:
1612 case TARGET_SO_ERROR
:
1615 case TARGET_SO_DONTROUTE
:
1616 optname
= SO_DONTROUTE
;
1618 case TARGET_SO_BROADCAST
:
1619 optname
= SO_BROADCAST
;
1621 case TARGET_SO_SNDBUF
:
1622 optname
= SO_SNDBUF
;
1624 case TARGET_SO_SNDBUFFORCE
:
1625 optname
= SO_SNDBUFFORCE
;
1627 case TARGET_SO_RCVBUF
:
1628 optname
= SO_RCVBUF
;
1630 case TARGET_SO_RCVBUFFORCE
:
1631 optname
= SO_RCVBUFFORCE
;
1633 case TARGET_SO_KEEPALIVE
:
1634 optname
= SO_KEEPALIVE
;
1636 case TARGET_SO_OOBINLINE
:
1637 optname
= SO_OOBINLINE
;
1639 case TARGET_SO_NO_CHECK
:
1640 optname
= SO_NO_CHECK
;
1642 case TARGET_SO_PRIORITY
:
1643 optname
= SO_PRIORITY
;
1646 case TARGET_SO_BSDCOMPAT
:
1647 optname
= SO_BSDCOMPAT
;
1650 case TARGET_SO_PASSCRED
:
1651 optname
= SO_PASSCRED
;
1653 case TARGET_SO_PASSSEC
:
1654 optname
= SO_PASSSEC
;
1656 case TARGET_SO_TIMESTAMP
:
1657 optname
= SO_TIMESTAMP
;
1659 case TARGET_SO_RCVLOWAT
:
1660 optname
= SO_RCVLOWAT
;
1666 if (optlen
< sizeof(uint32_t))
1667 return -TARGET_EINVAL
;
1669 if (get_user_u32(val
, optval_addr
))
1670 return -TARGET_EFAULT
;
1671 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
1675 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level
, optname
);
1676 ret
= -TARGET_ENOPROTOOPT
;
1681 /* do_getsockopt() Must return target values and target errnos. */
1682 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
1683 abi_ulong optval_addr
, abi_ulong optlen
)
1690 case TARGET_SOL_SOCKET
:
1693 /* These don't just return a single integer */
1694 case TARGET_SO_LINGER
:
1695 case TARGET_SO_RCVTIMEO
:
1696 case TARGET_SO_SNDTIMEO
:
1697 case TARGET_SO_PEERNAME
:
1699 case TARGET_SO_PEERCRED
: {
1702 struct target_ucred
*tcr
;
1704 if (get_user_u32(len
, optlen
)) {
1705 return -TARGET_EFAULT
;
1708 return -TARGET_EINVAL
;
1712 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
1720 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
1721 return -TARGET_EFAULT
;
1723 __put_user(cr
.pid
, &tcr
->pid
);
1724 __put_user(cr
.uid
, &tcr
->uid
);
1725 __put_user(cr
.gid
, &tcr
->gid
);
1726 unlock_user_struct(tcr
, optval_addr
, 1);
1727 if (put_user_u32(len
, optlen
)) {
1728 return -TARGET_EFAULT
;
1732 /* Options with 'int' argument. */
1733 case TARGET_SO_DEBUG
:
1736 case TARGET_SO_REUSEADDR
:
1737 optname
= SO_REUSEADDR
;
1739 case TARGET_SO_TYPE
:
1742 case TARGET_SO_ERROR
:
1745 case TARGET_SO_DONTROUTE
:
1746 optname
= SO_DONTROUTE
;
1748 case TARGET_SO_BROADCAST
:
1749 optname
= SO_BROADCAST
;
1751 case TARGET_SO_SNDBUF
:
1752 optname
= SO_SNDBUF
;
1754 case TARGET_SO_RCVBUF
:
1755 optname
= SO_RCVBUF
;
1757 case TARGET_SO_KEEPALIVE
:
1758 optname
= SO_KEEPALIVE
;
1760 case TARGET_SO_OOBINLINE
:
1761 optname
= SO_OOBINLINE
;
1763 case TARGET_SO_NO_CHECK
:
1764 optname
= SO_NO_CHECK
;
1766 case TARGET_SO_PRIORITY
:
1767 optname
= SO_PRIORITY
;
1770 case TARGET_SO_BSDCOMPAT
:
1771 optname
= SO_BSDCOMPAT
;
1774 case TARGET_SO_PASSCRED
:
1775 optname
= SO_PASSCRED
;
1777 case TARGET_SO_TIMESTAMP
:
1778 optname
= SO_TIMESTAMP
;
1780 case TARGET_SO_RCVLOWAT
:
1781 optname
= SO_RCVLOWAT
;
1783 case TARGET_SO_ACCEPTCONN
:
1784 optname
= SO_ACCEPTCONN
;
1791 /* TCP options all take an 'int' value. */
1793 if (get_user_u32(len
, optlen
))
1794 return -TARGET_EFAULT
;
1796 return -TARGET_EINVAL
;
1798 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
1801 if (optname
== SO_TYPE
) {
1802 val
= host_to_target_sock_type(val
);
1807 if (put_user_u32(val
, optval_addr
))
1808 return -TARGET_EFAULT
;
1810 if (put_user_u8(val
, optval_addr
))
1811 return -TARGET_EFAULT
;
1813 if (put_user_u32(len
, optlen
))
1814 return -TARGET_EFAULT
;
1821 case IP_ROUTER_ALERT
:
1825 case IP_MTU_DISCOVER
:
1831 case IP_MULTICAST_TTL
:
1832 case IP_MULTICAST_LOOP
:
1833 if (get_user_u32(len
, optlen
))
1834 return -TARGET_EFAULT
;
1836 return -TARGET_EINVAL
;
1838 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
1841 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
1843 if (put_user_u32(len
, optlen
)
1844 || put_user_u8(val
, optval_addr
))
1845 return -TARGET_EFAULT
;
1847 if (len
> sizeof(int))
1849 if (put_user_u32(len
, optlen
)
1850 || put_user_u32(val
, optval_addr
))
1851 return -TARGET_EFAULT
;
1855 ret
= -TARGET_ENOPROTOOPT
;
1861 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1863 ret
= -TARGET_EOPNOTSUPP
;
1869 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
1870 int count
, int copy
)
1872 struct target_iovec
*target_vec
;
1874 abi_ulong total_len
, max_len
;
1877 bool bad_address
= false;
1883 if (count
< 0 || count
> IOV_MAX
) {
1888 vec
= calloc(count
, sizeof(struct iovec
));
1894 target_vec
= lock_user(VERIFY_READ
, target_addr
,
1895 count
* sizeof(struct target_iovec
), 1);
1896 if (target_vec
== NULL
) {
1901 /* ??? If host page size > target page size, this will result in a
1902 value larger than what we can actually support. */
1903 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
1906 for (i
= 0; i
< count
; i
++) {
1907 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
1908 abi_long len
= tswapal(target_vec
[i
].iov_len
);
1913 } else if (len
== 0) {
1914 /* Zero length pointer is ignored. */
1915 vec
[i
].iov_base
= 0;
1917 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
1918 /* If the first buffer pointer is bad, this is a fault. But
1919 * subsequent bad buffers will result in a partial write; this
1920 * is realized by filling the vector with null pointers and
1922 if (!vec
[i
].iov_base
) {
1933 if (len
> max_len
- total_len
) {
1934 len
= max_len
- total_len
;
1937 vec
[i
].iov_len
= len
;
1941 unlock_user(target_vec
, target_addr
, 0);
1946 if (tswapal(target_vec
[i
].iov_len
) > 0) {
1947 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
1950 unlock_user(target_vec
, target_addr
, 0);
1957 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
1958 int count
, int copy
)
1960 struct target_iovec
*target_vec
;
1963 target_vec
= lock_user(VERIFY_READ
, target_addr
,
1964 count
* sizeof(struct target_iovec
), 1);
1966 for (i
= 0; i
< count
; i
++) {
1967 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
1968 abi_long len
= tswapal(target_vec
[i
].iov_len
);
1972 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
1974 unlock_user(target_vec
, target_addr
, 0);
1980 static inline int target_to_host_sock_type(int *type
)
1983 int target_type
= *type
;
1985 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
1986 case TARGET_SOCK_DGRAM
:
1987 host_type
= SOCK_DGRAM
;
1989 case TARGET_SOCK_STREAM
:
1990 host_type
= SOCK_STREAM
;
1993 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
1996 if (target_type
& TARGET_SOCK_CLOEXEC
) {
1997 #if defined(SOCK_CLOEXEC)
1998 host_type
|= SOCK_CLOEXEC
;
2000 return -TARGET_EINVAL
;
2003 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2004 #if defined(SOCK_NONBLOCK)
2005 host_type
|= SOCK_NONBLOCK
;
2006 #elif !defined(O_NONBLOCK)
2007 return -TARGET_EINVAL
;
2014 /* Try to emulate socket type flags after socket creation. */
2015 static int sock_flags_fixup(int fd
, int target_type
)
2017 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
2018 if (target_type
& TARGET_SOCK_NONBLOCK
) {
2019 int flags
= fcntl(fd
, F_GETFL
);
2020 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
2022 return -TARGET_EINVAL
;
2029 /* do_socket() Must return target values and target errnos. */
2030 static abi_long
do_socket(int domain
, int type
, int protocol
)
2032 int target_type
= type
;
2035 ret
= target_to_host_sock_type(&type
);
2040 if (domain
== PF_NETLINK
)
2041 return -TARGET_EAFNOSUPPORT
;
2042 ret
= get_errno(socket(domain
, type
, protocol
));
2044 ret
= sock_flags_fixup(ret
, target_type
);
2049 /* do_bind() Must return target values and target errnos. */
2050 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
2056 if ((int)addrlen
< 0) {
2057 return -TARGET_EINVAL
;
2060 addr
= alloca(addrlen
+1);
2062 ret
= target_to_host_sockaddr(addr
, target_addr
, addrlen
);
2066 return get_errno(bind(sockfd
, addr
, addrlen
));
2069 /* do_connect() Must return target values and target errnos. */
2070 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
2076 if ((int)addrlen
< 0) {
2077 return -TARGET_EINVAL
;
2080 addr
= alloca(addrlen
+1);
2082 ret
= target_to_host_sockaddr(addr
, target_addr
, addrlen
);
2086 return get_errno(connect(sockfd
, addr
, addrlen
));
2089 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
2090 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
2091 int flags
, int send
)
2097 abi_ulong target_vec
;
2099 if (msgp
->msg_name
) {
2100 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
2101 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
2102 ret
= target_to_host_sockaddr(msg
.msg_name
, tswapal(msgp
->msg_name
),
2108 msg
.msg_name
= NULL
;
2109 msg
.msg_namelen
= 0;
2111 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
2112 msg
.msg_control
= alloca(msg
.msg_controllen
);
2113 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
2115 count
= tswapal(msgp
->msg_iovlen
);
2116 target_vec
= tswapal(msgp
->msg_iov
);
2117 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
2118 target_vec
, count
, send
);
2120 ret
= -host_to_target_errno(errno
);
2123 msg
.msg_iovlen
= count
;
2127 ret
= target_to_host_cmsg(&msg
, msgp
);
2129 ret
= get_errno(sendmsg(fd
, &msg
, flags
));
2131 ret
= get_errno(recvmsg(fd
, &msg
, flags
));
2132 if (!is_error(ret
)) {
2134 ret
= host_to_target_cmsg(msgp
, &msg
);
2135 if (!is_error(ret
)) {
2136 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
2137 if (msg
.msg_name
!= NULL
) {
2138 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
2139 msg
.msg_name
, msg
.msg_namelen
);
2151 unlock_iovec(vec
, target_vec
, count
, !send
);
2156 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
2157 int flags
, int send
)
2160 struct target_msghdr
*msgp
;
2162 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
2166 return -TARGET_EFAULT
;
2168 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
2169 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
2173 #ifdef TARGET_NR_sendmmsg
2174 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
2175 * so it might not have this *mmsg-specific flag either.
2177 #ifndef MSG_WAITFORONE
2178 #define MSG_WAITFORONE 0x10000
2181 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
2182 unsigned int vlen
, unsigned int flags
,
2185 struct target_mmsghdr
*mmsgp
;
2189 if (vlen
> UIO_MAXIOV
) {
2193 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
2195 return -TARGET_EFAULT
;
2198 for (i
= 0; i
< vlen
; i
++) {
2199 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
2200 if (is_error(ret
)) {
2203 mmsgp
[i
].msg_len
= tswap32(ret
);
2204 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2205 if (flags
& MSG_WAITFORONE
) {
2206 flags
|= MSG_DONTWAIT
;
2210 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
2212 /* Return number of datagrams sent if we sent any at all;
2213 * otherwise return the error.
2222 /* If we don't have a system accept4() then just call accept.
2223 * The callsites to do_accept4() will ensure that they don't
2224 * pass a non-zero flags argument in this config.
2226 #ifndef CONFIG_ACCEPT4
2227 static inline int accept4(int sockfd
, struct sockaddr
*addr
,
2228 socklen_t
*addrlen
, int flags
)
2231 return accept(sockfd
, addr
, addrlen
);
2235 /* do_accept4() Must return target values and target errnos. */
2236 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
2237 abi_ulong target_addrlen_addr
, int flags
)
2244 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
2246 if (target_addr
== 0) {
2247 return get_errno(accept4(fd
, NULL
, NULL
, host_flags
));
2250 /* linux returns EINVAL if addrlen pointer is invalid */
2251 if (get_user_u32(addrlen
, target_addrlen_addr
))
2252 return -TARGET_EINVAL
;
2254 if ((int)addrlen
< 0) {
2255 return -TARGET_EINVAL
;
2258 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2259 return -TARGET_EINVAL
;
2261 addr
= alloca(addrlen
);
2263 ret
= get_errno(accept4(fd
, addr
, &addrlen
, host_flags
));
2264 if (!is_error(ret
)) {
2265 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
2266 if (put_user_u32(addrlen
, target_addrlen_addr
))
2267 ret
= -TARGET_EFAULT
;
2272 /* do_getpeername() Must return target values and target errnos. */
2273 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
2274 abi_ulong target_addrlen_addr
)
2280 if (get_user_u32(addrlen
, target_addrlen_addr
))
2281 return -TARGET_EFAULT
;
2283 if ((int)addrlen
< 0) {
2284 return -TARGET_EINVAL
;
2287 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2288 return -TARGET_EFAULT
;
2290 addr
= alloca(addrlen
);
2292 ret
= get_errno(getpeername(fd
, addr
, &addrlen
));
2293 if (!is_error(ret
)) {
2294 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
2295 if (put_user_u32(addrlen
, target_addrlen_addr
))
2296 ret
= -TARGET_EFAULT
;
2301 /* do_getsockname() Must return target values and target errnos. */
2302 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
2303 abi_ulong target_addrlen_addr
)
2309 if (get_user_u32(addrlen
, target_addrlen_addr
))
2310 return -TARGET_EFAULT
;
2312 if ((int)addrlen
< 0) {
2313 return -TARGET_EINVAL
;
2316 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
2317 return -TARGET_EFAULT
;
2319 addr
= alloca(addrlen
);
2321 ret
= get_errno(getsockname(fd
, addr
, &addrlen
));
2322 if (!is_error(ret
)) {
2323 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
2324 if (put_user_u32(addrlen
, target_addrlen_addr
))
2325 ret
= -TARGET_EFAULT
;
2330 /* do_socketpair() Must return target values and target errnos. */
2331 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
2332 abi_ulong target_tab_addr
)
2337 target_to_host_sock_type(&type
);
2339 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
2340 if (!is_error(ret
)) {
2341 if (put_user_s32(tab
[0], target_tab_addr
)
2342 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
2343 ret
= -TARGET_EFAULT
;
2348 /* do_sendto() Must return target values and target errnos. */
2349 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
2350 abi_ulong target_addr
, socklen_t addrlen
)
2356 if ((int)addrlen
< 0) {
2357 return -TARGET_EINVAL
;
2360 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
2362 return -TARGET_EFAULT
;
2364 addr
= alloca(addrlen
+1);
2365 ret
= target_to_host_sockaddr(addr
, target_addr
, addrlen
);
2367 unlock_user(host_msg
, msg
, 0);
2370 ret
= get_errno(sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
2372 ret
= get_errno(send(fd
, host_msg
, len
, flags
));
2374 unlock_user(host_msg
, msg
, 0);
2378 /* do_recvfrom() Must return target values and target errnos. */
2379 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
2380 abi_ulong target_addr
,
2381 abi_ulong target_addrlen
)
2388 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
2390 return -TARGET_EFAULT
;
2392 if (get_user_u32(addrlen
, target_addrlen
)) {
2393 ret
= -TARGET_EFAULT
;
2396 if ((int)addrlen
< 0) {
2397 ret
= -TARGET_EINVAL
;
2400 addr
= alloca(addrlen
);
2401 ret
= get_errno(recvfrom(fd
, host_msg
, len
, flags
, addr
, &addrlen
));
2403 addr
= NULL
; /* To keep compiler quiet. */
2404 ret
= get_errno(qemu_recv(fd
, host_msg
, len
, flags
));
2406 if (!is_error(ret
)) {
2408 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
2409 if (put_user_u32(addrlen
, target_addrlen
)) {
2410 ret
= -TARGET_EFAULT
;
2414 unlock_user(host_msg
, msg
, len
);
2417 unlock_user(host_msg
, msg
, 0);
2422 #ifdef TARGET_NR_socketcall
2423 /* do_socketcall() Must return target values and target errnos. */
2424 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
2426 static const unsigned ac
[] = { /* number of arguments per call */
2427 [SOCKOP_socket
] = 3, /* domain, type, protocol */
2428 [SOCKOP_bind
] = 3, /* sockfd, addr, addrlen */
2429 [SOCKOP_connect
] = 3, /* sockfd, addr, addrlen */
2430 [SOCKOP_listen
] = 2, /* sockfd, backlog */
2431 [SOCKOP_accept
] = 3, /* sockfd, addr, addrlen */
2432 [SOCKOP_accept4
] = 4, /* sockfd, addr, addrlen, flags */
2433 [SOCKOP_getsockname
] = 3, /* sockfd, addr, addrlen */
2434 [SOCKOP_getpeername
] = 3, /* sockfd, addr, addrlen */
2435 [SOCKOP_socketpair
] = 4, /* domain, type, protocol, tab */
2436 [SOCKOP_send
] = 4, /* sockfd, msg, len, flags */
2437 [SOCKOP_recv
] = 4, /* sockfd, msg, len, flags */
2438 [SOCKOP_sendto
] = 6, /* sockfd, msg, len, flags, addr, addrlen */
2439 [SOCKOP_recvfrom
] = 6, /* sockfd, msg, len, flags, addr, addrlen */
2440 [SOCKOP_shutdown
] = 2, /* sockfd, how */
2441 [SOCKOP_sendmsg
] = 3, /* sockfd, msg, flags */
2442 [SOCKOP_recvmsg
] = 3, /* sockfd, msg, flags */
2443 [SOCKOP_setsockopt
] = 5, /* sockfd, level, optname, optval, optlen */
2444 [SOCKOP_getsockopt
] = 5, /* sockfd, level, optname, optval, optlen */
2446 abi_long a
[6]; /* max 6 args */
2448 /* first, collect the arguments in a[] according to ac[] */
2449 if (num
>= 0 && num
< ARRAY_SIZE(ac
)) {
2451 assert(ARRAY_SIZE(a
) >= ac
[num
]); /* ensure we have space for args */
2452 for (i
= 0; i
< ac
[num
]; ++i
) {
2453 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
2454 return -TARGET_EFAULT
;
2459 /* now when we have the args, actually handle the call */
2461 case SOCKOP_socket
: /* domain, type, protocol */
2462 return do_socket(a
[0], a
[1], a
[2]);
2463 case SOCKOP_bind
: /* sockfd, addr, addrlen */
2464 return do_bind(a
[0], a
[1], a
[2]);
2465 case SOCKOP_connect
: /* sockfd, addr, addrlen */
2466 return do_connect(a
[0], a
[1], a
[2]);
2467 case SOCKOP_listen
: /* sockfd, backlog */
2468 return get_errno(listen(a
[0], a
[1]));
2469 case SOCKOP_accept
: /* sockfd, addr, addrlen */
2470 return do_accept4(a
[0], a
[1], a
[2], 0);
2471 case SOCKOP_accept4
: /* sockfd, addr, addrlen, flags */
2472 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
2473 case SOCKOP_getsockname
: /* sockfd, addr, addrlen */
2474 return do_getsockname(a
[0], a
[1], a
[2]);
2475 case SOCKOP_getpeername
: /* sockfd, addr, addrlen */
2476 return do_getpeername(a
[0], a
[1], a
[2]);
2477 case SOCKOP_socketpair
: /* domain, type, protocol, tab */
2478 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
2479 case SOCKOP_send
: /* sockfd, msg, len, flags */
2480 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
2481 case SOCKOP_recv
: /* sockfd, msg, len, flags */
2482 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
2483 case SOCKOP_sendto
: /* sockfd, msg, len, flags, addr, addrlen */
2484 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
2485 case SOCKOP_recvfrom
: /* sockfd, msg, len, flags, addr, addrlen */
2486 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
2487 case SOCKOP_shutdown
: /* sockfd, how */
2488 return get_errno(shutdown(a
[0], a
[1]));
2489 case SOCKOP_sendmsg
: /* sockfd, msg, flags */
2490 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
2491 case SOCKOP_recvmsg
: /* sockfd, msg, flags */
2492 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
2493 case SOCKOP_setsockopt
: /* sockfd, level, optname, optval, optlen */
2494 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
2495 case SOCKOP_getsockopt
: /* sockfd, level, optname, optval, optlen */
2496 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
2498 gemu_log("Unsupported socketcall: %d\n", num
);
2499 return -TARGET_ENOSYS
;
2504 #define N_SHM_REGIONS 32
2506 static struct shm_region
{
2509 } shm_regions
[N_SHM_REGIONS
];
2511 struct target_semid_ds
2513 struct target_ipc_perm sem_perm
;
2514 abi_ulong sem_otime
;
2515 #if !defined(TARGET_PPC64)
2516 abi_ulong __unused1
;
2518 abi_ulong sem_ctime
;
2519 #if !defined(TARGET_PPC64)
2520 abi_ulong __unused2
;
2522 abi_ulong sem_nsems
;
2523 abi_ulong __unused3
;
2524 abi_ulong __unused4
;
2527 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
2528 abi_ulong target_addr
)
2530 struct target_ipc_perm
*target_ip
;
2531 struct target_semid_ds
*target_sd
;
2533 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
2534 return -TARGET_EFAULT
;
2535 target_ip
= &(target_sd
->sem_perm
);
2536 host_ip
->__key
= tswap32(target_ip
->__key
);
2537 host_ip
->uid
= tswap32(target_ip
->uid
);
2538 host_ip
->gid
= tswap32(target_ip
->gid
);
2539 host_ip
->cuid
= tswap32(target_ip
->cuid
);
2540 host_ip
->cgid
= tswap32(target_ip
->cgid
);
2541 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
2542 host_ip
->mode
= tswap32(target_ip
->mode
);
2544 host_ip
->mode
= tswap16(target_ip
->mode
);
2546 #if defined(TARGET_PPC)
2547 host_ip
->__seq
= tswap32(target_ip
->__seq
);
2549 host_ip
->__seq
= tswap16(target_ip
->__seq
);
2551 unlock_user_struct(target_sd
, target_addr
, 0);
2555 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
2556 struct ipc_perm
*host_ip
)
2558 struct target_ipc_perm
*target_ip
;
2559 struct target_semid_ds
*target_sd
;
2561 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
2562 return -TARGET_EFAULT
;
2563 target_ip
= &(target_sd
->sem_perm
);
2564 target_ip
->__key
= tswap32(host_ip
->__key
);
2565 target_ip
->uid
= tswap32(host_ip
->uid
);
2566 target_ip
->gid
= tswap32(host_ip
->gid
);
2567 target_ip
->cuid
= tswap32(host_ip
->cuid
);
2568 target_ip
->cgid
= tswap32(host_ip
->cgid
);
2569 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
2570 target_ip
->mode
= tswap32(host_ip
->mode
);
2572 target_ip
->mode
= tswap16(host_ip
->mode
);
2574 #if defined(TARGET_PPC)
2575 target_ip
->__seq
= tswap32(host_ip
->__seq
);
2577 target_ip
->__seq
= tswap16(host_ip
->__seq
);
2579 unlock_user_struct(target_sd
, target_addr
, 1);
2583 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
2584 abi_ulong target_addr
)
2586 struct target_semid_ds
*target_sd
;
2588 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
2589 return -TARGET_EFAULT
;
2590 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
2591 return -TARGET_EFAULT
;
2592 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
2593 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
2594 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
2595 unlock_user_struct(target_sd
, target_addr
, 0);
2599 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
2600 struct semid_ds
*host_sd
)
2602 struct target_semid_ds
*target_sd
;
2604 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
2605 return -TARGET_EFAULT
;
2606 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
2607 return -TARGET_EFAULT
;
2608 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
2609 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
2610 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
2611 unlock_user_struct(target_sd
, target_addr
, 1);
2615 struct target_seminfo
{
2628 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
2629 struct seminfo
*host_seminfo
)
2631 struct target_seminfo
*target_seminfo
;
2632 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
2633 return -TARGET_EFAULT
;
2634 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
2635 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
2636 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
2637 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
2638 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
2639 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
2640 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
2641 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
2642 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
2643 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
2644 unlock_user_struct(target_seminfo
, target_addr
, 1);
2650 struct semid_ds
*buf
;
2651 unsigned short *array
;
2652 struct seminfo
*__buf
;
2655 union target_semun
{
2662 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
2663 abi_ulong target_addr
)
2666 unsigned short *array
;
2668 struct semid_ds semid_ds
;
2671 semun
.buf
= &semid_ds
;
2673 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
2675 return get_errno(ret
);
2677 nsems
= semid_ds
.sem_nsems
;
2679 *host_array
= malloc(nsems
*sizeof(unsigned short));
2681 return -TARGET_ENOMEM
;
2683 array
= lock_user(VERIFY_READ
, target_addr
,
2684 nsems
*sizeof(unsigned short), 1);
2687 return -TARGET_EFAULT
;
2690 for(i
=0; i
<nsems
; i
++) {
2691 __get_user((*host_array
)[i
], &array
[i
]);
2693 unlock_user(array
, target_addr
, 0);
2698 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
2699 unsigned short **host_array
)
2702 unsigned short *array
;
2704 struct semid_ds semid_ds
;
2707 semun
.buf
= &semid_ds
;
2709 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
2711 return get_errno(ret
);
2713 nsems
= semid_ds
.sem_nsems
;
2715 array
= lock_user(VERIFY_WRITE
, target_addr
,
2716 nsems
*sizeof(unsigned short), 0);
2718 return -TARGET_EFAULT
;
2720 for(i
=0; i
<nsems
; i
++) {
2721 __put_user((*host_array
)[i
], &array
[i
]);
2724 unlock_user(array
, target_addr
, 1);
2729 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
2730 union target_semun target_su
)
2733 struct semid_ds dsarg
;
2734 unsigned short *array
= NULL
;
2735 struct seminfo seminfo
;
2736 abi_long ret
= -TARGET_EINVAL
;
2743 /* In 64 bit cross-endian situations, we will erroneously pick up
2744 * the wrong half of the union for the "val" element. To rectify
2745 * this, the entire 8-byte structure is byteswapped, followed by
2746 * a swap of the 4 byte val field. In other cases, the data is
2747 * already in proper host byte order. */
2748 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
2749 target_su
.buf
= tswapal(target_su
.buf
);
2750 arg
.val
= tswap32(target_su
.val
);
2752 arg
.val
= target_su
.val
;
2754 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
2758 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
2762 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
2763 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
2770 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
2774 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
2775 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
2781 arg
.__buf
= &seminfo
;
2782 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
2783 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
2791 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
2798 struct target_sembuf
{
2799 unsigned short sem_num
;
2804 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
2805 abi_ulong target_addr
,
2808 struct target_sembuf
*target_sembuf
;
2811 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
2812 nsops
*sizeof(struct target_sembuf
), 1);
2814 return -TARGET_EFAULT
;
2816 for(i
=0; i
<nsops
; i
++) {
2817 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
2818 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
2819 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
2822 unlock_user(target_sembuf
, target_addr
, 0);
2827 static inline abi_long
do_semop(int semid
, abi_long ptr
, unsigned nsops
)
2829 struct sembuf sops
[nsops
];
2831 if (target_to_host_sembuf(sops
, ptr
, nsops
))
2832 return -TARGET_EFAULT
;
2834 return get_errno(semop(semid
, sops
, nsops
));
2837 struct target_msqid_ds
2839 struct target_ipc_perm msg_perm
;
2840 abi_ulong msg_stime
;
2841 #if TARGET_ABI_BITS == 32
2842 abi_ulong __unused1
;
2844 abi_ulong msg_rtime
;
2845 #if TARGET_ABI_BITS == 32
2846 abi_ulong __unused2
;
2848 abi_ulong msg_ctime
;
2849 #if TARGET_ABI_BITS == 32
2850 abi_ulong __unused3
;
2852 abi_ulong __msg_cbytes
;
2854 abi_ulong msg_qbytes
;
2855 abi_ulong msg_lspid
;
2856 abi_ulong msg_lrpid
;
2857 abi_ulong __unused4
;
2858 abi_ulong __unused5
;
2861 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
2862 abi_ulong target_addr
)
2864 struct target_msqid_ds
*target_md
;
2866 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
2867 return -TARGET_EFAULT
;
2868 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
2869 return -TARGET_EFAULT
;
2870 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
2871 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
2872 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
2873 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
2874 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
2875 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
2876 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
2877 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
2878 unlock_user_struct(target_md
, target_addr
, 0);
2882 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
2883 struct msqid_ds
*host_md
)
2885 struct target_msqid_ds
*target_md
;
2887 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
2888 return -TARGET_EFAULT
;
2889 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
2890 return -TARGET_EFAULT
;
2891 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
2892 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
2893 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
2894 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
2895 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
2896 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
2897 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
2898 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
2899 unlock_user_struct(target_md
, target_addr
, 1);
2903 struct target_msginfo
{
2911 unsigned short int msgseg
;
2914 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
2915 struct msginfo
*host_msginfo
)
2917 struct target_msginfo
*target_msginfo
;
2918 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
2919 return -TARGET_EFAULT
;
2920 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
2921 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
2922 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
2923 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
2924 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
2925 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
2926 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
2927 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
2928 unlock_user_struct(target_msginfo
, target_addr
, 1);
2932 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
2934 struct msqid_ds dsarg
;
2935 struct msginfo msginfo
;
2936 abi_long ret
= -TARGET_EINVAL
;
2944 if (target_to_host_msqid_ds(&dsarg
,ptr
))
2945 return -TARGET_EFAULT
;
2946 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
2947 if (host_to_target_msqid_ds(ptr
,&dsarg
))
2948 return -TARGET_EFAULT
;
2951 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
2955 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
2956 if (host_to_target_msginfo(ptr
, &msginfo
))
2957 return -TARGET_EFAULT
;
2964 struct target_msgbuf
{
2969 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
2970 ssize_t msgsz
, int msgflg
)
2972 struct target_msgbuf
*target_mb
;
2973 struct msgbuf
*host_mb
;
2977 return -TARGET_EINVAL
;
2980 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
2981 return -TARGET_EFAULT
;
2982 host_mb
= malloc(msgsz
+sizeof(long));
2984 unlock_user_struct(target_mb
, msgp
, 0);
2985 return -TARGET_ENOMEM
;
2987 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
2988 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
2989 ret
= get_errno(msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
2991 unlock_user_struct(target_mb
, msgp
, 0);
2996 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
2997 unsigned int msgsz
, abi_long msgtyp
,
3000 struct target_msgbuf
*target_mb
;
3002 struct msgbuf
*host_mb
;
3005 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
3006 return -TARGET_EFAULT
;
3008 host_mb
= g_malloc(msgsz
+sizeof(long));
3009 ret
= get_errno(msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
3012 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
3013 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
3014 if (!target_mtext
) {
3015 ret
= -TARGET_EFAULT
;
3018 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
3019 unlock_user(target_mtext
, target_mtext_addr
, ret
);
3022 target_mb
->mtype
= tswapal(host_mb
->mtype
);
3026 unlock_user_struct(target_mb
, msgp
, 1);
3031 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
3032 abi_ulong target_addr
)
3034 struct target_shmid_ds
*target_sd
;
3036 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
3037 return -TARGET_EFAULT
;
3038 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
3039 return -TARGET_EFAULT
;
3040 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3041 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3042 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3043 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3044 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3045 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3046 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3047 unlock_user_struct(target_sd
, target_addr
, 0);
3051 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
3052 struct shmid_ds
*host_sd
)
3054 struct target_shmid_ds
*target_sd
;
3056 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
3057 return -TARGET_EFAULT
;
3058 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
3059 return -TARGET_EFAULT
;
3060 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
3061 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
3062 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
3063 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
3064 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
3065 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
3066 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
3067 unlock_user_struct(target_sd
, target_addr
, 1);
3071 struct target_shminfo
{
3079 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
3080 struct shminfo
*host_shminfo
)
3082 struct target_shminfo
*target_shminfo
;
3083 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
3084 return -TARGET_EFAULT
;
3085 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
3086 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
3087 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
3088 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
3089 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
3090 unlock_user_struct(target_shminfo
, target_addr
, 1);
3094 struct target_shm_info
{
3099 abi_ulong swap_attempts
;
3100 abi_ulong swap_successes
;
3103 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
3104 struct shm_info
*host_shm_info
)
3106 struct target_shm_info
*target_shm_info
;
3107 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
3108 return -TARGET_EFAULT
;
3109 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
3110 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
3111 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
3112 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
3113 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
3114 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
3115 unlock_user_struct(target_shm_info
, target_addr
, 1);
3119 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
3121 struct shmid_ds dsarg
;
3122 struct shminfo shminfo
;
3123 struct shm_info shm_info
;
3124 abi_long ret
= -TARGET_EINVAL
;
3132 if (target_to_host_shmid_ds(&dsarg
, buf
))
3133 return -TARGET_EFAULT
;
3134 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
3135 if (host_to_target_shmid_ds(buf
, &dsarg
))
3136 return -TARGET_EFAULT
;
3139 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
3140 if (host_to_target_shminfo(buf
, &shminfo
))
3141 return -TARGET_EFAULT
;
3144 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
3145 if (host_to_target_shm_info(buf
, &shm_info
))
3146 return -TARGET_EFAULT
;
3151 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
3158 static inline abi_ulong
do_shmat(int shmid
, abi_ulong shmaddr
, int shmflg
)
3162 struct shmid_ds shm_info
;
3165 /* find out the length of the shared memory segment */
3166 ret
= get_errno(shmctl(shmid
, IPC_STAT
, &shm_info
));
3167 if (is_error(ret
)) {
3168 /* can't get length, bail out */
3175 host_raddr
= shmat(shmid
, (void *)g2h(shmaddr
), shmflg
);
3177 abi_ulong mmap_start
;
3179 mmap_start
= mmap_find_vma(0, shm_info
.shm_segsz
);
3181 if (mmap_start
== -1) {
3183 host_raddr
= (void *)-1;
3185 host_raddr
= shmat(shmid
, g2h(mmap_start
), shmflg
| SHM_REMAP
);
3188 if (host_raddr
== (void *)-1) {
3190 return get_errno((long)host_raddr
);
3192 raddr
=h2g((unsigned long)host_raddr
);
3194 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
3195 PAGE_VALID
| PAGE_READ
|
3196 ((shmflg
& SHM_RDONLY
)? 0 : PAGE_WRITE
));
3198 for (i
= 0; i
< N_SHM_REGIONS
; i
++) {
3199 if (shm_regions
[i
].start
== 0) {
3200 shm_regions
[i
].start
= raddr
;
3201 shm_regions
[i
].size
= shm_info
.shm_segsz
;
3211 static inline abi_long
do_shmdt(abi_ulong shmaddr
)
3215 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
3216 if (shm_regions
[i
].start
== shmaddr
) {
3217 shm_regions
[i
].start
= 0;
3218 page_set_flags(shmaddr
, shmaddr
+ shm_regions
[i
].size
, 0);
3223 return get_errno(shmdt(g2h(shmaddr
)));
3226 #ifdef TARGET_NR_ipc
3227 /* ??? This only works with linear mappings. */
3228 /* do_ipc() must return target values and target errnos. */
3229 static abi_long
do_ipc(unsigned int call
, abi_long first
,
3230 abi_long second
, abi_long third
,
3231 abi_long ptr
, abi_long fifth
)
3236 version
= call
>> 16;
3241 ret
= do_semop(first
, ptr
, second
);
3245 ret
= get_errno(semget(first
, second
, third
));
3248 case IPCOP_semctl
: {
3249 /* The semun argument to semctl is passed by value, so dereference the
3252 get_user_ual(atptr
, ptr
);
3253 ret
= do_semctl(first
, second
, third
,
3254 (union target_semun
) atptr
);
3259 ret
= get_errno(msgget(first
, second
));
3263 ret
= do_msgsnd(first
, ptr
, second
, third
);
3267 ret
= do_msgctl(first
, second
, ptr
);
3274 struct target_ipc_kludge
{
3279 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
3280 ret
= -TARGET_EFAULT
;
3284 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
3286 unlock_user_struct(tmp
, ptr
, 0);
3290 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
3299 raddr
= do_shmat(first
, ptr
, second
);
3300 if (is_error(raddr
))
3301 return get_errno(raddr
);
3302 if (put_user_ual(raddr
, third
))
3303 return -TARGET_EFAULT
;
3307 ret
= -TARGET_EINVAL
;
3312 ret
= do_shmdt(ptr
);
3316 /* IPC_* flag values are the same on all linux platforms */
3317 ret
= get_errno(shmget(first
, second
, third
));
3320 /* IPC_* and SHM_* command values are the same on all linux platforms */
3322 ret
= do_shmctl(first
, second
, ptr
);
3325 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
3326 ret
= -TARGET_ENOSYS
;
3333 /* kernel structure types definitions */
3335 #define STRUCT(name, ...) STRUCT_ ## name,
3336 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
3338 #include "syscall_types.h"
3342 #undef STRUCT_SPECIAL
3344 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
3345 #define STRUCT_SPECIAL(name)
3346 #include "syscall_types.h"
3348 #undef STRUCT_SPECIAL
3350 typedef struct IOCTLEntry IOCTLEntry
;
3352 typedef abi_long
do_ioctl_fn(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
3353 int fd
, int cmd
, abi_long arg
);
3357 unsigned int host_cmd
;
3360 do_ioctl_fn
*do_ioctl
;
3361 const argtype arg_type
[5];
3364 #define IOC_R 0x0001
3365 #define IOC_W 0x0002
3366 #define IOC_RW (IOC_R | IOC_W)
3368 #define MAX_STRUCT_SIZE 4096
3370 #ifdef CONFIG_FIEMAP
3371 /* So fiemap access checks don't overflow on 32 bit systems.
3372 * This is very slightly smaller than the limit imposed by
3373 * the underlying kernel.
3375 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
3376 / sizeof(struct fiemap_extent))
3378 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
3379 int fd
, int cmd
, abi_long arg
)
3381 /* The parameter for this ioctl is a struct fiemap followed
3382 * by an array of struct fiemap_extent whose size is set
3383 * in fiemap->fm_extent_count. The array is filled in by the
3386 int target_size_in
, target_size_out
;
3388 const argtype
*arg_type
= ie
->arg_type
;
3389 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
3392 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
3396 assert(arg_type
[0] == TYPE_PTR
);
3397 assert(ie
->access
== IOC_RW
);
3399 target_size_in
= thunk_type_size(arg_type
, 0);
3400 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
3402 return -TARGET_EFAULT
;
3404 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3405 unlock_user(argptr
, arg
, 0);
3406 fm
= (struct fiemap
*)buf_temp
;
3407 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
3408 return -TARGET_EINVAL
;
3411 outbufsz
= sizeof (*fm
) +
3412 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
3414 if (outbufsz
> MAX_STRUCT_SIZE
) {
3415 /* We can't fit all the extents into the fixed size buffer.
3416 * Allocate one that is large enough and use it instead.
3418 fm
= malloc(outbufsz
);
3420 return -TARGET_ENOMEM
;
3422 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
3425 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, fm
));
3426 if (!is_error(ret
)) {
3427 target_size_out
= target_size_in
;
3428 /* An extent_count of 0 means we were only counting the extents
3429 * so there are no structs to copy
3431 if (fm
->fm_extent_count
!= 0) {
3432 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
3434 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
3436 ret
= -TARGET_EFAULT
;
3438 /* Convert the struct fiemap */
3439 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
3440 if (fm
->fm_extent_count
!= 0) {
3441 p
= argptr
+ target_size_in
;
3442 /* ...and then all the struct fiemap_extents */
3443 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
3444 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
3449 unlock_user(argptr
, arg
, target_size_out
);
3459 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
3460 int fd
, int cmd
, abi_long arg
)
3462 const argtype
*arg_type
= ie
->arg_type
;
3466 struct ifconf
*host_ifconf
;
3468 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
3469 int target_ifreq_size
;
3474 abi_long target_ifc_buf
;
3478 assert(arg_type
[0] == TYPE_PTR
);
3479 assert(ie
->access
== IOC_RW
);
3482 target_size
= thunk_type_size(arg_type
, 0);
3484 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3486 return -TARGET_EFAULT
;
3487 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3488 unlock_user(argptr
, arg
, 0);
3490 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
3491 target_ifc_len
= host_ifconf
->ifc_len
;
3492 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
3494 target_ifreq_size
= thunk_type_size(ifreq_arg_type
, 0);
3495 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
3496 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
3498 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
3499 if (outbufsz
> MAX_STRUCT_SIZE
) {
3500 /* We can't fit all the extents into the fixed size buffer.
3501 * Allocate one that is large enough and use it instead.
3503 host_ifconf
= malloc(outbufsz
);
3505 return -TARGET_ENOMEM
;
3507 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
3510 host_ifc_buf
= (char*)host_ifconf
+ sizeof(*host_ifconf
);
3512 host_ifconf
->ifc_len
= host_ifc_len
;
3513 host_ifconf
->ifc_buf
= host_ifc_buf
;
3515 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, host_ifconf
));
3516 if (!is_error(ret
)) {
3517 /* convert host ifc_len to target ifc_len */
3519 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
3520 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
3521 host_ifconf
->ifc_len
= target_ifc_len
;
3523 /* restore target ifc_buf */
3525 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
3527 /* copy struct ifconf to target user */
3529 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
3531 return -TARGET_EFAULT
;
3532 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
3533 unlock_user(argptr
, arg
, target_size
);
3535 /* copy ifreq[] to target user */
3537 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
3538 for (i
= 0; i
< nb_ifreq
; i
++) {
3539 thunk_convert(argptr
+ i
* target_ifreq_size
,
3540 host_ifc_buf
+ i
* sizeof(struct ifreq
),
3541 ifreq_arg_type
, THUNK_TARGET
);
3543 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
3553 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
3554 int cmd
, abi_long arg
)
3557 struct dm_ioctl
*host_dm
;
3558 abi_long guest_data
;
3559 uint32_t guest_data_size
;
3561 const argtype
*arg_type
= ie
->arg_type
;
3563 void *big_buf
= NULL
;
3567 target_size
= thunk_type_size(arg_type
, 0);
3568 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3570 ret
= -TARGET_EFAULT
;
3573 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3574 unlock_user(argptr
, arg
, 0);
3576 /* buf_temp is too small, so fetch things into a bigger buffer */
3577 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
3578 memcpy(big_buf
, buf_temp
, target_size
);
3582 guest_data
= arg
+ host_dm
->data_start
;
3583 if ((guest_data
- arg
) < 0) {
3587 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
3588 host_data
= (char*)host_dm
+ host_dm
->data_start
;
3590 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
3591 switch (ie
->host_cmd
) {
3593 case DM_LIST_DEVICES
:
3596 case DM_DEV_SUSPEND
:
3599 case DM_TABLE_STATUS
:
3600 case DM_TABLE_CLEAR
:
3602 case DM_LIST_VERSIONS
:
3606 case DM_DEV_SET_GEOMETRY
:
3607 /* data contains only strings */
3608 memcpy(host_data
, argptr
, guest_data_size
);
3611 memcpy(host_data
, argptr
, guest_data_size
);
3612 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
3616 void *gspec
= argptr
;
3617 void *cur_data
= host_data
;
3618 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
3619 int spec_size
= thunk_type_size(arg_type
, 0);
3622 for (i
= 0; i
< host_dm
->target_count
; i
++) {
3623 struct dm_target_spec
*spec
= cur_data
;
3627 thunk_convert(spec
, gspec
, arg_type
, THUNK_HOST
);
3628 slen
= strlen((char*)gspec
+ spec_size
) + 1;
3630 spec
->next
= sizeof(*spec
) + slen
;
3631 strcpy((char*)&spec
[1], gspec
+ spec_size
);
3633 cur_data
+= spec
->next
;
3638 ret
= -TARGET_EINVAL
;
3639 unlock_user(argptr
, guest_data
, 0);
3642 unlock_user(argptr
, guest_data
, 0);
3644 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
3645 if (!is_error(ret
)) {
3646 guest_data
= arg
+ host_dm
->data_start
;
3647 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
3648 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
3649 switch (ie
->host_cmd
) {
3654 case DM_DEV_SUSPEND
:
3657 case DM_TABLE_CLEAR
:
3659 case DM_DEV_SET_GEOMETRY
:
3660 /* no return data */
3662 case DM_LIST_DEVICES
:
3664 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
3665 uint32_t remaining_data
= guest_data_size
;
3666 void *cur_data
= argptr
;
3667 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
3668 int nl_size
= 12; /* can't use thunk_size due to alignment */
3671 uint32_t next
= nl
->next
;
3673 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
3675 if (remaining_data
< nl
->next
) {
3676 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
3679 thunk_convert(cur_data
, nl
, arg_type
, THUNK_TARGET
);
3680 strcpy(cur_data
+ nl_size
, nl
->name
);
3681 cur_data
+= nl
->next
;
3682 remaining_data
-= nl
->next
;
3686 nl
= (void*)nl
+ next
;
3691 case DM_TABLE_STATUS
:
3693 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
3694 void *cur_data
= argptr
;
3695 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
3696 int spec_size
= thunk_type_size(arg_type
, 0);
3699 for (i
= 0; i
< host_dm
->target_count
; i
++) {
3700 uint32_t next
= spec
->next
;
3701 int slen
= strlen((char*)&spec
[1]) + 1;
3702 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
3703 if (guest_data_size
< spec
->next
) {
3704 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
3707 thunk_convert(cur_data
, spec
, arg_type
, THUNK_TARGET
);
3708 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
3709 cur_data
= argptr
+ spec
->next
;
3710 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
3716 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
3717 int count
= *(uint32_t*)hdata
;
3718 uint64_t *hdev
= hdata
+ 8;
3719 uint64_t *gdev
= argptr
+ 8;
3722 *(uint32_t*)argptr
= tswap32(count
);
3723 for (i
= 0; i
< count
; i
++) {
3724 *gdev
= tswap64(*hdev
);
3730 case DM_LIST_VERSIONS
:
3732 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
3733 uint32_t remaining_data
= guest_data_size
;
3734 void *cur_data
= argptr
;
3735 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
3736 int vers_size
= thunk_type_size(arg_type
, 0);
3739 uint32_t next
= vers
->next
;
3741 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
3743 if (remaining_data
< vers
->next
) {
3744 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
3747 thunk_convert(cur_data
, vers
, arg_type
, THUNK_TARGET
);
3748 strcpy(cur_data
+ vers_size
, vers
->name
);
3749 cur_data
+= vers
->next
;
3750 remaining_data
-= vers
->next
;
3754 vers
= (void*)vers
+ next
;
3759 unlock_user(argptr
, guest_data
, 0);
3760 ret
= -TARGET_EINVAL
;
3763 unlock_user(argptr
, guest_data
, guest_data_size
);
3765 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
3767 ret
= -TARGET_EFAULT
;
3770 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
3771 unlock_user(argptr
, arg
, target_size
);
3778 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
3779 int cmd
, abi_long arg
)
3783 const argtype
*arg_type
= ie
->arg_type
;
3784 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
3787 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
3788 struct blkpg_partition host_part
;
3790 /* Read and convert blkpg */
3792 target_size
= thunk_type_size(arg_type
, 0);
3793 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3795 ret
= -TARGET_EFAULT
;
3798 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3799 unlock_user(argptr
, arg
, 0);
3801 switch (host_blkpg
->op
) {
3802 case BLKPG_ADD_PARTITION
:
3803 case BLKPG_DEL_PARTITION
:
3804 /* payload is struct blkpg_partition */
3807 /* Unknown opcode */
3808 ret
= -TARGET_EINVAL
;
3812 /* Read and convert blkpg->data */
3813 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
3814 target_size
= thunk_type_size(part_arg_type
, 0);
3815 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3817 ret
= -TARGET_EFAULT
;
3820 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
3821 unlock_user(argptr
, arg
, 0);
3823 /* Swizzle the data pointer to our local copy and call! */
3824 host_blkpg
->data
= &host_part
;
3825 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, host_blkpg
));
3831 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
3832 int fd
, int cmd
, abi_long arg
)
3834 const argtype
*arg_type
= ie
->arg_type
;
3835 const StructEntry
*se
;
3836 const argtype
*field_types
;
3837 const int *dst_offsets
, *src_offsets
;
3840 abi_ulong
*target_rt_dev_ptr
;
3841 unsigned long *host_rt_dev_ptr
;
3845 assert(ie
->access
== IOC_W
);
3846 assert(*arg_type
== TYPE_PTR
);
3848 assert(*arg_type
== TYPE_STRUCT
);
3849 target_size
= thunk_type_size(arg_type
, 0);
3850 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3852 return -TARGET_EFAULT
;
3855 assert(*arg_type
== (int)STRUCT_rtentry
);
3856 se
= struct_entries
+ *arg_type
++;
3857 assert(se
->convert
[0] == NULL
);
3858 /* convert struct here to be able to catch rt_dev string */
3859 field_types
= se
->field_types
;
3860 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
3861 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
3862 for (i
= 0; i
< se
->nb_fields
; i
++) {
3863 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
3864 assert(*field_types
== TYPE_PTRVOID
);
3865 target_rt_dev_ptr
= (abi_ulong
*)(argptr
+ src_offsets
[i
]);
3866 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
3867 if (*target_rt_dev_ptr
!= 0) {
3868 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
3869 tswapal(*target_rt_dev_ptr
));
3870 if (!*host_rt_dev_ptr
) {
3871 unlock_user(argptr
, arg
, 0);
3872 return -TARGET_EFAULT
;
3875 *host_rt_dev_ptr
= 0;
3880 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
3881 argptr
+ src_offsets
[i
],
3882 field_types
, THUNK_HOST
);
3884 unlock_user(argptr
, arg
, 0);
3886 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
3887 if (*host_rt_dev_ptr
!= 0) {
3888 unlock_user((void *)*host_rt_dev_ptr
,
3889 *target_rt_dev_ptr
, 0);
3894 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
3895 int fd
, int cmd
, abi_long arg
)
3897 int sig
= target_to_host_signal(arg
);
3898 return get_errno(ioctl(fd
, ie
->host_cmd
, sig
));
3901 static IOCTLEntry ioctl_entries
[] = {
3902 #define IOCTL(cmd, access, ...) \
3903 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
3904 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
3905 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
3910 /* ??? Implement proper locking for ioctls. */
3911 /* do_ioctl() Must return target values and target errnos. */
3912 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
3914 const IOCTLEntry
*ie
;
3915 const argtype
*arg_type
;
3917 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
3923 if (ie
->target_cmd
== 0) {
3924 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
3925 return -TARGET_ENOSYS
;
3927 if (ie
->target_cmd
== cmd
)
3931 arg_type
= ie
->arg_type
;
3933 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd
, ie
->name
);
3936 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
3939 switch(arg_type
[0]) {
3942 ret
= get_errno(ioctl(fd
, ie
->host_cmd
));
3946 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, arg
));
3950 target_size
= thunk_type_size(arg_type
, 0);
3951 switch(ie
->access
) {
3953 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
3954 if (!is_error(ret
)) {
3955 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
3957 return -TARGET_EFAULT
;
3958 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
3959 unlock_user(argptr
, arg
, target_size
);
3963 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3965 return -TARGET_EFAULT
;
3966 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3967 unlock_user(argptr
, arg
, 0);
3968 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
3972 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
3974 return -TARGET_EFAULT
;
3975 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
3976 unlock_user(argptr
, arg
, 0);
3977 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
3978 if (!is_error(ret
)) {
3979 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
3981 return -TARGET_EFAULT
;
3982 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
3983 unlock_user(argptr
, arg
, target_size
);
3989 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
3990 (long)cmd
, arg_type
[0]);
3991 ret
= -TARGET_ENOSYS
;
3997 static const bitmask_transtbl iflag_tbl
[] = {
3998 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
3999 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
4000 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
4001 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
4002 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
4003 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
4004 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
4005 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
4006 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
4007 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
4008 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
4009 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
4010 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
4011 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
4015 static const bitmask_transtbl oflag_tbl
[] = {
4016 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
4017 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
4018 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
4019 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
4020 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
4021 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
4022 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
4023 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
4024 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
4025 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
4026 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
4027 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
4028 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
4029 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
4030 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
4031 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
4032 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
4033 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
4034 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
4035 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
4036 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
4037 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
4038 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
4039 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
4043 static const bitmask_transtbl cflag_tbl
[] = {
4044 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
4045 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
4046 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
4047 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
4048 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
4049 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
4050 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
4051 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
4052 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
4053 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
4054 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
4055 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
4056 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
4057 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
4058 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
4059 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
4060 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
4061 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
4062 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
4063 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
4064 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
4065 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
4066 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
4067 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
4068 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
4069 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
4070 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
4071 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
4072 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
4073 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
4074 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
4078 static const bitmask_transtbl lflag_tbl
[] = {
4079 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
4080 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
4081 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
4082 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
4083 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
4084 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
4085 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
4086 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
4087 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
4088 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
4089 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
4090 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
4091 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
4092 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
4093 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
4097 static void target_to_host_termios (void *dst
, const void *src
)
4099 struct host_termios
*host
= dst
;
4100 const struct target_termios
*target
= src
;
4103 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
4105 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
4107 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
4109 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
4110 host
->c_line
= target
->c_line
;
4112 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
4113 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
4114 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
4115 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
4116 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
4117 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
4118 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
4119 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
4120 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
4121 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
4122 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
4123 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
4124 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
4125 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
4126 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
4127 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
4128 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
4129 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
4132 static void host_to_target_termios (void *dst
, const void *src
)
4134 struct target_termios
*target
= dst
;
4135 const struct host_termios
*host
= src
;
4138 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
4140 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
4142 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
4144 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
4145 target
->c_line
= host
->c_line
;
4147 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
4148 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
4149 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
4150 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
4151 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
4152 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
4153 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
4154 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
4155 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
4156 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
4157 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
4158 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
4159 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
4160 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
4161 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
4162 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
4163 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
4164 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
4167 static const StructEntry struct_termios_def
= {
4168 .convert
= { host_to_target_termios
, target_to_host_termios
},
4169 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
4170 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
4173 static bitmask_transtbl mmap_flags_tbl
[] = {
4174 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
4175 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
4176 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
4177 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
, MAP_ANONYMOUS
, MAP_ANONYMOUS
},
4178 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
, MAP_GROWSDOWN
, MAP_GROWSDOWN
},
4179 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
, MAP_DENYWRITE
, MAP_DENYWRITE
},
4180 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
, MAP_EXECUTABLE
, MAP_EXECUTABLE
},
4181 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
4182 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
, MAP_NORESERVE
,
4187 #if defined(TARGET_I386)
4189 /* NOTE: there is really one LDT for all the threads */
4190 static uint8_t *ldt_table
;
4192 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
4199 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
4200 if (size
> bytecount
)
4202 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
4204 return -TARGET_EFAULT
;
4205 /* ??? Should this by byteswapped? */
4206 memcpy(p
, ldt_table
, size
);
4207 unlock_user(p
, ptr
, size
);
4211 /* XXX: add locking support */
4212 static abi_long
write_ldt(CPUX86State
*env
,
4213 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
4215 struct target_modify_ldt_ldt_s ldt_info
;
4216 struct target_modify_ldt_ldt_s
*target_ldt_info
;
4217 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
4218 int seg_not_present
, useable
, lm
;
4219 uint32_t *lp
, entry_1
, entry_2
;
4221 if (bytecount
!= sizeof(ldt_info
))
4222 return -TARGET_EINVAL
;
4223 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
4224 return -TARGET_EFAULT
;
4225 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
4226 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
4227 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
4228 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
4229 unlock_user_struct(target_ldt_info
, ptr
, 0);
4231 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
4232 return -TARGET_EINVAL
;
4233 seg_32bit
= ldt_info
.flags
& 1;
4234 contents
= (ldt_info
.flags
>> 1) & 3;
4235 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
4236 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
4237 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
4238 useable
= (ldt_info
.flags
>> 6) & 1;
4242 lm
= (ldt_info
.flags
>> 7) & 1;
4244 if (contents
== 3) {
4246 return -TARGET_EINVAL
;
4247 if (seg_not_present
== 0)
4248 return -TARGET_EINVAL
;
4250 /* allocate the LDT */
4252 env
->ldt
.base
= target_mmap(0,
4253 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
4254 PROT_READ
|PROT_WRITE
,
4255 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
4256 if (env
->ldt
.base
== -1)
4257 return -TARGET_ENOMEM
;
4258 memset(g2h(env
->ldt
.base
), 0,
4259 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
4260 env
->ldt
.limit
= 0xffff;
4261 ldt_table
= g2h(env
->ldt
.base
);
4264 /* NOTE: same code as Linux kernel */
4265 /* Allow LDTs to be cleared by the user. */
4266 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
4269 read_exec_only
== 1 &&
4271 limit_in_pages
== 0 &&
4272 seg_not_present
== 1 &&
4280 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
4281 (ldt_info
.limit
& 0x0ffff);
4282 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
4283 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
4284 (ldt_info
.limit
& 0xf0000) |
4285 ((read_exec_only
^ 1) << 9) |
4287 ((seg_not_present
^ 1) << 15) |
4289 (limit_in_pages
<< 23) |
4293 entry_2
|= (useable
<< 20);
4295 /* Install the new entry ... */
4297 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
4298 lp
[0] = tswap32(entry_1
);
4299 lp
[1] = tswap32(entry_2
);
4303 /* specific and weird i386 syscalls */
4304 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
4305 unsigned long bytecount
)
4311 ret
= read_ldt(ptr
, bytecount
);
4314 ret
= write_ldt(env
, ptr
, bytecount
, 1);
4317 ret
= write_ldt(env
, ptr
, bytecount
, 0);
4320 ret
= -TARGET_ENOSYS
;
4326 #if defined(TARGET_I386) && defined(TARGET_ABI32)
4327 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
4329 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
4330 struct target_modify_ldt_ldt_s ldt_info
;
4331 struct target_modify_ldt_ldt_s
*target_ldt_info
;
4332 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
4333 int seg_not_present
, useable
, lm
;
4334 uint32_t *lp
, entry_1
, entry_2
;
4337 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
4338 if (!target_ldt_info
)
4339 return -TARGET_EFAULT
;
4340 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
4341 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
4342 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
4343 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
4344 if (ldt_info
.entry_number
== -1) {
4345 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
4346 if (gdt_table
[i
] == 0) {
4347 ldt_info
.entry_number
= i
;
4348 target_ldt_info
->entry_number
= tswap32(i
);
4353 unlock_user_struct(target_ldt_info
, ptr
, 1);
4355 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
4356 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
4357 return -TARGET_EINVAL
;
4358 seg_32bit
= ldt_info
.flags
& 1;
4359 contents
= (ldt_info
.flags
>> 1) & 3;
4360 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
4361 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
4362 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
4363 useable
= (ldt_info
.flags
>> 6) & 1;
4367 lm
= (ldt_info
.flags
>> 7) & 1;
4370 if (contents
== 3) {
4371 if (seg_not_present
== 0)
4372 return -TARGET_EINVAL
;
4375 /* NOTE: same code as Linux kernel */
4376 /* Allow LDTs to be cleared by the user. */
4377 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
4378 if ((contents
== 0 &&
4379 read_exec_only
== 1 &&
4381 limit_in_pages
== 0 &&
4382 seg_not_present
== 1 &&
4390 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
4391 (ldt_info
.limit
& 0x0ffff);
4392 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
4393 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
4394 (ldt_info
.limit
& 0xf0000) |
4395 ((read_exec_only
^ 1) << 9) |
4397 ((seg_not_present
^ 1) << 15) |
4399 (limit_in_pages
<< 23) |
4404 /* Install the new entry ... */
4406 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
4407 lp
[0] = tswap32(entry_1
);
4408 lp
[1] = tswap32(entry_2
);
4412 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
4414 struct target_modify_ldt_ldt_s
*target_ldt_info
;
4415 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
4416 uint32_t base_addr
, limit
, flags
;
4417 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
4418 int seg_not_present
, useable
, lm
;
4419 uint32_t *lp
, entry_1
, entry_2
;
4421 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
4422 if (!target_ldt_info
)
4423 return -TARGET_EFAULT
;
4424 idx
= tswap32(target_ldt_info
->entry_number
);
4425 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
4426 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
4427 unlock_user_struct(target_ldt_info
, ptr
, 1);
4428 return -TARGET_EINVAL
;
4430 lp
= (uint32_t *)(gdt_table
+ idx
);
4431 entry_1
= tswap32(lp
[0]);
4432 entry_2
= tswap32(lp
[1]);
4434 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
4435 contents
= (entry_2
>> 10) & 3;
4436 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
4437 seg_32bit
= (entry_2
>> 22) & 1;
4438 limit_in_pages
= (entry_2
>> 23) & 1;
4439 useable
= (entry_2
>> 20) & 1;
4443 lm
= (entry_2
>> 21) & 1;
4445 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
4446 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
4447 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
4448 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
4449 base_addr
= (entry_1
>> 16) |
4450 (entry_2
& 0xff000000) |
4451 ((entry_2
& 0xff) << 16);
4452 target_ldt_info
->base_addr
= tswapal(base_addr
);
4453 target_ldt_info
->limit
= tswap32(limit
);
4454 target_ldt_info
->flags
= tswap32(flags
);
4455 unlock_user_struct(target_ldt_info
, ptr
, 1);
4458 #endif /* TARGET_I386 && TARGET_ABI32 */
4460 #ifndef TARGET_ABI32
4461 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
4468 case TARGET_ARCH_SET_GS
:
4469 case TARGET_ARCH_SET_FS
:
4470 if (code
== TARGET_ARCH_SET_GS
)
4474 cpu_x86_load_seg(env
, idx
, 0);
4475 env
->segs
[idx
].base
= addr
;
4477 case TARGET_ARCH_GET_GS
:
4478 case TARGET_ARCH_GET_FS
:
4479 if (code
== TARGET_ARCH_GET_GS
)
4483 val
= env
->segs
[idx
].base
;
4484 if (put_user(val
, addr
, abi_ulong
))
4485 ret
= -TARGET_EFAULT
;
4488 ret
= -TARGET_EINVAL
;
4495 #endif /* defined(TARGET_I386) */
4497 #define NEW_STACK_SIZE 0x40000
4500 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
4503 pthread_mutex_t mutex
;
4504 pthread_cond_t cond
;
4507 abi_ulong child_tidptr
;
4508 abi_ulong parent_tidptr
;
4512 static void *clone_func(void *arg
)
4514 new_thread_info
*info
= arg
;
4519 rcu_register_thread();
4521 cpu
= ENV_GET_CPU(env
);
4523 ts
= (TaskState
*)cpu
->opaque
;
4524 info
->tid
= gettid();
4525 cpu
->host_tid
= info
->tid
;
4527 if (info
->child_tidptr
)
4528 put_user_u32(info
->tid
, info
->child_tidptr
);
4529 if (info
->parent_tidptr
)
4530 put_user_u32(info
->tid
, info
->parent_tidptr
);
4531 /* Enable signals. */
4532 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
4533 /* Signal to the parent that we're ready. */
4534 pthread_mutex_lock(&info
->mutex
);
4535 pthread_cond_broadcast(&info
->cond
);
4536 pthread_mutex_unlock(&info
->mutex
);
4537 /* Wait until the parent has finshed initializing the tls state. */
4538 pthread_mutex_lock(&clone_lock
);
4539 pthread_mutex_unlock(&clone_lock
);
4545 /* do_fork() Must return host values and target errnos (unlike most
4546 do_*() functions). */
4547 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
4548 abi_ulong parent_tidptr
, target_ulong newtls
,
4549 abi_ulong child_tidptr
)
4551 CPUState
*cpu
= ENV_GET_CPU(env
);
4555 CPUArchState
*new_env
;
4556 unsigned int nptl_flags
;
4559 /* Emulate vfork() with fork() */
4560 if (flags
& CLONE_VFORK
)
4561 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
4563 if (flags
& CLONE_VM
) {
4564 TaskState
*parent_ts
= (TaskState
*)cpu
->opaque
;
4565 new_thread_info info
;
4566 pthread_attr_t attr
;
4568 ts
= g_malloc0(sizeof(TaskState
));
4569 init_task_state(ts
);
4570 /* we create a new CPU instance. */
4571 new_env
= cpu_copy(env
);
4572 /* Init regs that differ from the parent. */
4573 cpu_clone_regs(new_env
, newsp
);
4574 new_cpu
= ENV_GET_CPU(new_env
);
4575 new_cpu
->opaque
= ts
;
4576 ts
->bprm
= parent_ts
->bprm
;
4577 ts
->info
= parent_ts
->info
;
4579 flags
&= ~CLONE_NPTL_FLAGS2
;
4581 if (nptl_flags
& CLONE_CHILD_CLEARTID
) {
4582 ts
->child_tidptr
= child_tidptr
;
4585 if (nptl_flags
& CLONE_SETTLS
)
4586 cpu_set_tls (new_env
, newtls
);
4588 /* Grab a mutex so that thread setup appears atomic. */
4589 pthread_mutex_lock(&clone_lock
);
4591 memset(&info
, 0, sizeof(info
));
4592 pthread_mutex_init(&info
.mutex
, NULL
);
4593 pthread_mutex_lock(&info
.mutex
);
4594 pthread_cond_init(&info
.cond
, NULL
);
4596 if (nptl_flags
& CLONE_CHILD_SETTID
)
4597 info
.child_tidptr
= child_tidptr
;
4598 if (nptl_flags
& CLONE_PARENT_SETTID
)
4599 info
.parent_tidptr
= parent_tidptr
;
4601 ret
= pthread_attr_init(&attr
);
4602 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
4603 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
4604 /* It is not safe to deliver signals until the child has finished
4605 initializing, so temporarily block all signals. */
4606 sigfillset(&sigmask
);
4607 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
4609 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
4610 /* TODO: Free new CPU state if thread creation failed. */
4612 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
4613 pthread_attr_destroy(&attr
);
4615 /* Wait for the child to initialize. */
4616 pthread_cond_wait(&info
.cond
, &info
.mutex
);
4618 if (flags
& CLONE_PARENT_SETTID
)
4619 put_user_u32(ret
, parent_tidptr
);
4623 pthread_mutex_unlock(&info
.mutex
);
4624 pthread_cond_destroy(&info
.cond
);
4625 pthread_mutex_destroy(&info
.mutex
);
4626 pthread_mutex_unlock(&clone_lock
);
4628 /* if no CLONE_VM, we consider it is a fork */
4629 if ((flags
& ~(CSIGNAL
| CLONE_NPTL_FLAGS2
)) != 0) {
4630 return -TARGET_EINVAL
;
4635 /* Child Process. */
4637 cpu_clone_regs(env
, newsp
);
4639 /* There is a race condition here. The parent process could
4640 theoretically read the TID in the child process before the child
4641 tid is set. This would require using either ptrace
4642 (not implemented) or having *_tidptr to point at a shared memory
4643 mapping. We can't repeat the spinlock hack used above because
4644 the child process gets its own copy of the lock. */
4645 if (flags
& CLONE_CHILD_SETTID
)
4646 put_user_u32(gettid(), child_tidptr
);
4647 if (flags
& CLONE_PARENT_SETTID
)
4648 put_user_u32(gettid(), parent_tidptr
);
4649 ts
= (TaskState
*)cpu
->opaque
;
4650 if (flags
& CLONE_SETTLS
)
4651 cpu_set_tls (env
, newtls
);
4652 if (flags
& CLONE_CHILD_CLEARTID
)
4653 ts
->child_tidptr
= child_tidptr
;
4661 /* warning : doesn't handle linux specific flags... */
4662 static int target_to_host_fcntl_cmd(int cmd
)
4665 case TARGET_F_DUPFD
:
4666 case TARGET_F_GETFD
:
4667 case TARGET_F_SETFD
:
4668 case TARGET_F_GETFL
:
4669 case TARGET_F_SETFL
:
4671 case TARGET_F_GETLK
:
4673 case TARGET_F_SETLK
:
4675 case TARGET_F_SETLKW
:
4677 case TARGET_F_GETOWN
:
4679 case TARGET_F_SETOWN
:
4681 case TARGET_F_GETSIG
:
4683 case TARGET_F_SETSIG
:
4685 #if TARGET_ABI_BITS == 32
4686 case TARGET_F_GETLK64
:
4688 case TARGET_F_SETLK64
:
4690 case TARGET_F_SETLKW64
:
4693 case TARGET_F_SETLEASE
:
4695 case TARGET_F_GETLEASE
:
4697 #ifdef F_DUPFD_CLOEXEC
4698 case TARGET_F_DUPFD_CLOEXEC
:
4699 return F_DUPFD_CLOEXEC
;
4701 case TARGET_F_NOTIFY
:
4704 case TARGET_F_GETOWN_EX
:
4708 case TARGET_F_SETOWN_EX
:
4712 return -TARGET_EINVAL
;
4714 return -TARGET_EINVAL
;
4717 #define TRANSTBL_CONVERT(a) { -1, TARGET_##a, -1, a }
4718 static const bitmask_transtbl flock_tbl
[] = {
4719 TRANSTBL_CONVERT(F_RDLCK
),
4720 TRANSTBL_CONVERT(F_WRLCK
),
4721 TRANSTBL_CONVERT(F_UNLCK
),
4722 TRANSTBL_CONVERT(F_EXLCK
),
4723 TRANSTBL_CONVERT(F_SHLCK
),
4727 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
4730 struct target_flock
*target_fl
;
4731 struct flock64 fl64
;
4732 struct target_flock64
*target_fl64
;
4734 struct f_owner_ex fox
;
4735 struct target_f_owner_ex
*target_fox
;
4738 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
4740 if (host_cmd
== -TARGET_EINVAL
)
4744 case TARGET_F_GETLK
:
4745 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
4746 return -TARGET_EFAULT
;
4748 target_to_host_bitmask(tswap16(target_fl
->l_type
), flock_tbl
);
4749 fl
.l_whence
= tswap16(target_fl
->l_whence
);
4750 fl
.l_start
= tswapal(target_fl
->l_start
);
4751 fl
.l_len
= tswapal(target_fl
->l_len
);
4752 fl
.l_pid
= tswap32(target_fl
->l_pid
);
4753 unlock_user_struct(target_fl
, arg
, 0);
4754 ret
= get_errno(fcntl(fd
, host_cmd
, &fl
));
4756 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg
, 0))
4757 return -TARGET_EFAULT
;
4759 host_to_target_bitmask(tswap16(fl
.l_type
), flock_tbl
);
4760 target_fl
->l_whence
= tswap16(fl
.l_whence
);
4761 target_fl
->l_start
= tswapal(fl
.l_start
);
4762 target_fl
->l_len
= tswapal(fl
.l_len
);
4763 target_fl
->l_pid
= tswap32(fl
.l_pid
);
4764 unlock_user_struct(target_fl
, arg
, 1);
4768 case TARGET_F_SETLK
:
4769 case TARGET_F_SETLKW
:
4770 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
4771 return -TARGET_EFAULT
;
4773 target_to_host_bitmask(tswap16(target_fl
->l_type
), flock_tbl
);
4774 fl
.l_whence
= tswap16(target_fl
->l_whence
);
4775 fl
.l_start
= tswapal(target_fl
->l_start
);
4776 fl
.l_len
= tswapal(target_fl
->l_len
);
4777 fl
.l_pid
= tswap32(target_fl
->l_pid
);
4778 unlock_user_struct(target_fl
, arg
, 0);
4779 ret
= get_errno(fcntl(fd
, host_cmd
, &fl
));
4782 case TARGET_F_GETLK64
:
4783 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
4784 return -TARGET_EFAULT
;
4786 target_to_host_bitmask(tswap16(target_fl64
->l_type
), flock_tbl
) >> 1;
4787 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
4788 fl64
.l_start
= tswap64(target_fl64
->l_start
);
4789 fl64
.l_len
= tswap64(target_fl64
->l_len
);
4790 fl64
.l_pid
= tswap32(target_fl64
->l_pid
);
4791 unlock_user_struct(target_fl64
, arg
, 0);
4792 ret
= get_errno(fcntl(fd
, host_cmd
, &fl64
));
4794 if (!lock_user_struct(VERIFY_WRITE
, target_fl64
, arg
, 0))
4795 return -TARGET_EFAULT
;
4796 target_fl64
->l_type
=
4797 host_to_target_bitmask(tswap16(fl64
.l_type
), flock_tbl
) >> 1;
4798 target_fl64
->l_whence
= tswap16(fl64
.l_whence
);
4799 target_fl64
->l_start
= tswap64(fl64
.l_start
);
4800 target_fl64
->l_len
= tswap64(fl64
.l_len
);
4801 target_fl64
->l_pid
= tswap32(fl64
.l_pid
);
4802 unlock_user_struct(target_fl64
, arg
, 1);
4805 case TARGET_F_SETLK64
:
4806 case TARGET_F_SETLKW64
:
4807 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
4808 return -TARGET_EFAULT
;
4810 target_to_host_bitmask(tswap16(target_fl64
->l_type
), flock_tbl
) >> 1;
4811 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
4812 fl64
.l_start
= tswap64(target_fl64
->l_start
);
4813 fl64
.l_len
= tswap64(target_fl64
->l_len
);
4814 fl64
.l_pid
= tswap32(target_fl64
->l_pid
);
4815 unlock_user_struct(target_fl64
, arg
, 0);
4816 ret
= get_errno(fcntl(fd
, host_cmd
, &fl64
));
4819 case TARGET_F_GETFL
:
4820 ret
= get_errno(fcntl(fd
, host_cmd
, arg
));
4822 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
4826 case TARGET_F_SETFL
:
4827 ret
= get_errno(fcntl(fd
, host_cmd
, target_to_host_bitmask(arg
, fcntl_flags_tbl
)));
4831 case TARGET_F_GETOWN_EX
:
4832 ret
= get_errno(fcntl(fd
, host_cmd
, &fox
));
4834 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
4835 return -TARGET_EFAULT
;
4836 target_fox
->type
= tswap32(fox
.type
);
4837 target_fox
->pid
= tswap32(fox
.pid
);
4838 unlock_user_struct(target_fox
, arg
, 1);
4844 case TARGET_F_SETOWN_EX
:
4845 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
4846 return -TARGET_EFAULT
;
4847 fox
.type
= tswap32(target_fox
->type
);
4848 fox
.pid
= tswap32(target_fox
->pid
);
4849 unlock_user_struct(target_fox
, arg
, 0);
4850 ret
= get_errno(fcntl(fd
, host_cmd
, &fox
));
4854 case TARGET_F_SETOWN
:
4855 case TARGET_F_GETOWN
:
4856 case TARGET_F_SETSIG
:
4857 case TARGET_F_GETSIG
:
4858 case TARGET_F_SETLEASE
:
4859 case TARGET_F_GETLEASE
:
4860 ret
= get_errno(fcntl(fd
, host_cmd
, arg
));
4864 ret
= get_errno(fcntl(fd
, cmd
, arg
));
4872 static inline int high2lowuid(int uid
)
4880 static inline int high2lowgid(int gid
)
4888 static inline int low2highuid(int uid
)
4890 if ((int16_t)uid
== -1)
4896 static inline int low2highgid(int gid
)
4898 if ((int16_t)gid
== -1)
4903 static inline int tswapid(int id
)
4908 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
4910 #else /* !USE_UID16 */
4911 static inline int high2lowuid(int uid
)
4915 static inline int high2lowgid(int gid
)
4919 static inline int low2highuid(int uid
)
4923 static inline int low2highgid(int gid
)
4927 static inline int tswapid(int id
)
4932 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
4934 #endif /* USE_UID16 */
4936 void syscall_init(void)
4939 const argtype
*arg_type
;
4943 thunk_init(STRUCT_MAX
);
4945 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
4946 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
4947 #include "syscall_types.h"
4949 #undef STRUCT_SPECIAL
4951 /* Build target_to_host_errno_table[] table from
4952 * host_to_target_errno_table[]. */
4953 for (i
= 0; i
< ERRNO_TABLE_SIZE
; i
++) {
4954 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
4957 /* we patch the ioctl size if necessary. We rely on the fact that
4958 no ioctl has all the bits at '1' in the size field */
4960 while (ie
->target_cmd
!= 0) {
4961 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
4962 TARGET_IOC_SIZEMASK
) {
4963 arg_type
= ie
->arg_type
;
4964 if (arg_type
[0] != TYPE_PTR
) {
4965 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
4970 size
= thunk_type_size(arg_type
, 0);
4971 ie
->target_cmd
= (ie
->target_cmd
&
4972 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
4973 (size
<< TARGET_IOC_SIZESHIFT
);
4976 /* automatic consistency check if same arch */
4977 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
4978 (defined(__x86_64__) && defined(TARGET_X86_64))
4979 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
4980 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
4981 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
4988 #if TARGET_ABI_BITS == 32
4989 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
4991 #ifdef TARGET_WORDS_BIGENDIAN
4992 return ((uint64_t)word0
<< 32) | word1
;
4994 return ((uint64_t)word1
<< 32) | word0
;
4997 #else /* TARGET_ABI_BITS == 32 */
4998 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
5002 #endif /* TARGET_ABI_BITS != 32 */
5004 #ifdef TARGET_NR_truncate64
5005 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
5010 if (regpairs_aligned(cpu_env
)) {
5014 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
5018 #ifdef TARGET_NR_ftruncate64
5019 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
5024 if (regpairs_aligned(cpu_env
)) {
5028 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
5032 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
5033 abi_ulong target_addr
)
5035 struct target_timespec
*target_ts
;
5037 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
5038 return -TARGET_EFAULT
;
5039 host_ts
->tv_sec
= tswapal(target_ts
->tv_sec
);
5040 host_ts
->tv_nsec
= tswapal(target_ts
->tv_nsec
);
5041 unlock_user_struct(target_ts
, target_addr
, 0);
5045 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
5046 struct timespec
*host_ts
)
5048 struct target_timespec
*target_ts
;
5050 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
5051 return -TARGET_EFAULT
;
5052 target_ts
->tv_sec
= tswapal(host_ts
->tv_sec
);
5053 target_ts
->tv_nsec
= tswapal(host_ts
->tv_nsec
);
5054 unlock_user_struct(target_ts
, target_addr
, 1);
5058 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_itspec
,
5059 abi_ulong target_addr
)
5061 struct target_itimerspec
*target_itspec
;
5063 if (!lock_user_struct(VERIFY_READ
, target_itspec
, target_addr
, 1)) {
5064 return -TARGET_EFAULT
;
5067 host_itspec
->it_interval
.tv_sec
=
5068 tswapal(target_itspec
->it_interval
.tv_sec
);
5069 host_itspec
->it_interval
.tv_nsec
=
5070 tswapal(target_itspec
->it_interval
.tv_nsec
);
5071 host_itspec
->it_value
.tv_sec
= tswapal(target_itspec
->it_value
.tv_sec
);
5072 host_itspec
->it_value
.tv_nsec
= tswapal(target_itspec
->it_value
.tv_nsec
);
5074 unlock_user_struct(target_itspec
, target_addr
, 1);
5078 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
5079 struct itimerspec
*host_its
)
5081 struct target_itimerspec
*target_itspec
;
5083 if (!lock_user_struct(VERIFY_WRITE
, target_itspec
, target_addr
, 0)) {
5084 return -TARGET_EFAULT
;
5087 target_itspec
->it_interval
.tv_sec
= tswapal(host_its
->it_interval
.tv_sec
);
5088 target_itspec
->it_interval
.tv_nsec
= tswapal(host_its
->it_interval
.tv_nsec
);
5090 target_itspec
->it_value
.tv_sec
= tswapal(host_its
->it_value
.tv_sec
);
5091 target_itspec
->it_value
.tv_nsec
= tswapal(host_its
->it_value
.tv_nsec
);
5093 unlock_user_struct(target_itspec
, target_addr
, 0);
5097 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
5098 abi_ulong target_addr
)
5100 struct target_sigevent
*target_sevp
;
5102 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
5103 return -TARGET_EFAULT
;
5106 /* This union is awkward on 64 bit systems because it has a 32 bit
5107 * integer and a pointer in it; we follow the conversion approach
5108 * used for handling sigval types in signal.c so the guest should get
5109 * the correct value back even if we did a 64 bit byteswap and it's
5110 * using the 32 bit integer.
5112 host_sevp
->sigev_value
.sival_ptr
=
5113 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
5114 host_sevp
->sigev_signo
=
5115 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
5116 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
5117 host_sevp
->_sigev_un
._tid
= tswap32(target_sevp
->_sigev_un
._tid
);
5119 unlock_user_struct(target_sevp
, target_addr
, 1);
5123 #if defined(TARGET_NR_mlockall)
5124 static inline int target_to_host_mlockall_arg(int arg
)
5128 if (arg
& TARGET_MLOCKALL_MCL_CURRENT
) {
5129 result
|= MCL_CURRENT
;
5131 if (arg
& TARGET_MLOCKALL_MCL_FUTURE
) {
5132 result
|= MCL_FUTURE
;
5138 #if defined(TARGET_NR_stat64) || defined(TARGET_NR_newfstatat)
5139 static inline abi_long
host_to_target_stat64(void *cpu_env
,
5140 abi_ulong target_addr
,
5141 struct stat
*host_st
)
5143 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
5144 if (((CPUARMState
*)cpu_env
)->eabi
) {
5145 struct target_eabi_stat64
*target_st
;
5147 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
5148 return -TARGET_EFAULT
;
5149 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
5150 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
5151 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
5152 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
5153 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
5155 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
5156 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
5157 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
5158 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
5159 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
5160 __put_user(host_st
->st_size
, &target_st
->st_size
);
5161 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
5162 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
5163 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
5164 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
5165 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
5166 unlock_user_struct(target_st
, target_addr
, 1);
5170 #if defined(TARGET_HAS_STRUCT_STAT64)
5171 struct target_stat64
*target_st
;
5173 struct target_stat
*target_st
;
5176 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
5177 return -TARGET_EFAULT
;
5178 memset(target_st
, 0, sizeof(*target_st
));
5179 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
5180 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
5181 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
5182 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
5184 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
5185 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
5186 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
5187 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
5188 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
5189 /* XXX: better use of kernel struct */
5190 __put_user(host_st
->st_size
, &target_st
->st_size
);
5191 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
5192 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
5193 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
5194 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
5195 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
5196 unlock_user_struct(target_st
, target_addr
, 1);
5203 /* ??? Using host futex calls even when target atomic operations
5204 are not really atomic probably breaks things. However implementing
5205 futexes locally would make futexes shared between multiple processes
5206 tricky. However they're probably useless because guest atomic
5207 operations won't work either. */
5208 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
5209 target_ulong uaddr2
, int val3
)
5211 struct timespec ts
, *pts
;
5214 /* ??? We assume FUTEX_* constants are the same on both host
5216 #ifdef FUTEX_CMD_MASK
5217 base_op
= op
& FUTEX_CMD_MASK
;
5223 case FUTEX_WAIT_BITSET
:
5226 target_to_host_timespec(pts
, timeout
);
5230 return get_errno(sys_futex(g2h(uaddr
), op
, tswap32(val
),
5233 return get_errno(sys_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
5235 return get_errno(sys_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
5237 case FUTEX_CMP_REQUEUE
:
5239 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
5240 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
5241 But the prototype takes a `struct timespec *'; insert casts
5242 to satisfy the compiler. We do not need to tswap TIMEOUT
5243 since it's not compared to guest memory. */
5244 pts
= (struct timespec
*)(uintptr_t) timeout
;
5245 return get_errno(sys_futex(g2h(uaddr
), op
, val
, pts
,
5247 (base_op
== FUTEX_CMP_REQUEUE
5251 return -TARGET_ENOSYS
;
5254 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
5255 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
5256 abi_long handle
, abi_long mount_id
,
5259 struct file_handle
*target_fh
;
5260 struct file_handle
*fh
;
5264 unsigned int size
, total_size
;
5266 if (get_user_s32(size
, handle
)) {
5267 return -TARGET_EFAULT
;
5270 name
= lock_user_string(pathname
);
5272 return -TARGET_EFAULT
;
5275 total_size
= sizeof(struct file_handle
) + size
;
5276 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
5278 unlock_user(name
, pathname
, 0);
5279 return -TARGET_EFAULT
;
5282 fh
= g_malloc0(total_size
);
5283 fh
->handle_bytes
= size
;
5285 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
5286 unlock_user(name
, pathname
, 0);
5288 /* man name_to_handle_at(2):
5289 * Other than the use of the handle_bytes field, the caller should treat
5290 * the file_handle structure as an opaque data type
5293 memcpy(target_fh
, fh
, total_size
);
5294 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
5295 target_fh
->handle_type
= tswap32(fh
->handle_type
);
5297 unlock_user(target_fh
, handle
, total_size
);
5299 if (put_user_s32(mid
, mount_id
)) {
5300 return -TARGET_EFAULT
;
5308 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
5309 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
5312 struct file_handle
*target_fh
;
5313 struct file_handle
*fh
;
5314 unsigned int size
, total_size
;
5317 if (get_user_s32(size
, handle
)) {
5318 return -TARGET_EFAULT
;
5321 total_size
= sizeof(struct file_handle
) + size
;
5322 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
5324 return -TARGET_EFAULT
;
5327 fh
= g_malloc0(total_size
);
5328 memcpy(fh
, target_fh
, total_size
);
5329 fh
->handle_bytes
= size
;
5330 fh
->handle_type
= tswap32(target_fh
->handle_type
);
5332 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
5333 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
5337 unlock_user(target_fh
, handle
, total_size
);
5343 /* Map host to target signal numbers for the wait family of syscalls.
5344 Assume all other status bits are the same. */
5345 int host_to_target_waitstatus(int status
)
5347 if (WIFSIGNALED(status
)) {
5348 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
5350 if (WIFSTOPPED(status
)) {
5351 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
5357 static int open_self_cmdline(void *cpu_env
, int fd
)
5360 bool word_skipped
= false;
5362 fd_orig
= open("/proc/self/cmdline", O_RDONLY
);
5372 nb_read
= read(fd_orig
, buf
, sizeof(buf
));
5374 fd_orig
= close(fd_orig
);
5376 } else if (nb_read
== 0) {
5380 if (!word_skipped
) {
5381 /* Skip the first string, which is the path to qemu-*-static
5382 instead of the actual command. */
5383 cp_buf
= memchr(buf
, 0, sizeof(buf
));
5385 /* Null byte found, skip one string */
5387 nb_read
-= cp_buf
- buf
;
5388 word_skipped
= true;
5393 if (write(fd
, cp_buf
, nb_read
) != nb_read
) {
5400 return close(fd_orig
);
5403 static int open_self_maps(void *cpu_env
, int fd
)
5405 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
5406 TaskState
*ts
= cpu
->opaque
;
5412 fp
= fopen("/proc/self/maps", "r");
5417 while ((read
= getline(&line
, &len
, fp
)) != -1) {
5418 int fields
, dev_maj
, dev_min
, inode
;
5419 uint64_t min
, max
, offset
;
5420 char flag_r
, flag_w
, flag_x
, flag_p
;
5421 char path
[512] = "";
5422 fields
= sscanf(line
, "%"PRIx64
"-%"PRIx64
" %c%c%c%c %"PRIx64
" %x:%x %d"
5423 " %512s", &min
, &max
, &flag_r
, &flag_w
, &flag_x
,
5424 &flag_p
, &offset
, &dev_maj
, &dev_min
, &inode
, path
);
5426 if ((fields
< 10) || (fields
> 11)) {
5429 if (h2g_valid(min
)) {
5430 int flags
= page_get_flags(h2g(min
));
5431 max
= h2g_valid(max
- 1) ? max
: (uintptr_t)g2h(GUEST_ADDR_MAX
);
5432 if (page_check_range(h2g(min
), max
- min
, flags
) == -1) {
5435 if (h2g(min
) == ts
->info
->stack_limit
) {
5436 pstrcpy(path
, sizeof(path
), " [stack]");
5438 dprintf(fd
, TARGET_ABI_FMT_lx
"-" TARGET_ABI_FMT_lx
5439 " %c%c%c%c %08" PRIx64
" %02x:%02x %d %s%s\n",
5440 h2g(min
), h2g(max
- 1) + 1, flag_r
, flag_w
,
5441 flag_x
, flag_p
, offset
, dev_maj
, dev_min
, inode
,
5442 path
[0] ? " " : "", path
);
5452 static int open_self_stat(void *cpu_env
, int fd
)
5454 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
5455 TaskState
*ts
= cpu
->opaque
;
5456 abi_ulong start_stack
= ts
->info
->start_stack
;
5459 for (i
= 0; i
< 44; i
++) {
5467 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
5468 } else if (i
== 1) {
5470 snprintf(buf
, sizeof(buf
), "(%s) ", ts
->bprm
->argv
[0]);
5471 } else if (i
== 27) {
5474 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
5476 /* for the rest, there is MasterCard */
5477 snprintf(buf
, sizeof(buf
), "0%c", i
== 43 ? '\n' : ' ');
5481 if (write(fd
, buf
, len
) != len
) {
5489 static int open_self_auxv(void *cpu_env
, int fd
)
5491 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
5492 TaskState
*ts
= cpu
->opaque
;
5493 abi_ulong auxv
= ts
->info
->saved_auxv
;
5494 abi_ulong len
= ts
->info
->auxv_len
;
5498 * Auxiliary vector is stored in target process stack.
5499 * read in whole auxv vector and copy it to file
5501 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
5505 r
= write(fd
, ptr
, len
);
5512 lseek(fd
, 0, SEEK_SET
);
5513 unlock_user(ptr
, auxv
, len
);
5519 static int is_proc_myself(const char *filename
, const char *entry
)
5521 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
5522 filename
+= strlen("/proc/");
5523 if (!strncmp(filename
, "self/", strlen("self/"))) {
5524 filename
+= strlen("self/");
5525 } else if (*filename
>= '1' && *filename
<= '9') {
5527 snprintf(myself
, sizeof(myself
), "%d/", getpid());
5528 if (!strncmp(filename
, myself
, strlen(myself
))) {
5529 filename
+= strlen(myself
);
5536 if (!strcmp(filename
, entry
)) {
5543 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
5544 static int is_proc(const char *filename
, const char *entry
)
5546 return strcmp(filename
, entry
) == 0;
5549 static int open_net_route(void *cpu_env
, int fd
)
5556 fp
= fopen("/proc/net/route", "r");
5563 read
= getline(&line
, &len
, fp
);
5564 dprintf(fd
, "%s", line
);
5568 while ((read
= getline(&line
, &len
, fp
)) != -1) {
5570 uint32_t dest
, gw
, mask
;
5571 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
5572 sscanf(line
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
5573 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
5574 &mask
, &mtu
, &window
, &irtt
);
5575 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
5576 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
5577 metric
, tswap32(mask
), mtu
, window
, irtt
);
5587 static int do_openat(void *cpu_env
, int dirfd
, const char *pathname
, int flags
, mode_t mode
)
5590 const char *filename
;
5591 int (*fill
)(void *cpu_env
, int fd
);
5592 int (*cmp
)(const char *s1
, const char *s2
);
5594 const struct fake_open
*fake_open
;
5595 static const struct fake_open fakes
[] = {
5596 { "maps", open_self_maps
, is_proc_myself
},
5597 { "stat", open_self_stat
, is_proc_myself
},
5598 { "auxv", open_self_auxv
, is_proc_myself
},
5599 { "cmdline", open_self_cmdline
, is_proc_myself
},
5600 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
5601 { "/proc/net/route", open_net_route
, is_proc
},
5603 { NULL
, NULL
, NULL
}
5606 if (is_proc_myself(pathname
, "exe")) {
5607 int execfd
= qemu_getauxval(AT_EXECFD
);
5608 return execfd
? execfd
: get_errno(sys_openat(dirfd
, exec_path
, flags
, mode
));
5611 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
5612 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
5617 if (fake_open
->filename
) {
5619 char filename
[PATH_MAX
];
5622 /* create temporary file to map stat to */
5623 tmpdir
= getenv("TMPDIR");
5626 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
5627 fd
= mkstemp(filename
);
5633 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
5637 lseek(fd
, 0, SEEK_SET
);
5642 return get_errno(sys_openat(dirfd
, path(pathname
), flags
, mode
));
5645 #define TIMER_MAGIC 0x0caf0000
5646 #define TIMER_MAGIC_MASK 0xffff0000
5648 /* Convert QEMU provided timer ID back to internal 16bit index format */
5649 static target_timer_t
get_timer_id(abi_long arg
)
5651 target_timer_t timerid
= arg
;
5653 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
5654 return -TARGET_EINVAL
;
5659 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
5660 return -TARGET_EINVAL
;
5666 /* do_syscall() should always have a single exit point at the end so
5667 that actions, such as logging of syscall results, can be performed.
5668 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
5669 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
5670 abi_long arg2
, abi_long arg3
, abi_long arg4
,
5671 abi_long arg5
, abi_long arg6
, abi_long arg7
,
5674 CPUState
*cpu
= ENV_GET_CPU(cpu_env
);
5681 gemu_log("syscall %d", num
);
5684 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
5687 case TARGET_NR_exit
:
5688 /* In old applications this may be used to implement _exit(2).
5689 However in threaded applictions it is used for thread termination,
5690 and _exit_group is used for application termination.
5691 Do thread termination if we have more then one thread. */
5692 /* FIXME: This probably breaks if a signal arrives. We should probably
5693 be disabling signals. */
5694 if (CPU_NEXT(first_cpu
)) {
5698 /* Remove the CPU from the list. */
5699 QTAILQ_REMOVE(&cpus
, cpu
, node
);
5702 if (ts
->child_tidptr
) {
5703 put_user_u32(0, ts
->child_tidptr
);
5704 sys_futex(g2h(ts
->child_tidptr
), FUTEX_WAKE
, INT_MAX
,
5708 object_unref(OBJECT(cpu
));
5710 rcu_unregister_thread();
5716 gdb_exit(cpu_env
, arg1
);
5718 ret
= 0; /* avoid warning */
5720 case TARGET_NR_read
:
5724 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
5726 ret
= get_errno(read(arg1
, p
, arg3
));
5727 unlock_user(p
, arg2
, ret
);
5730 case TARGET_NR_write
:
5731 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
5733 ret
= get_errno(write(arg1
, p
, arg3
));
5734 unlock_user(p
, arg2
, 0);
5736 #ifdef TARGET_NR_open
5737 case TARGET_NR_open
:
5738 if (!(p
= lock_user_string(arg1
)))
5740 ret
= get_errno(do_openat(cpu_env
, AT_FDCWD
, p
,
5741 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
5743 unlock_user(p
, arg1
, 0);
5746 case TARGET_NR_openat
:
5747 if (!(p
= lock_user_string(arg2
)))
5749 ret
= get_errno(do_openat(cpu_env
, arg1
, p
,
5750 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
5752 unlock_user(p
, arg2
, 0);
5754 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
5755 case TARGET_NR_name_to_handle_at
:
5756 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
5759 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
5760 case TARGET_NR_open_by_handle_at
:
5761 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
5764 case TARGET_NR_close
:
5765 ret
= get_errno(close(arg1
));
5770 #ifdef TARGET_NR_fork
5771 case TARGET_NR_fork
:
5772 ret
= get_errno(do_fork(cpu_env
, SIGCHLD
, 0, 0, 0, 0));
5775 #ifdef TARGET_NR_waitpid
5776 case TARGET_NR_waitpid
:
5779 ret
= get_errno(waitpid(arg1
, &status
, arg3
));
5780 if (!is_error(ret
) && arg2
&& ret
5781 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
5786 #ifdef TARGET_NR_waitid
5787 case TARGET_NR_waitid
:
5791 ret
= get_errno(waitid(arg1
, arg2
, &info
, arg4
));
5792 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
5793 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
5795 host_to_target_siginfo(p
, &info
);
5796 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
5801 #ifdef TARGET_NR_creat /* not on alpha */
5802 case TARGET_NR_creat
:
5803 if (!(p
= lock_user_string(arg1
)))
5805 ret
= get_errno(creat(p
, arg2
));
5806 unlock_user(p
, arg1
, 0);
5809 #ifdef TARGET_NR_link
5810 case TARGET_NR_link
:
5813 p
= lock_user_string(arg1
);
5814 p2
= lock_user_string(arg2
);
5816 ret
= -TARGET_EFAULT
;
5818 ret
= get_errno(link(p
, p2
));
5819 unlock_user(p2
, arg2
, 0);
5820 unlock_user(p
, arg1
, 0);
5824 #if defined(TARGET_NR_linkat)
5825 case TARGET_NR_linkat
:
5830 p
= lock_user_string(arg2
);
5831 p2
= lock_user_string(arg4
);
5833 ret
= -TARGET_EFAULT
;
5835 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
5836 unlock_user(p
, arg2
, 0);
5837 unlock_user(p2
, arg4
, 0);
5841 #ifdef TARGET_NR_unlink
5842 case TARGET_NR_unlink
:
5843 if (!(p
= lock_user_string(arg1
)))
5845 ret
= get_errno(unlink(p
));
5846 unlock_user(p
, arg1
, 0);
5849 #if defined(TARGET_NR_unlinkat)
5850 case TARGET_NR_unlinkat
:
5851 if (!(p
= lock_user_string(arg2
)))
5853 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
5854 unlock_user(p
, arg2
, 0);
5857 case TARGET_NR_execve
:
5859 char **argp
, **envp
;
5862 abi_ulong guest_argp
;
5863 abi_ulong guest_envp
;
5870 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
5871 if (get_user_ual(addr
, gp
))
5879 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
5880 if (get_user_ual(addr
, gp
))
5887 argp
= alloca((argc
+ 1) * sizeof(void *));
5888 envp
= alloca((envc
+ 1) * sizeof(void *));
5890 for (gp
= guest_argp
, q
= argp
; gp
;
5891 gp
+= sizeof(abi_ulong
), q
++) {
5892 if (get_user_ual(addr
, gp
))
5896 if (!(*q
= lock_user_string(addr
)))
5898 total_size
+= strlen(*q
) + 1;
5902 for (gp
= guest_envp
, q
= envp
; gp
;
5903 gp
+= sizeof(abi_ulong
), q
++) {
5904 if (get_user_ual(addr
, gp
))
5908 if (!(*q
= lock_user_string(addr
)))
5910 total_size
+= strlen(*q
) + 1;
5914 if (!(p
= lock_user_string(arg1
)))
5916 ret
= get_errno(execve(p
, argp
, envp
));
5917 unlock_user(p
, arg1
, 0);
5922 ret
= -TARGET_EFAULT
;
5925 for (gp
= guest_argp
, q
= argp
; *q
;
5926 gp
+= sizeof(abi_ulong
), q
++) {
5927 if (get_user_ual(addr
, gp
)
5930 unlock_user(*q
, addr
, 0);
5932 for (gp
= guest_envp
, q
= envp
; *q
;
5933 gp
+= sizeof(abi_ulong
), q
++) {
5934 if (get_user_ual(addr
, gp
)
5937 unlock_user(*q
, addr
, 0);
5941 case TARGET_NR_chdir
:
5942 if (!(p
= lock_user_string(arg1
)))
5944 ret
= get_errno(chdir(p
));
5945 unlock_user(p
, arg1
, 0);
5947 #ifdef TARGET_NR_time
5948 case TARGET_NR_time
:
5951 ret
= get_errno(time(&host_time
));
5954 && put_user_sal(host_time
, arg1
))
5959 #ifdef TARGET_NR_mknod
5960 case TARGET_NR_mknod
:
5961 if (!(p
= lock_user_string(arg1
)))
5963 ret
= get_errno(mknod(p
, arg2
, arg3
));
5964 unlock_user(p
, arg1
, 0);
5967 #if defined(TARGET_NR_mknodat)
5968 case TARGET_NR_mknodat
:
5969 if (!(p
= lock_user_string(arg2
)))
5971 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
5972 unlock_user(p
, arg2
, 0);
5975 #ifdef TARGET_NR_chmod
5976 case TARGET_NR_chmod
:
5977 if (!(p
= lock_user_string(arg1
)))
5979 ret
= get_errno(chmod(p
, arg2
));
5980 unlock_user(p
, arg1
, 0);
5983 #ifdef TARGET_NR_break
5984 case TARGET_NR_break
:
5987 #ifdef TARGET_NR_oldstat
5988 case TARGET_NR_oldstat
:
5991 case TARGET_NR_lseek
:
5992 ret
= get_errno(lseek(arg1
, arg2
, arg3
));
5994 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
5995 /* Alpha specific */
5996 case TARGET_NR_getxpid
:
5997 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = getppid();
5998 ret
= get_errno(getpid());
6001 #ifdef TARGET_NR_getpid
6002 case TARGET_NR_getpid
:
6003 ret
= get_errno(getpid());
6006 case TARGET_NR_mount
:
6008 /* need to look at the data field */
6012 p
= lock_user_string(arg1
);
6020 p2
= lock_user_string(arg2
);
6023 unlock_user(p
, arg1
, 0);
6029 p3
= lock_user_string(arg3
);
6032 unlock_user(p
, arg1
, 0);
6034 unlock_user(p2
, arg2
, 0);
6041 /* FIXME - arg5 should be locked, but it isn't clear how to
6042 * do that since it's not guaranteed to be a NULL-terminated
6046 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
6048 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
));
6050 ret
= get_errno(ret
);
6053 unlock_user(p
, arg1
, 0);
6055 unlock_user(p2
, arg2
, 0);
6057 unlock_user(p3
, arg3
, 0);
6061 #ifdef TARGET_NR_umount
6062 case TARGET_NR_umount
:
6063 if (!(p
= lock_user_string(arg1
)))
6065 ret
= get_errno(umount(p
));
6066 unlock_user(p
, arg1
, 0);
6069 #ifdef TARGET_NR_stime /* not on alpha */
6070 case TARGET_NR_stime
:
6073 if (get_user_sal(host_time
, arg1
))
6075 ret
= get_errno(stime(&host_time
));
6079 case TARGET_NR_ptrace
:
6081 #ifdef TARGET_NR_alarm /* not on alpha */
6082 case TARGET_NR_alarm
:
6086 #ifdef TARGET_NR_oldfstat
6087 case TARGET_NR_oldfstat
:
6090 #ifdef TARGET_NR_pause /* not on alpha */
6091 case TARGET_NR_pause
:
6092 ret
= get_errno(pause());
6095 #ifdef TARGET_NR_utime
6096 case TARGET_NR_utime
:
6098 struct utimbuf tbuf
, *host_tbuf
;
6099 struct target_utimbuf
*target_tbuf
;
6101 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
6103 tbuf
.actime
= tswapal(target_tbuf
->actime
);
6104 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
6105 unlock_user_struct(target_tbuf
, arg2
, 0);
6110 if (!(p
= lock_user_string(arg1
)))
6112 ret
= get_errno(utime(p
, host_tbuf
));
6113 unlock_user(p
, arg1
, 0);
6117 #ifdef TARGET_NR_utimes
6118 case TARGET_NR_utimes
:
6120 struct timeval
*tvp
, tv
[2];
6122 if (copy_from_user_timeval(&tv
[0], arg2
)
6123 || copy_from_user_timeval(&tv
[1],
6124 arg2
+ sizeof(struct target_timeval
)))
6130 if (!(p
= lock_user_string(arg1
)))
6132 ret
= get_errno(utimes(p
, tvp
));
6133 unlock_user(p
, arg1
, 0);
6137 #if defined(TARGET_NR_futimesat)
6138 case TARGET_NR_futimesat
:
6140 struct timeval
*tvp
, tv
[2];
6142 if (copy_from_user_timeval(&tv
[0], arg3
)
6143 || copy_from_user_timeval(&tv
[1],
6144 arg3
+ sizeof(struct target_timeval
)))
6150 if (!(p
= lock_user_string(arg2
)))
6152 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
6153 unlock_user(p
, arg2
, 0);
6157 #ifdef TARGET_NR_stty
6158 case TARGET_NR_stty
:
6161 #ifdef TARGET_NR_gtty
6162 case TARGET_NR_gtty
:
6165 #ifdef TARGET_NR_access
6166 case TARGET_NR_access
:
6167 if (!(p
= lock_user_string(arg1
)))
6169 ret
= get_errno(access(path(p
), arg2
));
6170 unlock_user(p
, arg1
, 0);
6173 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
6174 case TARGET_NR_faccessat
:
6175 if (!(p
= lock_user_string(arg2
)))
6177 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
6178 unlock_user(p
, arg2
, 0);
6181 #ifdef TARGET_NR_nice /* not on alpha */
6182 case TARGET_NR_nice
:
6183 ret
= get_errno(nice(arg1
));
6186 #ifdef TARGET_NR_ftime
6187 case TARGET_NR_ftime
:
6190 case TARGET_NR_sync
:
6194 case TARGET_NR_kill
:
6195 ret
= get_errno(kill(arg1
, target_to_host_signal(arg2
)));
6197 #ifdef TARGET_NR_rename
6198 case TARGET_NR_rename
:
6201 p
= lock_user_string(arg1
);
6202 p2
= lock_user_string(arg2
);
6204 ret
= -TARGET_EFAULT
;
6206 ret
= get_errno(rename(p
, p2
));
6207 unlock_user(p2
, arg2
, 0);
6208 unlock_user(p
, arg1
, 0);
6212 #if defined(TARGET_NR_renameat)
6213 case TARGET_NR_renameat
:
6216 p
= lock_user_string(arg2
);
6217 p2
= lock_user_string(arg4
);
6219 ret
= -TARGET_EFAULT
;
6221 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
6222 unlock_user(p2
, arg4
, 0);
6223 unlock_user(p
, arg2
, 0);
6227 #ifdef TARGET_NR_mkdir
6228 case TARGET_NR_mkdir
:
6229 if (!(p
= lock_user_string(arg1
)))
6231 ret
= get_errno(mkdir(p
, arg2
));
6232 unlock_user(p
, arg1
, 0);
6235 #if defined(TARGET_NR_mkdirat)
6236 case TARGET_NR_mkdirat
:
6237 if (!(p
= lock_user_string(arg2
)))
6239 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
6240 unlock_user(p
, arg2
, 0);
6243 #ifdef TARGET_NR_rmdir
6244 case TARGET_NR_rmdir
:
6245 if (!(p
= lock_user_string(arg1
)))
6247 ret
= get_errno(rmdir(p
));
6248 unlock_user(p
, arg1
, 0);
6252 ret
= get_errno(dup(arg1
));
6254 #ifdef TARGET_NR_pipe
6255 case TARGET_NR_pipe
:
6256 ret
= do_pipe(cpu_env
, arg1
, 0, 0);
6259 #ifdef TARGET_NR_pipe2
6260 case TARGET_NR_pipe2
:
6261 ret
= do_pipe(cpu_env
, arg1
,
6262 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
6265 case TARGET_NR_times
:
6267 struct target_tms
*tmsp
;
6269 ret
= get_errno(times(&tms
));
6271 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
6274 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
6275 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
6276 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
6277 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
6280 ret
= host_to_target_clock_t(ret
);
6283 #ifdef TARGET_NR_prof
6284 case TARGET_NR_prof
:
6287 #ifdef TARGET_NR_signal
6288 case TARGET_NR_signal
:
6291 case TARGET_NR_acct
:
6293 ret
= get_errno(acct(NULL
));
6295 if (!(p
= lock_user_string(arg1
)))
6297 ret
= get_errno(acct(path(p
)));
6298 unlock_user(p
, arg1
, 0);
6301 #ifdef TARGET_NR_umount2
6302 case TARGET_NR_umount2
:
6303 if (!(p
= lock_user_string(arg1
)))
6305 ret
= get_errno(umount2(p
, arg2
));
6306 unlock_user(p
, arg1
, 0);
6309 #ifdef TARGET_NR_lock
6310 case TARGET_NR_lock
:
6313 case TARGET_NR_ioctl
:
6314 ret
= do_ioctl(arg1
, arg2
, arg3
);
6316 case TARGET_NR_fcntl
:
6317 ret
= do_fcntl(arg1
, arg2
, arg3
);
6319 #ifdef TARGET_NR_mpx
6323 case TARGET_NR_setpgid
:
6324 ret
= get_errno(setpgid(arg1
, arg2
));
6326 #ifdef TARGET_NR_ulimit
6327 case TARGET_NR_ulimit
:
6330 #ifdef TARGET_NR_oldolduname
6331 case TARGET_NR_oldolduname
:
6334 case TARGET_NR_umask
:
6335 ret
= get_errno(umask(arg1
));
6337 case TARGET_NR_chroot
:
6338 if (!(p
= lock_user_string(arg1
)))
6340 ret
= get_errno(chroot(p
));
6341 unlock_user(p
, arg1
, 0);
6343 #ifdef TARGET_NR_ustat
6344 case TARGET_NR_ustat
:
6347 #ifdef TARGET_NR_dup2
6348 case TARGET_NR_dup2
:
6349 ret
= get_errno(dup2(arg1
, arg2
));
6352 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
6353 case TARGET_NR_dup3
:
6354 ret
= get_errno(dup3(arg1
, arg2
, arg3
));
6357 #ifdef TARGET_NR_getppid /* not on alpha */
6358 case TARGET_NR_getppid
:
6359 ret
= get_errno(getppid());
6362 #ifdef TARGET_NR_getpgrp
6363 case TARGET_NR_getpgrp
:
6364 ret
= get_errno(getpgrp());
6367 case TARGET_NR_setsid
:
6368 ret
= get_errno(setsid());
6370 #ifdef TARGET_NR_sigaction
6371 case TARGET_NR_sigaction
:
6373 #if defined(TARGET_ALPHA)
6374 struct target_sigaction act
, oact
, *pact
= 0;
6375 struct target_old_sigaction
*old_act
;
6377 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
6379 act
._sa_handler
= old_act
->_sa_handler
;
6380 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
6381 act
.sa_flags
= old_act
->sa_flags
;
6382 act
.sa_restorer
= 0;
6383 unlock_user_struct(old_act
, arg2
, 0);
6386 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
6387 if (!is_error(ret
) && arg3
) {
6388 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
6390 old_act
->_sa_handler
= oact
._sa_handler
;
6391 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
6392 old_act
->sa_flags
= oact
.sa_flags
;
6393 unlock_user_struct(old_act
, arg3
, 1);
6395 #elif defined(TARGET_MIPS)
6396 struct target_sigaction act
, oact
, *pact
, *old_act
;
6399 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
6401 act
._sa_handler
= old_act
->_sa_handler
;
6402 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
6403 act
.sa_flags
= old_act
->sa_flags
;
6404 unlock_user_struct(old_act
, arg2
, 0);
6410 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
6412 if (!is_error(ret
) && arg3
) {
6413 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
6415 old_act
->_sa_handler
= oact
._sa_handler
;
6416 old_act
->sa_flags
= oact
.sa_flags
;
6417 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
6418 old_act
->sa_mask
.sig
[1] = 0;
6419 old_act
->sa_mask
.sig
[2] = 0;
6420 old_act
->sa_mask
.sig
[3] = 0;
6421 unlock_user_struct(old_act
, arg3
, 1);
6424 struct target_old_sigaction
*old_act
;
6425 struct target_sigaction act
, oact
, *pact
;
6427 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
6429 act
._sa_handler
= old_act
->_sa_handler
;
6430 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
6431 act
.sa_flags
= old_act
->sa_flags
;
6432 act
.sa_restorer
= old_act
->sa_restorer
;
6433 unlock_user_struct(old_act
, arg2
, 0);
6438 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
6439 if (!is_error(ret
) && arg3
) {
6440 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
6442 old_act
->_sa_handler
= oact
._sa_handler
;
6443 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
6444 old_act
->sa_flags
= oact
.sa_flags
;
6445 old_act
->sa_restorer
= oact
.sa_restorer
;
6446 unlock_user_struct(old_act
, arg3
, 1);
6452 case TARGET_NR_rt_sigaction
:
6454 #if defined(TARGET_ALPHA)
6455 struct target_sigaction act
, oact
, *pact
= 0;
6456 struct target_rt_sigaction
*rt_act
;
6457 /* ??? arg4 == sizeof(sigset_t). */
6459 if (!lock_user_struct(VERIFY_READ
, rt_act
, arg2
, 1))
6461 act
._sa_handler
= rt_act
->_sa_handler
;
6462 act
.sa_mask
= rt_act
->sa_mask
;
6463 act
.sa_flags
= rt_act
->sa_flags
;
6464 act
.sa_restorer
= arg5
;
6465 unlock_user_struct(rt_act
, arg2
, 0);
6468 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
6469 if (!is_error(ret
) && arg3
) {
6470 if (!lock_user_struct(VERIFY_WRITE
, rt_act
, arg3
, 0))
6472 rt_act
->_sa_handler
= oact
._sa_handler
;
6473 rt_act
->sa_mask
= oact
.sa_mask
;
6474 rt_act
->sa_flags
= oact
.sa_flags
;
6475 unlock_user_struct(rt_act
, arg3
, 1);
6478 struct target_sigaction
*act
;
6479 struct target_sigaction
*oact
;
6482 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1))
6487 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
6488 ret
= -TARGET_EFAULT
;
6489 goto rt_sigaction_fail
;
6493 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
6496 unlock_user_struct(act
, arg2
, 0);
6498 unlock_user_struct(oact
, arg3
, 1);
6502 #ifdef TARGET_NR_sgetmask /* not on alpha */
6503 case TARGET_NR_sgetmask
:
6506 abi_ulong target_set
;
6507 do_sigprocmask(0, NULL
, &cur_set
);
6508 host_to_target_old_sigset(&target_set
, &cur_set
);
6513 #ifdef TARGET_NR_ssetmask /* not on alpha */
6514 case TARGET_NR_ssetmask
:
6516 sigset_t set
, oset
, cur_set
;
6517 abi_ulong target_set
= arg1
;
6518 do_sigprocmask(0, NULL
, &cur_set
);
6519 target_to_host_old_sigset(&set
, &target_set
);
6520 sigorset(&set
, &set
, &cur_set
);
6521 do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
6522 host_to_target_old_sigset(&target_set
, &oset
);
6527 #ifdef TARGET_NR_sigprocmask
6528 case TARGET_NR_sigprocmask
:
6530 #if defined(TARGET_ALPHA)
6531 sigset_t set
, oldset
;
6536 case TARGET_SIG_BLOCK
:
6539 case TARGET_SIG_UNBLOCK
:
6542 case TARGET_SIG_SETMASK
:
6546 ret
= -TARGET_EINVAL
;
6550 target_to_host_old_sigset(&set
, &mask
);
6552 ret
= get_errno(do_sigprocmask(how
, &set
, &oldset
));
6553 if (!is_error(ret
)) {
6554 host_to_target_old_sigset(&mask
, &oldset
);
6556 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0; /* force no error */
6559 sigset_t set
, oldset
, *set_ptr
;
6564 case TARGET_SIG_BLOCK
:
6567 case TARGET_SIG_UNBLOCK
:
6570 case TARGET_SIG_SETMASK
:
6574 ret
= -TARGET_EINVAL
;
6577 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
6579 target_to_host_old_sigset(&set
, p
);
6580 unlock_user(p
, arg2
, 0);
6586 ret
= get_errno(do_sigprocmask(how
, set_ptr
, &oldset
));
6587 if (!is_error(ret
) && arg3
) {
6588 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
6590 host_to_target_old_sigset(p
, &oldset
);
6591 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
6597 case TARGET_NR_rt_sigprocmask
:
6600 sigset_t set
, oldset
, *set_ptr
;
6604 case TARGET_SIG_BLOCK
:
6607 case TARGET_SIG_UNBLOCK
:
6610 case TARGET_SIG_SETMASK
:
6614 ret
= -TARGET_EINVAL
;
6617 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
6619 target_to_host_sigset(&set
, p
);
6620 unlock_user(p
, arg2
, 0);
6626 ret
= get_errno(do_sigprocmask(how
, set_ptr
, &oldset
));
6627 if (!is_error(ret
) && arg3
) {
6628 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
6630 host_to_target_sigset(p
, &oldset
);
6631 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
6635 #ifdef TARGET_NR_sigpending
6636 case TARGET_NR_sigpending
:
6639 ret
= get_errno(sigpending(&set
));
6640 if (!is_error(ret
)) {
6641 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
6643 host_to_target_old_sigset(p
, &set
);
6644 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
6649 case TARGET_NR_rt_sigpending
:
6652 ret
= get_errno(sigpending(&set
));
6653 if (!is_error(ret
)) {
6654 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
6656 host_to_target_sigset(p
, &set
);
6657 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
6661 #ifdef TARGET_NR_sigsuspend
6662 case TARGET_NR_sigsuspend
:
6665 #if defined(TARGET_ALPHA)
6666 abi_ulong mask
= arg1
;
6667 target_to_host_old_sigset(&set
, &mask
);
6669 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
6671 target_to_host_old_sigset(&set
, p
);
6672 unlock_user(p
, arg1
, 0);
6674 ret
= get_errno(sigsuspend(&set
));
6678 case TARGET_NR_rt_sigsuspend
:
6681 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
6683 target_to_host_sigset(&set
, p
);
6684 unlock_user(p
, arg1
, 0);
6685 ret
= get_errno(sigsuspend(&set
));
6688 case TARGET_NR_rt_sigtimedwait
:
6691 struct timespec uts
, *puts
;
6694 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
6696 target_to_host_sigset(&set
, p
);
6697 unlock_user(p
, arg1
, 0);
6700 target_to_host_timespec(puts
, arg3
);
6704 ret
= get_errno(sigtimedwait(&set
, &uinfo
, puts
));
6705 if (!is_error(ret
)) {
6707 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
6712 host_to_target_siginfo(p
, &uinfo
);
6713 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
6715 ret
= host_to_target_signal(ret
);
6719 case TARGET_NR_rt_sigqueueinfo
:
6722 if (!(p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_sigset_t
), 1)))
6724 target_to_host_siginfo(&uinfo
, p
);
6725 unlock_user(p
, arg1
, 0);
6726 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
6729 #ifdef TARGET_NR_sigreturn
6730 case TARGET_NR_sigreturn
:
6731 /* NOTE: ret is eax, so not transcoding must be done */
6732 ret
= do_sigreturn(cpu_env
);
6735 case TARGET_NR_rt_sigreturn
:
6736 /* NOTE: ret is eax, so not transcoding must be done */
6737 ret
= do_rt_sigreturn(cpu_env
);
6739 case TARGET_NR_sethostname
:
6740 if (!(p
= lock_user_string(arg1
)))
6742 ret
= get_errno(sethostname(p
, arg2
));
6743 unlock_user(p
, arg1
, 0);
6745 case TARGET_NR_setrlimit
:
6747 int resource
= target_to_host_resource(arg1
);
6748 struct target_rlimit
*target_rlim
;
6750 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
6752 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
6753 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
6754 unlock_user_struct(target_rlim
, arg2
, 0);
6755 ret
= get_errno(setrlimit(resource
, &rlim
));
6758 case TARGET_NR_getrlimit
:
6760 int resource
= target_to_host_resource(arg1
);
6761 struct target_rlimit
*target_rlim
;
6764 ret
= get_errno(getrlimit(resource
, &rlim
));
6765 if (!is_error(ret
)) {
6766 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
6768 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
6769 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
6770 unlock_user_struct(target_rlim
, arg2
, 1);
6774 case TARGET_NR_getrusage
:
6776 struct rusage rusage
;
6777 ret
= get_errno(getrusage(arg1
, &rusage
));
6778 if (!is_error(ret
)) {
6779 ret
= host_to_target_rusage(arg2
, &rusage
);
6783 case TARGET_NR_gettimeofday
:
6786 ret
= get_errno(gettimeofday(&tv
, NULL
));
6787 if (!is_error(ret
)) {
6788 if (copy_to_user_timeval(arg1
, &tv
))
6793 case TARGET_NR_settimeofday
:
6795 struct timeval tv
, *ptv
= NULL
;
6796 struct timezone tz
, *ptz
= NULL
;
6799 if (copy_from_user_timeval(&tv
, arg1
)) {
6806 if (copy_from_user_timezone(&tz
, arg2
)) {
6812 ret
= get_errno(settimeofday(ptv
, ptz
));
6815 #if defined(TARGET_NR_select)
6816 case TARGET_NR_select
:
6817 #if defined(TARGET_S390X) || defined(TARGET_ALPHA)
6818 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
6821 struct target_sel_arg_struct
*sel
;
6822 abi_ulong inp
, outp
, exp
, tvp
;
6825 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1))
6827 nsel
= tswapal(sel
->n
);
6828 inp
= tswapal(sel
->inp
);
6829 outp
= tswapal(sel
->outp
);
6830 exp
= tswapal(sel
->exp
);
6831 tvp
= tswapal(sel
->tvp
);
6832 unlock_user_struct(sel
, arg1
, 0);
6833 ret
= do_select(nsel
, inp
, outp
, exp
, tvp
);
6838 #ifdef TARGET_NR_pselect6
6839 case TARGET_NR_pselect6
:
6841 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
6842 fd_set rfds
, wfds
, efds
;
6843 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
6844 struct timespec ts
, *ts_ptr
;
6847 * The 6th arg is actually two args smashed together,
6848 * so we cannot use the C library.
6856 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
6857 target_sigset_t
*target_sigset
;
6865 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
6869 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
6873 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
6879 * This takes a timespec, and not a timeval, so we cannot
6880 * use the do_select() helper ...
6883 if (target_to_host_timespec(&ts
, ts_addr
)) {
6891 /* Extract the two packed args for the sigset */
6894 sig
.size
= _NSIG
/ 8;
6896 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
6900 arg_sigset
= tswapal(arg7
[0]);
6901 arg_sigsize
= tswapal(arg7
[1]);
6902 unlock_user(arg7
, arg6
, 0);
6906 if (arg_sigsize
!= sizeof(*target_sigset
)) {
6907 /* Like the kernel, we enforce correct size sigsets */
6908 ret
= -TARGET_EINVAL
;
6911 target_sigset
= lock_user(VERIFY_READ
, arg_sigset
,
6912 sizeof(*target_sigset
), 1);
6913 if (!target_sigset
) {
6916 target_to_host_sigset(&set
, target_sigset
);
6917 unlock_user(target_sigset
, arg_sigset
, 0);
6925 ret
= get_errno(sys_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
6928 if (!is_error(ret
)) {
6929 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
6931 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
6933 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
6936 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
))
6942 #ifdef TARGET_NR_symlink
6943 case TARGET_NR_symlink
:
6946 p
= lock_user_string(arg1
);
6947 p2
= lock_user_string(arg2
);
6949 ret
= -TARGET_EFAULT
;
6951 ret
= get_errno(symlink(p
, p2
));
6952 unlock_user(p2
, arg2
, 0);
6953 unlock_user(p
, arg1
, 0);
6957 #if defined(TARGET_NR_symlinkat)
6958 case TARGET_NR_symlinkat
:
6961 p
= lock_user_string(arg1
);
6962 p2
= lock_user_string(arg3
);
6964 ret
= -TARGET_EFAULT
;
6966 ret
= get_errno(symlinkat(p
, arg2
, p2
));
6967 unlock_user(p2
, arg3
, 0);
6968 unlock_user(p
, arg1
, 0);
6972 #ifdef TARGET_NR_oldlstat
6973 case TARGET_NR_oldlstat
:
6976 #ifdef TARGET_NR_readlink
6977 case TARGET_NR_readlink
:
6980 p
= lock_user_string(arg1
);
6981 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
6983 ret
= -TARGET_EFAULT
;
6985 /* Short circuit this for the magic exe check. */
6986 ret
= -TARGET_EINVAL
;
6987 } else if (is_proc_myself((const char *)p
, "exe")) {
6988 char real
[PATH_MAX
], *temp
;
6989 temp
= realpath(exec_path
, real
);
6990 /* Return value is # of bytes that we wrote to the buffer. */
6992 ret
= get_errno(-1);
6994 /* Don't worry about sign mismatch as earlier mapping
6995 * logic would have thrown a bad address error. */
6996 ret
= MIN(strlen(real
), arg3
);
6997 /* We cannot NUL terminate the string. */
6998 memcpy(p2
, real
, ret
);
7001 ret
= get_errno(readlink(path(p
), p2
, arg3
));
7003 unlock_user(p2
, arg2
, ret
);
7004 unlock_user(p
, arg1
, 0);
7008 #if defined(TARGET_NR_readlinkat)
7009 case TARGET_NR_readlinkat
:
7012 p
= lock_user_string(arg2
);
7013 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
7015 ret
= -TARGET_EFAULT
;
7016 } else if (is_proc_myself((const char *)p
, "exe")) {
7017 char real
[PATH_MAX
], *temp
;
7018 temp
= realpath(exec_path
, real
);
7019 ret
= temp
== NULL
? get_errno(-1) : strlen(real
) ;
7020 snprintf((char *)p2
, arg4
, "%s", real
);
7022 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
7024 unlock_user(p2
, arg3
, ret
);
7025 unlock_user(p
, arg2
, 0);
7029 #ifdef TARGET_NR_uselib
7030 case TARGET_NR_uselib
:
7033 #ifdef TARGET_NR_swapon
7034 case TARGET_NR_swapon
:
7035 if (!(p
= lock_user_string(arg1
)))
7037 ret
= get_errno(swapon(p
, arg2
));
7038 unlock_user(p
, arg1
, 0);
7041 case TARGET_NR_reboot
:
7042 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
7043 /* arg4 must be ignored in all other cases */
7044 p
= lock_user_string(arg4
);
7048 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
7049 unlock_user(p
, arg4
, 0);
7051 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
7054 #ifdef TARGET_NR_readdir
7055 case TARGET_NR_readdir
:
7058 #ifdef TARGET_NR_mmap
7059 case TARGET_NR_mmap
:
7060 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
7061 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
7062 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
7063 || defined(TARGET_S390X)
7066 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
7067 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
7075 unlock_user(v
, arg1
, 0);
7076 ret
= get_errno(target_mmap(v1
, v2
, v3
,
7077 target_to_host_bitmask(v4
, mmap_flags_tbl
),
7081 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
7082 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
7088 #ifdef TARGET_NR_mmap2
7089 case TARGET_NR_mmap2
:
7091 #define MMAP_SHIFT 12
7093 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
7094 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
7096 arg6
<< MMAP_SHIFT
));
7099 case TARGET_NR_munmap
:
7100 ret
= get_errno(target_munmap(arg1
, arg2
));
7102 case TARGET_NR_mprotect
:
7104 TaskState
*ts
= cpu
->opaque
;
7105 /* Special hack to detect libc making the stack executable. */
7106 if ((arg3
& PROT_GROWSDOWN
)
7107 && arg1
>= ts
->info
->stack_limit
7108 && arg1
<= ts
->info
->start_stack
) {
7109 arg3
&= ~PROT_GROWSDOWN
;
7110 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
7111 arg1
= ts
->info
->stack_limit
;
7114 ret
= get_errno(target_mprotect(arg1
, arg2
, arg3
));
7116 #ifdef TARGET_NR_mremap
7117 case TARGET_NR_mremap
:
7118 ret
= get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
7121 /* ??? msync/mlock/munlock are broken for softmmu. */
7122 #ifdef TARGET_NR_msync
7123 case TARGET_NR_msync
:
7124 ret
= get_errno(msync(g2h(arg1
), arg2
, arg3
));
7127 #ifdef TARGET_NR_mlock
7128 case TARGET_NR_mlock
:
7129 ret
= get_errno(mlock(g2h(arg1
), arg2
));
7132 #ifdef TARGET_NR_munlock
7133 case TARGET_NR_munlock
:
7134 ret
= get_errno(munlock(g2h(arg1
), arg2
));
7137 #ifdef TARGET_NR_mlockall
7138 case TARGET_NR_mlockall
:
7139 ret
= get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
7142 #ifdef TARGET_NR_munlockall
7143 case TARGET_NR_munlockall
:
7144 ret
= get_errno(munlockall());
7147 case TARGET_NR_truncate
:
7148 if (!(p
= lock_user_string(arg1
)))
7150 ret
= get_errno(truncate(p
, arg2
));
7151 unlock_user(p
, arg1
, 0);
7153 case TARGET_NR_ftruncate
:
7154 ret
= get_errno(ftruncate(arg1
, arg2
));
7156 case TARGET_NR_fchmod
:
7157 ret
= get_errno(fchmod(arg1
, arg2
));
7159 #if defined(TARGET_NR_fchmodat)
7160 case TARGET_NR_fchmodat
:
7161 if (!(p
= lock_user_string(arg2
)))
7163 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
7164 unlock_user(p
, arg2
, 0);
7167 case TARGET_NR_getpriority
:
7168 /* Note that negative values are valid for getpriority, so we must
7169 differentiate based on errno settings. */
7171 ret
= getpriority(arg1
, arg2
);
7172 if (ret
== -1 && errno
!= 0) {
7173 ret
= -host_to_target_errno(errno
);
7177 /* Return value is the unbiased priority. Signal no error. */
7178 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0;
7180 /* Return value is a biased priority to avoid negative numbers. */
7184 case TARGET_NR_setpriority
:
7185 ret
= get_errno(setpriority(arg1
, arg2
, arg3
));
7187 #ifdef TARGET_NR_profil
7188 case TARGET_NR_profil
:
7191 case TARGET_NR_statfs
:
7192 if (!(p
= lock_user_string(arg1
)))
7194 ret
= get_errno(statfs(path(p
), &stfs
));
7195 unlock_user(p
, arg1
, 0);
7197 if (!is_error(ret
)) {
7198 struct target_statfs
*target_stfs
;
7200 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
7202 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
7203 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
7204 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
7205 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
7206 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
7207 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
7208 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
7209 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
7210 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
7211 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
7212 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
7213 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
7214 unlock_user_struct(target_stfs
, arg2
, 1);
7217 case TARGET_NR_fstatfs
:
7218 ret
= get_errno(fstatfs(arg1
, &stfs
));
7219 goto convert_statfs
;
7220 #ifdef TARGET_NR_statfs64
7221 case TARGET_NR_statfs64
:
7222 if (!(p
= lock_user_string(arg1
)))
7224 ret
= get_errno(statfs(path(p
), &stfs
));
7225 unlock_user(p
, arg1
, 0);
7227 if (!is_error(ret
)) {
7228 struct target_statfs64
*target_stfs
;
7230 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
7232 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
7233 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
7234 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
7235 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
7236 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
7237 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
7238 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
7239 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
7240 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
7241 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
7242 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
7243 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
7244 unlock_user_struct(target_stfs
, arg3
, 1);
7247 case TARGET_NR_fstatfs64
:
7248 ret
= get_errno(fstatfs(arg1
, &stfs
));
7249 goto convert_statfs64
;
7251 #ifdef TARGET_NR_ioperm
7252 case TARGET_NR_ioperm
:
7255 #ifdef TARGET_NR_socketcall
7256 case TARGET_NR_socketcall
:
7257 ret
= do_socketcall(arg1
, arg2
);
7260 #ifdef TARGET_NR_accept
7261 case TARGET_NR_accept
:
7262 ret
= do_accept4(arg1
, arg2
, arg3
, 0);
7265 #ifdef TARGET_NR_accept4
7266 case TARGET_NR_accept4
:
7267 #ifdef CONFIG_ACCEPT4
7268 ret
= do_accept4(arg1
, arg2
, arg3
, arg4
);
7274 #ifdef TARGET_NR_bind
7275 case TARGET_NR_bind
:
7276 ret
= do_bind(arg1
, arg2
, arg3
);
7279 #ifdef TARGET_NR_connect
7280 case TARGET_NR_connect
:
7281 ret
= do_connect(arg1
, arg2
, arg3
);
7284 #ifdef TARGET_NR_getpeername
7285 case TARGET_NR_getpeername
:
7286 ret
= do_getpeername(arg1
, arg2
, arg3
);
7289 #ifdef TARGET_NR_getsockname
7290 case TARGET_NR_getsockname
:
7291 ret
= do_getsockname(arg1
, arg2
, arg3
);
7294 #ifdef TARGET_NR_getsockopt
7295 case TARGET_NR_getsockopt
:
7296 ret
= do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
7299 #ifdef TARGET_NR_listen
7300 case TARGET_NR_listen
:
7301 ret
= get_errno(listen(arg1
, arg2
));
7304 #ifdef TARGET_NR_recv
7305 case TARGET_NR_recv
:
7306 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
7309 #ifdef TARGET_NR_recvfrom
7310 case TARGET_NR_recvfrom
:
7311 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
7314 #ifdef TARGET_NR_recvmsg
7315 case TARGET_NR_recvmsg
:
7316 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
7319 #ifdef TARGET_NR_send
7320 case TARGET_NR_send
:
7321 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
7324 #ifdef TARGET_NR_sendmsg
7325 case TARGET_NR_sendmsg
:
7326 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
7329 #ifdef TARGET_NR_sendmmsg
7330 case TARGET_NR_sendmmsg
:
7331 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
7333 case TARGET_NR_recvmmsg
:
7334 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
7337 #ifdef TARGET_NR_sendto
7338 case TARGET_NR_sendto
:
7339 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
7342 #ifdef TARGET_NR_shutdown
7343 case TARGET_NR_shutdown
:
7344 ret
= get_errno(shutdown(arg1
, arg2
));
7347 #ifdef TARGET_NR_socket
7348 case TARGET_NR_socket
:
7349 ret
= do_socket(arg1
, arg2
, arg3
);
7352 #ifdef TARGET_NR_socketpair
7353 case TARGET_NR_socketpair
:
7354 ret
= do_socketpair(arg1
, arg2
, arg3
, arg4
);
7357 #ifdef TARGET_NR_setsockopt
7358 case TARGET_NR_setsockopt
:
7359 ret
= do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
7363 case TARGET_NR_syslog
:
7364 if (!(p
= lock_user_string(arg2
)))
7366 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
7367 unlock_user(p
, arg2
, 0);
7370 case TARGET_NR_setitimer
:
7372 struct itimerval value
, ovalue
, *pvalue
;
7376 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
7377 || copy_from_user_timeval(&pvalue
->it_value
,
7378 arg2
+ sizeof(struct target_timeval
)))
7383 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
7384 if (!is_error(ret
) && arg3
) {
7385 if (copy_to_user_timeval(arg3
,
7386 &ovalue
.it_interval
)
7387 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
7393 case TARGET_NR_getitimer
:
7395 struct itimerval value
;
7397 ret
= get_errno(getitimer(arg1
, &value
));
7398 if (!is_error(ret
) && arg2
) {
7399 if (copy_to_user_timeval(arg2
,
7401 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
7407 #ifdef TARGET_NR_stat
7408 case TARGET_NR_stat
:
7409 if (!(p
= lock_user_string(arg1
)))
7411 ret
= get_errno(stat(path(p
), &st
));
7412 unlock_user(p
, arg1
, 0);
7415 #ifdef TARGET_NR_lstat
7416 case TARGET_NR_lstat
:
7417 if (!(p
= lock_user_string(arg1
)))
7419 ret
= get_errno(lstat(path(p
), &st
));
7420 unlock_user(p
, arg1
, 0);
7423 case TARGET_NR_fstat
:
7425 ret
= get_errno(fstat(arg1
, &st
));
7426 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
7429 if (!is_error(ret
)) {
7430 struct target_stat
*target_st
;
7432 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
7434 memset(target_st
, 0, sizeof(*target_st
));
7435 __put_user(st
.st_dev
, &target_st
->st_dev
);
7436 __put_user(st
.st_ino
, &target_st
->st_ino
);
7437 __put_user(st
.st_mode
, &target_st
->st_mode
);
7438 __put_user(st
.st_uid
, &target_st
->st_uid
);
7439 __put_user(st
.st_gid
, &target_st
->st_gid
);
7440 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
7441 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
7442 __put_user(st
.st_size
, &target_st
->st_size
);
7443 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
7444 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
7445 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
7446 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
7447 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
7448 unlock_user_struct(target_st
, arg2
, 1);
7452 #ifdef TARGET_NR_olduname
7453 case TARGET_NR_olduname
:
7456 #ifdef TARGET_NR_iopl
7457 case TARGET_NR_iopl
:
7460 case TARGET_NR_vhangup
:
7461 ret
= get_errno(vhangup());
7463 #ifdef TARGET_NR_idle
7464 case TARGET_NR_idle
:
7467 #ifdef TARGET_NR_syscall
7468 case TARGET_NR_syscall
:
7469 ret
= do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
7470 arg6
, arg7
, arg8
, 0);
7473 case TARGET_NR_wait4
:
7476 abi_long status_ptr
= arg2
;
7477 struct rusage rusage
, *rusage_ptr
;
7478 abi_ulong target_rusage
= arg4
;
7479 abi_long rusage_err
;
7481 rusage_ptr
= &rusage
;
7484 ret
= get_errno(wait4(arg1
, &status
, arg3
, rusage_ptr
));
7485 if (!is_error(ret
)) {
7486 if (status_ptr
&& ret
) {
7487 status
= host_to_target_waitstatus(status
);
7488 if (put_user_s32(status
, status_ptr
))
7491 if (target_rusage
) {
7492 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
7500 #ifdef TARGET_NR_swapoff
7501 case TARGET_NR_swapoff
:
7502 if (!(p
= lock_user_string(arg1
)))
7504 ret
= get_errno(swapoff(p
));
7505 unlock_user(p
, arg1
, 0);
7508 case TARGET_NR_sysinfo
:
7510 struct target_sysinfo
*target_value
;
7511 struct sysinfo value
;
7512 ret
= get_errno(sysinfo(&value
));
7513 if (!is_error(ret
) && arg1
)
7515 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
7517 __put_user(value
.uptime
, &target_value
->uptime
);
7518 __put_user(value
.loads
[0], &target_value
->loads
[0]);
7519 __put_user(value
.loads
[1], &target_value
->loads
[1]);
7520 __put_user(value
.loads
[2], &target_value
->loads
[2]);
7521 __put_user(value
.totalram
, &target_value
->totalram
);
7522 __put_user(value
.freeram
, &target_value
->freeram
);
7523 __put_user(value
.sharedram
, &target_value
->sharedram
);
7524 __put_user(value
.bufferram
, &target_value
->bufferram
);
7525 __put_user(value
.totalswap
, &target_value
->totalswap
);
7526 __put_user(value
.freeswap
, &target_value
->freeswap
);
7527 __put_user(value
.procs
, &target_value
->procs
);
7528 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
7529 __put_user(value
.freehigh
, &target_value
->freehigh
);
7530 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
7531 unlock_user_struct(target_value
, arg1
, 1);
7535 #ifdef TARGET_NR_ipc
7537 ret
= do_ipc(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
7540 #ifdef TARGET_NR_semget
7541 case TARGET_NR_semget
:
7542 ret
= get_errno(semget(arg1
, arg2
, arg3
));
7545 #ifdef TARGET_NR_semop
7546 case TARGET_NR_semop
:
7547 ret
= do_semop(arg1
, arg2
, arg3
);
7550 #ifdef TARGET_NR_semctl
7551 case TARGET_NR_semctl
:
7552 ret
= do_semctl(arg1
, arg2
, arg3
, (union target_semun
)(abi_ulong
)arg4
);
7555 #ifdef TARGET_NR_msgctl
7556 case TARGET_NR_msgctl
:
7557 ret
= do_msgctl(arg1
, arg2
, arg3
);
7560 #ifdef TARGET_NR_msgget
7561 case TARGET_NR_msgget
:
7562 ret
= get_errno(msgget(arg1
, arg2
));
7565 #ifdef TARGET_NR_msgrcv
7566 case TARGET_NR_msgrcv
:
7567 ret
= do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
7570 #ifdef TARGET_NR_msgsnd
7571 case TARGET_NR_msgsnd
:
7572 ret
= do_msgsnd(arg1
, arg2
, arg3
, arg4
);
7575 #ifdef TARGET_NR_shmget
7576 case TARGET_NR_shmget
:
7577 ret
= get_errno(shmget(arg1
, arg2
, arg3
));
7580 #ifdef TARGET_NR_shmctl
7581 case TARGET_NR_shmctl
:
7582 ret
= do_shmctl(arg1
, arg2
, arg3
);
7585 #ifdef TARGET_NR_shmat
7586 case TARGET_NR_shmat
:
7587 ret
= do_shmat(arg1
, arg2
, arg3
);
7590 #ifdef TARGET_NR_shmdt
7591 case TARGET_NR_shmdt
:
7592 ret
= do_shmdt(arg1
);
7595 case TARGET_NR_fsync
:
7596 ret
= get_errno(fsync(arg1
));
7598 case TARGET_NR_clone
:
7599 /* Linux manages to have three different orderings for its
7600 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
7601 * match the kernel's CONFIG_CLONE_* settings.
7602 * Microblaze is further special in that it uses a sixth
7603 * implicit argument to clone for the TLS pointer.
7605 #if defined(TARGET_MICROBLAZE)
7606 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
7607 #elif defined(TARGET_CLONE_BACKWARDS)
7608 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
7609 #elif defined(TARGET_CLONE_BACKWARDS2)
7610 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
7612 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
7615 #ifdef __NR_exit_group
7616 /* new thread calls */
7617 case TARGET_NR_exit_group
:
7621 gdb_exit(cpu_env
, arg1
);
7622 ret
= get_errno(exit_group(arg1
));
7625 case TARGET_NR_setdomainname
:
7626 if (!(p
= lock_user_string(arg1
)))
7628 ret
= get_errno(setdomainname(p
, arg2
));
7629 unlock_user(p
, arg1
, 0);
7631 case TARGET_NR_uname
:
7632 /* no need to transcode because we use the linux syscall */
7634 struct new_utsname
* buf
;
7636 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
7638 ret
= get_errno(sys_uname(buf
));
7639 if (!is_error(ret
)) {
7640 /* Overrite the native machine name with whatever is being
7642 strcpy (buf
->machine
, cpu_to_uname_machine(cpu_env
));
7643 /* Allow the user to override the reported release. */
7644 if (qemu_uname_release
&& *qemu_uname_release
)
7645 strcpy (buf
->release
, qemu_uname_release
);
7647 unlock_user_struct(buf
, arg1
, 1);
7651 case TARGET_NR_modify_ldt
:
7652 ret
= do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
7654 #if !defined(TARGET_X86_64)
7655 case TARGET_NR_vm86old
:
7657 case TARGET_NR_vm86
:
7658 ret
= do_vm86(cpu_env
, arg1
, arg2
);
7662 case TARGET_NR_adjtimex
:
7664 #ifdef TARGET_NR_create_module
7665 case TARGET_NR_create_module
:
7667 case TARGET_NR_init_module
:
7668 case TARGET_NR_delete_module
:
7669 #ifdef TARGET_NR_get_kernel_syms
7670 case TARGET_NR_get_kernel_syms
:
7673 case TARGET_NR_quotactl
:
7675 case TARGET_NR_getpgid
:
7676 ret
= get_errno(getpgid(arg1
));
7678 case TARGET_NR_fchdir
:
7679 ret
= get_errno(fchdir(arg1
));
7681 #ifdef TARGET_NR_bdflush /* not on x86_64 */
7682 case TARGET_NR_bdflush
:
7685 #ifdef TARGET_NR_sysfs
7686 case TARGET_NR_sysfs
:
7689 case TARGET_NR_personality
:
7690 ret
= get_errno(personality(arg1
));
7692 #ifdef TARGET_NR_afs_syscall
7693 case TARGET_NR_afs_syscall
:
7696 #ifdef TARGET_NR__llseek /* Not on alpha */
7697 case TARGET_NR__llseek
:
7700 #if !defined(__NR_llseek)
7701 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | arg3
, arg5
);
7703 ret
= get_errno(res
);
7708 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
7710 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
7716 #ifdef TARGET_NR_getdents
7717 case TARGET_NR_getdents
:
7718 #ifdef __NR_getdents
7719 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
7721 struct target_dirent
*target_dirp
;
7722 struct linux_dirent
*dirp
;
7723 abi_long count
= arg3
;
7725 dirp
= malloc(count
);
7727 ret
= -TARGET_ENOMEM
;
7731 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
7732 if (!is_error(ret
)) {
7733 struct linux_dirent
*de
;
7734 struct target_dirent
*tde
;
7736 int reclen
, treclen
;
7737 int count1
, tnamelen
;
7741 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
7745 reclen
= de
->d_reclen
;
7746 tnamelen
= reclen
- offsetof(struct linux_dirent
, d_name
);
7747 assert(tnamelen
>= 0);
7748 treclen
= tnamelen
+ offsetof(struct target_dirent
, d_name
);
7749 assert(count1
+ treclen
<= count
);
7750 tde
->d_reclen
= tswap16(treclen
);
7751 tde
->d_ino
= tswapal(de
->d_ino
);
7752 tde
->d_off
= tswapal(de
->d_off
);
7753 memcpy(tde
->d_name
, de
->d_name
, tnamelen
);
7754 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
7756 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
7760 unlock_user(target_dirp
, arg2
, ret
);
7766 struct linux_dirent
*dirp
;
7767 abi_long count
= arg3
;
7769 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
7771 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
7772 if (!is_error(ret
)) {
7773 struct linux_dirent
*de
;
7778 reclen
= de
->d_reclen
;
7781 de
->d_reclen
= tswap16(reclen
);
7782 tswapls(&de
->d_ino
);
7783 tswapls(&de
->d_off
);
7784 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
7788 unlock_user(dirp
, arg2
, ret
);
7792 /* Implement getdents in terms of getdents64 */
7794 struct linux_dirent64
*dirp
;
7795 abi_long count
= arg3
;
7797 dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
7801 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
7802 if (!is_error(ret
)) {
7803 /* Convert the dirent64 structs to target dirent. We do this
7804 * in-place, since we can guarantee that a target_dirent is no
7805 * larger than a dirent64; however this means we have to be
7806 * careful to read everything before writing in the new format.
7808 struct linux_dirent64
*de
;
7809 struct target_dirent
*tde
;
7814 tde
= (struct target_dirent
*)dirp
;
7816 int namelen
, treclen
;
7817 int reclen
= de
->d_reclen
;
7818 uint64_t ino
= de
->d_ino
;
7819 int64_t off
= de
->d_off
;
7820 uint8_t type
= de
->d_type
;
7822 namelen
= strlen(de
->d_name
);
7823 treclen
= offsetof(struct target_dirent
, d_name
)
7825 treclen
= QEMU_ALIGN_UP(treclen
, sizeof(abi_long
));
7827 memmove(tde
->d_name
, de
->d_name
, namelen
+ 1);
7828 tde
->d_ino
= tswapal(ino
);
7829 tde
->d_off
= tswapal(off
);
7830 tde
->d_reclen
= tswap16(treclen
);
7831 /* The target_dirent type is in what was formerly a padding
7832 * byte at the end of the structure:
7834 *(((char *)tde
) + treclen
- 1) = type
;
7836 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
7837 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
7843 unlock_user(dirp
, arg2
, ret
);
7847 #endif /* TARGET_NR_getdents */
7848 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
7849 case TARGET_NR_getdents64
:
7851 struct linux_dirent64
*dirp
;
7852 abi_long count
= arg3
;
7853 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
7855 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
7856 if (!is_error(ret
)) {
7857 struct linux_dirent64
*de
;
7862 reclen
= de
->d_reclen
;
7865 de
->d_reclen
= tswap16(reclen
);
7866 tswap64s((uint64_t *)&de
->d_ino
);
7867 tswap64s((uint64_t *)&de
->d_off
);
7868 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
7872 unlock_user(dirp
, arg2
, ret
);
7875 #endif /* TARGET_NR_getdents64 */
7876 #if defined(TARGET_NR__newselect)
7877 case TARGET_NR__newselect
:
7878 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
7881 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
7882 # ifdef TARGET_NR_poll
7883 case TARGET_NR_poll
:
7885 # ifdef TARGET_NR_ppoll
7886 case TARGET_NR_ppoll
:
7889 struct target_pollfd
*target_pfd
;
7890 unsigned int nfds
= arg2
;
7895 target_pfd
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_pollfd
) * nfds
, 1);
7899 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
7900 for(i
= 0; i
< nfds
; i
++) {
7901 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
7902 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
7905 # ifdef TARGET_NR_ppoll
7906 if (num
== TARGET_NR_ppoll
) {
7907 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
7908 target_sigset_t
*target_set
;
7909 sigset_t _set
, *set
= &_set
;
7912 if (target_to_host_timespec(timeout_ts
, arg3
)) {
7913 unlock_user(target_pfd
, arg1
, 0);
7921 target_set
= lock_user(VERIFY_READ
, arg4
, sizeof(target_sigset_t
), 1);
7923 unlock_user(target_pfd
, arg1
, 0);
7926 target_to_host_sigset(set
, target_set
);
7931 ret
= get_errno(sys_ppoll(pfd
, nfds
, timeout_ts
, set
, _NSIG
/8));
7933 if (!is_error(ret
) && arg3
) {
7934 host_to_target_timespec(arg3
, timeout_ts
);
7937 unlock_user(target_set
, arg4
, 0);
7941 ret
= get_errno(poll(pfd
, nfds
, timeout
));
7943 if (!is_error(ret
)) {
7944 for(i
= 0; i
< nfds
; i
++) {
7945 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
7948 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
7952 case TARGET_NR_flock
:
7953 /* NOTE: the flock constant seems to be the same for every
7955 ret
= get_errno(flock(arg1
, arg2
));
7957 case TARGET_NR_readv
:
7959 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
7961 ret
= get_errno(readv(arg1
, vec
, arg3
));
7962 unlock_iovec(vec
, arg2
, arg3
, 1);
7964 ret
= -host_to_target_errno(errno
);
7968 case TARGET_NR_writev
:
7970 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
7972 ret
= get_errno(writev(arg1
, vec
, arg3
));
7973 unlock_iovec(vec
, arg2
, arg3
, 0);
7975 ret
= -host_to_target_errno(errno
);
7979 case TARGET_NR_getsid
:
7980 ret
= get_errno(getsid(arg1
));
7982 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
7983 case TARGET_NR_fdatasync
:
7984 ret
= get_errno(fdatasync(arg1
));
7987 #ifdef TARGET_NR__sysctl
7988 case TARGET_NR__sysctl
:
7989 /* We don't implement this, but ENOTDIR is always a safe
7991 ret
= -TARGET_ENOTDIR
;
7994 case TARGET_NR_sched_getaffinity
:
7996 unsigned int mask_size
;
7997 unsigned long *mask
;
8000 * sched_getaffinity needs multiples of ulong, so need to take
8001 * care of mismatches between target ulong and host ulong sizes.
8003 if (arg2
& (sizeof(abi_ulong
) - 1)) {
8004 ret
= -TARGET_EINVAL
;
8007 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
8009 mask
= alloca(mask_size
);
8010 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
8012 if (!is_error(ret
)) {
8014 /* More data returned than the caller's buffer will fit.
8015 * This only happens if sizeof(abi_long) < sizeof(long)
8016 * and the caller passed us a buffer holding an odd number
8017 * of abi_longs. If the host kernel is actually using the
8018 * extra 4 bytes then fail EINVAL; otherwise we can just
8019 * ignore them and only copy the interesting part.
8021 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
8022 if (numcpus
> arg2
* 8) {
8023 ret
= -TARGET_EINVAL
;
8029 if (copy_to_user(arg3
, mask
, ret
)) {
8035 case TARGET_NR_sched_setaffinity
:
8037 unsigned int mask_size
;
8038 unsigned long *mask
;
8041 * sched_setaffinity needs multiples of ulong, so need to take
8042 * care of mismatches between target ulong and host ulong sizes.
8044 if (arg2
& (sizeof(abi_ulong
) - 1)) {
8045 ret
= -TARGET_EINVAL
;
8048 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
8050 mask
= alloca(mask_size
);
8051 if (!lock_user_struct(VERIFY_READ
, p
, arg3
, 1)) {
8054 memcpy(mask
, p
, arg2
);
8055 unlock_user_struct(p
, arg2
, 0);
8057 ret
= get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
8060 case TARGET_NR_sched_setparam
:
8062 struct sched_param
*target_schp
;
8063 struct sched_param schp
;
8066 return -TARGET_EINVAL
;
8068 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
8070 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
8071 unlock_user_struct(target_schp
, arg2
, 0);
8072 ret
= get_errno(sched_setparam(arg1
, &schp
));
8075 case TARGET_NR_sched_getparam
:
8077 struct sched_param
*target_schp
;
8078 struct sched_param schp
;
8081 return -TARGET_EINVAL
;
8083 ret
= get_errno(sched_getparam(arg1
, &schp
));
8084 if (!is_error(ret
)) {
8085 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
8087 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
8088 unlock_user_struct(target_schp
, arg2
, 1);
8092 case TARGET_NR_sched_setscheduler
:
8094 struct sched_param
*target_schp
;
8095 struct sched_param schp
;
8097 return -TARGET_EINVAL
;
8099 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
8101 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
8102 unlock_user_struct(target_schp
, arg3
, 0);
8103 ret
= get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
8106 case TARGET_NR_sched_getscheduler
:
8107 ret
= get_errno(sched_getscheduler(arg1
));
8109 case TARGET_NR_sched_yield
:
8110 ret
= get_errno(sched_yield());
8112 case TARGET_NR_sched_get_priority_max
:
8113 ret
= get_errno(sched_get_priority_max(arg1
));
8115 case TARGET_NR_sched_get_priority_min
:
8116 ret
= get_errno(sched_get_priority_min(arg1
));
8118 case TARGET_NR_sched_rr_get_interval
:
8121 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
8122 if (!is_error(ret
)) {
8123 ret
= host_to_target_timespec(arg2
, &ts
);
8127 case TARGET_NR_nanosleep
:
8129 struct timespec req
, rem
;
8130 target_to_host_timespec(&req
, arg1
);
8131 ret
= get_errno(nanosleep(&req
, &rem
));
8132 if (is_error(ret
) && arg2
) {
8133 host_to_target_timespec(arg2
, &rem
);
8137 #ifdef TARGET_NR_query_module
8138 case TARGET_NR_query_module
:
8141 #ifdef TARGET_NR_nfsservctl
8142 case TARGET_NR_nfsservctl
:
8145 case TARGET_NR_prctl
:
8147 case PR_GET_PDEATHSIG
:
8150 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
8151 if (!is_error(ret
) && arg2
8152 && put_user_ual(deathsig
, arg2
)) {
8160 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
8164 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
8166 unlock_user(name
, arg2
, 16);
8171 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
8175 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
8177 unlock_user(name
, arg2
, 0);
8182 /* Most prctl options have no pointer arguments */
8183 ret
= get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
8187 #ifdef TARGET_NR_arch_prctl
8188 case TARGET_NR_arch_prctl
:
8189 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
8190 ret
= do_arch_prctl(cpu_env
, arg1
, arg2
);
8196 #ifdef TARGET_NR_pread64
8197 case TARGET_NR_pread64
:
8198 if (regpairs_aligned(cpu_env
)) {
8202 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
8204 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
8205 unlock_user(p
, arg2
, ret
);
8207 case TARGET_NR_pwrite64
:
8208 if (regpairs_aligned(cpu_env
)) {
8212 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
8214 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
8215 unlock_user(p
, arg2
, 0);
8218 case TARGET_NR_getcwd
:
8219 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
8221 ret
= get_errno(sys_getcwd1(p
, arg2
));
8222 unlock_user(p
, arg1
, ret
);
8224 case TARGET_NR_capget
:
8225 case TARGET_NR_capset
:
8227 struct target_user_cap_header
*target_header
;
8228 struct target_user_cap_data
*target_data
= NULL
;
8229 struct __user_cap_header_struct header
;
8230 struct __user_cap_data_struct data
[2];
8231 struct __user_cap_data_struct
*dataptr
= NULL
;
8232 int i
, target_datalen
;
8235 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
8238 header
.version
= tswap32(target_header
->version
);
8239 header
.pid
= tswap32(target_header
->pid
);
8241 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
8242 /* Version 2 and up takes pointer to two user_data structs */
8246 target_datalen
= sizeof(*target_data
) * data_items
;
8249 if (num
== TARGET_NR_capget
) {
8250 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
8252 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
8255 unlock_user_struct(target_header
, arg1
, 0);
8259 if (num
== TARGET_NR_capset
) {
8260 for (i
= 0; i
< data_items
; i
++) {
8261 data
[i
].effective
= tswap32(target_data
[i
].effective
);
8262 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
8263 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
8270 if (num
== TARGET_NR_capget
) {
8271 ret
= get_errno(capget(&header
, dataptr
));
8273 ret
= get_errno(capset(&header
, dataptr
));
8276 /* The kernel always updates version for both capget and capset */
8277 target_header
->version
= tswap32(header
.version
);
8278 unlock_user_struct(target_header
, arg1
, 1);
8281 if (num
== TARGET_NR_capget
) {
8282 for (i
= 0; i
< data_items
; i
++) {
8283 target_data
[i
].effective
= tswap32(data
[i
].effective
);
8284 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
8285 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
8287 unlock_user(target_data
, arg2
, target_datalen
);
8289 unlock_user(target_data
, arg2
, 0);
8294 case TARGET_NR_sigaltstack
:
8295 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
8296 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \
8297 defined(TARGET_M68K) || defined(TARGET_S390X) || defined(TARGET_OPENRISC)
8298 ret
= do_sigaltstack(arg1
, arg2
, get_sp_from_cpustate((CPUArchState
*)cpu_env
));
8304 #ifdef CONFIG_SENDFILE
8305 case TARGET_NR_sendfile
:
8310 ret
= get_user_sal(off
, arg3
);
8311 if (is_error(ret
)) {
8316 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
8317 if (!is_error(ret
) && arg3
) {
8318 abi_long ret2
= put_user_sal(off
, arg3
);
8319 if (is_error(ret2
)) {
8325 #ifdef TARGET_NR_sendfile64
8326 case TARGET_NR_sendfile64
:
8331 ret
= get_user_s64(off
, arg3
);
8332 if (is_error(ret
)) {
8337 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
8338 if (!is_error(ret
) && arg3
) {
8339 abi_long ret2
= put_user_s64(off
, arg3
);
8340 if (is_error(ret2
)) {
8348 case TARGET_NR_sendfile
:
8349 #ifdef TARGET_NR_sendfile64
8350 case TARGET_NR_sendfile64
:
8355 #ifdef TARGET_NR_getpmsg
8356 case TARGET_NR_getpmsg
:
8359 #ifdef TARGET_NR_putpmsg
8360 case TARGET_NR_putpmsg
:
8363 #ifdef TARGET_NR_vfork
8364 case TARGET_NR_vfork
:
8365 ret
= get_errno(do_fork(cpu_env
, CLONE_VFORK
| CLONE_VM
| SIGCHLD
,
8369 #ifdef TARGET_NR_ugetrlimit
8370 case TARGET_NR_ugetrlimit
:
8373 int resource
= target_to_host_resource(arg1
);
8374 ret
= get_errno(getrlimit(resource
, &rlim
));
8375 if (!is_error(ret
)) {
8376 struct target_rlimit
*target_rlim
;
8377 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
8379 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
8380 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
8381 unlock_user_struct(target_rlim
, arg2
, 1);
8386 #ifdef TARGET_NR_truncate64
8387 case TARGET_NR_truncate64
:
8388 if (!(p
= lock_user_string(arg1
)))
8390 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
8391 unlock_user(p
, arg1
, 0);
8394 #ifdef TARGET_NR_ftruncate64
8395 case TARGET_NR_ftruncate64
:
8396 ret
= target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
8399 #ifdef TARGET_NR_stat64
8400 case TARGET_NR_stat64
:
8401 if (!(p
= lock_user_string(arg1
)))
8403 ret
= get_errno(stat(path(p
), &st
));
8404 unlock_user(p
, arg1
, 0);
8406 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
8409 #ifdef TARGET_NR_lstat64
8410 case TARGET_NR_lstat64
:
8411 if (!(p
= lock_user_string(arg1
)))
8413 ret
= get_errno(lstat(path(p
), &st
));
8414 unlock_user(p
, arg1
, 0);
8416 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
8419 #ifdef TARGET_NR_fstat64
8420 case TARGET_NR_fstat64
:
8421 ret
= get_errno(fstat(arg1
, &st
));
8423 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
8426 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
8427 #ifdef TARGET_NR_fstatat64
8428 case TARGET_NR_fstatat64
:
8430 #ifdef TARGET_NR_newfstatat
8431 case TARGET_NR_newfstatat
:
8433 if (!(p
= lock_user_string(arg2
)))
8435 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
8437 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
8440 #ifdef TARGET_NR_lchown
8441 case TARGET_NR_lchown
:
8442 if (!(p
= lock_user_string(arg1
)))
8444 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
8445 unlock_user(p
, arg1
, 0);
8448 #ifdef TARGET_NR_getuid
8449 case TARGET_NR_getuid
:
8450 ret
= get_errno(high2lowuid(getuid()));
8453 #ifdef TARGET_NR_getgid
8454 case TARGET_NR_getgid
:
8455 ret
= get_errno(high2lowgid(getgid()));
8458 #ifdef TARGET_NR_geteuid
8459 case TARGET_NR_geteuid
:
8460 ret
= get_errno(high2lowuid(geteuid()));
8463 #ifdef TARGET_NR_getegid
8464 case TARGET_NR_getegid
:
8465 ret
= get_errno(high2lowgid(getegid()));
8468 case TARGET_NR_setreuid
:
8469 ret
= get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
8471 case TARGET_NR_setregid
:
8472 ret
= get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
8474 case TARGET_NR_getgroups
:
8476 int gidsetsize
= arg1
;
8477 target_id
*target_grouplist
;
8481 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
8482 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
8483 if (gidsetsize
== 0)
8485 if (!is_error(ret
)) {
8486 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* sizeof(target_id
), 0);
8487 if (!target_grouplist
)
8489 for(i
= 0;i
< ret
; i
++)
8490 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
8491 unlock_user(target_grouplist
, arg2
, gidsetsize
* sizeof(target_id
));
8495 case TARGET_NR_setgroups
:
8497 int gidsetsize
= arg1
;
8498 target_id
*target_grouplist
;
8499 gid_t
*grouplist
= NULL
;
8502 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
8503 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* sizeof(target_id
), 1);
8504 if (!target_grouplist
) {
8505 ret
= -TARGET_EFAULT
;
8508 for (i
= 0; i
< gidsetsize
; i
++) {
8509 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
8511 unlock_user(target_grouplist
, arg2
, 0);
8513 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
8516 case TARGET_NR_fchown
:
8517 ret
= get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
8519 #if defined(TARGET_NR_fchownat)
8520 case TARGET_NR_fchownat
:
8521 if (!(p
= lock_user_string(arg2
)))
8523 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
8524 low2highgid(arg4
), arg5
));
8525 unlock_user(p
, arg2
, 0);
8528 #ifdef TARGET_NR_setresuid
8529 case TARGET_NR_setresuid
:
8530 ret
= get_errno(setresuid(low2highuid(arg1
),
8532 low2highuid(arg3
)));
8535 #ifdef TARGET_NR_getresuid
8536 case TARGET_NR_getresuid
:
8538 uid_t ruid
, euid
, suid
;
8539 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
8540 if (!is_error(ret
)) {
8541 if (put_user_id(high2lowuid(ruid
), arg1
)
8542 || put_user_id(high2lowuid(euid
), arg2
)
8543 || put_user_id(high2lowuid(suid
), arg3
))
8549 #ifdef TARGET_NR_getresgid
8550 case TARGET_NR_setresgid
:
8551 ret
= get_errno(setresgid(low2highgid(arg1
),
8553 low2highgid(arg3
)));
8556 #ifdef TARGET_NR_getresgid
8557 case TARGET_NR_getresgid
:
8559 gid_t rgid
, egid
, sgid
;
8560 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
8561 if (!is_error(ret
)) {
8562 if (put_user_id(high2lowgid(rgid
), arg1
)
8563 || put_user_id(high2lowgid(egid
), arg2
)
8564 || put_user_id(high2lowgid(sgid
), arg3
))
8570 #ifdef TARGET_NR_chown
8571 case TARGET_NR_chown
:
8572 if (!(p
= lock_user_string(arg1
)))
8574 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
8575 unlock_user(p
, arg1
, 0);
8578 case TARGET_NR_setuid
:
8579 ret
= get_errno(setuid(low2highuid(arg1
)));
8581 case TARGET_NR_setgid
:
8582 ret
= get_errno(setgid(low2highgid(arg1
)));
8584 case TARGET_NR_setfsuid
:
8585 ret
= get_errno(setfsuid(arg1
));
8587 case TARGET_NR_setfsgid
:
8588 ret
= get_errno(setfsgid(arg1
));
8591 #ifdef TARGET_NR_lchown32
8592 case TARGET_NR_lchown32
:
8593 if (!(p
= lock_user_string(arg1
)))
8595 ret
= get_errno(lchown(p
, arg2
, arg3
));
8596 unlock_user(p
, arg1
, 0);
8599 #ifdef TARGET_NR_getuid32
8600 case TARGET_NR_getuid32
:
8601 ret
= get_errno(getuid());
8605 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
8606 /* Alpha specific */
8607 case TARGET_NR_getxuid
:
8611 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=euid
;
8613 ret
= get_errno(getuid());
8616 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
8617 /* Alpha specific */
8618 case TARGET_NR_getxgid
:
8622 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=egid
;
8624 ret
= get_errno(getgid());
8627 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
8628 /* Alpha specific */
8629 case TARGET_NR_osf_getsysinfo
:
8630 ret
= -TARGET_EOPNOTSUPP
;
8632 case TARGET_GSI_IEEE_FP_CONTROL
:
8634 uint64_t swcr
, fpcr
= cpu_alpha_load_fpcr (cpu_env
);
8636 /* Copied from linux ieee_fpcr_to_swcr. */
8637 swcr
= (fpcr
>> 35) & SWCR_STATUS_MASK
;
8638 swcr
|= (fpcr
>> 36) & SWCR_MAP_DMZ
;
8639 swcr
|= (~fpcr
>> 48) & (SWCR_TRAP_ENABLE_INV
8640 | SWCR_TRAP_ENABLE_DZE
8641 | SWCR_TRAP_ENABLE_OVF
);
8642 swcr
|= (~fpcr
>> 57) & (SWCR_TRAP_ENABLE_UNF
8643 | SWCR_TRAP_ENABLE_INE
);
8644 swcr
|= (fpcr
>> 47) & SWCR_MAP_UMZ
;
8645 swcr
|= (~fpcr
>> 41) & SWCR_TRAP_ENABLE_DNO
;
8647 if (put_user_u64 (swcr
, arg2
))
8653 /* case GSI_IEEE_STATE_AT_SIGNAL:
8654 -- Not implemented in linux kernel.
8656 -- Retrieves current unaligned access state; not much used.
8658 -- Retrieves implver information; surely not used.
8660 -- Grabs a copy of the HWRPB; surely not used.
8665 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
8666 /* Alpha specific */
8667 case TARGET_NR_osf_setsysinfo
:
8668 ret
= -TARGET_EOPNOTSUPP
;
8670 case TARGET_SSI_IEEE_FP_CONTROL
:
8672 uint64_t swcr
, fpcr
, orig_fpcr
;
8674 if (get_user_u64 (swcr
, arg2
)) {
8677 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
8678 fpcr
= orig_fpcr
& FPCR_DYN_MASK
;
8680 /* Copied from linux ieee_swcr_to_fpcr. */
8681 fpcr
|= (swcr
& SWCR_STATUS_MASK
) << 35;
8682 fpcr
|= (swcr
& SWCR_MAP_DMZ
) << 36;
8683 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_INV
8684 | SWCR_TRAP_ENABLE_DZE
8685 | SWCR_TRAP_ENABLE_OVF
)) << 48;
8686 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_UNF
8687 | SWCR_TRAP_ENABLE_INE
)) << 57;
8688 fpcr
|= (swcr
& SWCR_MAP_UMZ
? FPCR_UNDZ
| FPCR_UNFD
: 0);
8689 fpcr
|= (~swcr
& SWCR_TRAP_ENABLE_DNO
) << 41;
8691 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
8696 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
8698 uint64_t exc
, fpcr
, orig_fpcr
;
8701 if (get_user_u64(exc
, arg2
)) {
8705 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
8707 /* We only add to the exception status here. */
8708 fpcr
= orig_fpcr
| ((exc
& SWCR_STATUS_MASK
) << 35);
8710 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
8713 /* Old exceptions are not signaled. */
8714 fpcr
&= ~(orig_fpcr
& FPCR_STATUS_MASK
);
8716 /* If any exceptions set by this call,
8717 and are unmasked, send a signal. */
8719 if ((fpcr
& (FPCR_INE
| FPCR_INED
)) == FPCR_INE
) {
8720 si_code
= TARGET_FPE_FLTRES
;
8722 if ((fpcr
& (FPCR_UNF
| FPCR_UNFD
)) == FPCR_UNF
) {
8723 si_code
= TARGET_FPE_FLTUND
;
8725 if ((fpcr
& (FPCR_OVF
| FPCR_OVFD
)) == FPCR_OVF
) {
8726 si_code
= TARGET_FPE_FLTOVF
;
8728 if ((fpcr
& (FPCR_DZE
| FPCR_DZED
)) == FPCR_DZE
) {
8729 si_code
= TARGET_FPE_FLTDIV
;
8731 if ((fpcr
& (FPCR_INV
| FPCR_INVD
)) == FPCR_INV
) {
8732 si_code
= TARGET_FPE_FLTINV
;
8735 target_siginfo_t info
;
8736 info
.si_signo
= SIGFPE
;
8738 info
.si_code
= si_code
;
8739 info
._sifields
._sigfault
._addr
8740 = ((CPUArchState
*)cpu_env
)->pc
;
8741 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
, &info
);
8746 /* case SSI_NVPAIRS:
8747 -- Used with SSIN_UACPROC to enable unaligned accesses.
8748 case SSI_IEEE_STATE_AT_SIGNAL:
8749 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
8750 -- Not implemented in linux kernel
8755 #ifdef TARGET_NR_osf_sigprocmask
8756 /* Alpha specific. */
8757 case TARGET_NR_osf_sigprocmask
:
8761 sigset_t set
, oldset
;
8764 case TARGET_SIG_BLOCK
:
8767 case TARGET_SIG_UNBLOCK
:
8770 case TARGET_SIG_SETMASK
:
8774 ret
= -TARGET_EINVAL
;
8778 target_to_host_old_sigset(&set
, &mask
);
8779 do_sigprocmask(how
, &set
, &oldset
);
8780 host_to_target_old_sigset(&mask
, &oldset
);
8786 #ifdef TARGET_NR_getgid32
8787 case TARGET_NR_getgid32
:
8788 ret
= get_errno(getgid());
8791 #ifdef TARGET_NR_geteuid32
8792 case TARGET_NR_geteuid32
:
8793 ret
= get_errno(geteuid());
8796 #ifdef TARGET_NR_getegid32
8797 case TARGET_NR_getegid32
:
8798 ret
= get_errno(getegid());
8801 #ifdef TARGET_NR_setreuid32
8802 case TARGET_NR_setreuid32
:
8803 ret
= get_errno(setreuid(arg1
, arg2
));
8806 #ifdef TARGET_NR_setregid32
8807 case TARGET_NR_setregid32
:
8808 ret
= get_errno(setregid(arg1
, arg2
));
8811 #ifdef TARGET_NR_getgroups32
8812 case TARGET_NR_getgroups32
:
8814 int gidsetsize
= arg1
;
8815 uint32_t *target_grouplist
;
8819 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
8820 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
8821 if (gidsetsize
== 0)
8823 if (!is_error(ret
)) {
8824 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
8825 if (!target_grouplist
) {
8826 ret
= -TARGET_EFAULT
;
8829 for(i
= 0;i
< ret
; i
++)
8830 target_grouplist
[i
] = tswap32(grouplist
[i
]);
8831 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
8836 #ifdef TARGET_NR_setgroups32
8837 case TARGET_NR_setgroups32
:
8839 int gidsetsize
= arg1
;
8840 uint32_t *target_grouplist
;
8844 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
8845 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
8846 if (!target_grouplist
) {
8847 ret
= -TARGET_EFAULT
;
8850 for(i
= 0;i
< gidsetsize
; i
++)
8851 grouplist
[i
] = tswap32(target_grouplist
[i
]);
8852 unlock_user(target_grouplist
, arg2
, 0);
8853 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
8857 #ifdef TARGET_NR_fchown32
8858 case TARGET_NR_fchown32
:
8859 ret
= get_errno(fchown(arg1
, arg2
, arg3
));
8862 #ifdef TARGET_NR_setresuid32
8863 case TARGET_NR_setresuid32
:
8864 ret
= get_errno(setresuid(arg1
, arg2
, arg3
));
8867 #ifdef TARGET_NR_getresuid32
8868 case TARGET_NR_getresuid32
:
8870 uid_t ruid
, euid
, suid
;
8871 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
8872 if (!is_error(ret
)) {
8873 if (put_user_u32(ruid
, arg1
)
8874 || put_user_u32(euid
, arg2
)
8875 || put_user_u32(suid
, arg3
))
8881 #ifdef TARGET_NR_setresgid32
8882 case TARGET_NR_setresgid32
:
8883 ret
= get_errno(setresgid(arg1
, arg2
, arg3
));
8886 #ifdef TARGET_NR_getresgid32
8887 case TARGET_NR_getresgid32
:
8889 gid_t rgid
, egid
, sgid
;
8890 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
8891 if (!is_error(ret
)) {
8892 if (put_user_u32(rgid
, arg1
)
8893 || put_user_u32(egid
, arg2
)
8894 || put_user_u32(sgid
, arg3
))
8900 #ifdef TARGET_NR_chown32
8901 case TARGET_NR_chown32
:
8902 if (!(p
= lock_user_string(arg1
)))
8904 ret
= get_errno(chown(p
, arg2
, arg3
));
8905 unlock_user(p
, arg1
, 0);
8908 #ifdef TARGET_NR_setuid32
8909 case TARGET_NR_setuid32
:
8910 ret
= get_errno(setuid(arg1
));
8913 #ifdef TARGET_NR_setgid32
8914 case TARGET_NR_setgid32
:
8915 ret
= get_errno(setgid(arg1
));
8918 #ifdef TARGET_NR_setfsuid32
8919 case TARGET_NR_setfsuid32
:
8920 ret
= get_errno(setfsuid(arg1
));
8923 #ifdef TARGET_NR_setfsgid32
8924 case TARGET_NR_setfsgid32
:
8925 ret
= get_errno(setfsgid(arg1
));
8929 case TARGET_NR_pivot_root
:
8931 #ifdef TARGET_NR_mincore
8932 case TARGET_NR_mincore
:
8935 ret
= -TARGET_EFAULT
;
8936 if (!(a
= lock_user(VERIFY_READ
, arg1
,arg2
, 0)))
8938 if (!(p
= lock_user_string(arg3
)))
8940 ret
= get_errno(mincore(a
, arg2
, p
));
8941 unlock_user(p
, arg3
, ret
);
8943 unlock_user(a
, arg1
, 0);
8947 #ifdef TARGET_NR_arm_fadvise64_64
8948 case TARGET_NR_arm_fadvise64_64
:
8951 * arm_fadvise64_64 looks like fadvise64_64 but
8952 * with different argument order
8960 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)
8961 #ifdef TARGET_NR_fadvise64_64
8962 case TARGET_NR_fadvise64_64
:
8964 #ifdef TARGET_NR_fadvise64
8965 case TARGET_NR_fadvise64
:
8969 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
8970 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
8971 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
8972 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
8976 ret
= -posix_fadvise(arg1
, arg2
, arg3
, arg4
);
8979 #ifdef TARGET_NR_madvise
8980 case TARGET_NR_madvise
:
8981 /* A straight passthrough may not be safe because qemu sometimes
8982 turns private file-backed mappings into anonymous mappings.
8983 This will break MADV_DONTNEED.
8984 This is a hint, so ignoring and returning success is ok. */
8988 #if TARGET_ABI_BITS == 32
8989 case TARGET_NR_fcntl64
:
8993 struct target_flock64
*target_fl
;
8995 struct target_eabi_flock64
*target_efl
;
8998 cmd
= target_to_host_fcntl_cmd(arg2
);
8999 if (cmd
== -TARGET_EINVAL
) {
9005 case TARGET_F_GETLK64
:
9007 if (((CPUARMState
*)cpu_env
)->eabi
) {
9008 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
9010 fl
.l_type
= tswap16(target_efl
->l_type
);
9011 fl
.l_whence
= tswap16(target_efl
->l_whence
);
9012 fl
.l_start
= tswap64(target_efl
->l_start
);
9013 fl
.l_len
= tswap64(target_efl
->l_len
);
9014 fl
.l_pid
= tswap32(target_efl
->l_pid
);
9015 unlock_user_struct(target_efl
, arg3
, 0);
9019 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
9021 fl
.l_type
= tswap16(target_fl
->l_type
);
9022 fl
.l_whence
= tswap16(target_fl
->l_whence
);
9023 fl
.l_start
= tswap64(target_fl
->l_start
);
9024 fl
.l_len
= tswap64(target_fl
->l_len
);
9025 fl
.l_pid
= tswap32(target_fl
->l_pid
);
9026 unlock_user_struct(target_fl
, arg3
, 0);
9028 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
9031 if (((CPUARMState
*)cpu_env
)->eabi
) {
9032 if (!lock_user_struct(VERIFY_WRITE
, target_efl
, arg3
, 0))
9034 target_efl
->l_type
= tswap16(fl
.l_type
);
9035 target_efl
->l_whence
= tswap16(fl
.l_whence
);
9036 target_efl
->l_start
= tswap64(fl
.l_start
);
9037 target_efl
->l_len
= tswap64(fl
.l_len
);
9038 target_efl
->l_pid
= tswap32(fl
.l_pid
);
9039 unlock_user_struct(target_efl
, arg3
, 1);
9043 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg3
, 0))
9045 target_fl
->l_type
= tswap16(fl
.l_type
);
9046 target_fl
->l_whence
= tswap16(fl
.l_whence
);
9047 target_fl
->l_start
= tswap64(fl
.l_start
);
9048 target_fl
->l_len
= tswap64(fl
.l_len
);
9049 target_fl
->l_pid
= tswap32(fl
.l_pid
);
9050 unlock_user_struct(target_fl
, arg3
, 1);
9055 case TARGET_F_SETLK64
:
9056 case TARGET_F_SETLKW64
:
9058 if (((CPUARMState
*)cpu_env
)->eabi
) {
9059 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
9061 fl
.l_type
= tswap16(target_efl
->l_type
);
9062 fl
.l_whence
= tswap16(target_efl
->l_whence
);
9063 fl
.l_start
= tswap64(target_efl
->l_start
);
9064 fl
.l_len
= tswap64(target_efl
->l_len
);
9065 fl
.l_pid
= tswap32(target_efl
->l_pid
);
9066 unlock_user_struct(target_efl
, arg3
, 0);
9070 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
9072 fl
.l_type
= tswap16(target_fl
->l_type
);
9073 fl
.l_whence
= tswap16(target_fl
->l_whence
);
9074 fl
.l_start
= tswap64(target_fl
->l_start
);
9075 fl
.l_len
= tswap64(target_fl
->l_len
);
9076 fl
.l_pid
= tswap32(target_fl
->l_pid
);
9077 unlock_user_struct(target_fl
, arg3
, 0);
9079 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
9082 ret
= do_fcntl(arg1
, arg2
, arg3
);
9088 #ifdef TARGET_NR_cacheflush
9089 case TARGET_NR_cacheflush
:
9090 /* self-modifying code is handled automatically, so nothing needed */
9094 #ifdef TARGET_NR_security
9095 case TARGET_NR_security
:
9098 #ifdef TARGET_NR_getpagesize
9099 case TARGET_NR_getpagesize
:
9100 ret
= TARGET_PAGE_SIZE
;
9103 case TARGET_NR_gettid
:
9104 ret
= get_errno(gettid());
9106 #ifdef TARGET_NR_readahead
9107 case TARGET_NR_readahead
:
9108 #if TARGET_ABI_BITS == 32
9109 if (regpairs_aligned(cpu_env
)) {
9114 ret
= get_errno(readahead(arg1
, ((off64_t
)arg3
<< 32) | arg2
, arg4
));
9116 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
9121 #ifdef TARGET_NR_setxattr
9122 case TARGET_NR_listxattr
:
9123 case TARGET_NR_llistxattr
:
9127 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9129 ret
= -TARGET_EFAULT
;
9133 p
= lock_user_string(arg1
);
9135 if (num
== TARGET_NR_listxattr
) {
9136 ret
= get_errno(listxattr(p
, b
, arg3
));
9138 ret
= get_errno(llistxattr(p
, b
, arg3
));
9141 ret
= -TARGET_EFAULT
;
9143 unlock_user(p
, arg1
, 0);
9144 unlock_user(b
, arg2
, arg3
);
9147 case TARGET_NR_flistxattr
:
9151 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9153 ret
= -TARGET_EFAULT
;
9157 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
9158 unlock_user(b
, arg2
, arg3
);
9161 case TARGET_NR_setxattr
:
9162 case TARGET_NR_lsetxattr
:
9164 void *p
, *n
, *v
= 0;
9166 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
9168 ret
= -TARGET_EFAULT
;
9172 p
= lock_user_string(arg1
);
9173 n
= lock_user_string(arg2
);
9175 if (num
== TARGET_NR_setxattr
) {
9176 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
9178 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
9181 ret
= -TARGET_EFAULT
;
9183 unlock_user(p
, arg1
, 0);
9184 unlock_user(n
, arg2
, 0);
9185 unlock_user(v
, arg3
, 0);
9188 case TARGET_NR_fsetxattr
:
9192 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
9194 ret
= -TARGET_EFAULT
;
9198 n
= lock_user_string(arg2
);
9200 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
9202 ret
= -TARGET_EFAULT
;
9204 unlock_user(n
, arg2
, 0);
9205 unlock_user(v
, arg3
, 0);
9208 case TARGET_NR_getxattr
:
9209 case TARGET_NR_lgetxattr
:
9211 void *p
, *n
, *v
= 0;
9213 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
9215 ret
= -TARGET_EFAULT
;
9219 p
= lock_user_string(arg1
);
9220 n
= lock_user_string(arg2
);
9222 if (num
== TARGET_NR_getxattr
) {
9223 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
9225 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
9228 ret
= -TARGET_EFAULT
;
9230 unlock_user(p
, arg1
, 0);
9231 unlock_user(n
, arg2
, 0);
9232 unlock_user(v
, arg3
, arg4
);
9235 case TARGET_NR_fgetxattr
:
9239 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
9241 ret
= -TARGET_EFAULT
;
9245 n
= lock_user_string(arg2
);
9247 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
9249 ret
= -TARGET_EFAULT
;
9251 unlock_user(n
, arg2
, 0);
9252 unlock_user(v
, arg3
, arg4
);
9255 case TARGET_NR_removexattr
:
9256 case TARGET_NR_lremovexattr
:
9259 p
= lock_user_string(arg1
);
9260 n
= lock_user_string(arg2
);
9262 if (num
== TARGET_NR_removexattr
) {
9263 ret
= get_errno(removexattr(p
, n
));
9265 ret
= get_errno(lremovexattr(p
, n
));
9268 ret
= -TARGET_EFAULT
;
9270 unlock_user(p
, arg1
, 0);
9271 unlock_user(n
, arg2
, 0);
9274 case TARGET_NR_fremovexattr
:
9277 n
= lock_user_string(arg2
);
9279 ret
= get_errno(fremovexattr(arg1
, n
));
9281 ret
= -TARGET_EFAULT
;
9283 unlock_user(n
, arg2
, 0);
9287 #endif /* CONFIG_ATTR */
9288 #ifdef TARGET_NR_set_thread_area
9289 case TARGET_NR_set_thread_area
:
9290 #if defined(TARGET_MIPS)
9291 ((CPUMIPSState
*) cpu_env
)->active_tc
.CP0_UserLocal
= arg1
;
9294 #elif defined(TARGET_CRIS)
9296 ret
= -TARGET_EINVAL
;
9298 ((CPUCRISState
*) cpu_env
)->pregs
[PR_PID
] = arg1
;
9302 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
9303 ret
= do_set_thread_area(cpu_env
, arg1
);
9305 #elif defined(TARGET_M68K)
9307 TaskState
*ts
= cpu
->opaque
;
9308 ts
->tp_value
= arg1
;
9313 goto unimplemented_nowarn
;
9316 #ifdef TARGET_NR_get_thread_area
9317 case TARGET_NR_get_thread_area
:
9318 #if defined(TARGET_I386) && defined(TARGET_ABI32)
9319 ret
= do_get_thread_area(cpu_env
, arg1
);
9321 #elif defined(TARGET_M68K)
9323 TaskState
*ts
= cpu
->opaque
;
9328 goto unimplemented_nowarn
;
9331 #ifdef TARGET_NR_getdomainname
9332 case TARGET_NR_getdomainname
:
9333 goto unimplemented_nowarn
;
9336 #ifdef TARGET_NR_clock_gettime
9337 case TARGET_NR_clock_gettime
:
9340 ret
= get_errno(clock_gettime(arg1
, &ts
));
9341 if (!is_error(ret
)) {
9342 host_to_target_timespec(arg2
, &ts
);
9347 #ifdef TARGET_NR_clock_getres
9348 case TARGET_NR_clock_getres
:
9351 ret
= get_errno(clock_getres(arg1
, &ts
));
9352 if (!is_error(ret
)) {
9353 host_to_target_timespec(arg2
, &ts
);
9358 #ifdef TARGET_NR_clock_nanosleep
9359 case TARGET_NR_clock_nanosleep
:
9362 target_to_host_timespec(&ts
, arg3
);
9363 ret
= get_errno(clock_nanosleep(arg1
, arg2
, &ts
, arg4
? &ts
: NULL
));
9365 host_to_target_timespec(arg4
, &ts
);
9367 #if defined(TARGET_PPC)
9368 /* clock_nanosleep is odd in that it returns positive errno values.
9369 * On PPC, CR0 bit 3 should be set in such a situation. */
9371 ((CPUPPCState
*)cpu_env
)->crf
[0] |= 1;
9378 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
9379 case TARGET_NR_set_tid_address
:
9380 ret
= get_errno(set_tid_address((int *)g2h(arg1
)));
9384 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
9385 case TARGET_NR_tkill
:
9386 ret
= get_errno(sys_tkill((int)arg1
, target_to_host_signal(arg2
)));
9390 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
9391 case TARGET_NR_tgkill
:
9392 ret
= get_errno(sys_tgkill((int)arg1
, (int)arg2
,
9393 target_to_host_signal(arg3
)));
9397 #ifdef TARGET_NR_set_robust_list
9398 case TARGET_NR_set_robust_list
:
9399 case TARGET_NR_get_robust_list
:
9400 /* The ABI for supporting robust futexes has userspace pass
9401 * the kernel a pointer to a linked list which is updated by
9402 * userspace after the syscall; the list is walked by the kernel
9403 * when the thread exits. Since the linked list in QEMU guest
9404 * memory isn't a valid linked list for the host and we have
9405 * no way to reliably intercept the thread-death event, we can't
9406 * support these. Silently return ENOSYS so that guest userspace
9407 * falls back to a non-robust futex implementation (which should
9408 * be OK except in the corner case of the guest crashing while
9409 * holding a mutex that is shared with another process via
9412 goto unimplemented_nowarn
;
9415 #if defined(TARGET_NR_utimensat)
9416 case TARGET_NR_utimensat
:
9418 struct timespec
*tsp
, ts
[2];
9422 target_to_host_timespec(ts
, arg3
);
9423 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
9427 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
9429 if (!(p
= lock_user_string(arg2
))) {
9430 ret
= -TARGET_EFAULT
;
9433 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
9434 unlock_user(p
, arg2
, 0);
9439 case TARGET_NR_futex
:
9440 ret
= do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9442 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
9443 case TARGET_NR_inotify_init
:
9444 ret
= get_errno(sys_inotify_init());
9447 #ifdef CONFIG_INOTIFY1
9448 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
9449 case TARGET_NR_inotify_init1
:
9450 ret
= get_errno(sys_inotify_init1(arg1
));
9454 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
9455 case TARGET_NR_inotify_add_watch
:
9456 p
= lock_user_string(arg2
);
9457 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
9458 unlock_user(p
, arg2
, 0);
9461 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
9462 case TARGET_NR_inotify_rm_watch
:
9463 ret
= get_errno(sys_inotify_rm_watch(arg1
, arg2
));
9467 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
9468 case TARGET_NR_mq_open
:
9470 struct mq_attr posix_mq_attr
, *attrp
;
9472 p
= lock_user_string(arg1
- 1);
9474 copy_from_user_mq_attr (&posix_mq_attr
, arg4
);
9475 attrp
= &posix_mq_attr
;
9479 ret
= get_errno(mq_open(p
, arg2
, arg3
, attrp
));
9480 unlock_user (p
, arg1
, 0);
9484 case TARGET_NR_mq_unlink
:
9485 p
= lock_user_string(arg1
- 1);
9486 ret
= get_errno(mq_unlink(p
));
9487 unlock_user (p
, arg1
, 0);
9490 case TARGET_NR_mq_timedsend
:
9494 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
9496 target_to_host_timespec(&ts
, arg5
);
9497 ret
= get_errno(mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
9498 host_to_target_timespec(arg5
, &ts
);
9501 ret
= get_errno(mq_send(arg1
, p
, arg3
, arg4
));
9502 unlock_user (p
, arg2
, arg3
);
9506 case TARGET_NR_mq_timedreceive
:
9511 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
9513 target_to_host_timespec(&ts
, arg5
);
9514 ret
= get_errno(mq_timedreceive(arg1
, p
, arg3
, &prio
, &ts
));
9515 host_to_target_timespec(arg5
, &ts
);
9518 ret
= get_errno(mq_receive(arg1
, p
, arg3
, &prio
));
9519 unlock_user (p
, arg2
, arg3
);
9521 put_user_u32(prio
, arg4
);
9525 /* Not implemented for now... */
9526 /* case TARGET_NR_mq_notify: */
9529 case TARGET_NR_mq_getsetattr
:
9531 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
9534 ret
= mq_getattr(arg1
, &posix_mq_attr_out
);
9535 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
9538 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
9539 ret
|= mq_setattr(arg1
, &posix_mq_attr_in
, &posix_mq_attr_out
);
9546 #ifdef CONFIG_SPLICE
9547 #ifdef TARGET_NR_tee
9550 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
9554 #ifdef TARGET_NR_splice
9555 case TARGET_NR_splice
:
9557 loff_t loff_in
, loff_out
;
9558 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
9560 if (get_user_u64(loff_in
, arg2
)) {
9563 ploff_in
= &loff_in
;
9566 if (get_user_u64(loff_out
, arg4
)) {
9569 ploff_out
= &loff_out
;
9571 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
9573 if (put_user_u64(loff_in
, arg2
)) {
9578 if (put_user_u64(loff_out
, arg4
)) {
9585 #ifdef TARGET_NR_vmsplice
9586 case TARGET_NR_vmsplice
:
9588 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
9590 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
9591 unlock_iovec(vec
, arg2
, arg3
, 0);
9593 ret
= -host_to_target_errno(errno
);
9598 #endif /* CONFIG_SPLICE */
9599 #ifdef CONFIG_EVENTFD
9600 #if defined(TARGET_NR_eventfd)
9601 case TARGET_NR_eventfd
:
9602 ret
= get_errno(eventfd(arg1
, 0));
9605 #if defined(TARGET_NR_eventfd2)
9606 case TARGET_NR_eventfd2
:
9608 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
));
9609 if (arg2
& TARGET_O_NONBLOCK
) {
9610 host_flags
|= O_NONBLOCK
;
9612 if (arg2
& TARGET_O_CLOEXEC
) {
9613 host_flags
|= O_CLOEXEC
;
9615 ret
= get_errno(eventfd(arg1
, host_flags
));
9619 #endif /* CONFIG_EVENTFD */
9620 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
9621 case TARGET_NR_fallocate
:
9622 #if TARGET_ABI_BITS == 32
9623 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
9624 target_offset64(arg5
, arg6
)));
9626 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
9630 #if defined(CONFIG_SYNC_FILE_RANGE)
9631 #if defined(TARGET_NR_sync_file_range)
9632 case TARGET_NR_sync_file_range
:
9633 #if TARGET_ABI_BITS == 32
9634 #if defined(TARGET_MIPS)
9635 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
9636 target_offset64(arg5
, arg6
), arg7
));
9638 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
9639 target_offset64(arg4
, arg5
), arg6
));
9640 #endif /* !TARGET_MIPS */
9642 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
9646 #if defined(TARGET_NR_sync_file_range2)
9647 case TARGET_NR_sync_file_range2
:
9648 /* This is like sync_file_range but the arguments are reordered */
9649 #if TARGET_ABI_BITS == 32
9650 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
9651 target_offset64(arg5
, arg6
), arg2
));
9653 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
9658 #if defined(CONFIG_EPOLL)
9659 #if defined(TARGET_NR_epoll_create)
9660 case TARGET_NR_epoll_create
:
9661 ret
= get_errno(epoll_create(arg1
));
9664 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
9665 case TARGET_NR_epoll_create1
:
9666 ret
= get_errno(epoll_create1(arg1
));
9669 #if defined(TARGET_NR_epoll_ctl)
9670 case TARGET_NR_epoll_ctl
:
9672 struct epoll_event ep
;
9673 struct epoll_event
*epp
= 0;
9675 struct target_epoll_event
*target_ep
;
9676 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
9679 ep
.events
= tswap32(target_ep
->events
);
9680 /* The epoll_data_t union is just opaque data to the kernel,
9681 * so we transfer all 64 bits across and need not worry what
9682 * actual data type it is.
9684 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
9685 unlock_user_struct(target_ep
, arg4
, 0);
9688 ret
= get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
9693 #if defined(TARGET_NR_epoll_pwait) && defined(CONFIG_EPOLL_PWAIT)
9694 #define IMPLEMENT_EPOLL_PWAIT
9696 #if defined(TARGET_NR_epoll_wait) || defined(IMPLEMENT_EPOLL_PWAIT)
9697 #if defined(TARGET_NR_epoll_wait)
9698 case TARGET_NR_epoll_wait
:
9700 #if defined(IMPLEMENT_EPOLL_PWAIT)
9701 case TARGET_NR_epoll_pwait
:
9704 struct target_epoll_event
*target_ep
;
9705 struct epoll_event
*ep
;
9707 int maxevents
= arg3
;
9710 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
9711 maxevents
* sizeof(struct target_epoll_event
), 1);
9716 ep
= alloca(maxevents
* sizeof(struct epoll_event
));
9719 #if defined(IMPLEMENT_EPOLL_PWAIT)
9720 case TARGET_NR_epoll_pwait
:
9722 target_sigset_t
*target_set
;
9723 sigset_t _set
, *set
= &_set
;
9726 target_set
= lock_user(VERIFY_READ
, arg5
,
9727 sizeof(target_sigset_t
), 1);
9729 unlock_user(target_ep
, arg2
, 0);
9732 target_to_host_sigset(set
, target_set
);
9733 unlock_user(target_set
, arg5
, 0);
9738 ret
= get_errno(epoll_pwait(epfd
, ep
, maxevents
, timeout
, set
));
9742 #if defined(TARGET_NR_epoll_wait)
9743 case TARGET_NR_epoll_wait
:
9744 ret
= get_errno(epoll_wait(epfd
, ep
, maxevents
, timeout
));
9748 ret
= -TARGET_ENOSYS
;
9750 if (!is_error(ret
)) {
9752 for (i
= 0; i
< ret
; i
++) {
9753 target_ep
[i
].events
= tswap32(ep
[i
].events
);
9754 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
9757 unlock_user(target_ep
, arg2
, ret
* sizeof(struct target_epoll_event
));
9762 #ifdef TARGET_NR_prlimit64
9763 case TARGET_NR_prlimit64
:
9765 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
9766 struct target_rlimit64
*target_rnew
, *target_rold
;
9767 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
9768 int resource
= target_to_host_resource(arg2
);
9770 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
9773 rnew
.rlim_cur
= tswap64(target_rnew
->rlim_cur
);
9774 rnew
.rlim_max
= tswap64(target_rnew
->rlim_max
);
9775 unlock_user_struct(target_rnew
, arg3
, 0);
9779 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
9780 if (!is_error(ret
) && arg4
) {
9781 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
9784 target_rold
->rlim_cur
= tswap64(rold
.rlim_cur
);
9785 target_rold
->rlim_max
= tswap64(rold
.rlim_max
);
9786 unlock_user_struct(target_rold
, arg4
, 1);
9791 #ifdef TARGET_NR_gethostname
9792 case TARGET_NR_gethostname
:
9794 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
9796 ret
= get_errno(gethostname(name
, arg2
));
9797 unlock_user(name
, arg1
, arg2
);
9799 ret
= -TARGET_EFAULT
;
9804 #ifdef TARGET_NR_atomic_cmpxchg_32
9805 case TARGET_NR_atomic_cmpxchg_32
:
9807 /* should use start_exclusive from main.c */
9808 abi_ulong mem_value
;
9809 if (get_user_u32(mem_value
, arg6
)) {
9810 target_siginfo_t info
;
9811 info
.si_signo
= SIGSEGV
;
9813 info
.si_code
= TARGET_SEGV_MAPERR
;
9814 info
._sifields
._sigfault
._addr
= arg6
;
9815 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
, &info
);
9819 if (mem_value
== arg2
)
9820 put_user_u32(arg1
, arg6
);
9825 #ifdef TARGET_NR_atomic_barrier
9826 case TARGET_NR_atomic_barrier
:
9828 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
9834 #ifdef TARGET_NR_timer_create
9835 case TARGET_NR_timer_create
:
9837 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
9839 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
9842 int timer_index
= next_free_host_timer();
9844 if (timer_index
< 0) {
9845 ret
= -TARGET_EAGAIN
;
9847 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
9850 phost_sevp
= &host_sevp
;
9851 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
9857 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
9861 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
9870 #ifdef TARGET_NR_timer_settime
9871 case TARGET_NR_timer_settime
:
9873 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
9874 * struct itimerspec * old_value */
9875 target_timer_t timerid
= get_timer_id(arg1
);
9879 } else if (arg3
== 0) {
9880 ret
= -TARGET_EINVAL
;
9882 timer_t htimer
= g_posix_timers
[timerid
];
9883 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
9885 target_to_host_itimerspec(&hspec_new
, arg3
);
9887 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
9888 host_to_target_itimerspec(arg2
, &hspec_old
);
9894 #ifdef TARGET_NR_timer_gettime
9895 case TARGET_NR_timer_gettime
:
9897 /* args: timer_t timerid, struct itimerspec *curr_value */
9898 target_timer_t timerid
= get_timer_id(arg1
);
9903 ret
= -TARGET_EFAULT
;
9905 timer_t htimer
= g_posix_timers
[timerid
];
9906 struct itimerspec hspec
;
9907 ret
= get_errno(timer_gettime(htimer
, &hspec
));
9909 if (host_to_target_itimerspec(arg2
, &hspec
)) {
9910 ret
= -TARGET_EFAULT
;
9917 #ifdef TARGET_NR_timer_getoverrun
9918 case TARGET_NR_timer_getoverrun
:
9920 /* args: timer_t timerid */
9921 target_timer_t timerid
= get_timer_id(arg1
);
9926 timer_t htimer
= g_posix_timers
[timerid
];
9927 ret
= get_errno(timer_getoverrun(htimer
));
9933 #ifdef TARGET_NR_timer_delete
9934 case TARGET_NR_timer_delete
:
9936 /* args: timer_t timerid */
9937 target_timer_t timerid
= get_timer_id(arg1
);
9942 timer_t htimer
= g_posix_timers
[timerid
];
9943 ret
= get_errno(timer_delete(htimer
));
9944 g_posix_timers
[timerid
] = 0;
9950 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
9951 case TARGET_NR_timerfd_create
:
9952 ret
= get_errno(timerfd_create(arg1
,
9953 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
9957 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
9958 case TARGET_NR_timerfd_gettime
:
9960 struct itimerspec its_curr
;
9962 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
9964 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
9971 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
9972 case TARGET_NR_timerfd_settime
:
9974 struct itimerspec its_new
, its_old
, *p_new
;
9977 if (target_to_host_itimerspec(&its_new
, arg3
)) {
9985 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
9987 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
9994 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
9995 case TARGET_NR_ioprio_get
:
9996 ret
= get_errno(ioprio_get(arg1
, arg2
));
10000 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
10001 case TARGET_NR_ioprio_set
:
10002 ret
= get_errno(ioprio_set(arg1
, arg2
, arg3
));
10006 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
10007 case TARGET_NR_setns
:
10008 ret
= get_errno(setns(arg1
, arg2
));
10011 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
10012 case TARGET_NR_unshare
:
10013 ret
= get_errno(unshare(arg1
));
10019 gemu_log("qemu: Unsupported syscall: %d\n", num
);
10020 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
10021 unimplemented_nowarn
:
10023 ret
= -TARGET_ENOSYS
;
10028 gemu_log(" = " TARGET_ABI_FMT_ld
"\n", ret
);
10031 print_syscall_ret(num
, ret
);
10034 ret
= -TARGET_EFAULT
;