GDB - 在单独的窗口中显示目标应用程序的输出

Question

我正在使用 GDB 来调试一些 C 应用程序。我当前所做的是加载目标应用程序，在第 30 行设置断点并运行它。

我想让 GDB 在新的终端窗口中显示我自己的应用程序的输出，同时我仍然能够通过 GDB 终端窗口控制断点处理，但我似乎找不到合适的开关。有什么办法让 GDB 在它自己的窗口中显示我的程序的输出吗？

Answer 1

对于想知道如何使用 GDB tty 命令的人，这里有一个简短的描述...

• 打开一个新的控制台窗口。我们将在这里重定向 GDB 下运行的程序的输出。这是我们的输出窗口。

• 在输出窗口中运行tty命令。这将显示底层控制台正在使用的 tty 的名称。

  $tty
/dev/pts/4

• 打开另一个控制台窗口并在此处启动 GDB。我们将其称为 GDB 窗口。

• 现在使用上面获得的tty文件名在GDB中运行tty命令，然后开始调试过程。

  (gdb) tty /dev/pts/4
(gdb) run

现在您应该能够在输出窗口中单独看到程序输出。

注意：GDB set new-console on 命令在 Linux 上不起作用！它只能在 Windows 上运行。在 Linux 上使用上述 tty 方法。

Answer 2

您可以使用 set new-console on 来完成此操作，如此处所示。

Answer 3

另一种方法是使用 gdbserver 启动目标程序（假设您可以使用它）。然后您可以将在单独窗口中启动的 GDB 连接到 gdbserver。

GNU gdbserver 文档

从窗口 A：

gdbserver :12345 myprog [args...]

从窗口 B：

gdb myprog
GNU gdb 6.6
...
(gdb) target remote localhost:12345
Remote debugging using localhost:12345
0x009867c0 in ?? ()
(gdb) b main
Breakpoint 1 at 0x804834a: file myprog.c, line 40.
(gdb) c
Continuing.

Breakpoint 1, main (argc=1, argv=0xffff8904) at myprog.c:40
40          int i = 1;
(gdb) 

Answer 4

我知道的最好方法是将程序的输出重定向到一个文件，然后在另一个终端中 tail -f 该文件。重定向是通过 run > 完成的。文件名，如GDB 文档中所述。

Answer 5

GDB 的 tty 命令确实可以工作，但它不适用于交互式程序，例如您想调试 bash。即使对于非交互式程序，您也会得到以下结果：

warning: GDB: Failed to set controlling terminal: Operation not permitted

我编写了一个小程序来解决这两个问题：

// Open a pty and let it idle, so that a process spawned in a different window
// can attach to it, start a new session, and set it as the controlling
// terminal. Useful for gdb debugging with gdb's `tty` command.
 
#include <inttypes.h>
typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64;
typedef  int8_t i8; typedef  int16_t i16; typedef  int32_t i32; typedef  int64_t i64;
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>

#include <termios.h>
#include <pty.h>
#include <liburing.h>

#define BSIZE 4096

void raw_terminal(void)
{
    if (!isatty(0))
        return;
    struct termios t;
    tcgetattr(0, &t);
    t.c_lflag &= ~(ISIG | ICANON | ECHO);
    tcsetattr(0, TCSANOW, &t);
}

