ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Linux-user changes, mostly bugfixes and adding support for some 

new syscalls and some obscure syscalls as well. Includes some
 missed patches from earlier rounds, and dropping unicore32 target.
 
 v2: fix the syslog patch and test build with clang-3.8
 v3: drop ustat patch
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIVAwUAWAoMLrRIkN7ePJvAAQgkCA//eUDHirGhOF7VI4s9oOq8lPJCcaprpL7W
 QP9ObOVg+C7TPpMSCWO03HFp8lDRoTTvwo+UPqEZWjPzYp6zu5rmQYqXN13nw1Hq
 tw+EDxiWfpNKamLd22PehYoKmU15p4HbkXYLvY728bvc9E8cloZkF8HrQZeXRIhS
 V9NKoasPTahn3C54ltdDpC/aDLzhhE18W8zca1s0PhYPaq1NRiULe+esT8D7PvVf
 XEpyvFMFMt4Hb4/KLMxQBnPd+jfcvpIh7xWnd0p62cYPVwci+b9CCmGwnIwGLwZx
 qIWj6HuekUk2R31u7G1B4IIj2zg94k1fMdsycbxt5tTkpbXSATUvkpXFjE1mqPwO
 NPLubcEp21g4ocB+agUcs1YoSojBycLBPE/zBCFRSf2ehSulKthYKWOcifXwhioI
 u8vLQvGftqJfHo3Axk4MxZZxBp1MeZDC9gr9veaVvSMnK0iyOeCePMl8CS8K9rX9
 7Xx6nFwG8pa3p2J9akGJVOczhJXG3buwmagTic6kdHNqV986IafqlmxSI/X8B5bq
 B3rh1q/YDXinH25i6oKFlopcK7EZ6He8Bj1wg+QvAo5RSvc2Wbz6qRuhqx9g14zD
 +TKOhgGZ7hgtb/lcp2VEVIsumdKy3+e0dcUXzuVxiHvlrdG3csY0lcmNl+RFIoSb
 WHgdCBUQos8=
 =BOgy
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/riku/tags/pull-linux-user-20160921' into staging

Linux-user changes, mostly bugfixes and adding support for some
new syscalls and some obscure syscalls as well. Includes some
missed patches from earlier rounds, and dropping unicore32 target.

v2: fix the syslog patch and test build with clang-3.8
v3: drop ustat patch

# gpg: Signature made Fri 21 Oct 2016 13:38:06 BST
# gpg:                using RSA key 0xB44890DEDE3C9BC0
# gpg: Good signature from "Riku Voipio <riku.voipio@iki.fi>"
# gpg:                 aka "Riku Voipio <riku.voipio@linaro.org>"
# Primary key fingerprint: FF82 03C8 C391 98AE 0581  41EF B448 90DE DE3C 9BC0

* remotes/riku/tags/pull-linux-user-20160921: (21 commits)
  linux-user: disable unicore32 linux-user build
  linux-user: added support for pwritev() system call.
  linux-user: added support for preadv() system call.
  linux-user: Fix fadvise64() syscall support for Mips32
  linux-user: Redirect termbits.h for Mips64 to termbits.h for Mips32
  linux-user: Update ioctls definitions for Mips32
  linux-user: Update mips_syscall_args[] array in main.c
  linux-user: Add support for syncfs() syscall
  linux-user: Add support for clock_adjtime() syscall
  linux-user: Fix definition of target_sigevent for 32-bit guests
  linux-user: use libc wrapper instead of direct mremap syscall
  linux-user: Don't use alloca() for epoll_wait's epoll event array
  linux-user: add RTA_PRIORITY in netlink
  linux-user: add kcmp() syscall
  linux-user: sparc64: Use correct target SHMLBA in shmat()
  linux-user: Remove a duplicate item from strace.list
  linux-user: Fix syslog() syscall support
  linux-user: Fix socketcall() syscall support
  linux-user: Fix msgrcv() and msgsnd() syscalls support
  linux-user: Fix mq_open() syscall support
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-10-21 13:49:58 +01:00
parent da158a86c4 5e2b40f727
commit b49e452fe9
12 changed files with 673 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
configure vendored
View File

@ -3911,6 +3911,36 @@ if compile_prog "" "" ; then
setns=yes
fi
# clock_adjtime probe
clock_adjtime=no
cat > $TMPC <<EOF
#include <time.h>
int main(void)
{
return clock_adjtime(0, 0);
}
EOF
clock_adjtime=no
if compile_prog "" "" ; then
clock_adjtime=yes
fi
# syncfs probe
syncfs=no
cat > $TMPC <<EOF
#include <unistd.h>
int main(void)
{
return syncfs(0);
}
EOF
syncfs=no
if compile_prog "" "" ; then
syncfs=yes
fi
# Check if tools are available to build documentation.
if test "$docs" != "no" ; then
if has makeinfo && has pod2man; then
@ -5196,6 +5226,12 @@ fi
if test "$setns" = "yes" ; then
echo "CONFIG_SETNS=y" >> $config_host_mak
fi
if test "$clock_adjtime" = "yes" ; then
echo "CONFIG_CLOCK_ADJTIME=y" >> $config_host_mak
fi
if test "$syncfs" = "yes" ; then
echo "CONFIG_SYNCFS=y" >> $config_host_mak
fi
if test "$inotify" = "yes" ; then
echo "CONFIG_INOTIFY=y" >> $config_host_mak
fi

1
default-configs/unicore32-linux-user.mak
View File

@ -1 +0,0 @@
# Default configuration for unicore32-linux-user

24
linux-user/main.c
View File

