gdbstub: Allow late attachment
PATCH 2/8 gdbstub: Try unlinking the unix socket before binding
In reply to Ilya LeoshkevichIn case an emulated process execve()s another emulated process, bind() will fail, because the socket already exists. So try deleting it.
Note that it is not possible to handle this in do_execv(): deleting gdbserver_user_state.socket_path before safe_execve() is not correct, because the latter may fail, and afterwards we may lose control.
--- gdbstub/user.c | 1 + 1 file changed, 1 insertion(+)
gdbstub/user.c +1 -0
@@ -337,6 +337,7 @@ static int gdbserver_open_socket(const char *path) sockaddr.sun_family =AF_UNIX ;pstrcpy (sockaddr.sun_path,sizeof (sockaddr.sun_path) -1 , path); +unlink (sockaddr.sun_path); ret =bind (fd, (struct sockaddr *)&sockaddr,sizeof (sockaddr));if (ret <0 ) {perror ("bind socket" );
Signature · 1 line
2.47.0
PATCH 3/8 user: Introduce user/signal.h
In reply to Ilya Leoshkevichgdbstub needs target_to_host_signal(), so move its declaration to a public header.
--- bsd-user/signal-common.h | 1 - bsd-user/signal.c | 1 + include/user/signal.h | 23 +++++++++++++++++++++++ linux-user/signal-common.h | 1 - linux-user/signal.c | 1 + linux-user/syscall.c | 1 + 6 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 include/user/signal.h
bsd-user/signal-common.h +0 -1
@@ -42,7 +42,6 @@ void process_pending_signals(CPUArchState *env);void queue_signal (CPUArchState *env,int sig,int si_type,target_siginfo_t *info);void signal_init (void ); -int target_to_host_signal (int sig);void target_to_host_sigset (sigset_t *d,const target_sigset_t *s);/*
bsd-user/signal.c +1 -0
@@ -22,6 +22,7 @@#include "qemu/log.h" #include "qemu.h" #include "exec/page-protection.h" +#include "user/signal.h" #include "user/tswap-target.h" #include "gdbstub/user.h" #include "signal-common.h"
include/user/signal.h new file +23 -0
@@ -0,0 +1,23 @@ +/* +* Signal-related declarations. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ +#ifndef USER_SIGNAL_H +#define USER_SIGNAL_H + +#ifndef CONFIG_USER_ONLY +#error Cannot include this header from system emulation +#endif + +/** +* target_to_host_signal: +* @sig: target signal. +* +* On success, return the host signal between 0 (inclusive) and NSIG +* (exclusive) corresponding to the target signal @sig. Return any other value +* on failure. +*/ +int target_to_host_signal (int sig); + +#endif
linux-user/signal-common.h +0 -1
@@ -61,7 +61,6 @@ void queue_signal(CPUArchState *env, int sig, int si_type, target_siginfo_t *info);void host_to_target_siginfo (target_siginfo_t *tinfo,const siginfo_t *info);void target_to_host_siginfo (siginfo_t *info,const target_siginfo_t *tinfo); -int target_to_host_signal (int sig);int host_to_target_signal (int sig);long do_sigreturn (CPUArchState *env);long do_rt_sigreturn (CPUArchState *env);
linux-user/signal.c +1 -0
@@ -33,6 +33,7 @@#include "signal-common.h" #include "host-signal.h" #include "user/safe-syscall.h" +#include "user/signal.h" #include "tcg/tcg.h" /* target_siginfo_t must fit in gdbstub's siginfo save area. */
linux-user/syscall.c +1 -0
@@ -136,6 +136,7 @@#include "loader.h" #include "user-mmap.h" #include "user/safe-syscall.h" +#include "user/signal.h" #include "qemu/guest-random.h" #include "qemu/selfmap.h" #include "user/syscall-trace.h"
Signature · 1 line
2.47.0
PATCH 8/8 tests/tcg: Add late gdbstub attach test
In reply to Ilya LeoshkevichAdd a small test to prevent regressions.
Make sure that host_interrupt_signal is not visible to the guest.
--- tests/guest-debug/run-test.py | 15 ++++++-- tests/tcg/multiarch/Makefile.target | 9 ++++- tests/tcg/multiarch/gdbstub/late-attach.py | 28 +++++++++++++++ tests/tcg/multiarch/late-attach.c | 41 ++++++++++++++++++++++ 4 files changed, 90 insertions(+), 3 deletions(-) create mode 100644 tests/tcg/multiarch/gdbstub/late-attach.py create mode 100644 tests/tcg/multiarch/late-attach.c
tests/guest-debug/run-test.py +13 -2
@@ -36,6 +36,8 @@ def get_args(): parser.add_argument("--gdb-args", help="Additional gdb arguments") parser.add_argument("--output", help="A file to redirect output to") parser.add_argument("--stderr", help="A file to redirect stderr to") + parser.add_argument("--no-suspend", action="store_true", + help="Ask the binary to not wait for GDB connection") return parser.parse_args()
@@ -73,10 +75,19 @@ def log(output, msg): # Launch QEMU with binary if "system" in args.qemu: + if args.no_suspend: + suspend = '' + else: + suspend = ' -S' cmd = f'{args.qemu} {args.qargs} {args.binary}' \ - f' -S -gdb unix:path={socket_name},server=on' + f'{suspend} -gdb unix:path={socket_name},server=on' else: - cmd = f'{args.qemu} {args.qargs} -g {socket_name} {args.binary}' + if args.no_suspend: + suspend = ',suspend=n' + else: + suspend = '' + cmd = f'{args.qemu} {args.qargs} -g {socket_name}{suspend}' \ + f' {args.binary}' log(output, "QEMU CMD: %s" % (cmd)) inferior = subprocess.Popen(shlex.split(cmd))
tests/tcg/multiarch/Makefile.target +8 -1
@@ -127,6 +127,13 @@ run-gdbstub-follow-fork-mode-parent: follow-fork-mode --bin $< --test $(MULTIARCH_SRC)/gdbstub/follow-fork-mode-parent.py, \ following parents on fork) +run-gdbstub-late-attach: late-attach + $(call run-test, $@, env LATE_ATTACH_PY=1 $(GDB_SCRIPT) \ + --gdb $(GDB) \ + --qemu $(QEMU) --qargs "$(QEMU_OPTS)" --no-suspend \ + --bin $< --test $(MULTIARCH_SRC)/gdbstub/late-attach.py, \ + attaching to a running process) + else run-gdbstub-%: $(call skip-test, "gdbstub test $*", "need working gdb with $(patsubst -%,,$(TARGET_NAME)) support")
@@ -136,7 +143,7 @@ EXTRA_RUNS += run-gdbstub-sha1 run-gdbstub-qxfer-auxv-read \ run-gdbstub-registers run-gdbstub-prot-none \ run-gdbstub-catch-syscalls run-gdbstub-follow-fork-mode-child \ run-gdbstub-follow-fork-mode-parent \ - run-gdbstub-qxfer-siginfo-read + run-gdbstub-qxfer-siginfo-read run-gdbstub-late-attach # ARM Compatible Semi Hosting Tests #
tests/tcg/multiarch/gdbstub/late-attach.py new file +28 -0
@@ -0,0 +1,28 @@ +"""Test attaching GDB to a running process. + +SPDX-License-Identifier: GPL-2.0-or-later +""" +from test_gdbstub import main, report + + +def run_test(): + """Run through the tests one by one""" + try: + phase = gdb.parse_and_eval("phase").string() + except gdb.error: + # Assume the guest did not reach main(). + phase = "start" + + if phase == "start": + gdb.execute("break sigwait") + gdb.execute("continue") + phase = gdb.parse_and_eval("phase").string() + report(phase == "sigwait", "{} == \"sigwait\"".format(phase)) + + gdb.execute("signal SIGUSR1") + + exitcode = int(gdb.parse_and_eval("$_exitcode")) + report(exitcode == 0, "{} == 0".format(exitcode)) + + +main(run_test)
tests/tcg/multiarch/late-attach.c new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
2.47.0
cover gdbstub: Allow late attachment
Hi,
This series adds the ability to attach GDB to a running qemu-user instance. This is useful for debugging multi-process apps.
Patches 1 and 2 implement a small related feature: the ability to create individual UNIX sockets for each child process.
Patches 3-5 add the required infrastructure. In particular, we need to reserve a host signal for waking up threads, as discussed in [1]. By the way, the problem with atomicity of checking for pending signals and invoking syscalls that I'm describing in that thread seems to have already been solved by the safe_syscall infrastructure, so the changes are fairly simple.
If this series is accepted, I will rebase the all-stop series on top of it.
Patch 6 is the implementation, patch 7 is a documentation update, patch 8 is a test. I tested this series on Linux and only compile-tested on the BSDs.
Best regards,
Ilya
[1] https://lore.kernel.org/qemu-devel/[email protected]/
Ilya Leoshkevich (8):
gdbstub: Allow the %d placeholder in the socket path
gdbstub: Try unlinking the unix socket before binding
user: Introduce user/signal.h
user: Introduce host_interrupt_signal
osdep: Introduce qemu_kill_thread()
gdbstub: Allow late attachment
docs/user: Document the %d placeholder and suspend=n QEMU_GDB features tests/tcg: Add late gdbstub attach test
bsd-user/main.c | 1 - bsd-user/signal-common.h | 1 - bsd-user/signal.c | 13 ++ docs/user/main.rst | 16 ++- gdbstub/user.c | 131 +++++++++++++++++++-- include/qemu/osdep.h | 9 ++ include/user/signal.h | 25 ++++ linux-user/main.c | 1 - linux-user/signal-common.h | 1 - linux-user/signal.c | 12 ++ linux-user/syscall.c | 1 + tests/guest-debug/run-test.py | 15 ++- tests/tcg/multiarch/Makefile.target | 9 +- tests/tcg/multiarch/gdbstub/late-attach.py | 28 +++++ tests/tcg/multiarch/late-attach.c | 41 +++++++ util/oslib-posix.c | 15 +++ 16 files changed, 299 insertions(+), 20 deletions(-) create mode 100644 include/user/signal.h create mode 100644 tests/tcg/multiarch/gdbstub/late-attach.py create mode 100644 tests/tcg/multiarch/late-attach.c
Signature · 1 line
2.47.0
PATCH 6/8 gdbstub: Allow late attachment
Allow debugging individual processes in multi-process applications by starting them with export QEMU_GDB=/tmp/qemu-%d.sock,suspend=n. Currently one would have to attach to every process to ensure the app makes progress.
In case suspend=n is not specified, the flow remains unchanged. If it is specified, then accepting the client connection is delegated to a thread. In the future this machinery may be reused for handling reconnections and interruptions.
On accepting a connection, the thread schedules gdb_handlesig() on the first CPU and wakes it up with host_interrupt_signal. Note that the result of this gdb_handlesig() invocation is handled, as opposed to many other existing call sites. These other call sites probably need to be fixed separately.
--- bsd-user/main.c | 1 - gdbstub/user.c | 120 ++++++++++++++++++++++++++++++++++++++++++---- linux-user/main.c | 1 - 3 files changed, 110 insertions(+), 12 deletions(-)
bsd-user/main.c +0 -1
@@ -618,7 +618,6 @@ int main(int argc, char **argv)if (gdbstub) {gdbserver_start (gdbstub); -gdb_handlesig (cpu,0 ,NULL ,NULL ,0 ); }cpu_loop (env);/* never exits */
gdbstub/user.c +110 -10
149 lines not on this page · raw message
linux-user/main.c +0 -1
@@ -1017,7 +1017,6 @@ int main(int argc, char **argv, char **envp) gdbstub);exit (EXIT_FAILURE ); } -gdb_handlesig (cpu,0 ,NULL ,NULL ,0 ); }#ifdef CONFIG_SEMIHOSTING
Signature · 1 line
2.47.0
PATCH 4/8 user: Introduce host_interrupt_signal
In reply to Ilya LeoshkevichAttaching to the gdbstub of a running process requires stopping its threads. For threads that run on a CPU, cpu_exit() is enough, but the only way to grab attention of a thread that is stuck in a long-running syscall is to interrupt it with a signal.
Reserve a host realtime signal for this, just like it's already done for TARGET_SIGABRT on Linux. This may reduce the number of available guest realtime signals by one, but this is acceptable, since there are quite a lot of them, and it's unlikely that there are apps that need them all.
Set signal_pending for the safe_sycall machinery to prevent invoking the syscall. This is a lie, since we don't queue a guest signal, but process_pending_signals() can handle the absence of pending signals. The syscall returns with QEMU_ERESTARTSYS errno, which arranges for the automatic restart. This is important, because it helps avoiding disturbing poorly written guests.
--- bsd-user/signal.c | 12 ++++++++++++ include/user/signal.h | 2 ++ linux-user/signal.c | 11 +++++++++++ 3 files changed, 25 insertions(+)
bsd-user/signal.c +12 -0
@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp)on_sig_stack (ts, sp) ?SS_ONSTACK :0 ; } +int host_interrupt_signal =SIGRTMAX ; +/* * The BSD ABIs use the same signal numbers across all the CPU architectures, so * (unlike Linux) these functions are just the identity mapping. This might not
@@ -489,6 +491,12 @@ static void host_signal_handler(int host_sig, siginfo_t *info, void *puc)uintptr_t pc =0 ;bool sync_sig = false; +if (host_sig == host_interrupt_signal) { + ts->signal_pending =1 ; +cpu_exit (thread_cpu); +return ; + } +/* * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special * handling wrt signal blocking and unwinding.
@@ -852,6 +860,9 @@ void signal_init(void)for (i =1 ; i <=TARGET_NSIG ; i++) { host_sig =target_to_host_signal (i); +if (host_sig == host_interrupt_signal) { +continue ; + }sigaction (host_sig,NULL , &oact);if (oact.sa_sigaction == (void *)SIG_IGN ) { sigact_table[i -1 ]._sa_handler =TARGET_SIG_IGN ;
@@ -870,6 +881,7 @@ void signal_init(void)sigaction (host_sig, &act,NULL ); } } +sigaction (host_interrupt_signal, &act,NULL ); } static void handle_pending_signal(CPUArchState *env, int sig,
include/user/signal.h +2 -0
@@ -20,4 +20,6 @@*/ int target_to_host_signal (int sig); +extern int host_interrupt_signal; +#endif
linux-user/signal.c +11 -0
@@ -514,6 +514,8 @@ static int core_dump_signal(int sig) } } +int host_interrupt_signal; +static void signal_table_init (void ) {int hsig, tsig, count;
@@ -540,6 +542,7 @@ static void signal_table_init(void) hsig =SIGRTMIN ; host_to_target_signal_table[SIGABRT ] =0 ; host_to_target_signal_table[hsig++] =TARGET_SIGABRT ; + host_interrupt_signal = hsig++; for (tsig = TARGET_SIGRTMIN; hsig <= SIGRTMAX && tsig <= TARGET_NSIG;
@@ -619,6 +622,8 @@ void signal_init(void) } sigact_table[tsig -1 ]._sa_handler = thand; } + +sigaction (host_interrupt_signal, &act,NULL ); }/* Force a synchronously taken signal. The kernel force_sig() function
@@ -966,6 +971,12 @@ static void host_signal_handler(int host_sig, siginfo_t *info, void *puc)bool sync_sig = false;void *sigmask; +if (host_sig == host_interrupt_signal) { + ts->signal_pending =1 ; +cpu_exit (thread_cpu); +return ; + } +/* * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special * handling wrt signal blocking and unwinding. Non-spoofed SIGILL,
Signature · 1 line
2.47.0
PATCH 1/8 gdbstub: Allow the %d placeholder in the socket path
In reply to Ilya LeoshkevichJust like for QEMU_LOG_FILENAME, replace %d with PID in the GDB socket path. This allows running multi-process applications with, e.g., export QEMU_GDB=/tmp/qemu-%d.sock. Currently this is not possible, since the first process will cause the subsequent ones to fail due to not being able to bind() the GDB socket.
--- gdbstub/user.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
gdbstub/user.c +10 -0
@@ -316,9 +316,19 @@ static bool gdb_accept_socket(int gdb_fd)static int gdbserver_open_socket (const char *path) { +g_autoptr (GString) buf =g_string_new ("" );struct sockaddr_un sockaddr = {}; +char *pid_placeholder;int fd, ret; + pid_placeholder =strstr (path,"%d" ); +if (pid_placeholder !=NULL ) { +g_string_append_len (buf, path, pid_placeholder - path); +g_string_append_printf (buf,"%d" ,getpid ()); +g_string_append (buf, pid_placeholder +2 ); + path = buf->str; + } + fd =socket (AF_UNIX ,SOCK_STREAM ,0 );if (fd <0 ) {perror ("create socket" );
Signature · 1 line
2.47.0
PATCH 7/8 docs/user: Document the %d placeholder and suspend=n QEMU_GDB features
In reply to Ilya Leoshkevich--- docs/user/main.rst | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
docs/user/main.rst +13 -3
@@ -50,7 +50,7 @@ Command line options :: - qemu-i386 [-h] [-d] [-L path] [-s size] [-cpu model] [-g port] [-B offset] [-R size] program [arguments...] + qemu-i386 [-h] [-d] [-L path] [-s size] [-cpu model] [-g endpoint] [-B offset] [-R size] program [arguments...] ``-h`` Print the help
@@ -87,8 +87,18 @@ Debug options: Activate logging of the specified items (use '-d help' for a list of log items) -``-g port`` - Wait gdb connection to port +``-g endpoint`` + Wait gdb connection to a port (e.g., ``1234``) or a unix socket (e.g., + ``/tmp/qemu.sock``). + + If a unix socket path contains single ``%d`` placeholder (e.g., + ``/tmp/qemu-%d.sock``), it is replaced by the emulator PID, which is useful + when passing this option via the ``QEMU_GDB`` environment variable to a + multi-process application. + + If the endpoint address is followed by ``,suspend=n`` (e.g., + ``1234,suspend=n``), then the emulated program starts without waiting for a + connection, which can be established at any later point in time. ``-one-insn-per-tb`` Run the emulation with one guest instruction per translation block.
Signature · 1 line
2.47.0
PATCH 5/8 osdep: Introduce qemu_kill_thread()
In reply to Ilya LeoshkevichAdd a function for sending signals to individual threads. It does not make sense on Windows, so do not provide an implementation, so that if someone uses it by accident, they will get a linker error.
--- include/qemu/osdep.h | 9 +++++++++ util/oslib-posix.c | 15 +++++++++++++++ 2 files changed, 24 insertions(+)
include/qemu/osdep.h +9 -0
@@ -626,6 +626,15 @@ bool qemu_write_pidfile(const char *pidfile, Error **errp);int qemu_get_thread_id (void ); +/** +* qemu_kill_thread: +* @tid: thread id. +* @sig: host signal. +* +* Send @sig to one of QEMU's own threads with identifier @tid. +*/ +int qemu_kill_thread (int tid,int sig); + #ifndef CONFIG_IOVEC struct iovec { void *iov_base;
util/oslib-posix.c +15 -0
@@ -111,6 +111,21 @@ int qemu_get_thread_id(void)#endif } +int qemu_kill_thread (int tid,int sig) +{ +#if defined(__linux__) +return syscall (__NR_tgkill,getpid (), tid, sig); +#elif defined(__FreeBSD__) +return thr_kill2 (getpid (), tid, sig); +#elif defined(__NetBSD__) +return _lwp_kill (tid, sig); +#elif defined(__OpenBSD__) +return thrkill (tid, sig,NULL ); +#else +return kill (tid, sig); +#endif +} +int qemu_daemon (int nochdir,int noclose) {return daemon (nochdir, noclose);
Signature · 1 line
2.47.0
Re: [PATCH 1/8] gdbstub: Allow the %d placeholder in the socket path
In reply to Ilya LeoshkevichQuoted 18 lines · Ilya Leoshkevich
Just like for
QEMU_LOG_FILENAME, replace %d with PID in the GDB socket path. This allows running multi-process applications with, e.g., export QEMU_GDB=/tmp/qemu-%d.sock. Currently this is not possible, since the first process will cause the subsequent ones to fail due to not being able tobind()the GDB socket.Signed-off-by Ilya Leoshkevich <[email protected]>--- gdbstub/user.c | 10 ++++++++++ 1 file changed, 10 insertions(+)gdbstub/user.c +0
-0@@ -316,9 +316,19 @@ static bool gdb_accept_socket(int gdb_fd)static int gdbserver_open_socket (const char *path)
gdbstub/user.c static bool gdb_accept_socket(int gdb_fd) · line 327
Quoted 10 lines
gdbstub/user.c +6
-0{ +g_autoptr (GString) buf =g_string_new ("" );struct sockaddr_un sockaddr = {}; +char *pid_placeholder;int fd, ret; + pid_placeholder =strstr (path,"%d" ); +if (pid_placeholder !=NULL ) { +g_string_append_len (buf, path, pid_placeholder - path); +g_string_append_printf (buf,"%d" ,getpid ());
qemu_get_thread_id().
Otherwise,
r~
Re: [PATCH 3/8] user: Introduce user/signal.h
In reply to Ilya LeoshkevichQuoted 12 lines · Ilya Leoshkevich
gdbstub needs
target_to_host_signal(), so move its declaration to a public header.Signed-off-by Ilya Leoshkevich<[email protected]>--- bsd-user/signal-common.h | 1 - bsd-user/signal.c | 1 + include/user/signal.h | 23 +++++++++++++++++++++++ linux-user/signal-common.h | 1 - linux-user/signal.c | 1 + linux-user/syscall.c | 1 + 6 files changed, 26 insertions(+), 2 deletions(-)
Quoted 1 line
create mode 100644
include/user/signal.h
r~
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
In reply to Ilya LeoshkevichQuoted 18 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its threads. For threads that run on a CPU,
cpu_exit()is enough, but the only way to grab attention of a thread that is stuck in a long-running syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done for
TARGET_SIGABRTon Linux. This may reduce the number of available guest realtime signals by one, but this is acceptable, since there are quite a lot of them, and it's unlikely that there are apps that need them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking the syscall. This is a lie, since we don't queue a guest signal, butprocess_pending_signals()can handle the absence of pending signals. The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for the automatic restart. This is important, because it helps avoiding disturbing poorly written guests.
Quoted 6 lines
Signed-off-by Ilya Leoshkevich<[email protected]>--- bsd-user/signal.c | 12 ++++++++++++ include/user/signal.h | 2 ++ linux-user/signal.c | 11 +++++++++++ 3 files changed, 25 insertions(+)
r~
Re: [PATCH 5/8] osdep: Introduce qemu_kill_thread()
In reply to Ilya LeoshkevichQuoted 9 lines · Ilya Leoshkevich
Add a function for sending signals to individual threads. It does not make sense on Windows, so do not provide an implementation, so that if someone uses it by accident, they will get a linker error.
Signed-off-by Ilya Leoshkevich<[email protected]>--- include/qemu/osdep.h | 9 +++++++++ util/oslib-posix.c | 15 +++++++++++++++ 2 files changed, 24 insertions(+)
I am annoyed that musl does not have tgkill in <signal.h>.
r~
Warner Losh
Reviewed-byRe: [PATCH 1/8] gdbstub: Allow the %d placeholder in the socket path
In reply to Richard HendersonQuoted 32 lines · Richard Henderson
Quoted 18 lines · Ilya Leoshkevich
Just like for
QEMU_LOG_FILENAME, replace %d with PID in the GDB socket path. This allows running multi-process applications with, e.g., export QEMU_GDB=/tmp/qemu-%d.sock. Currently this is not possible, since the first process will cause the subsequent ones to fail due to not being able tobind()the GDB socket.Signed-off-by Ilya Leoshkevich <[email protected]>--- gdbstub/user.c | 10 ++++++++++ 1 file changed, 10 insertions(+)gdbstub/user.c +0
-0@@ -316,9 +316,19 @@ static bool gdb_accept_socket(int gdb_fd)static int gdbserver_open_socket (const char *path)gdbstub/user.c static bool gdb_accept_socket(int gdb_fd) · line 327
Quoted 10 lines
gdbstub/user.c +6
-0{ +g_autoptr (GString) buf =g_string_new ("" );struct sockaddr_un sockaddr = {}; +char *pid_placeholder;int fd, ret; + pid_placeholder =strstr (path,"%d" ); +if (pid_placeholder !=NULL ) { +g_string_append_len (buf, path, pid_placeholder - path); +g_string_append_printf (buf,"%d" ,getpid ());
qemu_get_thread_id().
Quoted 3 lines
Otherwise,
Reviewed-by Richard Henderson <[email protected]>
Same.
Re: [PATCH 3/8] user: Introduce user/signal.h
In reply to Ilya LeoshkevichQuoted 4 lines · Ilya Leoshkevich
gdbstub needs
target_to_host_signal(), so move its declaration to a public header.Signed-off-by Ilya Leoshkevich <[email protected]>
Quoted 10 lines
--- bsd-user/signal-common.h | 1 - bsd-user/signal.c | 1 + include/user/signal.h | 23 +++++++++++++++++++++++ linux-user/signal-common.h | 1 - linux-user/signal.c | 1 + linux-user/syscall.c | 1 + 6 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 include/user/signal.h
Quoted 97 lines
bsd-user/signal-common.h +0
-1@@ -42,7 +42,6 @@ void process_pending_signals(CPUArchState *env);void queue_signal (CPUArchState *env,int sig,int si_type,target_siginfo_t *info);void signal_init (void ); -int target_to_host_signal (int sig);void target_to_host_sigset (sigset_t *d,const target_sigset_t *s);/* bsd-user/signal.c +1
-0@@ -22,6 +22,7 @@#include "qemu/log.h" #include "qemu.h" #include "exec/page-protection.h" +#include "user/signal.h" #include "user/tswap-target.h" #include "gdbstub/user.h" #include "signal-common.h" include/user/signal.h new file +18
-0@@ -0,0 +1,23 @@ +/* +* Signal-related declarations. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ +#ifndef USER_SIGNAL_H +#define USER_SIGNAL_H + +#ifndef CONFIG_USER_ONLY +#error Cannot include this header from system emulation +#endif + +/** +* target_to_host_signal: +* @sig: target signal. +* +* On success, return the host signal between 0 (inclusive) and NSIG +* (exclusive) corresponding to the target signal @sig. Return any other value
+ * on failure.
+ */include/user/signal.h new file +3
-0+int target_to_host_signal (int sig); + +#endif linux-user/signal-common.h +0
-1@@ -61,7 +61,6 @@ void queue_signal(CPUArchState *env, int sig, int si_type, target_siginfo_t *info);void host_to_target_siginfo (target_siginfo_t *tinfo,const siginfo_t *info);void target_to_host_siginfo (siginfo_t *info,const target_siginfo_t *tinfo); -int target_to_host_signal (int sig);int
host_to_target_signal(int sig);
longdo_sigreturn(CPUArchState *env);
longdo_rt_sigreturn(CPUArchState *env);linux-user/signal.c +1
-0@@ -33,6 +33,7 @@#include "signal-common.h" #include "host-signal.h" #include "user/safe-syscall.h" +#include "user/signal.h" #include "tcg/tcg.h" /* target_siginfo_t must fit in gdbstub's siginfo save area. */ linux-user/syscall.c +1
-1@@ -136,6 +136,7 @@#include "loader.h" #include "user-mmap.h" #include "user/safe-syscall.h" +#include "user/signal.h" #include "qemu/guest-random.h" #include "qemu/selfmap.h" #include "user/syscall-trace.h" --2.47.0
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
In reply to Ilya LeoshkevichQuoted 30 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its threads. For threads that run on a CPU,
cpu_exit()is enough, but the only way to grab attention of a thread that is stuck in a long-running syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done for
TARGET_SIGABRTon Linux. This may reduce the number of available guest realtime signals by one, but this is acceptable, since there are quite a lot of them, and it's unlikely that there are apps that need them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking the syscall. This is a lie, since we don't queue a guest signal, butprocess_pending_signals()can handle the absence of pending signals. The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for the automatic restart. This is important, because it helps avoiding disturbing poorly written guests.Signed-off-by Ilya Leoshkevich <[email protected]>--- bsd-user/signal.c | 12 ++++++++++++ include/user/signal.h | 2 ++ linux-user/signal.c | 11 +++++++++++ 3 files changed, 25 insertions(+)bsd-user/signal.c +0
-0
bsd-user/signal.c static inline int sas_ss_flags(TaskState *ts, unsigned · line 55
Quoted 7 lines
bsd-user/signal.c +2
-0@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp) on_sig_stack(ts, sp) ? SS_ONSTACK : 0; } +int host_interrupt_signal =SIGRTMAX ; +
I'd be tempted to use SIGRTMAX + 1 or even TARGET_NSIG. 127 or 128 would work and not overflow any arrays (or hit any bounds tests) I'd likely use SIGRTMAX + 1,
though, since it avoids any edge-cases from sig == NSIG that might be in the code
unnoticed.
Now, having said that, I don't think that there's too many (any?) programs we need
to run as bsd-user that have real-time signals, much less one that uses SIGRTMAX,
but stranger things have happened. But it is a little wiggle room just in case.
Other than that:
Quoted 96 lines
bsd-user/signal.c +0
-0/* * The BSD ABIs use the same signal numbers across all the CPU
architectures, so
* (unlike Linux) these functions are just the identity mapping. This
might notbsd-user/signal.c +6
-0@@ -489,6 +491,12 @@ static void host_signal_handler(int host_sig, siginfo_t *info, void *puc)uintptr_t pc =0 ;bool sync_sig = false; +if (host_sig == host_interrupt_signal) { + ts->signal_pending =1 ; +cpu_exit (thread_cpu); +return ; + } +/* * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special * handling wrt signal blocking and unwinding.
bsd-user/signal.c +4
-0@@ -852,6 +860,9 @@ void signal_init(void)for (i =1 ; i <=TARGET_NSIG ; i++) { host_sig =target_to_host_signal (i); +if (host_sig == host_interrupt_signal) { +continue ; + }sigaction (host_sig,NULL , &oact);if (oact.sa_sigaction == (void *)SIG_IGN ) { sigact_table[i -1 ]._sa_handler =TARGET_SIG_IGN ;@@ -870,6 +881,7 @@ void signal_init(void)sigaction (host_sig, &act,NULL ); } } +sigaction (host_interrupt_signal, &act,NULL ); } static void handle_pending_signal(CPUArchState *env, int sig,include/user/signal.h +2
-0@@ -20,4 +20,6 @@*/ int target_to_host_signal (int sig); +extern int host_interrupt_signal; +#endif linux-user/signal.c +11
-0@@ -514,6 +514,8 @@ static int core_dump_signal(int sig) } } +int host_interrupt_signal; +static void signal_table_init (void ) {int hsig, tsig, count;@@ -540,6 +542,7 @@ static void signal_table_init(void) hsig =SIGRTMIN ; host_to_target_signal_table[SIGABRT ] =0 ; host_to_target_signal_table[hsig++] =TARGET_SIGABRT ; + host_interrupt_signal = hsig++; for (tsig = TARGET_SIGRTMIN; hsig <= SIGRTMAX && tsig <= TARGET_NSIG;@@ -619,6 +622,8 @@ void signal_init(void) } sigact_table[tsig -1 ]._sa_handler = thand; } + +sigaction (host_interrupt_signal, &act,NULL ); }/* Force a synchronously taken signal. The kernel force_sig() function @@ -966,6 +971,12 @@ static void host_signal_handler(int host_sig, siginfo_t *info, void *puc)bool sync_sig = false;void *sigmask; +if (host_sig == host_interrupt_signal) { + ts->signal_pending =1 ; +cpu_exit (thread_cpu); +return ; + } +/* * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special * handling wrt signal blocking and unwinding. Non-spoofed SIGILL,
--
2.47.0
Re: [PATCH 5/8] osdep: Introduce qemu_kill_thread()
In reply to Ilya LeoshkevichQuoted 10 lines · Ilya Leoshkevich
Add a function for sending signals to individual threads. It does not make sense on Windows, so do not provide an implementation, so that if someone uses it by accident, they will get a linker error.
Signed-off-by Ilya Leoshkevich <[email protected]>--- include/qemu/osdep.h | 9 +++++++++ util/oslib-posix.c | 15 +++++++++++++++ 2 files changed, 24 insertions(+)
Quoted 51 lines
include/qemu/osdep.h +9
-0@@ -626,6 +626,15 @@ bool qemu_write_pidfile(const char *pidfile, Error **errp);int qemu_get_thread_id (void ); +/** +* qemu_kill_thread: +* @tid: thread id. +* @sig: host signal. +* +* Send @sig to one of QEMU's own threads with identifier @tid. +*/ +int qemu_kill_thread (int tid,int sig); +#ifndef CONFIG_IOVEC struct iovec {void *iov_base;util/oslib-posix.c +15
-1@@ -111,6 +111,21 @@ int qemu_get_thread_id(void)#endif } +int qemu_kill_thread (int tid,int sig) +{ +#if defined(__linux__) +return syscall (__NR_tgkill,getpid (), tid, sig); +#elif defined(__FreeBSD__) +return thr_kill2 (getpid (), tid, sig); +#elif defined(__NetBSD__) +return _lwp_kill (tid, sig); +#elif defined(__OpenBSD__) +return thrkill (tid, sig,NULL ); +#else +return kill (tid, sig); +#endif +} +int qemu_daemon (int nochdir,int noclose) {return daemon (nochdir, noclose); --2.47.0
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
In reply to Warner LoshQuoted 65 lines · Warner Losh
Quoted 39 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its threads. For threads that run on a CPU,
cpu_exit()is enough, but the
only way to grab attention of a thread that is stuck in a long- running
syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done
forTARGET_SIGABRTon Linux. This may reduce the number of available
guest realtime signals by one, but this is acceptable, since there are
quite a lot of them, and it's unlikely that there are apps that need
them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking
the syscall. This is a lie, since we don't queue a guest signal, butprocess_pending_signals()can handle the absence of pending signals.
The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for the automatic restart. This is important, because it helps avoiding disturbing poorly written guests.Signed-off-by Ilya Leoshkevich <[email protected]>---
bsd-user/signal.c | 12 ++++++++++++
include/user/signal.h | 2 ++
linux-user/signal.c | 11 +++++++++++3 files changed, 25 insertions(+)bsd-user/signal.c +0
-0bsd-user/signal.c static inline int sas_ss_flags(TaskState *ts, · line 55
Quoted 7 lines
bsd-user/signal.c +2
-0@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp) on_sig_stack(ts, sp) ? SS_ONSTACK : 0; } +int host_interrupt_signal = SIGRTMAX; +I'd be tempted to use SIGRTMAX + 1 or even
TARGET_NSIG. 127 or 128 would
work and not overflow any arrays (or hit any bounds tests) I'd likely use SIGRTMAX + 1,
though, since it avoids any edge-cases from sig == NSIG that might be in the code
unnoticed.Now, having said that, I don't think that there's too many (any?) programs we need
to run as bsd-user that have real-time signals, much less one that uses SIGRTMAX,
but stranger things have happened. But it is a little wiggle room just in case.
Quoted 3 lines
Other than that:
Reviewed-by Warner Losh <[email protected]>
Thanks for the suggestion, I'll use SIGRTMAX + 1 in v2.
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
Quoted 66 lines · Ilya Leoshkevich
Quoted 65 lines · Warner Losh
Quoted 39 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its threads. For threads that run on a CPU,
cpu_exit()is enough, but the
only way to grab attention of a thread that is stuck in a long- running
syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done
forTARGET_SIGABRTon Linux. This may reduce the number of available
guest realtime signals by one, but this is acceptable, since there are
quite a lot of them, and it's unlikely that there are apps that need
them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking
the syscall. This is a lie, since we don't queue a guest signal, butprocess_pending_signals()can handle the absence of pending signals.
The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for the automatic restart. This is important, because it helps avoiding disturbing poorly written guests.Signed-off-by Ilya Leoshkevich <[email protected]>--- bsd-user/signal.c | 12 ++++++++++++ include/user/signal.h | 2 ++ linux-user/signal.c | 11 +++++++++++ 3 files changed, 25 insertions(+)bsd-user/signal.c +0
-0bsd-user/signal.c static inline int sas_ss_flags(TaskState *ts, · line 55
Quoted 7 lines
bsd-user/signal.c +2
-0@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp) on_sig_stack(ts, sp) ? SS_ONSTACK : 0; } +int host_interrupt_signal = SIGRTMAX; +I'd be tempted to use SIGRTMAX + 1 or even
TARGET_NSIG. 127 or 128 would
work and not overflow any arrays (or hit any bounds tests) I'd likely use SIGRTMAX + 1,
though, since it avoids any edge-cases from sig == NSIG that might be in the code
unnoticed.Now, having said that, I don't think that there's too many (any?) programs we need
to run as bsd-user that have real-time signals, much less one that uses SIGRTMAX,
but stranger things have happened. But it is a little wiggle room just in case.
Quoted 5 lines
Quoted 3 lines
Other than that:
Reviewed-by Warner Losh <[email protected]>Thanks for the suggestion, I'll use SIGRTMAX + 1 in v2.
That can't be right -- SIGRTMAX+1 is not a valid signal.
r~
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
Quoted 82 lines · Richard Henderson
Quoted 81 lines · Ilya Leoshkevich
Quoted 79 lines · Warner Losh
Quoted 45 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its
threads. For threads that run on a CPU,cpu_exit()is enough, but
the
only way to grab attention of a thread that is stuck in a long- running
syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done
forTARGET_SIGABRTon Linux. This may reduce the number of available
guest realtime signals by one, but this is acceptable, since there
are
quite a lot of them, and it's unlikely that there are apps that need
them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking
the syscall. This is a lie, since we don't queue a guest signal,
butprocess_pending_signals()can handle the absence of pending signals.
The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for
the automatic restart. This is important, because it helps avoiding
disturbing poorly written guests.Signed-off-by Ilya Leoshkevich <[email protected]>---
bsd-user/signal.c | 12 ++++++++++++
include/user/signal.h | 2 ++
linux-user/signal.c | 11 +++++++++++3 files changed, 25 insertions(+)bsd-user/signal.c +0
-0bsd-user/signal.c static inline int sas_ss_flags(TaskState *ts, · line 55
Quoted 7 lines
bsd-user/signal.c +2
-0@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp) on_sig_stack(ts, sp) ? SS_ONSTACK : 0; } +int host_interrupt_signal = SIGRTMAX; +I'd be tempted to use SIGRTMAX + 1 or even
TARGET_NSIG. 127 or 128
would
work and not overflow any arrays (or hit any bounds tests) I'd likely
use SIGRTMAX + 1,
though, since it avoids any edge-cases from sig == NSIG that might be
in the code
unnoticed.Now, having said that, I don't think that there's too many (any?) programs we need
to run as bsd-user that have real-time signals, much less one that
uses SIGRTMAX,
but stranger things have happened. But it is a little wiggle room just in case.Other than that:
Reviewed-by Warner Losh <[email protected]>
Quoted 7 lines
Quoted 1 line
Thanks for the suggestion, I'll use SIGRTMAX + 1 in v2.
That can't be right -- SIGRTMAX+1 is not a valid signal.
r~
I have to admit I didn't look into this too deeply, but I ran the following experiment on a FreeBSD 14.1 box:
/usr/include $ grep -R SIGRTMAX .
./sys/signal.h:#define SIGRTMAX 126
$ sleep 100 &
$ kill -126 %1
[1] Unknown signal: 126 sleep 100
$ sleep 100 &
$ kill -127 %1
[1] + Unknown signal: 0 sleep 100Clearly, something is wrong - at least with the shell - but at the same time the signal delivery seems to have occurred.
Warner, does the above look normal to you?
Re: [PATCH 4/8] user: Introduce host_interrupt_signal
Quoted 105 lines · Ilya Leoshkevich
Quoted 82 lines · Richard Henderson
Quoted 81 lines · Ilya Leoshkevich
Quoted 79 lines · Warner Losh
Quoted 45 lines · Ilya Leoshkevich
Attaching to the gdbstub of a running process requires stopping its
threads. For threads that run on a CPU,cpu_exit()is enough, but
the
only way to grab attention of a thread that is stuck in a long- running
syscall is to interrupt it with a signal.Reserve a host realtime signal for this, just like it's already done
forTARGET_SIGABRTon Linux. This may reduce the number of available
guest realtime signals by one, but this is acceptable, since there
are
quite a lot of them, and it's unlikely that there are apps that need
them all.Set
signal_pendingfor thesafe_sycallmachinery to prevent invoking
the syscall. This is a lie, since we don't queue a guest signal,
butprocess_pending_signals()can handle the absence of pending signals.
The syscall returns withQEMU_ERESTARTSYSerrno, which arranges for
the automatic restart. This is important, because it helps avoiding
disturbing poorly written guests.Signed-off-by Ilya Leoshkevich <[email protected]>--- bsd-user/signal.c | 12 ++++++++++++ include/user/signal.h | 2 ++ linux-user/signal.c | 11 +++++++++++ 3 files changed, 25 insertions(+)bsd-user/signal.c +0
-0bsd-user/signal.c static inline int sas_ss_flags(TaskState *ts, · line 55
Quoted 7 lines
bsd-user/signal.c +2
-0@@ -49,6 +49,8 @@ static inline int sas_ss_flags(TaskState *ts, unsigned long sp) on_sig_stack(ts, sp) ? SS_ONSTACK : 0; } +int host_interrupt_signal =SIGRTMAX ; +I'd be tempted to use SIGRTMAX + 1 or even
TARGET_NSIG. 127 or 128
would
work and not overflow any arrays (or hit any bounds tests) I'd likely
use SIGRTMAX + 1,
though, since it avoids any edge-cases from sig == NSIG that might be
in the code
unnoticed.Now, having said that, I don't think that there's too many (any?) programs we need
to run as bsd-user that have real-time signals, much less one that
uses SIGRTMAX,
but stranger things have happened. But it is a little wiggle room just in case.Other than that:
Reviewed-by Warner Losh <[email protected]>Quoted 7 lines
Quoted 1 line
Thanks for the suggestion, I'll use SIGRTMAX + 1 in v2.
That can't be right -- SIGRTMAX+1 is not a valid signal.
r~
I have to admit I didn't look into this too deeply, but I ran the following experiment on a FreeBSD 14.1 box:
/usr/include $ grep -R SIGRTMAX . ./sys/signal.h:#define SIGRTMAX 126 $ sleep 100 & $ kill -126 %1 [1] Unknown signal: 126 sleep 100 $ sleep 100 & $ kill -127 %1 [1] + Unknown signal: 0 sleep 100
Quoted 5 lines
Clearly, something is wrong - at least with the shell - but at the same time the signal delivery seems to have occurred.
Warner, does the above look normal to you?
Oh! I understand.... I thought there was a gap above SIGRTMAX. It sure looks like there is. However, 0177 (127) is used to signal that the process is STOPPED, so can't be used. This is why SIGRTMAX is 126 and not 127. There's room in sigset_t, but that's not sufficient. And it has to be an actual signal we send, not just a flag.
So forget I said anything. This was a silly idea. If we find any real thing that's using SIGRTMAX, we'll cope.
Warner