/* Machine independent support for Solaris /proc (process file system) for GDB.
- Copyright (C) 1999-2019 Free Software Foundation, Inc.
+ Copyright (C) 1999-2020 Free Software Foundation, Inc.
Written by Michael Snyder at Cygnus Solutions.
Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
#include "regcache.h"
#include "inf-child.h"
#include "nat/fork-inferior.h"
-#include "common/filestuff.h"
+#include "gdbarch.h"
#define _STRUCTURED_PROC 1 /* Should be done by configure script. */
#include <sys/procfs.h>
#include <sys/fault.h>
#include <sys/syscall.h>
-#include "common/gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include <signal.h>
#include <ctype.h>
#include "gdb_bfd.h"
#include "auxv.h"
#include "procfs.h"
#include "observable.h"
-#include "common/scoped_fd.h"
-#include "common/pathstuff.h"
+#include "gdbsupport/scoped_fd.h"
+#include "gdbsupport/pathstuff.h"
/* This module provides the interface between GDB and the
/proc file system, which is used on many versions of Unix
bool thread_alive (ptid_t ptid) override;
- const char *pid_to_str (ptid_t) override;
+ std::string pid_to_str (ptid_t) override;
char *pid_to_exec_file (int pid) override;
int can_use_hw_breakpoint (enum bptype, int, int) override;
bool stopped_data_address (CORE_ADDR *) override;
+
+ void procfs_init_inferior (int pid);
};
static procfs_target the_procfs_target;
several. Here is some rationale:
There are several file descriptors that may need to be open
- for any given process or LWP. The ones we're intereted in are:
+ for any given process or LWP. The ones we're interested in are:
- control (ctl) write-only change the state
- status (status) read-only query the state
- address space (as) read/write access memory
}
/* Reset inherit_on_fork flag. If the process forks a child while we
- are registered for events in the parent, then we will NOT recieve
+ are registered for events in the parent, then we will NOT receive
events from the child. Returns non-zero for success, zero for
failure. */
procfs_ctl_t cmd = PCWSTOP;
+ set_sigint_trap ();
+
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
+
+ clear_sigint_trap ();
+
/* We been runnin' and we stopped -- need to update status. */
pi->status_valid = 0;
char sinfo[sizeof (siginfo_t)];
} arg;
siginfo_t mysinfo;
+ process_stratum_target *wait_target;
ptid_t wait_ptid;
struct target_waitstatus wait_status;
pi = find_procinfo_or_die (pi->pid, 0);
/* The pointer is just a type alias. */
- get_last_target_status (&wait_ptid, &wait_status);
- if (wait_ptid == inferior_ptid
+ get_last_target_status (&wait_target, &wait_ptid, &wait_status);
+ if (wait_target == &the_procfs_target
+ && wait_ptid == inferior_ptid
&& wait_status.kind == TARGET_WAITKIND_STOPPED
&& wait_status.value.sig == gdb_signal_from_host (signo)
&& proc_get_status (pi)
void
procfs_target::attach (const char *args, int from_tty)
{
- char *exec_file;
int pid;
pid = parse_pid_to_attach (args);
if (from_tty)
{
- exec_file = get_exec_file (0);
+ const char *exec_file = get_exec_file (0);
if (exec_file)
printf_filtered (_("Attaching to program `%s', %s\n"),
- exec_file, target_pid_to_str (ptid_t (pid)));
+ exec_file, target_pid_to_str (ptid_t (pid)).c_str ());
else
printf_filtered (_("Attaching to %s\n"),
- target_pid_to_str (ptid_t (pid)));
+ target_pid_to_str (ptid_t (pid)).c_str ());
fflush (stdout);
}
exec_file = "";
printf_filtered (_("Detaching from program: %s, %s\n"), exec_file,
- target_pid_to_str (ptid_t (pid)));
- gdb_flush (gdb_stdout);
+ target_pid_to_str (ptid_t (pid)).c_str ());
}
do_detach ();
/* Add it to gdb's thread list. */
ptid = ptid_t (pi->pid, lwpid, 0);
- add_thread (ptid);
+ add_thread (&the_procfs_target, ptid);
return ptid;
}
if (pi == NULL)
error (_("procfs: fetch_registers failed to find procinfo for %s"),
- target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
gregs = proc_get_gregs (pi);
if (gregs == NULL)
if (pi == NULL)
error (_("procfs: store_registers: failed to find procinfo for %s"),
- target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
gregs = proc_get_gregs (pi);
if (gregs == NULL)
{
if (print_thread_events)
printf_unfiltered (_("[%s exited]\n"),
- target_pid_to_str (retval));
- delete_thread (find_thread_ptid (retval));
+ target_pid_to_str (retval).c_str ());
+ delete_thread (find_thread_ptid (this, retval));
status->kind = TARGET_WAITKIND_SPURIOUS;
return retval;
}
if (!proc_run_process (pi, 0, 0))
proc_error (pi, "target_wait, run_process", __LINE__);
- inf = find_inferior_pid (pi->pid);
+ inf = find_inferior_pid (this, pi->pid);
if (inf->attach_flag)
{
/* Don't call wait: simulate waiting for exit,
temp_ptid = ptid_t (pi->pid, temp_tid, 0);
/* If not in GDB's thread list, add it. */
- if (!in_thread_list (temp_ptid))
- add_thread (temp_ptid);
+ if (!in_thread_list (this, temp_ptid))
+ add_thread (this, temp_ptid);
/* Return to WFI, but tell it to immediately resume. */
status->kind = TARGET_WAITKIND_SPURIOUS;
{
if (print_thread_events)
printf_unfiltered (_("[%s exited]\n"),
- target_pid_to_str (retval));
- delete_thread (find_thread_ptid (retval));
+ target_pid_to_str (retval).c_str ());
+ delete_thread (find_thread_ptid (this, retval));
status->kind = TARGET_WAITKIND_SPURIOUS;
return retval;
}
/* If not in GDB's thread list, add it. */
temp_ptid = ptid_t (pi->pid, temp_tid, 0);
- if (!in_thread_list (temp_ptid))
- add_thread (temp_ptid);
+ if (!in_thread_list (this, temp_ptid))
+ add_thread (this, temp_ptid);
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = GDB_SIGNAL_0;
wstat = (what << 8) | 0177;
break;
case PR_FAULTED:
- switch (what) {
- case FLTWATCH:
- wstat = (SIGTRAP << 8) | 0177;
- break;
- /* FIXME: use si_signo where possible. */
- case FLTPRIV:
- case FLTILL:
- wstat = (SIGILL << 8) | 0177;
- break;
- case FLTBPT:
- case FLTTRACE:
- wstat = (SIGTRAP << 8) | 0177;
- break;
- case FLTSTACK:
- case FLTACCESS:
- case FLTBOUNDS:
- wstat = (SIGSEGV << 8) | 0177;
- break;
- case FLTIOVF:
- case FLTIZDIV:
- case FLTFPE:
- wstat = (SIGFPE << 8) | 0177;
- break;
- case FLTPAGE: /* Recoverable page fault */
- default: /* FIXME: use si_signo if possible for
- fault. */
- retval = ptid_t (-1);
- printf_filtered ("procfs:%d -- ", __LINE__);
- printf_filtered (_("child stopped for unknown reason:\n"));
- proc_prettyprint_why (why, what, 1);
- error (_("... giving up..."));
- break;
+ {
+ int signo = pi->prstatus.pr_lwp.pr_info.si_signo;
+ if (signo != 0)
+ wstat = (signo << 8) | 0177;
}
- break; /* case PR_FAULTED: */
+ break;
default: /* switch (why) unmatched */
printf_filtered ("procfs:%d -- ", __LINE__);
printf_filtered (_("child stopped for unknown reason:\n"));
threads database, add it. */
if (retval.pid () > 0
&& retval != inferior_ptid
- && !in_thread_list (retval))
+ && !in_thread_list (this, retval))
{
/* We have a new thread. We need to add it both to
GDB's list and to our own. If we don't create a
procinfo, resume may be unhappy later. */
- add_thread (retval);
+ add_thread (this, retval);
if (find_procinfo (retval.pid (),
retval.lwp ()) == NULL)
create_procinfo (retval.pid (),
File descriptors are also cached. As they are a limited resource,
we cannot hold onto them indefinitely. However, as they are
expensive to open, we don't want to throw them away
- indescriminately either. As a compromise, we will keep the file
+ indiscriminately either. As a compromise, we will keep the file
descriptors for the parent process, but discard any file
descriptors we may have accumulated for the threads.
printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
inf->attach_flag? "attached": "child",
- target_pid_to_str (inferior_ptid));
+ target_pid_to_str (inferior_ptid).c_str ());
}
/* Make it die. Wait for it to die. Clean up after it. Note: this
whatever is necessary to make the child ready to be debugged, and
then wait for the child to synchronize. */
-static void
-procfs_init_inferior (struct target_ops *ops, int pid)
+void
+procfs_target::procfs_init_inferior (int pid)
{
procinfo *pi;
int fail;
/* This routine called on the parent side (GDB side)
after GDB forks the inferior. */
- if (!target_is_pushed (ops))
- push_target (ops);
+ if (!target_is_pushed (this))
+ push_target (this);
pi = create_procinfo (pid, 0);
if (pi == NULL)
/* We already have a main thread registered in the thread table at
this point, but it didn't have any lwp info yet. Notify the core
about it. This changes inferior_ptid as well. */
- thread_change_ptid (ptid_t (pid),
- ptid_t (pid, lwpid, 0));
+ thread_change_ptid (this, ptid_t (pid), ptid_t (pid, lwpid, 0));
gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
}
/* We have something that executes now. We'll be running through
the shell at this point (if startup-with-shell is true), but the
pid shouldn't change. */
- add_thread_silent (ptid_t (pid));
+ add_thread_silent (this, ptid_t (pid));
- procfs_init_inferior (this, pid);
+ procfs_init_inferior (pid);
}
/* An observer for the "inferior_created" event. */
{
ptid_t gdb_threadid = ptid_t (pi->pid, thread->tid, 0);
- thread_info *thr = find_thread_ptid (gdb_threadid);
+ thread_info *thr = find_thread_ptid (&the_procfs_target, gdb_threadid);
if (thr == NULL || thr->state == THREAD_EXITED)
- add_thread (gdb_threadid);
+ add_thread (&the_procfs_target, gdb_threadid);
return 0;
}
return true;
}
-/* Convert PTID to a string. Returns the string in a static
- buffer. */
+/* Convert PTID to a string. */
-const char *
+std::string
procfs_target::pid_to_str (ptid_t ptid)
{
- static char buf[80];
-
if (ptid.lwp () == 0)
- xsnprintf (buf, sizeof (buf), "process %d", ptid.pid ());
+ return string_printf ("process %d", ptid.pid ());
else
- xsnprintf (buf, sizeof (buf), "LWP %ld", ptid.lwp ());
-
- return buf;
+ return string_printf ("LWP %ld", ptid.lwp ());
}
/* Accepts an integer PID; Returns a string representing a file that
char *note_data, int *note_size,
enum gdb_signal stop_signal)
{
- struct regcache *regcache = get_thread_regcache (ptid);
+ struct regcache *regcache = get_thread_regcache (&the_procfs_target, ptid);
gdb_gregset_t gregs;
gdb_fpregset_t fpregs;
unsigned long merged_pid;