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", codename);
}
+static void get_target_siginfo(target_siginfo_t *tinfo,
+ const target_siginfo_t *info)
+{
+ abi_ulong sival_ptr;
+
+ int sig;
+ int si_errno;
+ int si_code;
+ int si_type;
+
+ __get_user(sig, &info->si_signo);
+ __get_user(si_errno, &tinfo->si_errno);
+ __get_user(si_code, &info->si_code);
+
+ tinfo->si_signo = sig;
+ tinfo->si_errno = si_errno;
+ tinfo->si_code = si_code;
+
+ /* Ensure we don't leak random junk to the guest later */
+ memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
+
+ /* This is awkward, because we have to use a combination of
+ * the si_code and si_signo to figure out which of the union's
+ * members are valid. (Within the host kernel it is always possible
+ * to tell, but the kernel carefully avoids giving userspace the
+ * high 16 bits of si_code, so we don't have the information to
+ * do this the easy way...) We therefore make our best guess,
+ * bearing in mind that a guest can spoof most of the si_codes
+ * via rt_sigqueueinfo() if it likes.
+ *
+ * Once we have made our guess, we record it in the top 16 bits of
+ * the si_code, so that print_siginfo() later can use it.
+ * print_siginfo() will strip these top bits out before printing
+ * the si_code.
+ */
+
+ switch (si_code) {
+ case SI_USER:
+ case SI_TKILL:
+ case SI_KERNEL:
+ /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
+ * These are the only unspoofable si_code values.
+ */
+ __get_user(tinfo->_sifields._kill._pid, &info->_sifields._kill._pid);
+ __get_user(tinfo->_sifields._kill._uid, &info->_sifields._kill._uid);
+ si_type = QEMU_SI_KILL;
+ break;
+ default:
+ /* Everything else is spoofable. Make best guess based on signal */
+ switch (sig) {
+ case TARGET_SIGCHLD:
+ __get_user(tinfo->_sifields._sigchld._pid,
+ &info->_sifields._sigchld._pid);
+ __get_user(tinfo->_sifields._sigchld._uid,
+ &info->_sifields._sigchld._uid);
+ __get_user(tinfo->_sifields._sigchld._status,
+ &info->_sifields._sigchld._status);
+ __get_user(tinfo->_sifields._sigchld._utime,
+ &info->_sifields._sigchld._utime);
+ __get_user(tinfo->_sifields._sigchld._stime,
+ &info->_sifields._sigchld._stime);
+ si_type = QEMU_SI_CHLD;
+ break;
+ case TARGET_SIGIO:
+ __get_user(tinfo->_sifields._sigpoll._band,
+ &info->_sifields._sigpoll._band);
+ __get_user(tinfo->_sifields._sigpoll._fd,
+ &info->_sifields._sigpoll._fd);
+ si_type = QEMU_SI_POLL;
+ break;
+ default:
+ /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
+ __get_user(tinfo->_sifields._rt._pid, &info->_sifields._rt._pid);
+ __get_user(tinfo->_sifields._rt._uid, &info->_sifields._rt._uid);
+ /* XXX: potential problem if 64 bit */
+ __get_user(sival_ptr, &info->_sifields._rt._sigval.sival_ptr);
+ tinfo->_sifields._rt._sigval.sival_ptr = sival_ptr;
+
+ si_type = QEMU_SI_RT;
+ break;
+ }
+ break;
+ }
+
+ tinfo->si_code = deposit32(si_code, 16, 16, si_type);
+}
+
static void print_siginfo(const target_siginfo_t *tinfo)
{
/* Print a target_siginfo_t in the format desired for printing
switch (si_type) {
case QEMU_SI_KILL:
- gemu_log(", si_pid = %u, si_uid = %u",
+ 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",
+ 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",
+ 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 = ");
+ 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"
+ 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),
tinfo->_sifields._sigchld._stime);
break;
case QEMU_SI_RT:
- gemu_log(", si_pid = %u, si_uid = %u, si_sigval = " TARGET_ABI_FMT_ld,
+ 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);
#endif
#ifdef O_PATH
FLAG_TARGET(O_PATH),
+#endif
+#ifdef O_TMPFILE
+ FLAG_TARGET(O_TMPFILE),
+ FLAG_TARGET(__O_TMPFILE),
#endif
FLAG_END,
};
}
#endif
+#ifdef TARGET_NR_rt_sigqueueinfo
+static void
+print_rt_sigqueueinfo(const struct syscallname *name,
+ abi_long arg0, abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4, abi_long arg5)
+{
+ void *p;
+ target_siginfo_t uinfo;
+
+ print_syscall_prologue(name);
+ print_raw_param("%d", arg0, 0);
+ print_signal(arg1, 0);
+ p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
+ if (p) {
+ get_target_siginfo(&uinfo, p);
+ print_siginfo(&uinfo);
+
+ unlock_user(p, arg2, 0);
+ } else {
+ print_pointer(arg2, 1);
+ }
+ print_syscall_epilogue(name);
+}
+#endif
+
+#ifdef TARGET_NR_rt_tgsigqueueinfo
+static void
+print_rt_tgsigqueueinfo(const struct syscallname *name,
+ abi_long arg0, abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4, abi_long arg5)
+{
+ void *p;
+ target_siginfo_t uinfo;
+
+ print_syscall_prologue(name);
+ print_raw_param("%d", arg0, 0);
+ print_raw_param("%d", arg1, 0);
+ print_signal(arg2, 0);
+ p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
+ if (p) {
+ get_target_siginfo(&uinfo, p);
+ print_siginfo(&uinfo);
+
+ unlock_user(p, arg3, 0);
+ } else {
+ print_pointer(arg3, 1);
+ }
+ print_syscall_epilogue(name);
+}
+#endif
+
#ifdef TARGET_NR_syslog
static void
print_syslog_action(abi_ulong arg, int last)
}
#endif
+#ifdef TARGET_NR_tkill
+static void
+print_tkill(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_raw_param("%d", arg0, 0);
+ print_signal(arg1, 1);
+ print_syscall_epilogue(name);
+}
+#endif
+
+#ifdef TARGET_NR_tgkill
+static void
+print_tgkill(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_raw_param("%d", arg0, 0);
+ print_raw_param("%d", arg1, 0);
+ print_signal(arg2, 1);
+ print_syscall_epilogue(name);
+}
+#endif
+
/*
* An array of all of the syscalls we know about
*/
projects / qemu.git / blobdiff