@ -2295,8 +2295,8 @@ static const uint8_t mips_syscall_args[] = {
MIPS_SYS(sys_dup3, 3)
MIPS_SYS(sys_pipe2, 2)
MIPS_SYS(sys_inotify_init1, 1)
MIPS_SYS(sys_preadv, 6) /* 4330 */
MIPS_SYS(sys_pwritev, 6)
MIPS_SYS(sys_preadv, 5) /* 4330 */
MIPS_SYS(sys_pwritev, 5)
MIPS_SYS(sys_rt_tgsigqueueinfo, 4)
MIPS_SYS(sys_perf_event_open, 5)
MIPS_SYS(sys_accept4, 4)
@ -2308,6 +2308,26 @@ static const uint8_t mips_syscall_args[] = {
MIPS_SYS(sys_open_by_handle_at, 3) /* 4340 */
MIPS_SYS(sys_clock_adjtime, 2)
MIPS_SYS(sys_syncfs, 1)
MIPS_SYS(sys_sendmmsg, 4)
MIPS_SYS(sys_setns, 2)
MIPS_SYS(sys_process_vm_readv, 6) /* 345 */
MIPS_SYS(sys_process_vm_writev, 6)
MIPS_SYS(sys_kcmp, 5)
MIPS_SYS(sys_finit_module, 3)
MIPS_SYS(sys_sched_setattr, 2)
MIPS_SYS(sys_sched_getattr, 3) /* 350 */
MIPS_SYS(sys_renameat2, 5)
MIPS_SYS(sys_seccomp, 3)
MIPS_SYS(sys_getrandom, 3)
MIPS_SYS(sys_memfd_create, 2)
MIPS_SYS(sys_bpf, 3) /* 355 */
MIPS_SYS(sys_execveat, 5)
MIPS_SYS(sys_userfaultfd, 1)
MIPS_SYS(sys_membarrier, 2)
MIPS_SYS(sys_mlock2, 3)
MIPS_SYS(sys_copy_file_range, 6) /* 360 */
MIPS_SYS(sys_preadv2, 6)
MIPS_SYS(sys_pwritev2, 6)
};
# undef MIPS_SYS
# endif /* O32 */

2
linux-user/mips/syscall_nr.h
View File

@ -256,7 +256,7 @@
#define TARGET_NR_remap_file_pages (TARGET_NR_Linux + 251)
#define TARGET_NR_set_tid_address (TARGET_NR_Linux + 252)
#define TARGET_NR_restart_syscall (TARGET_NR_Linux + 253)
#define TARGET_NR_fadvise64 (TARGET_NR_Linux + 254)
#define TARGET_NR_fadvise64_64 (TARGET_NR_Linux + 254)
#define TARGET_NR_statfs64 (TARGET_NR_Linux + 255)
#define TARGET_NR_fstatfs64 (TARGET_NR_Linux + 256)
#define TARGET_NR_timer_create (TARGET_NR_Linux + 257)

12
linux-user/mips/termbits.h
View File

@ -219,8 +219,20 @@ struct target_termios {
#define TARGET_TIOCSBRK 0x5427 /* BSD compatibility */
#define TARGET_TIOCCBRK 0x5428 /* BSD compatibility */
#define TARGET_TIOCGSID 0x7416 /* Return the session ID of FD */
#define TARGET_TCGETS2 TARGET_IOR('T', 0x2A, struct termios2)
#define TARGET_TCSETS2 TARGET_IOW('T', 0x2B, struct termios2)
#define TARGET_TCSETSW2 TARGET_IOW('T', 0x2C, struct termios2)
#define TARGET_TCSETSF2 TARGET_IOW('T', 0x2D, struct termios2)
#define TARGET_TIOCGRS485 TARGET_IOR('T', 0x2E, struct serial_rs485)
#define TARGET_TIOCSRS485 TARGET_IOWR('T', 0x2F, struct serial_rs485)
#define TARGET_TIOCGPTN TARGET_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
#define TARGET_TIOCSPTLCK TARGET_IOW('T',0x31, int) /* Lock/unlock Pty */
#define TARGET_TIOCGDEV TARGET_IOR('T', 0x32, unsigned int)
#define TARGET_TIOCSIG TARGET_IOW('T', 0x36, int)
#define TARGET_TIOCVHANGUP 0x5437
#define TARGET_TIOCGPKT TARGET_IOR('T', 0x38, int)
#define TARGET_TIOCGPTLCK TARGET_IOR('T', 0x39, int)
#define TARGET_TIOCGEXCL TARGET_IOR('T', 0x40, int)
/* I hope the range from 0x5480 on is free ... */
#define TARGET_TIOCSCTTY 0x5480 /* become controlling tty */

245
linux-user/mips64/termbits.h
View File

@ -1,245 +1,2 @@
/* from asm/termbits.h */
#include "../mips/termbits.h"
#define TARGET_NCCS 23
struct target_termios {
unsigned int c_iflag; /* input mode flags */
unsigned int c_oflag; /* output mode flags */
unsigned int c_cflag; /* control mode flags */
unsigned int c_lflag; /* local mode flags */
unsigned char c_line; /* line discipline */
unsigned char c_cc[TARGET_NCCS]; /* control characters */
};
/* c_iflag bits */
#define TARGET_IGNBRK 0000001
#define TARGET_BRKINT 0000002
#define TARGET_IGNPAR 0000004
#define TARGET_PARMRK 0000010
#define TARGET_INPCK 0000020
#define TARGET_ISTRIP 0000040
#define TARGET_INLCR 0000100
#define TARGET_IGNCR 0000200
#define TARGET_ICRNL 0000400
#define TARGET_IUCLC 0001000
#define TARGET_IXON 0002000
#define TARGET_IXANY 0004000
#define TARGET_IXOFF 0010000
#define TARGET_IMAXBEL 0020000
#define TARGET_IUTF8 0040000
/* c_oflag bits */
#define TARGET_OPOST 0000001
#define TARGET_OLCUC 0000002
#define TARGET_ONLCR 0000004
#define TARGET_OCRNL 0000010
#define TARGET_ONOCR 0000020
#define TARGET_ONLRET 0000040
#define TARGET_OFILL 0000100
#define TARGET_OFDEL 0000200
#define TARGET_NLDLY 0000400
#define TARGET_NL0 0000000
#define TARGET_NL1 0000400
#define TARGET_CRDLY 0003000
#define TARGET_CR0 0000000
#define TARGET_CR1 0001000
#define TARGET_CR2 0002000
#define TARGET_CR3 0003000
#define TARGET_TABDLY 0014000
#define TARGET_TAB0 0000000
#define TARGET_TAB1 0004000
#define TARGET_TAB2 0010000
#define TARGET_TAB3 0014000
#define TARGET_XTABS 0014000
#define TARGET_BSDLY 0020000
#define TARGET_BS0 0000000
#define TARGET_BS1 0020000
#define TARGET_VTDLY 0040000
#define TARGET_VT0 0000000
#define TARGET_VT1 0040000
#define TARGET_FFDLY 0100000
#define TARGET_FF0 0000000
#define TARGET_FF1 0100000
/* c_cflag bit meaning */
#define TARGET_CBAUD 0010017
#define TARGET_B0 0000000 /* hang up */
#define TARGET_B50 0000001
#define TARGET_B75 0000002
#define TARGET_B110 0000003
#define TARGET_B134 0000004
#define TARGET_B150 0000005
#define TARGET_B200 0000006
#define TARGET_B300 0000007
#define TARGET_B600 0000010
#define TARGET_B1200 0000011
#define TARGET_B1800 0000012
#define TARGET_B2400 0000013
#define TARGET_B4800 0000014
#define TARGET_B9600 0000015
#define TARGET_B19200 0000016
#define TARGET_B38400 0000017
#define TARGET_EXTA B19200
#define TARGET_EXTB B38400
#define TARGET_CSIZE 0000060
#define TARGET_CS5 0000000
#define TARGET_CS6 0000020
#define TARGET_CS7 0000040
#define TARGET_CS8 0000060
#define TARGET_CSTOPB 0000100
#define TARGET_CREAD 0000200
#define TARGET_PARENB 0000400
#define TARGET_PARODD 0001000
#define TARGET_HUPCL 0002000
#define TARGET_CLOCAL 0004000
#define TARGET_CBAUDEX 0010000
#define TARGET_BOTHER 0010000
#define TARGET_B57600 0010001
#define TARGET_B115200 0010002
#define TARGET_B230400 0010003
#define TARGET_B460800 0010004
#define TARGET_B500000 0010005
#define TARGET_B576000 0010006
#define TARGET_B921600 0010007
#define TARGET_B1000000 0010010
#define TARGET_B1152000 0010011
#define TARGET_B1500000 0010012
#define TARGET_B2000000 0010013
#define TARGET_B2500000 0010014
#define TARGET_B3000000 0010015
#define TARGET_B3500000 0010016
#define TARGET_B4000000 0010017
#define TARGET_CIBAUD 002003600000 /* input baud rate (not used) */
#define TARGET_CMSPAR 010000000000 /* mark or space (stick) parity */
#define TARGET_CRTSCTS 020000000000 /* flow control */
/* c_lflag bits */
#define TARGET_ISIG 0000001
#define TARGET_ICANON 0000002
#define TARGET_XCASE 0000004
#define TARGET_ECHO 0000010
#define TARGET_ECHOE 0000020
#define TARGET_ECHOK 0000040
#define TARGET_ECHONL 0000100
#define TARGET_NOFLSH 0000200
#define TARGET_IEXTEN 0000400
#define TARGET_ECHOCTL 0001000
#define TARGET_ECHOPRT 0002000
#define TARGET_ECHOKE 0004000
#define TARGET_FLUSHO 0010000
#define TARGET_PENDIN 0040000
#define TARGET_TOSTOP 0100000
#define TARGET_ITOSTOP TARGET_TOSTOP
/* c_cc character offsets */
#define TARGET_VINTR 0
#define TARGET_VQUIT 1
#define TARGET_VERASE 2
#define TARGET_VKILL 3
#define TARGET_VMIN 4
#define TARGET_VTIME 5
#define TARGET_VEOL2 6
#define TARGET_VSWTC 7
#define TARGET_VSTART 8
#define TARGET_VSTOP 9
#define TARGET_VSUSP 10
/* VDSUSP not supported */
#define TARGET_VREPRINT 12
#define TARGET_VDISCARD 13
#define TARGET_VWERASE 14
#define TARGET_VLNEXT 15
#define TARGET_VEOF 16
#define TARGET_VEOL 17
/* ioctls */
#define TARGET_TCGETA 0x5401
#define TARGET_TCSETA 0x5402 /* Clashes with SNDCTL_TMR_START sound ioctl */
#define TARGET_TCSETAW 0x5403
#define TARGET_TCSETAF 0x5404
#define TARGET_TCSBRK 0x5405
#define TARGET_TCXONC 0x5406
#define TARGET_TCFLSH 0x5407
#define TARGET_TCGETS 0x540d
#define TARGET_TCSETS 0x540e
#define TARGET_TCSETSW 0x540f
#define TARGET_TCSETSF 0x5410
#define TARGET_TIOCEXCL 0x740d /* set exclusive use of tty */
#define TARGET_TIOCNXCL 0x740e /* reset exclusive use of tty */
#define TARGET_TIOCOUTQ 0x7472 /* output queue size */
#define TARGET_TIOCSTI 0x5472 /* simulate terminal input */
#define TARGET_TIOCMGET 0x741d /* get all modem bits */
#define TARGET_TIOCMBIS 0x741b /* bis modem bits */
#define TARGET_TIOCMBIC 0x741c /* bic modem bits */
#define TARGET_TIOCMSET 0x741a /* set all modem bits */
#define TARGET_TIOCPKT 0x5470 /* pty: set/clear packet mode */
#define TARGET_TIOCPKT_DATA 0x00 /* data packet */
#define TARGET_TIOCPKT_FLUSHREAD 0x01 /* flush packet */
#define TARGET_TIOCPKT_FLUSHWRITE 0x02 /* flush packet */
#define TARGET_TIOCPKT_STOP 0x04 /* stop output */
#define TARGET_TIOCPKT_START 0x08 /* start output */
#define TARGET_TIOCPKT_NOSTOP 0x10 /* no more ^S, ^Q */
#define TARGET_TIOCPKT_DOSTOP 0x20 /* now do ^S ^Q */
/* #define TIOCPKT_IOCTL 0x40 state change of pty driver */
#define TARGET_TIOCSWINSZ TARGET_IOW('t', 103, struct winsize) /* set window size */
#define TARGET_TIOCGWINSZ TARGET_IOR('t', 104, struct winsize) /* get window size */
#define TARGET_TIOCNOTTY 0x5471 /* void tty association */
#define TARGET_TIOCSETD 0x7401
#define TARGET_TIOCGETD 0x7400
#define TARGET_FIOCLEX 0x6601
#define TARGET_FIONCLEX 0x6602
#define TARGET_FIOASYNC 0x667d
#define TARGET_FIONBIO 0x667e
#define TARGET_FIOQSIZE 0x667f
#define TARGET_TIOCGLTC 0x7474 /* get special local chars */
#define TARGET_TIOCSLTC 0x7475 /* set special local chars */
#define TARGET_TIOCSPGRP TARGET_IOW('t', 118, int) /* set pgrp of tty */
#define TARGET_TIOCGPGRP TARGET_IOR('t', 119, int) /* get pgrp of tty */
#define TARGET_TIOCCONS TARGET_IOW('t', 120, int) /* become virtual console */
#define TARGET_FIONREAD 0x467f
#define TARGET_TIOCINQ TARGET_FIONREAD
#define TARGET_TIOCGETP 0x7408
#define TARGET_TIOCSETP 0x7409
#define TARGET_TIOCSETN 0x740a /* TIOCSETP wo flush */
/* #define TARGET_TIOCSETA TARGET_IOW('t', 20, struct termios) set termios struct */
/* #define TARGET_TIOCSETAW TARGET_IOW('t', 21, struct termios) drain output, set */
/* #define TARGET_TIOCSETAF TARGET_IOW('t', 22, struct termios) drn out, fls in, set */
/* #define TARGET_TIOCGETD TARGET_IOR('t', 26, int) get line discipline */
/* #define TARGET_TIOCSETD TARGET_IOW('t', 27, int) set line discipline */
/* 127-124 compat */
#define TARGET_TIOCSBRK 0x5427 /* BSD compatibility */
#define TARGET_TIOCCBRK 0x5428 /* BSD compatibility */
#define TARGET_TIOCGSID 0x7416 /* Return the session ID of FD */
#define TARGET_TIOCGPTN TARGET_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
#define TARGET_TIOCSPTLCK TARGET_IOW('T',0x31, int) /* Lock/unlock Pty */
/* I hope the range from 0x5480 on is free ... */
#define TARGET_TIOCSCTTY 0x5480 /* become controlling tty */
#define TARGET_TIOCGSOFTCAR 0x5481
#define TARGET_TIOCSSOFTCAR 0x5482
#define TARGET_TIOCLINUX 0x5483
#define TARGET_TIOCGSERIAL 0x5484
#define TARGET_TIOCSSERIAL 0x5485
#define TARGET_TCSBRKP 0x5486 /* Needed for POSIX tcsendbreak() */
#define TARGET_TIOCSERCONFIG 0x5488
#define TARGET_TIOCSERGWILD 0x5489
#define TARGET_TIOCSERSWILD 0x548a
#define TARGET_TIOCGLCKTRMIOS 0x548b
#define TARGET_TIOCSLCKTRMIOS 0x548c
#define TARGET_TIOCSERGSTRUCT 0x548d /* For debugging only */
#define TARGET_TIOCSERGETLSR 0x548e /* Get line status register */
#define TARGET_TIOCSERGETMULTI 0x548f /* Get multiport config */
#define TARGET_TIOCSERSETMULTI 0x5490 /* Set multiport config */
#define TARGET_TIOCMIWAIT 0x5491 /* wait for a change on serial input line(s) */
#define TARGET_TIOCGICOUNT 0x5492 /* read serial port inline interrupt counts */
#define TARGET_TIOCGHAYESESP 0x5493 /* Get Hayes ESP configuration */
#define TARGET_TIOCSHAYESESP 0x5494 /* Set Hayes ESP configuration */

14
linux-user/mmap.c
View File

@ -17,8 +17,6 @@
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include <linux/mman.h>
#include <linux/unistd.h>
#include "qemu.h"
#include "qemu-common.h"
@ -681,10 +679,8 @@ abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
mmap_lock();
if (flags & MREMAP_FIXED) {
host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
old_size, new_size,
flags,
g2h(new_addr));
host_addr = mremap(g2h(old_addr), old_size, new_size,
flags, g2h(new_addr));
if (reserved_va && host_addr != MAP_FAILED) {
/* If new and old addresses overlap then the above mremap will
@ -700,10 +696,8 @@ abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
errno = ENOMEM;
host_addr = MAP_FAILED;
} else {
host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
old_size, new_size,
flags | MREMAP_FIXED,
g2h(mmap_start));
host_addr = mremap(g2h(old_addr), old_size, new_size,
flags | MREMAP_FIXED, g2h(mmap_start));
if (reserved_va) {
mmap_reserve(old_addr, old_size);
}

7
linux-user/sparc64/target_syscall.h
View File

@ -23,4 +23,11 @@ struct target_pt_regs {
#define TARGET_MLOCKALL_MCL_CURRENT 0x2000
#define TARGET_MLOCKALL_MCL_FUTURE 0x4000
#define TARGET_FORCE_SHMLBA
static inline abi_ulong target_shmlba(CPUSPARCState *env)
{
return MAX(TARGET_PAGE_SIZE, 16 * 1024);
}
#endif /* SPARC64_TARGET_SYSCALL_H */

233
linux-user/strace.c
View File

@ -435,6 +435,69 @@ print_fdset(int n, abi_ulong target_fds_addr)
}
#endif
#ifdef TARGET_NR_clock_adjtime
/* IDs of the various system clocks */
#define TARGET_CLOCK_REALTIME 0
#define TARGET_CLOCK_MONOTONIC 1
#define TARGET_CLOCK_PROCESS_CPUTIME_ID 2
#define TARGET_CLOCK_THREAD_CPUTIME_ID 3
#define TARGET_CLOCK_MONOTONIC_RAW 4
#define TARGET_CLOCK_REALTIME_COARSE 5
#define TARGET_CLOCK_MONOTONIC_COARSE 6
#define TARGET_CLOCK_BOOTTIME 7
#define TARGET_CLOCK_REALTIME_ALARM 8
#define TARGET_CLOCK_BOOTTIME_ALARM 9
#define TARGET_CLOCK_SGI_CYCLE 10
#define TARGET_CLOCK_TAI 11
static void
print_clockid(int clockid, int last)
{
switch (clockid) {
case TARGET_CLOCK_REALTIME:
gemu_log("CLOCK_REALTIME");
break;
case TARGET_CLOCK_MONOTONIC:
gemu_log("CLOCK_MONOTONIC");
break;
case TARGET_CLOCK_PROCESS_CPUTIME_ID:
gemu_log("CLOCK_PROCESS_CPUTIME_ID");
break;
case TARGET_CLOCK_THREAD_CPUTIME_ID:
gemu_log("CLOCK_THREAD_CPUTIME_ID");
break;
case TARGET_CLOCK_MONOTONIC_RAW:
gemu_log("CLOCK_MONOTONIC_RAW");
break;
case TARGET_CLOCK_REALTIME_COARSE:
gemu_log("CLOCK_REALTIME_COARSE");
break;
case TARGET_CLOCK_MONOTONIC_COARSE:
gemu_log("CLOCK_MONOTONIC_COARSE");
break;
case TARGET_CLOCK_BOOTTIME:
gemu_log("CLOCK_BOOTTIME");
break;
case TARGET_CLOCK_REALTIME_ALARM:
gemu_log("CLOCK_REALTIME_ALARM");
break;
case TARGET_CLOCK_BOOTTIME_ALARM:
gemu_log("CLOCK_BOOTTIME_ALARM");
break;
case TARGET_CLOCK_SGI_CYCLE:
gemu_log("CLOCK_SGI_CYCLE");
break;
case TARGET_CLOCK_TAI:
gemu_log("CLOCK_TAI");
break;
default:
gemu_log("%d", clockid);
break;
}
gemu_log("%s", get_comma(last));
}
#endif
/*
* Sysycall specific output functions
*/
@ -577,6 +640,52 @@ print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
}
#endif
/* special meanings of adjtimex()' non-negative return values */
#define TARGET_TIME_OK 0 /* clock synchronized, no leap second */
#define TARGET_TIME_INS 1 /* insert leap second */
#define TARGET_TIME_DEL 2 /* delete leap second */
#define TARGET_TIME_OOP 3 /* leap second in progress */
#define TARGET_TIME_WAIT 4 /* leap second has occurred */
#define TARGET_TIME_ERROR 5 /* clock not synchronized */
static void
print_syscall_ret_adjtimex(const struct syscallname *name, abi_long ret)
{
const char *errstr = NULL;
gemu_log(" = ");
if (ret < 0) {
gemu_log("-1 errno=%d", errno);
errstr = target_strerror(-ret);
if (errstr) {
gemu_log(" (%s)", errstr);
}
} else {
gemu_log(TARGET_ABI_FMT_ld, ret);
switch (ret) {
case TARGET_TIME_OK:
gemu_log(" TIME_OK (clock synchronized, no leap second)");
break;
case TARGET_TIME_INS:
gemu_log(" TIME_INS (insert leap second)");
break;
case TARGET_TIME_DEL:
gemu_log(" TIME_DEL (delete leap second)");
break;
case TARGET_TIME_OOP:
gemu_log(" TIME_OOP (leap second in progress)");
break;
case TARGET_TIME_WAIT:
gemu_log(" TIME_WAIT (leap second has occurred)");
break;
case TARGET_TIME_ERROR:
gemu_log(" TIME_ERROR (clock not synchronized)");
break;
}
}
gemu_log("\n");
}
UNUSED static struct flags access_flags[] = {
FLAG_GENERIC(F_OK),
FLAG_GENERIC(R_OK),
@ -1050,6 +1159,19 @@ print_chmod(const struct syscallname *name,
}
#endif
#ifdef TARGET_NR_clock_adjtime
static void
print_clock_adjtime(const struct syscallname *name,
abi_long arg0, abi_long arg1, abi_long arg2,
abi_long arg3, abi_long arg4, abi_long arg5)
{
print_syscall_prologue(name);
print_clockid(arg0, 0);
print_pointer(arg1, 1);
print_syscall_epilogue(name);
}
#endif
#ifdef TARGET_NR_clone
static void do_print_clone(unsigned int flags, abi_ulong newsp,
abi_ulong parent_tidptr, target_ulong newtls,
@ -1629,29 +1751,32 @@ print_optint:
}
#define PRINT_SOCKOP(name, func) \
[SOCKOP_##name] = { #name, func }
[TARGET_SYS_##name] = { #name, func }
static struct {
const char *name;
void (*print)(const char *, abi_long);
} scall[] = {
PRINT_SOCKOP(socket, do_print_socket),
PRINT_SOCKOP(bind, do_print_sockaddr),
PRINT_SOCKOP(connect, do_print_sockaddr),
PRINT_SOCKOP(listen, do_print_listen),
PRINT_SOCKOP(accept, do_print_sockaddr),
PRINT_SOCKOP(getsockname, do_print_sockaddr),
PRINT_SOCKOP(getpeername, do_print_sockaddr),
PRINT_SOCKOP(socketpair, do_print_socketpair),
PRINT_SOCKOP(send, do_print_sendrecv),
PRINT_SOCKOP(recv, do_print_sendrecv),
PRINT_SOCKOP(sendto, do_print_msgaddr),
PRINT_SOCKOP(recvfrom, do_print_msgaddr),
PRINT_SOCKOP(shutdown, do_print_shutdown),
PRINT_SOCKOP(sendmsg, do_print_msg),
PRINT_SOCKOP(recvmsg, do_print_msg),
PRINT_SOCKOP(setsockopt, do_print_sockopt),
PRINT_SOCKOP(getsockopt, do_print_sockopt),
PRINT_SOCKOP(SOCKET, do_print_socket),
PRINT_SOCKOP(BIND, do_print_sockaddr),
PRINT_SOCKOP(CONNECT, do_print_sockaddr),
PRINT_SOCKOP(LISTEN, do_print_listen),
PRINT_SOCKOP(ACCEPT, do_print_sockaddr),
PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr),
PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr),
PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair),
PRINT_SOCKOP(SEND, do_print_sendrecv),
PRINT_SOCKOP(RECV, do_print_sendrecv),
PRINT_SOCKOP(SENDTO, do_print_msgaddr),
PRINT_SOCKOP(RECVFROM, do_print_msgaddr),
PRINT_SOCKOP(SHUTDOWN, do_print_shutdown),
PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt),
PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt),
PRINT_SOCKOP(SENDMSG, do_print_msg),
PRINT_SOCKOP(RECVMSG, do_print_msg),
PRINT_SOCKOP(ACCEPT4, NULL),
PRINT_SOCKOP(RECVMMSG, NULL),
PRINT_SOCKOP(SENDMMSG, NULL),
};
static void
@ -1778,6 +1903,78 @@ print_rt_sigprocmask(const struct syscallname *name,
}
#endif
#ifdef TARGET_NR_syslog
static void
print_syslog_action(abi_ulong arg, int last)
{
const char *type;
switch (arg) {
case TARGET_SYSLOG_ACTION_CLOSE: {
type = "SYSLOG_ACTION_CLOSE";
break;
}
case TARGET_SYSLOG_ACTION_OPEN: {
type = "SYSLOG_ACTION_OPEN";
break;
}
case TARGET_SYSLOG_ACTION_READ: {
type = "SYSLOG_ACTION_READ";
break;
}
case TARGET_SYSLOG_ACTION_READ_ALL: {
type = "SYSLOG_ACTION_READ_ALL";
break;
}
case TARGET_SYSLOG_ACTION_READ_CLEAR: {
type = "SYSLOG_ACTION_READ_CLEAR";
break;
}
case TARGET_SYSLOG_ACTION_CLEAR: {
type = "SYSLOG_ACTION_CLEAR";
break;
}
case TARGET_SYSLOG_ACTION_CONSOLE_OFF: {
type = "SYSLOG_ACTION_CONSOLE_OFF";
break;
}
case TARGET_SYSLOG_ACTION_CONSOLE_ON: {
type = "SYSLOG_ACTION_CONSOLE_ON";
break;
}
case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: {
type = "SYSLOG_ACTION_CONSOLE_LEVEL";
break;
}
case TARGET_SYSLOG_ACTION_SIZE_UNREAD: {
type = "SYSLOG_ACTION_SIZE_UNREAD";
break;
}
case TARGET_SYSLOG_ACTION_SIZE_BUFFER: {
type = "SYSLOG_ACTION_SIZE_BUFFER";
break;
}
default: {
print_raw_param("%ld", arg, last);
return;
}
}
gemu_log("%s%s", type, get_comma(last));
}
static void
print_syslog(const struct syscallname *name,
abi_long arg0, abi_long arg1, abi_long arg2,
abi_long arg3, abi_long arg4, abi_long arg5)
{
print_syscall_prologue(name);
print_syslog_action(arg0, 0);
print_pointer(arg1, 0);
print_raw_param("%d", arg2, 1);
print_syscall_epilogue(name);
}
#endif
#ifdef TARGET_NR_mknod
static void
print_mknod(const struct syscallname *name,

13
linux-user/strace.list
View File

@ -19,7 +19,8 @@
{ TARGET_NR_add_key, "add_key" , NULL, NULL, NULL },
#endif
#ifdef TARGET_NR_adjtimex
{ TARGET_NR_adjtimex, "adjtimex" , NULL, NULL, NULL },
{ TARGET_NR_adjtimex, "adjtimex" , "%s(%p)", NULL,
print_syscall_ret_adjtimex },
#endif
#ifdef TARGET_NR_afs_syscall
{ TARGET_NR_afs_syscall, "afs_syscall" , NULL, NULL, NULL },
@ -78,6 +79,9 @@
#ifdef TARGET_NR_chroot
{ TARGET_NR_chroot, "chroot" , NULL, NULL, NULL },
#endif
#ifdef TARGET_NR_clock_adjtime
{ TARGET_NR_clock_adjtime, "clock_adjtime" , NULL, print_clock_adjtime, NULL },
#endif
#ifdef TARGET_NR_clock_getres
{ TARGET_NR_clock_getres, "clock_getres" , NULL, NULL, NULL },
#endif
@ -1454,11 +1458,8 @@
#ifdef TARGET_NR_sync
{ TARGET_NR_sync, "sync" , NULL, NULL, NULL },
#endif
#ifdef TARGET_NR_sync_file_range
{ TARGET_NR_sync_file_range, "sync_file_range" , NULL, NULL, NULL },
#endif
#ifdef TARGET_NR_syncfs
{ TARGET_NR_syncfs, "syncfs" , NULL, NULL, NULL },
{ TARGET_NR_syncfs, "syncfs" , "%s(%d)", NULL, NULL },
#endif
#ifdef TARGET_NR_syscall
{ TARGET_NR_syscall, "syscall" , NULL, NULL, NULL },
@ -1485,7 +1486,7 @@
{ TARGET_NR_sys_kexec_load, "sys_kexec_load" , NULL, NULL, NULL },
#endif
#ifdef TARGET_NR_syslog
{ TARGET_NR_syslog, "syslog" , NULL, NULL, NULL },
{ TARGET_NR_syslog, "syslog" , NULL, print_syslog, NULL },
#endif
#ifdef TARGET_NR_sysmips
{ TARGET_NR_sysmips, "sysmips" , NULL, NULL, NULL },

360
linux-user/syscall.c
View File

@ -35,6 +35,7 @@
#include <sys/swap.h>
#include <linux/capability.h>
#include <sched.h>
#include <sys/timex.h>
#ifdef __ia64__
int __clone2(int (*fn)(void *), void *child_stack_base,
size_t stack_size, int flags, void *arg, ...);
@ -47,6 +48,7 @@ int __clone2(int (*fn)(void *), void *child_stack_base,
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/statfs.h>
#include <time.h>
#include <utime.h>
#include <sys/sysinfo.h>
#include <sys/signalfd.h>
@ -304,6 +306,11 @@ _syscall3(int, ioprio_set, int, which, int, who, int, ioprio)
_syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags)
#endif
#if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
_syscall5(int, kcmp, pid_t, pid1, pid_t, pid2, int, type,
unsigned long, idx1, unsigned long, idx2)
#endif
static bitmask_transtbl fcntl_flags_tbl[] = {
{ TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
{ TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
@ -788,6 +795,9 @@ static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
#ifdef ENOTRECOVERABLE
[ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
#endif
#ifdef ENOMSG
[ENOMSG] = TARGET_ENOMSG,
#endif
};
static inline int host_to_target_errno(int err)
@ -908,6 +918,10 @@ safe_syscall2(int, tkill, int, tid, int, sig)
safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig)
safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt)
safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt)
safe_syscall5(ssize_t, preadv, int, fd, const struct iovec *, iov, int, iovcnt,
unsigned long, pos_l, unsigned long, pos_h)
safe_syscall5(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt,
unsigned long, pos_l, unsigned long, pos_h)
safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr,
socklen_t, addrlen)
safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len,
@ -2591,6 +2605,7 @@ static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
case RTA_GATEWAY:
break;
/* u32 */
case RTA_PRIORITY:
case RTA_OIF:
u32 = RTA_DATA(rtattr);
*u32 = tswap32(*u32);
@ -3893,89 +3908,94 @@ fail:
}
#ifdef TARGET_NR_socketcall
/* do_socketcall() Must return target values and target errnos. */
/* do_socketcall() must return target values and target errnos. */
static abi_long do_socketcall(int num, abi_ulong vptr)
{
static const unsigned ac[] = { /* number of arguments per call */
[SOCKOP_socket] = 3, /* domain, type, protocol */
[SOCKOP_bind] = 3, /* sockfd, addr, addrlen */
[SOCKOP_connect] = 3, /* sockfd, addr, addrlen */
[SOCKOP_listen] = 2, /* sockfd, backlog */
[SOCKOP_accept] = 3, /* sockfd, addr, addrlen */
[SOCKOP_accept4] = 4, /* sockfd, addr, addrlen, flags */
[SOCKOP_getsockname] = 3, /* sockfd, addr, addrlen */
[SOCKOP_getpeername] = 3, /* sockfd, addr, addrlen */
[SOCKOP_socketpair] = 4, /* domain, type, protocol, tab */
[SOCKOP_send] = 4, /* sockfd, msg, len, flags */
[SOCKOP_recv] = 4, /* sockfd, msg, len, flags */
[SOCKOP_sendto] = 6, /* sockfd, msg, len, flags, addr, addrlen */
[SOCKOP_recvfrom] = 6, /* sockfd, msg, len, flags, addr, addrlen */
[SOCKOP_shutdown] = 2, /* sockfd, how */
[SOCKOP_sendmsg] = 3, /* sockfd, msg, flags */
[SOCKOP_recvmsg] = 3, /* sockfd, msg, flags */
[SOCKOP_sendmmsg] = 4, /* sockfd, msgvec, vlen, flags */
[SOCKOP_recvmmsg] = 4, /* sockfd, msgvec, vlen, flags */
[SOCKOP_setsockopt] = 5, /* sockfd, level, optname, optval, optlen */
[SOCKOP_getsockopt] = 5, /* sockfd, level, optname, optval, optlen */
static const unsigned nargs[] = { /* number of arguments per operation */
[TARGET_SYS_SOCKET] = 3, /* domain, type, protocol */
[TARGET_SYS_BIND] = 3, /* fd, addr, addrlen */
[TARGET_SYS_CONNECT] = 3, /* fd, addr, addrlen */
[TARGET_SYS_LISTEN] = 2, /* fd, backlog */
[TARGET_SYS_ACCEPT] = 3, /* fd, addr, addrlen */
[TARGET_SYS_GETSOCKNAME] = 3, /* fd, addr, addrlen */
[TARGET_SYS_GETPEERNAME] = 3, /* fd, addr, addrlen */
[TARGET_SYS_SOCKETPAIR] = 4, /* domain, type, protocol, tab */
[TARGET_SYS_SEND] = 4, /* fd, msg, len, flags */
[TARGET_SYS_RECV] = 4, /* fd, msg, len, flags */
[TARGET_SYS_SENDTO] = 6, /* fd, msg, len, flags, addr, addrlen */
[TARGET_SYS_RECVFROM] = 6, /* fd, msg, len, flags, addr, addrlen */
[TARGET_SYS_SHUTDOWN] = 2, /* fd, how */
[TARGET_SYS_SETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
[TARGET_SYS_GETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
[TARGET_SYS_SENDMSG] = 3, /* fd, msg, flags */
[TARGET_SYS_RECVMSG] = 3, /* fd, msg, flags */
[TARGET_SYS_ACCEPT4] = 4, /* fd, addr, addrlen, flags */
[TARGET_SYS_RECVMMSG] = 4, /* fd, msgvec, vlen, flags */
[TARGET_SYS_SENDMMSG] = 4, /* fd, msgvec, vlen, flags */
};
abi_long a[6]; /* max 6 args */
unsigned i;
/* first, collect the arguments in a[] according to ac[] */
if (num >= 0 && num < ARRAY_SIZE(ac)) {
unsigned i;
assert(ARRAY_SIZE(a) >= ac[num]); /* ensure we have space for args */
for (i = 0; i < ac[num]; ++i) {
if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
return -TARGET_EFAULT;
}
/* check the range of the first argument num */
/* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
if (num < 1 || num > TARGET_SYS_SENDMMSG) {
return -TARGET_EINVAL;
}
/* ensure we have space for args */
if (nargs[num] > ARRAY_SIZE(a)) {
return -TARGET_EINVAL;
}
/* collect the arguments in a[] according to nargs[] */
for (i = 0; i < nargs[num]; ++i) {
if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
return -TARGET_EFAULT;
}
}
/* now when we have the args, actually handle the call */
/* now when we have the args, invoke the appropriate underlying function */
switch (num) {
case SOCKOP_socket: /* domain, type, protocol */
case TARGET_SYS_SOCKET: /* domain, type, protocol */
return do_socket(a[0], a[1], a[2]);
case SOCKOP_bind: /* sockfd, addr, addrlen */
case TARGET_SYS_BIND: /* sockfd, addr, addrlen */
return do_bind(a[0], a[1], a[2]);
case SOCKOP_connect: /* sockfd, addr, addrlen */
case TARGET_SYS_CONNECT: /* sockfd, addr, addrlen */
return do_connect(a[0], a[1], a[2]);
case SOCKOP_listen: /* sockfd, backlog */
case TARGET_SYS_LISTEN: /* sockfd, backlog */
return get_errno(listen(a[0], a[1]));
case SOCKOP_accept: /* sockfd, addr, addrlen */
case TARGET_SYS_ACCEPT: /* sockfd, addr, addrlen */
return do_accept4(a[0], a[1], a[2], 0);
case SOCKOP_accept4: /* sockfd, addr, addrlen, flags */
return do_accept4(a[0], a[1], a[2], a[3]);
case SOCKOP_getsockname: /* sockfd, addr, addrlen */
case TARGET_SYS_GETSOCKNAME: /* sockfd, addr, addrlen */
return do_getsockname(a[0], a[1], a[2]);
case SOCKOP_getpeername: /* sockfd, addr, addrlen */
case TARGET_SYS_GETPEERNAME: /* sockfd, addr, addrlen */
return do_getpeername(a[0], a[1], a[2]);
case SOCKOP_socketpair: /* domain, type, protocol, tab */
case TARGET_SYS_SOCKETPAIR: /* domain, type, protocol, tab */
return do_socketpair(a[0], a[1], a[2], a[3]);
case SOCKOP_send: /* sockfd, msg, len, flags */
case TARGET_SYS_SEND: /* sockfd, msg, len, flags */
return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
case SOCKOP_recv: /* sockfd, msg, len, flags */
case TARGET_SYS_RECV: /* sockfd, msg, len, flags */
return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
case SOCKOP_sendto: /* sockfd, msg, len, flags, addr, addrlen */
case TARGET_SYS_SENDTO: /* sockfd, msg, len, flags, addr, addrlen */
return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
case SOCKOP_recvfrom: /* sockfd, msg, len, flags, addr, addrlen */
case TARGET_SYS_RECVFROM: /* sockfd, msg, len, flags, addr, addrlen */
return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
case SOCKOP_shutdown: /* sockfd, how */
case TARGET_SYS_SHUTDOWN: /* sockfd, how */
return get_errno(shutdown(a[0], a[1]));
case SOCKOP_sendmsg: /* sockfd, msg, flags */
return do_sendrecvmsg(a[0], a[1], a[2], 1);
case SOCKOP_recvmsg: /* sockfd, msg, flags */
return do_sendrecvmsg(a[0], a[1], a[2], 0);
case SOCKOP_sendmmsg: /* sockfd, msgvec, vlen, flags */
return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
case SOCKOP_recvmmsg: /* sockfd, msgvec, vlen, flags */
return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
case SOCKOP_setsockopt: /* sockfd, level, optname, optval, optlen */
case TARGET_SYS_SETSOCKOPT: /* sockfd, level, optname, optval, optlen */
return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
case SOCKOP_getsockopt: /* sockfd, level, optname, optval, optlen */
case TARGET_SYS_GETSOCKOPT: /* sockfd, level, optname, optval, optlen */
return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
case TARGET_SYS_SENDMSG: /* sockfd, msg, flags */
return do_sendrecvmsg(a[0], a[1], a[2], 1);
case TARGET_SYS_RECVMSG: /* sockfd, msg, flags */
return do_sendrecvmsg(a[0], a[1], a[2], 0);
case TARGET_SYS_ACCEPT4: /* sockfd, addr, addrlen, flags */
return do_accept4(a[0], a[1], a[2], a[3]);
case TARGET_SYS_RECVMMSG: /* sockfd, msgvec, vlen, flags */
return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */
return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
default:
gemu_log("Unsupported socketcall: %d\n", num);
return -TARGET_ENOSYS;
return -TARGET_EINVAL;
}
}
#endif
@ -6770,6 +6790,77 @@ static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
return 0;
}
static inline abi_long target_to_host_timex(struct timex *host_tx,
abi_long target_addr)
{
struct target_timex *target_tx;
if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
return -TARGET_EFAULT;
}
__get_user(host_tx->modes, &target_tx->modes);
__get_user(host_tx->offset, &target_tx->offset);
__get_user(host_tx->freq, &target_tx->freq);
__get_user(host_tx->maxerror, &target_tx->maxerror);
__get_user(host_tx->esterror, &target_tx->esterror);
__get_user(host_tx->status, &target_tx->status);
__get_user(host_tx->constant, &target_tx->constant);
__get_user(host_tx->precision, &target_tx->precision);
__get_user(host_tx->tolerance, &target_tx->tolerance);
__get_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
__get_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
__get_user(host_tx->tick, &target_tx->tick);
__get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
__get_user(host_tx->jitter, &target_tx->jitter);
__get_user(host_tx->shift, &target_tx->shift);
__get_user(host_tx->stabil, &target_tx->stabil);
__get_user(host_tx->jitcnt, &target_tx->jitcnt);
__get_user(host_tx->calcnt, &target_tx->calcnt);
__get_user(host_tx->errcnt, &target_tx->errcnt);
__get_user(host_tx->stbcnt, &target_tx->stbcnt);
__get_user(host_tx->tai, &target_tx->tai);
unlock_user_struct(target_tx, target_addr, 0);
return 0;
}
static inline abi_long host_to_target_timex(abi_long target_addr,
struct timex *host_tx)
{
struct target_timex *target_tx;
if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
return -TARGET_EFAULT;
}
__put_user(host_tx->modes, &target_tx->modes);
__put_user(host_tx->offset, &target_tx->offset);
__put_user(host_tx->freq, &target_tx->freq);
__put_user(host_tx->maxerror, &target_tx->maxerror);
__put_user(host_tx->esterror, &target_tx->esterror);
__put_user(host_tx->status, &target_tx->status);
__put_user(host_tx->constant, &target_tx->constant);
__put_user(host_tx->precision, &target_tx->precision);
__put_user(host_tx->tolerance, &target_tx->tolerance);
__put_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
__put_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
__put_user(host_tx->tick, &target_tx->tick);
__put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
__put_user(host_tx->jitter, &target_tx->jitter);
__put_user(host_tx->shift, &target_tx->shift);
__put_user(host_tx->stabil, &target_tx->stabil);
__put_user(host_tx->jitcnt, &target_tx->jitcnt);
__put_user(host_tx->calcnt, &target_tx->calcnt);
__put_user(host_tx->errcnt, &target_tx->errcnt);
__put_user(host_tx->stbcnt, &target_tx->stbcnt);
__put_user(host_tx->tai, &target_tx->tai);
unlock_user_struct(target_tx, target_addr, 1);
return 0;
}
static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp,
abi_ulong target_addr)
{
@ -8003,6 +8094,11 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
sync();
ret = 0;
break;
#if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
case TARGET_NR_syncfs:
ret = get_errno(syncfs(arg1));
break;
#endif
case TARGET_NR_kill:
ret = get_errno(safe_kill(arg1, target_to_host_signal(arg2)));
break;
@ -9240,14 +9336,52 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
break;
#endif
#if defined(TARGET_NR_syslog)
case TARGET_NR_syslog:
if (!(p = lock_user_string(arg2)))
goto efault;
ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
unlock_user(p, arg2, 0);
break;
{
int len = arg2;
switch (arg1) {
case TARGET_SYSLOG_ACTION_CLOSE: /* Close log */
case TARGET_SYSLOG_ACTION_OPEN: /* Open log */
case TARGET_SYSLOG_ACTION_CLEAR: /* Clear ring buffer */
case TARGET_SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging */
case TARGET_SYSLOG_ACTION_CONSOLE_ON: /* Enable logging */
case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */
case TARGET_SYSLOG_ACTION_SIZE_UNREAD: /* Number of chars */
case TARGET_SYSLOG_ACTION_SIZE_BUFFER: /* Size of the buffer */
{
ret = get_errno(sys_syslog((int)arg1, NULL, (int)arg3));
}
break;
case TARGET_SYSLOG_ACTION_READ: /* Read from log */
case TARGET_SYSLOG_ACTION_READ_CLEAR: /* Read/clear msgs */
case TARGET_SYSLOG_ACTION_READ_ALL: /* Read last messages */
{
ret = -TARGET_EINVAL;
if (len < 0) {
goto fail;
}
ret = 0;
if (len == 0) {
break;
}
p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
if (!p) {
ret = -TARGET_EFAULT;
goto fail;
}
ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
unlock_user(p, arg2, arg3);
}
break;
default:
ret = -EINVAL;
break;
}
}
break;
#endif
case TARGET_NR_setitimer:
{
struct itimerval value, ovalue, *pvalue;
@ -9543,7 +9677,37 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
#endif
#endif
case TARGET_NR_adjtimex:
goto unimplemented;
{
struct timex host_buf;
if (target_to_host_timex(&host_buf, arg1) != 0) {
goto efault;
}
ret = get_errno(adjtimex(&host_buf));
if (!is_error(ret)) {
if (host_to_target_timex(arg1, &host_buf) != 0) {
goto efault;
}
}
}
break;
#if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
case TARGET_NR_clock_adjtime:
{
struct timex htx, *phtx = &htx;
if (target_to_host_timex(phtx, arg2) != 0) {
goto efault;
}
ret = get_errno(clock_adjtime(arg1, phtx));
if (!is_error(ret) && phtx) {
if (host_to_target_timex(arg2, phtx) != 0) {
goto efault;
}
}
}
break;
#endif
#ifdef TARGET_NR_create_module
case TARGET_NR_create_module:
#endif
@ -9899,6 +10063,32 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
}
}
break;
#if defined(TARGET_NR_preadv)
case TARGET_NR_preadv:
{
struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
if (vec != NULL) {
ret = get_errno(safe_preadv(arg1, vec, arg3, arg4, arg5));
unlock_iovec(vec, arg2, arg3, 1);
} else {
ret = -host_to_target_errno(errno);
}
}
break;
#endif
#if defined(TARGET_NR_pwritev)
case TARGET_NR_pwritev:
{
struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
if (vec != NULL) {
ret = get_errno(safe_pwritev(arg1, vec, arg3, arg4, arg5));
unlock_iovec(vec, arg2, arg3, 0);
} else {
ret = -host_to_target_errno(errno);
}
}
break;
#endif
case TARGET_NR_getsid:
ret = get_errno(getsid(arg1));
break;
@ -11372,16 +11562,18 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
case TARGET_NR_mq_open:
{
struct mq_attr posix_mq_attr, *attrp;
struct mq_attr posix_mq_attr;
int host_flags;
p = lock_user_string(arg1 - 1);
if (arg4 != 0) {
copy_from_user_mq_attr (&posix_mq_attr, arg4);
attrp = &posix_mq_attr;
} else {
attrp = 0;
host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl);
if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) {
goto efault;
}
ret = get_errno(mq_open(p, arg2, arg3, attrp));
p = lock_user_string(arg1 - 1);
if (!p) {
goto efault;
}
ret = get_errno(mq_open(p, host_flags, arg3, &posix_mq_attr));
unlock_user (p, arg1, 0);
}
break;
@ -11638,7 +11830,12 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
goto efault;
}
ep = alloca(maxevents * sizeof(struct epoll_event));
ep = g_try_new(struct epoll_event, maxevents);
if (!ep) {
unlock_user(target_ep, arg2, 0);
ret = -TARGET_ENOMEM;
break;
}
switch (num) {
#if defined(TARGET_NR_epoll_pwait)
@ -11656,8 +11853,8 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
target_set = lock_user(VERIFY_READ, arg5,
sizeof(target_sigset_t), 1);
if (!target_set) {
unlock_user(target_ep, arg2, 0);
goto efault;
ret = -TARGET_EFAULT;
break;
}
target_to_host_sigset(set, target_set);
unlock_user(target_set, arg5, 0);
@ -11685,8 +11882,12 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
target_ep[i].events = tswap32(ep[i].events);
target_ep[i].data.u64 = tswap64(ep[i].data.u64);
}
unlock_user(target_ep, arg2,
ret * sizeof(struct target_epoll_event));
} else {
unlock_user(target_ep, arg2, 0);
}
unlock_user(target_ep, arg2, ret * sizeof(struct target_epoll_event));
g_free(ep);
break;
}
#endif
@ -11947,6 +12148,11 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
ret = get_errno(unshare(arg1));
break;
#endif
#if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
case TARGET_NR_kcmp:
ret = get_errno(kcmp(arg1, arg2, arg3, arg4, arg5));
break;
#endif
default:
unimplemented:

