GDB not stopping with "interrupt" command from python script

I had the same problem, from what I can tell from googling it is a current limitation of gdb: interrupt simply doesn't work in batch mode (when specifying commands with --ex, or -x file, or on stdin, or sourcing from file), it runs the following commands before actually stopping the execution (inserting a delay doesn't help). Building on the @dwjbosman's solution, here's a compact version suitable for feeding to gdb with --ex arguments for example:

python import threading, gdb
python threading.Timer(1.0, lambda: gdb.post_event(lambda: gdb.execute("interrupt"))).start()
cont
thread apply all bt full # or whatever you wanted to do

It schedules an interrupt after 1 second and resumes the program, then you can do whatever you wanted to do after the pause right in the main script.

I just ran into this same issue while writing some automated testing scripts. What I've noticed is that the 'interrupt' command doesn't stop the application until after the current script has exited.

Unfortunately, this means that you would need to segment your scripts anytime you are causing an interrupt.

Script 1:

gdb.execute('c&')
gdb.execute('interrupt')

Script 2:

gdb.execute("dump binary memory montiormem.bin 0x0 (&__etext + 4)")

I used multi threading to get arround this issue:

def post(cmd):
    def _callable():
        print("exec " + cmd , flush=True)
        gdb.execute(cmd)

    print("schedule " + cmd , flush=True)
    gdb.post_event(_callable)

class ScriptThread (threading.Thread):
    def run (self):

        while True:
            post("echo hello\n")
            time.sleep(1)

x = ScriptThread()
x.start()

Save this as "test_script.py"

Use the script as follows:

gdb
> source test_script.py

Note: that you can also pipe "source test_script.py", but you need to keep the pipe open.

Once the thread is started GDB will wait for the thread to end and will process any commands you send to it via the "post_event" function. Even "interrupt"!

Little background

After spending a good amount of time, here's a summary:

The initial bug, being that the GIL does not get released when executing GDB command, was actually fixed in 2014. 1 2

That should have allowed to do something like

gdb.execute("continue")
# Do some processing in the main thread
gdb.execute("interrupt")

However, a few years later, a series of bugs due to a too early release of the GIL were undiscovered, and so other patches were added, which again removed the ability to do so. here's one of them

Also, a Threading module module was added, which can thus execute things in GDB's context, while the GIL is still locked.

In 2023, gdb.interrupt was added. You can find the docs in the Threading module also (not detected by intellisense on my machine, but it does work)

It helps in that it only interrupts if the target is actually running, and sends a Ctrl-C if needed. If you don't want your script to be interrupted by it, you have to catch the exception. I personnally handle it like that:

def halt(self):
    try:
        gdb.interrupt()
    except KeyboardInterrupt:
        pass

Current Situation

If you need to programmatically interrupt GDB, @Chris Moore's Answer remains the best one.

def run_and_stop():
   gdb.post_event(lambda: gdb.interrupt())
   gdb.execute("continue")

I personnally use it like that:

def main():
    while True:
        backtrace = gdb.execute("backtrace")

        def do_async():
            process_backtrace(backtrace)
            halt()
        
        gdb.post_event(do_async)
        gdb.execute("resume")

A few more notes

• I could not manage to manage to make gdb.execute("continue &") to work.

• For some reason, executing interrupt when already halted, then continue immediately halted upon resume, like if it had been without the need to run interrupt again. In my case I wanted to make sure it ran for at least a few milliseconds between each run, so I could not use that.

• Halting repeatedly like this is extremely innefficient, with pyOCD, I can get 2 fps, and with OpenOCD I can get 4.

• You may be tempted to use monitor resume and monitor halt instead. Not that you'll then have to use maintenance clear register-cache, and that you'll often still end up with broken stacktraces. Why? Good question.

• My Atmel-ICE crashes after a few minutes when I do that repeatedly. Not sure why. It seems to be less frequent when I stop with PyOCD instead of OpenOCD. Is it juste because of the speed?