-/* Default child (native) target interface, for GDB when running under
- Unix.
+/* Base/prototype target for default child (native) targets.
- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
- 1999, 2000, 2001, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 1988-2022 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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* This file provides a common base class/target that all native
+ target implementations extend, by calling inf_child_target to get a
+ new prototype target and then overriding target methods as
+ necessary. */
#include "defs.h"
#include "regcache.h"
#include "symtab.h"
#include "target.h"
#include "inferior.h"
-#include "gdb_string.h"
+#include <sys/stat.h>
+#include "inf-child.h"
+#include "gdbsupport/fileio.h"
+#include "gdbsupport/agent.h"
+#include "gdbsupport/gdb_wait.h"
+#include "gdbsupport/filestuff.h"
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
-/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
- for all registers. */
+static const target_info inf_child_target_info = {
+ "native",
+ N_("Native process"),
+ N_("Native process (started by the \"run\" command).")
+};
-static void
-inf_child_fetch_inferior_registers (int regnum)
+const target_info &
+inf_child_target::info () const
{
- if (regnum == -1)
- {
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- regcache_raw_supply (current_regcache, regnum, NULL);
- }
- else
- regcache_raw_supply (current_regcache, regnum, NULL);
+ return inf_child_target_info;
}
-/* Store register REGNUM back into the inferior. If REGNUM is -1, do
- this for all registers (including the floating point registers). */
+/* See inf-child.h. */
-static void
-inf_child_store_inferior_registers (int regnum)
+target_waitstatus
+host_status_to_waitstatus (int hoststatus)
{
+ if (WIFEXITED (hoststatus))
+ return target_waitstatus ().set_exited (WEXITSTATUS (hoststatus));
+ else if (!WIFSTOPPED (hoststatus))
+ return target_waitstatus ().set_signalled
+ (gdb_signal_from_host (WTERMSIG (hoststatus)));
+ else
+ return target_waitstatus ().set_stopped
+ (gdb_signal_from_host (WSTOPSIG (hoststatus)));
}
-static void
-inf_child_post_attach (int pid)
+inf_child_target::~inf_child_target ()
+{}
+
+void
+inf_child_target::post_attach (int pid)
{
- /* This version of Unix doesn't require a meaningful "post attach"
- operation by a debugger. */
+ /* This target doesn't require a meaningful "post attach" operation
+ by a debugger. */
}
/* Get ready to modify the registers array. On machines which store
makes sure that registers contains all the registers from the
program being debugged. */
-static void
-inf_child_prepare_to_store (void)
+void
+inf_child_target::prepare_to_store (struct regcache *regcache)
+{
+}
+
+bool
+inf_child_target::supports_terminal_ours ()
+{
+ return true;
+}
+
+void
+inf_child_target::terminal_init ()
+{
+ child_terminal_init (this);
+}
+
+void
+inf_child_target::terminal_inferior ()
{
+ child_terminal_inferior (this);
}
-static void
-inf_child_open (char *arg, int from_tty)
+void
+inf_child_target::terminal_save_inferior ()
{
- error (_("Use the \"run\" command to start a Unix child process."));
+ child_terminal_save_inferior (this);
}
-static void
-inf_child_post_startup_inferior (ptid_t ptid)
+void
+inf_child_target::terminal_ours_for_output ()
{
- /* This version of Unix doesn't require a meaningful "post startup
- inferior" operation by a debugger. */
+ child_terminal_ours_for_output (this);
}
-static void
-inf_child_acknowledge_created_inferior (int pid)
+void
+inf_child_target::terminal_ours ()
{
- /* This version of Unix doesn't require a meaningful "acknowledge
- created inferior" operation by a debugger. */
+ child_terminal_ours (this);
}
-static void
-inf_child_insert_fork_catchpoint (int pid)
+void
+inf_child_target::interrupt ()
{
- /* This version of Unix doesn't support notification of fork
- events. */
+ child_interrupt (this);
}
-static int
-inf_child_remove_fork_catchpoint (int pid)
+void
+inf_child_target::pass_ctrlc ()
{
- /* This version of Unix doesn't support notification of fork
- events. */
- return 0;
+ child_pass_ctrlc (this);
}
-static void
-inf_child_insert_vfork_catchpoint (int pid)
+void
+inf_child_target::terminal_info (const char *args, int from_tty)
{
- /* This version of Unix doesn't support notification of vfork
- events. */
+ child_terminal_info (this, args, from_tty);
}
-static int
-inf_child_remove_vfork_catchpoint (int pid)
+/* True if the user did "target native". In that case, we won't
+ unpush the child target automatically when the last inferior is
+ gone. */
+static int inf_child_explicitly_opened;
+
+/* See inf-child.h. */
+
+void
+inf_child_open_target (const char *arg, int from_tty)
{
- /* This version of Unix doesn't support notification of vfork
- events. */
- return 0;
+ target_ops *target = get_native_target ();
+
+ /* There's always only ever one native target, and if we get here,
+ it better be an inf-child target. */
+ gdb_assert (dynamic_cast<inf_child_target *> (target) != NULL);
+
+ target_preopen (from_tty);
+ current_inferior ()->push_target (target);
+ inf_child_explicitly_opened = 1;
+ if (from_tty)
+ gdb_printf ("Done. Use the \"run\" command to start a process.\n");
}
-static int
-inf_child_follow_fork (struct target_ops *ops, int follow_child)
+/* Implement the to_disconnect target_ops method. */
+
+void
+inf_child_target::disconnect (const char *args, int from_tty)
{
- /* This version of Unix doesn't support following fork or vfork
- events. */
- return 0;
+ if (args != NULL)
+ error (_("Argument given to \"disconnect\"."));
+
+ /* This offers to detach/kill current inferiors, and then pops all
+ targets. */
+ target_preopen (from_tty);
}
-static void
-inf_child_insert_exec_catchpoint (int pid)
+/* Implement the to_close target_ops method. */
+
+void
+inf_child_target::close ()
{
- /* This version of Unix doesn't support notification of exec
- events. */
+ /* In case we were forcibly closed. */
+ inf_child_explicitly_opened = 0;
}
-static int
-inf_child_remove_exec_catchpoint (int pid)
+void
+inf_child_target::mourn_inferior ()
{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 0;
+ generic_mourn_inferior ();
+ maybe_unpush_target ();
}
-static int
-inf_child_reported_exec_events_per_exec_call (void)
+/* See inf-child.h. */
+
+void
+inf_child_target::maybe_unpush_target ()
{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 1;
+ if (!inf_child_explicitly_opened)
+ current_inferior ()->unpush_target (this);
}
-static int
-inf_child_can_run (void)
+bool
+inf_child_target::can_run ()
{
- return 1;
+ return true;
}
-static struct symtab_and_line *
-inf_child_enable_exception_callback (enum exception_event_kind kind,
- int enable)
+bool
+inf_child_target::can_create_inferior ()
{
- return (struct symtab_and_line *) NULL;
+ return true;
}
-static struct exception_event_record *
-inf_child_get_current_exception_event (void)
+bool
+inf_child_target::can_attach ()
{
- return (struct exception_event_record *) NULL;
+ return true;
}
-static char *
-inf_child_pid_to_exec_file (int pid)
+const char *
+inf_child_target::pid_to_exec_file (int pid)
{
- /* This version of Unix doesn't support translation of a process ID
- to the filename of the executable file. */
+ /* This target doesn't support translation of a process ID to the
+ filename of the executable file. */
return NULL;
}
-struct target_ops *
-inf_child_target (void)
-{
- struct target_ops *t = XZALLOC (struct target_ops);
- t->to_shortname = "child";
- t->to_longname = "Unix child process";
- t->to_doc = "Unix child process (started by the \"run\" command).";
- t->to_open = inf_child_open;
- t->to_post_attach = inf_child_post_attach;
- t->to_fetch_registers = inf_child_fetch_inferior_registers;
- t->to_store_registers = inf_child_store_inferior_registers;
- t->to_prepare_to_store = inf_child_prepare_to_store;
- t->to_insert_breakpoint = memory_insert_breakpoint;
- t->to_remove_breakpoint = memory_remove_breakpoint;
- t->to_terminal_init = terminal_init_inferior;
- t->to_terminal_inferior = terminal_inferior;
- t->to_terminal_ours_for_output = terminal_ours_for_output;
- t->to_terminal_save_ours = terminal_save_ours;
- t->to_terminal_ours = terminal_ours;
- t->to_terminal_info = child_terminal_info;
- t->to_post_startup_inferior = inf_child_post_startup_inferior;
- t->to_acknowledge_created_inferior = inf_child_acknowledge_created_inferior;
- t->to_insert_fork_catchpoint = inf_child_insert_fork_catchpoint;
- t->to_remove_fork_catchpoint = inf_child_remove_fork_catchpoint;
- t->to_insert_vfork_catchpoint = inf_child_insert_vfork_catchpoint;
- t->to_remove_vfork_catchpoint = inf_child_remove_vfork_catchpoint;
- t->to_follow_fork = inf_child_follow_fork;
- t->to_insert_exec_catchpoint = inf_child_insert_exec_catchpoint;
- t->to_remove_exec_catchpoint = inf_child_remove_exec_catchpoint;
- t->to_reported_exec_events_per_exec_call =
- inf_child_reported_exec_events_per_exec_call;
- t->to_can_run = inf_child_can_run;
- t->to_enable_exception_callback = inf_child_enable_exception_callback;
- t->to_get_current_exception_event = inf_child_get_current_exception_event;
- t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
- t->to_stratum = process_stratum;
- t->to_has_all_memory = 1;
- t->to_has_memory = 1;
- t->to_has_stack = 1;
- t->to_has_registers = 1;
- t->to_has_execution = 1;
- t->to_magic = OPS_MAGIC;
- return t;
+/* Implementation of to_fileio_open. */
+
+int
+inf_child_target::fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno)
+{
+ int nat_flags;
+ mode_t nat_mode;
+ int fd;
+
+ if (fileio_to_host_openflags (flags, &nat_flags) == -1
+ || fileio_to_host_mode (mode, &nat_mode) == -1)
+ {
+ *target_errno = FILEIO_EINVAL;
+ return -1;
+ }
+
+ fd = gdb_open_cloexec (filename, nat_flags, nat_mode).release ();
+ if (fd == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return fd;
+}
+
+/* Implementation of to_fileio_pwrite. */
+
+int
+inf_child_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *target_errno)
+{
+ int ret;
+
+#ifdef HAVE_PWRITE
+ ret = pwrite (fd, write_buf, len, (long) offset);
+#else
+ ret = -1;
+#endif
+ /* If we have no pwrite or it failed for this file, use lseek/write. */
+ if (ret == -1)
+ {
+ ret = lseek (fd, (long) offset, SEEK_SET);
+ if (ret != -1)
+ ret = write (fd, write_buf, len);
+ }
+
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_pread. */
+
+int
+inf_child_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *target_errno)
+{
+ int ret;
+
+#ifdef HAVE_PREAD
+ ret = pread (fd, read_buf, len, (long) offset);
+#else
+ ret = -1;
+#endif
+ /* If we have no pread or it failed for this file, use lseek/read. */
+ if (ret == -1)
+ {
+ ret = lseek (fd, (long) offset, SEEK_SET);
+ if (ret != -1)
+ ret = read (fd, read_buf, len);
+ }
+
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_fstat. */
+
+int
+inf_child_target::fileio_fstat (int fd, struct stat *sb, int *target_errno)
+{
+ int ret;
+
+ ret = fstat (fd, sb);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_close. */
+
+int
+inf_child_target::fileio_close (int fd, int *target_errno)
+{
+ int ret;
+
+ ret = ::close (fd);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_unlink. */
+
+int
+inf_child_target::fileio_unlink (struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ int ret;
+
+ ret = unlink (filename);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_readlink. */
+
+gdb::optional<std::string>
+inf_child_target::fileio_readlink (struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ /* We support readlink only on systems that also provide a compile-time
+ maximum path length (PATH_MAX), at least for now. */
+#if defined (PATH_MAX)
+ char buf[PATH_MAX];
+ int len;
+
+ len = readlink (filename, buf, sizeof buf);
+ if (len < 0)
+ {
+ *target_errno = host_to_fileio_error (errno);
+ return {};
+ }
+
+ return std::string (buf, len);
+#else
+ *target_errno = FILEIO_ENOSYS;
+ return {};
+#endif
+}
+
+bool
+inf_child_target::use_agent (bool use)
+{
+ if (agent_loaded_p ())
+ {
+ ::use_agent = use;
+ return true;
+ }
+ else
+ return false;
+}
+
+bool
+inf_child_target::can_use_agent ()
+{
+ return agent_loaded_p ();
+}
+
+void
+inf_child_target::follow_exec (inferior *follow_inf, ptid_t ptid,
+ const char *execd_pathname)
+{
+ inferior *orig_inf = current_inferior ();
+
+ process_stratum_target::follow_exec (follow_inf, ptid, execd_pathname);
+
+ if (orig_inf != follow_inf)
+ {
+ /* If the target was implicitly push in the original inferior, unpush
+ it. */
+ scoped_restore_current_thread restore_thread;
+ switch_to_inferior_no_thread (orig_inf);
+ maybe_unpush_target ();
+ }
+}
+
+/* See inf-child.h. */
+
+void
+add_inf_child_target (inf_child_target *target)
+{
+ set_native_target (target);
+ add_target (inf_child_target_info, inf_child_open_target);
}
projects / binutils-gdb.git / blobdiff