// Refers to the state of a Joint /while it's waiting in io_uring_enter/.
enum State {
    READ,
    WRITE
};
// Joins two fds together, like splice, but not a syscall and works on any two
// fds.
struct Joint {
    u8 buf[BSIZE];
    i32 ifd;
    i32 ofd;
    enum State state;
    u32 nread;
};
void roll_joint(struct Joint *j, struct io_uring *ur, i32 ifd, i32 ofd)
{
    j->ifd = ifd;
    j->ofd = ofd;
    j->state = READ;
    struct io_uring_sqe *sqe = io_uring_get_sqe(ur);
    io_uring_prep_read(sqe, j->ifd, j->buf, BSIZE, 0);
    io_uring_sqe_set_data(sqe, j);
    io_uring_submit(ur);
}
i32 main(i32 argc, char **argv)
{
    raw_terminal();
    struct io_uring ur;
    assert(io_uring_queue_init(256, &ur, 0) == 0);

    i32 ptm, pts;
    assert(openpty(&ptm, &pts, NULL, NULL, NULL) == 0);
    dprintf(2, "pid = %u   tty = %s\n", getpid(), ttyname(pts));

    struct Joint jkbd;
    roll_joint(&jkbd, &ur, 0, ptm);
    struct Joint jscreen;
    roll_joint(&jscreen, &ur, ptm, 1);

    for (;;) {
        struct io_uring_cqe *cqe;
        for (;;) {
            // Actions like suspend to RAM can interrupt the io_uring_enter
            // syscall. If we get interrupted, try again. For all other errors,
            // bail. Also, wait_cqe negates the error for no reason. It never
            // returns positive numbers. Very silly.
            u32 res = -io_uring_wait_cqe(&ur, &cqe);
            if (res == 0)
                break;
            else if (res != EINTR) {
                dprintf(2, "io_uring_enter returns errno %d\n", res);
                exit(res);
            }
        }
        struct Joint *j = io_uring_cqe_get_data(cqe);
        if (j->state == READ) {
            // Exiting READ state. Finish with the read...
            j->nread = cqe->res;
            assert(j->nread > 0);

            // Now, start the write.
            j->state = WRITE;
            struct io_uring_sqe *sqe = io_uring_get_sqe(&ur);
            io_uring_prep_write(sqe, j->ofd, j->buf, j->nread, 0);
            io_uring_sqe_set_data(sqe, j);
            io_uring_submit(&ur);
        }
        else if (j->state == WRITE) {
            // Exiting WRITE state. Finish with the write...
            i64 nwritten = cqe->res;
            assert(nwritten == j->nread);

            // Now, start the read.
            j->state = READ;
            struct io_uring_sqe *sqe = io_uring_get_sqe(&ur);
            io_uring_prep_read(sqe, j->ifd, j->buf, BSIZE, 0);
            io_uring_sqe_set_data(sqe, j);
            io_uring_submit(&ur);
        }
        io_uring_cqe_seen(&ur, cqe);
    }

    io_uring_queue_exit(&ur);
    return 0;
}

假设您将该程序保存到 idleterm.c。编译它：

> gcc -o idleterm idleterm.c -luring

要使用它，请启动一个终端窗口，然后在该窗口上运行 idleterm。它将打印要附加到的 tty 的名称：

> ./idleterm
pid = 3405922   tty = /dev/pts/0
█

复制该 tty 路径并将其粘贴到第二个窗口中的 gdb 会话中：

> gdb bash
Reading symbols from bash...
(No debugging symbols found in bash)
(gdb) tty /dev/pts/0
(gdb) r
Starting program: /usr/bin/bash
…

第一个窗口中将出现 bash 提示符。所有需要特殊 TTY 行为的 bash 交互都将正常工作，包括 ^C、^Z 等。

idleterm 传递所有 键盘输入到正在调试的子进程，包括^C和^Z。因此，为了停止idleterm，您必须从单独的窗口中终止它。这就是 idleterm 打印其 pid 的原因。复制 pid，然后将其粘贴到 Kill 命令中：

> kill 3405922

如果系统上只有一个 idleterm 实例运行，您当然可以只使用 killall。

Answer 6

只需使用 tty 命令即可。如果您希望程序的输出重定向到 /dev/pts/5 ，请输入：

tty /dev/pts/5

Answer 7

对于 Mac 上的 lldb，以下命令在新的终端窗口中运行程序，而调试器从原始窗口进行控制：

$ lldb   <prog>
(lldb) b main   # if you want to set a breakpoint
(lldb) process launch --tty -- <args>

这将程序作为指定 tty（终端窗口）中的进程运行：

$ tty   # (in other window, get tty name)
/dev/ttys002

$ lldb  
(lldb) b main   # if you want to set a breakpoint
(lldb) process launch --tty=/dev/ttys002 -- <args>