mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-23 18:14:13 +08:00
59912fb2d2
Initially I just wanted a Python event for when GDB removes a program space, I'm writing a Python extension that caches information for each program space, and need to know when I should discard entries for a particular program space. But, it seemed easy enough to also add an event for when GDB adds a new program space, so I went ahead and added both new events. Of course, we don't currently have an observable for program space addition or removal, so I first needed to add these. After that it's pretty simple to add two new Python events and have these trigger. The two new event registries are: events.new_progspace events.free_progspace These emit NewProgspaceEvent and FreeProgspaceEvent objects respectively, each of these new event types has a 'progspace' attribute that contains the relevant gdb.Progspace object. There's a couple of things to be mindful of. First, it is not possible to catch the NewProgspaceEvent for the very first program space, the one that is created when GDB first starts, as this program space is created before any Python scripts are sourced. In order to allow this event to be caught we would need to defer creating the first program space, and as a consequence the first inferior, until some later time. But, existing scripts could easily depend on there being an initial inferior, so I really don't think we should change that -- and so, we end up with the consequence that we can't catch the event for the first program space. The second, I think minor, issue, is that GDB doesn't clean up its program spaces upon exit -- or at least, they are not cleaned up before Python is shut down. As a result, any program spaces in use at the time GDB exits don't generate a FreeProgspaceEvent. I'm not particularly worried about this for my use case, I'm using the event to ensure that a cache doesn't hold stale entries within a single GDB session. It's also easy enough to add a Python at-exit callback which can do any final cleanup if needed. Finally, when testing, I did hit a slightly weird issue with some of the remote boards (e.g. remote-stdio-gdbserver). As a consequence of this issue I see some output like this in the gdb.log: (gdb) PASS: gdb.python/py-progspace-events.exp: inferior 1 step FreeProgspaceEvent: <gdb.Progspace object at 0x7fb7e1d19c10> warning: cannot close "target:/lib64/libm.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. warning: cannot close "target:/lib64/libc.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. warning: cannot close "target:/lib64/ld-linux-x86-64.so.2": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. do_parent_stuff () at py-progspace-events.c:41 41 ++global_var; (gdb) PASS: gdb.python/py-progspace-events.exp: step The 'FreeProgspaceEvent ...' line is expected, that's my test Python extension logging the event. What isn't expected are all the blocks like: warning: cannot close "target:/lib64/libm.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. It turns out that this has nothing to do with my changes, this is just a consequence of reading files over the remote protocol. The test forks a child process which GDB stays attached too. When the child exits, GDB cleans up by calling prune_inferiors, which in turn can result in GDB trying to close some files that are open because of the inferior being deleted. If the prune_inferiors call occurs when the remote target is running (and in non-async mode) then GDB will try to send a fileio packet while the remote target is waiting for a stop reply, and the remote target will throw an error, see remote_target::putpkt_binary in remote.c for details. I'm going to look at fixing this, but, as I said, this is nothing to do with this change, I just mention it because I ended up needing to account for these warning messages in one of my tests, and it all looks a bit weird. Approved-By: Tom Tromey <tom@tromey.com> Reviewed-By: Eli Zaretskii <eliz@gnu.org>
101 lines
3.1 KiB
C
101 lines
3.1 KiB
C
/* GDB Notifications to Observers.
|
|
|
|
Copyright (C) 2003-2023 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "observable.h"
|
|
#include "command.h"
|
|
#include "gdbcmd.h"
|
|
|
|
namespace gdb
|
|
{
|
|
|
|
namespace observers
|
|
{
|
|
|
|
bool observer_debug = false;
|
|
|
|
#define DEFINE_OBSERVABLE(name) decltype (name) name (# name)
|
|
|
|
DEFINE_OBSERVABLE (normal_stop);
|
|
DEFINE_OBSERVABLE (signal_received);
|
|
DEFINE_OBSERVABLE (target_changed);
|
|
DEFINE_OBSERVABLE (executable_changed);
|
|
DEFINE_OBSERVABLE (inferior_created);
|
|
DEFINE_OBSERVABLE (inferior_execd);
|
|
DEFINE_OBSERVABLE (inferior_forked);
|
|
DEFINE_OBSERVABLE (solib_loaded);
|
|
DEFINE_OBSERVABLE (solib_unloaded);
|
|
DEFINE_OBSERVABLE (new_objfile);
|
|
DEFINE_OBSERVABLE (free_objfile);
|
|
DEFINE_OBSERVABLE (new_thread);
|
|
DEFINE_OBSERVABLE (thread_exit);
|
|
DEFINE_OBSERVABLE (thread_stop_requested);
|
|
DEFINE_OBSERVABLE (target_resumed);
|
|
DEFINE_OBSERVABLE (about_to_proceed);
|
|
DEFINE_OBSERVABLE (breakpoint_created);
|
|
DEFINE_OBSERVABLE (breakpoint_deleted);
|
|
DEFINE_OBSERVABLE (breakpoint_modified);
|
|
DEFINE_OBSERVABLE (architecture_changed);
|
|
DEFINE_OBSERVABLE (thread_ptid_changed);
|
|
DEFINE_OBSERVABLE (inferior_added);
|
|
DEFINE_OBSERVABLE (inferior_appeared);
|
|
DEFINE_OBSERVABLE (inferior_pre_detach);
|
|
DEFINE_OBSERVABLE (inferior_exit);
|
|
DEFINE_OBSERVABLE (inferior_removed);
|
|
DEFINE_OBSERVABLE (inferior_cloned);
|
|
DEFINE_OBSERVABLE (memory_changed);
|
|
DEFINE_OBSERVABLE (before_prompt);
|
|
DEFINE_OBSERVABLE (gdb_datadir_changed);
|
|
DEFINE_OBSERVABLE (inferior_call_pre);
|
|
DEFINE_OBSERVABLE (inferior_call_post);
|
|
DEFINE_OBSERVABLE (register_changed);
|
|
DEFINE_OBSERVABLE (user_selected_context_changed);
|
|
DEFINE_OBSERVABLE (styling_changed);
|
|
DEFINE_OBSERVABLE (current_source_symtab_and_line_changed);
|
|
DEFINE_OBSERVABLE (gdb_exiting);
|
|
DEFINE_OBSERVABLE (connection_removed);
|
|
DEFINE_OBSERVABLE (target_pre_wait);
|
|
DEFINE_OBSERVABLE (target_post_wait);
|
|
DEFINE_OBSERVABLE (new_program_space);
|
|
DEFINE_OBSERVABLE (free_program_space);
|
|
|
|
} /* namespace observers */
|
|
} /* namespace gdb */
|
|
|
|
static void
|
|
show_observer_debug (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
gdb_printf (file, _("Observer debugging is %s.\n"), value);
|
|
}
|
|
|
|
void _initialize_observer ();
|
|
void
|
|
_initialize_observer ()
|
|
{
|
|
add_setshow_boolean_cmd ("observer", class_maintenance,
|
|
&gdb::observers::observer_debug, _("\
|
|
Set observer debugging."), _("\
|
|
Show observer debugging."), _("\
|
|
When non-zero, observer debugging is enabled."),
|
|
NULL,
|
|
show_observer_debug,
|
|
&setdebuglist, &showdebuglist);
|
|
}
|