output_cmd( IPC_STAT );
output_cmd( IPC_INFO );
/* msgctl() commands */
- #ifdef __USER_MISC
output_cmd( MSG_STAT );
output_cmd( MSG_INFO );
- #endif
/* shmctl() commands */
output_cmd( SHM_LOCK );
output_cmd( SHM_UNLOCK );
gemu_log("%s%s", signal_name, get_comma(last));
}
+static void print_si_code(int arg)
+{
+ const char *codename = NULL;
+
+ switch (arg) {
+ case SI_USER:
+ codename = "SI_USER";
+ break;
+ case SI_KERNEL:
+ codename = "SI_KERNEL";
+ break;
+ case SI_QUEUE:
+ codename = "SI_QUEUE";
+ break;
+ case SI_TIMER:
+ codename = "SI_TIMER";
+ break;
+ case SI_MESGQ:
+ codename = "SI_MESGQ";
+ break;
+ case SI_ASYNCIO:
+ codename = "SI_ASYNCIO";
+ break;
+ case SI_SIGIO:
+ codename = "SI_SIGIO";
+ break;
+ case SI_TKILL:
+ codename = "SI_TKILL";
+ break;
+ default:
+ gemu_log("%d", arg);
+ return;
+ }
+ gemu_log("%s", codename);
+}
+
+static void print_siginfo(const target_siginfo_t *tinfo)
+{
+ /* Print a target_siginfo_t in the format desired for printing
+ * signals being taken. We assume the target_siginfo_t is in the
+ * internal form where the top 16 bits of si_code indicate which
+ * part of the union is valid, rather than in the guest-visible
+ * form where the bottom 16 bits are sign-extended into the top 16.
+ */
+ int si_type = extract32(tinfo->si_code, 16, 16);
+ int si_code = sextract32(tinfo->si_code, 0, 16);
+
+ gemu_log("{si_signo=");
+ print_signal(tinfo->si_signo, 1);
+ gemu_log(", si_code=");
+ print_si_code(si_code);
+
+ switch (si_type) {
+ case QEMU_SI_KILL:
+ gemu_log(", si_pid = %u, si_uid = %u",
+ (unsigned int)tinfo->_sifields._kill._pid,
+ (unsigned int)tinfo->_sifields._kill._uid);
+ break;
+ case QEMU_SI_TIMER:
+ gemu_log(", si_timer1 = %u, si_timer2 = %u",
+ tinfo->_sifields._timer._timer1,
+ tinfo->_sifields._timer._timer2);
+ break;
+ case QEMU_SI_POLL:
+ gemu_log(", si_band = %d, si_fd = %d",
+ tinfo->_sifields._sigpoll._band,
+ tinfo->_sifields._sigpoll._fd);
+ break;
+ case QEMU_SI_FAULT:
+ gemu_log(", si_addr = ");
+ print_pointer(tinfo->_sifields._sigfault._addr, 1);
+ break;
+ case QEMU_SI_CHLD:
+ gemu_log(", si_pid = %u, si_uid = %u, si_status = %d"
+ ", si_utime=" TARGET_ABI_FMT_ld
+ ", si_stime=" TARGET_ABI_FMT_ld,
+ (unsigned int)(tinfo->_sifields._sigchld._pid),
+ (unsigned int)(tinfo->_sifields._sigchld._uid),
+ tinfo->_sifields._sigchld._status,
+ tinfo->_sifields._sigchld._utime,
+ tinfo->_sifields._sigchld._stime);
+ break;
+ case QEMU_SI_RT:
+ gemu_log(", si_pid = %u, si_uid = %u, si_sigval = " TARGET_ABI_FMT_ld,
+ (unsigned int)tinfo->_sifields._rt._pid,
+ (unsigned int)tinfo->_sifields._rt._uid,
+ tinfo->_sifields._rt._sigval.sival_ptr);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+ gemu_log("}");
+}
+
static void
print_sockaddr(abi_ulong addr, abi_long addrlen)
{
}
#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
*/
}
#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),
}
#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,
}
#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
}
#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,
break;
}
}
+
+void print_taken_signal(int target_signum, const target_siginfo_t *tinfo)
+{
+ /* Print the strace output for a signal being taken:
+ * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
+ */
+ gemu_log("--- ");
+ print_signal(target_signum, 1);
+ gemu_log(" ");
+ print_siginfo(tinfo);
+ gemu_log(" ---\n");
+}