111
linux-user/syscall_defs.h
View File

@ -9,26 +9,28 @@
#include "syscall_nr.h"
#define SOCKOP_socket 1
#define SOCKOP_bind 2
#define SOCKOP_connect 3
#define SOCKOP_listen 4
#define SOCKOP_accept 5
#define SOCKOP_getsockname 6
#define SOCKOP_getpeername 7
#define SOCKOP_socketpair 8
#define SOCKOP_send 9
#define SOCKOP_recv 10
#define SOCKOP_sendto 11
#define SOCKOP_recvfrom 12
#define SOCKOP_shutdown 13
#define SOCKOP_setsockopt 14
#define SOCKOP_getsockopt 15
#define SOCKOP_sendmsg 16
#define SOCKOP_recvmsg 17
#define SOCKOP_accept4 18
#define SOCKOP_recvmmsg 19
#define SOCKOP_sendmmsg 20
/* socket operations for socketcall() */
#define TARGET_SYS_SOCKET 1 /* socket() */
#define TARGET_SYS_BIND 2 /* bind() */
#define TARGET_SYS_CONNECT 3 /* connect() */
#define TARGET_SYS_LISTEN 4 /* listen() */
#define TARGET_SYS_ACCEPT 5 /* accept() */
#define TARGET_SYS_GETSOCKNAME 6 /* getsockname() */
#define TARGET_SYS_GETPEERNAME 7 /* getpeername() */
#define TARGET_SYS_SOCKETPAIR 8 /* socketpair() */
#define TARGET_SYS_SEND 9 /* send() */
#define TARGET_SYS_RECV 10 /* recv() */
#define TARGET_SYS_SENDTO 11 /* sendto() */
#define TARGET_SYS_RECVFROM 12 /* recvfrom() */
#define TARGET_SYS_SHUTDOWN 13 /* shutdown() */
#define TARGET_SYS_SETSOCKOPT 14 /* setsockopt() */
#define TARGET_SYS_GETSOCKOPT 15 /* getsockopt() */
#define TARGET_SYS_SENDMSG 16 /* sendmsg() */
#define TARGET_SYS_RECVMSG 17 /* recvmsg() */
#define TARGET_SYS_ACCEPT4 18 /* accept4() */
#define TARGET_SYS_RECVMMSG 19 /* recvmmsg() */
#define TARGET_SYS_SENDMMSG 20 /* sendmmsg() */
#define IPCOP_semop 1
#define IPCOP_semget 2
@ -207,6 +209,34 @@ struct target_itimerspec {
struct target_timespec it_value;
};
struct target_timex {
abi_uint modes; /* Mode selector */
abi_long offset; /* Time offset */
abi_long freq; /* Frequency offset */
abi_long maxerror; /* Maximum error (microseconds) */
abi_long esterror; /* Estimated error (microseconds) */
abi_int status; /* Clock command/status */
abi_long constant; /* PLL (phase-locked loop) time constant */
abi_long precision; /* Clock precision (microseconds, ro) */
abi_long tolerance; /* Clock freq. tolerance (ppm, ro) */
struct target_timeval time; /* Current time */
abi_long tick; /* Microseconds between clock ticks */
abi_long ppsfreq; /* PPS (pulse per second) frequency */
abi_long jitter; /* PPS jitter (ro); nanoseconds */
abi_int shift; /* PPS interval duration (seconds) */
abi_long stabil; /* PPS stability */
abi_long jitcnt; /* PPS jitter limit exceeded (ro) */
abi_long calcnt; /* PPS calibration intervals */
abi_long errcnt; /* PPS calibration errors */
abi_long stbcnt; /* PPS stability limit exceeded */
abi_int tai; /* TAI offset */
/* Further padding bytes to allow for future expansion */
abi_int:32; abi_int:32; abi_int:32; abi_int:32;
abi_int:32; abi_int:32; abi_int:32; abi_int:32;
abi_int:32; abi_int:32; abi_int:32;
};
typedef abi_long target_clock_t;
#define TARGET_HZ 100
@ -2628,15 +2658,19 @@ typedef int32_t target_timer_t;
struct target_sigevent {
target_sigval_t sigev_value;
int32_t sigev_signo;
int32_t sigev_notify;
abi_int sigev_signo;
abi_int sigev_notify;
union {
int32_t _pad[TARGET_SIGEV_PAD_SIZE];
int32_t _tid;
abi_int _pad[TARGET_SIGEV_PAD_SIZE];
abi_int _tid;
/* The kernel (and thus QEMU) never looks at these;
* they're only used as part of the ABI between a
* userspace program and libc.
*/
struct {
void (*_function)(sigval_t);
void *_attribute;
abi_ulong _function;
abi_ulong _attribute;
} _sigev_thread;
} _sigev_un;
};
@ -2652,4 +2686,29 @@ struct target_user_cap_data {
uint32_t inheritable;
};
/* from kernel's include/linux/syslog.h */
/* Close the log. Currently a NOP. */
#define TARGET_SYSLOG_ACTION_CLOSE 0
/* Open the log. Currently a NOP. */
#define TARGET_SYSLOG_ACTION_OPEN 1
/* Read from the log. */
#define TARGET_SYSLOG_ACTION_READ 2
/* Read all messages remaining in the ring buffer. */
#define TARGET_SYSLOG_ACTION_READ_ALL 3
/* Read and clear all messages remaining in the ring buffer */
#define TARGET_SYSLOG_ACTION_READ_CLEAR 4
/* Clear ring buffer. */
#define TARGET_SYSLOG_ACTION_CLEAR 5
/* Disable printk's to console */
#define TARGET_SYSLOG_ACTION_CONSOLE_OFF 6
/* Enable printk's to console */
#define TARGET_SYSLOG_ACTION_CONSOLE_ON 7
/* Set level of messages printed to console */
#define TARGET_SYSLOG_ACTION_CONSOLE_LEVEL 8
/* Return number of unread characters in the log buffer */
#define TARGET_SYSLOG_ACTION_SIZE_UNREAD 9
/* Return size of the log buffer */
#define TARGET_SYSLOG_ACTION_SIZE_BUFFER 10
#endif