/* Machine independent support for SVR4 /proc (process file system) for GDB.
- Copyright 1991, 1992-97, 1998 Free Software Foundation, Inc.
+ Copyright 1991, 1992-98, 1999 Free Software Foundation, Inc.
Written by Fred Fish at Cygnus Support. Changes for sysv4.2mp procfs
compatibility by Geoffrey Noer at Cygnus Solutions.
#endif
/* the name of the proc status struct depends on the implementation */
-#ifdef HAVE_PSTATUS_T
- typedef pstatus_t gdb_prstatus_t;
-#else
+/* Wrap Light Weight Process member in THE_PR_LWP macro for clearer code */
+#ifndef HAVE_PSTATUS_T
typedef prstatus_t gdb_prstatus_t;
+#define THE_PR_LWP(a) a
+#else /* HAVE_PSTATUS_T */
+ typedef pstatus_t gdb_prstatus_t;
+#define THE_PR_LWP(a) a.pr_lwp
+#if !defined(HAVE_PRRUN_T) && defined(HAVE_MULTIPLE_PROC_FDS)
+ /* Fallback definitions - for using configure information directly */
+#ifndef UNIXWARE
+#define UNIXWARE 1
+#endif
+#if !defined(PROCFS_USE_READ_WRITE) && !defined(HAVE_PROCFS_PIOCSET)
+#define PROCFS_USE_READ_WRITE 1
#endif
+#endif /* !HAVE_PRRUN_T && HAVE_MULTIPLE_PROC_FDS */
+#endif /* HAVE_PSTATUS_T */
#define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
#define MAX_PROC_NAME_SIZE sizeof("/proc/1234567890/status")
-extern struct target_ops procfs_ops; /* Forward declaration */
+struct target_ops procfs_ops;
int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
be a runnable target. Used by targets
int had_event; /* poll/select says something happened */
int was_stopped; /* Nonzero if was stopped prior to attach */
int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
-#ifndef HAVE_NO_PRRUN_T
+#ifdef HAVE_PRRUN_T
prrun_t prrun; /* Control state when it is run */
#endif
gdb_prstatus_t prstatus; /* Current process status info */
static void proc_set_exec_trap PARAMS ((void));
-static int procfs_init_inferior PARAMS ((int));
+static void procfs_init_inferior PARAMS ((int));
static struct procinfo *create_procinfo PARAMS ((int));
static void close_proc_file PARAMS ((struct procinfo *));
+static void close_proc_file_cleanup PARAMS ((void*));
+
+static struct cleanup *make_cleanup_close_proc_file PARAMS ((struct procinfo *));
+
static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
static void procfs_resume PARAMS ((int pid, int step,
enum target_signal signo));
+static void init_procfs_ops PARAMS ((void));
+
/* External function prototypes that can't be easily included in any
header file because the args are typedefs in system include files. */
printf_filtered ("LWP %d exited.\n",
(pi->pid >> 16) & 0xffff);
close_proc_file (pi);
+ i--; /* don't skip deleted entry */
if (num_fds != 0)
- continue; /* already another event to process */
+ break; /* already another event to process */
else
goto wait_again; /* wait for another event */
}
LOCAL FUNCTION
- procfs_kill_inferior - kill any currently inferior
+ procfs_kill_inferior - kill any current inferior
SYNOPSIS
SYNOPSIS
- int procfs_init_inferior (int pid)
+ void procfs_init_inferior (int pid)
DESCRIPTION
*/
-static int
+static void
procfs_init_inferior (pid)
int pid;
{
/* One trap to exec the shell, one to exec the program being debugged. */
startup_inferior (2);
#endif
-
- return pid;
}
/*
pi = find_procinfo (pid, 0);
-#ifdef UNIXWARE
+#ifndef HAVE_PRRUN_T
premptyset (&sctl.sigset);
#else
sctl.sigset = pi->prrun.pr_trace;
notice_signals (pi, &sctl);
-#ifndef UNIXWARE
+#ifdef HAVE_PRRUN_T
pi->prrun.pr_trace = sctl.sigset;
#endif
}
if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0)
pi = init_procinfo ((*lwps << 16) | pid, 0);
-#ifdef UNIXWARE
- if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))
-#else
- if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
-#endif
+ if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
{
pi->was_stopped = 1;
}
}
else
{
-#ifdef UNIXWARE
- if (signal || (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
-#else
- if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
-#endif
+ if (signal
+ || (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
{
long cmd;
struct proc_ctl pctl;
if (!pi->had_event)
continue;
-#ifdef UNIXWARE
- if (! (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)) )
- continue;
-
- why = pi->prstatus.pr_lwp.pr_why;
- what = pi->prstatus.pr_lwp.pr_what;
-#else
- if (! (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)) )
+ if (! (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)) )
continue;
- why = pi->prstatus.pr_why;
- what = pi->prstatus.pr_what;
-#endif
+ why = THE_PR_LWP(pi->prstatus).pr_why;
+ what = THE_PR_LWP(pi->prstatus).pr_what;
if (why == PR_SYSENTRY || why == PR_SYSEXIT)
{
int i;
goto scan_again;
}
-#ifdef UNIXWARE
- if (!checkerr && !(pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
-#else
- if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
-#endif
+ if (!checkerr
+ && !(THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
{
if (!procfs_write_pcwstop (pi))
{
/* NOTREACHED */
}
}
-#ifdef UNIXWARE
- else if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))
-#else
- else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
-#endif
+ else if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
{
#ifdef UNIXWARE
rtnval = pi->prstatus.pr_pid;
- why = pi->prstatus.pr_lwp.pr_why;
- what = pi->prstatus.pr_lwp.pr_what;
#else
rtnval = pi->pid;
- why = pi->prstatus.pr_why;
- what = pi->prstatus.pr_what;
#endif
+ why = THE_PR_LWP(pi->prstatus).pr_why;
+ what = THE_PR_LWP(pi->prstatus).pr_what;
switch (why)
{
/* Use the signal which the kernel assigns. This is better than
trying to second-guess it from the fault. In fact, I suspect
that FLTACCESS can be either SIGSEGV or SIGBUS. */
-#ifdef UNIXWARE
- statval = ((pi->prstatus.pr_lwp.pr_info.si_signo) << 8) | 0177;
-#else
- statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
-#endif
+ statval =
+ ((THE_PR_LWP(pi->prstatus).pr_info.si_signo) << 8) | 0177;
break;
}
break;
else
{
error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
-#ifdef UNIXWARE
- pi->prstatus.pr_lwp.pr_flags);
-#else
- pi->prstatus.pr_flags);
-#endif
+ THE_PR_LWP(pi->prstatus).pr_flags);
}
store_waitstatus (ourstatus, statval);
If we are not delivering the same signal that the prstatus siginfo
struct contains information about, then synthesize a siginfo struct
- to match the signal we are doing to deliver, make it of the type
+ to match the signal we are going to deliver, make it of the type
"generated by a user process", and send this synthesized copy. When
used to set the inferior's signal state, this will be required if we
are not currently stopped because of a traced signal, or if we decide
/* With Alpha OSF/1 procfs, the kernel gets really confused if it
receives a PIOCSSIG with a signal identical to the current signal,
it messes up the current signal. Work around the kernel bug. */
-#ifdef UNIXWARE
- if (signo == pip -> prstatus.pr_lwp.pr_cursig)
-#else
- if (signo == pip -> prstatus.pr_cursig)
-#endif
+ if (signo == THE_PR_LWP(pip->prstatus).pr_cursig)
return;
#endif
#ifdef UNIXWARE
- if (signo == pip->prstatus.pr_lwp.pr_info.si_signo)
+ if (signo == THE_PR_LWP(pip->prstatus).pr_info.si_signo)
{
memcpy ((char *) &sictl.siginfo, (char *) &pip->prstatus.pr_lwp.pr_info,
sizeof (siginfo_t));
}
#else
- if (signo == pip -> prstatus.pr_info.si_signo)
+ if (signo == THE_PR_LWP(pip->prstatus).pr_info.si_signo)
{
sip = &pip -> prstatus.pr_info;
}
an inferior to continue running at the same time as gdb. (FIXME?) */
signal_to_pass = 0;
else if (signo == TARGET_SIGNAL_TSTP
-#ifdef UNIXWARE
- && pi->prstatus.pr_lwp.pr_cursig == SIGTSTP
- && pi->prstatus.pr_lwp.pr_action.sa_handler == SIG_DFL
-#else
- && pi->prstatus.pr_cursig == SIGTSTP
- && pi->prstatus.pr_action.sa_handler == SIG_DFL
-#endif
+ && THE_PR_LWP(pi->prstatus).pr_cursig == SIGTSTP
+ && THE_PR_LWP(pi->prstatus).pr_action.sa_handler == SIG_DFL
)
/* We are about to pass the inferior a SIGTSTP whose action is
}
}
+static void
+close_proc_file_cleanup (pip)
+ void *pip;
+{
+ close_proc_file ((struct procinfo *) pip);
+}
+
+static struct cleanup *
+make_cleanup_close_proc_file (pip)
+ struct procinfo *pip;
+{
+ return make_cleanup (close_proc_file_cleanup, pip);
+}
+
/*
LOCAL FUNCTION
return 0;
}
- sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
- if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
- {
- close (pip->status_fd);
- close (pip->as_fd);
- return 0;
- }
-
if (control)
{
sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
int why;
int what;
-#ifdef UNIXWARE
- why = pip -> prstatus.pr_lwp.pr_why;
- what = pip -> prstatus.pr_lwp.pr_what;
-#else
- why = pip -> prstatus.pr_why;
- what = pip -> prstatus.pr_what;
-#endif
+ why = THE_PR_LWP(pip->prstatus).pr_why;
+ what = THE_PR_LWP(pip->prstatus).pr_what;
-#ifdef UNIXWARE
- if (pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED)
-#else
- if (pip -> prstatus.pr_flags & PR_STOPPED)
-#endif
+ if (THE_PR_LWP(pip->prstatus).pr_flags & PR_STOPPED)
{
printf_filtered ("%-32s", "Reason for stopping:");
if (!summary)
{
struct siginfo *sip;
-#ifdef UNIXWARE
- if ((pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED) &&
- (pip -> prstatus.pr_lwp.pr_why == PR_SIGNALLED ||
- pip -> prstatus.pr_lwp.pr_why == PR_FAULTED))
-#else
- if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
- (pip -> prstatus.pr_why == PR_SIGNALLED ||
- pip -> prstatus.pr_why == PR_FAULTED))
-#endif
+ if ((THE_PR_LWP(pip->prstatus).pr_flags & PR_STOPPED) &&
+ (THE_PR_LWP(pip->prstatus).pr_why == PR_SIGNALLED ||
+ THE_PR_LWP(pip->prstatus).pr_why == PR_FAULTED))
{
printf_filtered ("%-32s", "Additional signal/fault info:");
-#ifdef UNIXWARE
- sip = &pip -> prstatus.pr_lwp.pr_info;
-#else
- sip = &pip -> prstatus.pr_info;
-#endif
+ sip = &(THE_PR_LWP(pip->prstatus).pr_info);
if (summary)
{
printf_filtered ("%s ", signalname (sip -> si_signo));
{
nomem (0);
}
- make_cleanup (freeargv, (char *) argv);
+ make_cleanup_freeargv (argv);
while (*argv != NULL)
{
/* NOTREACHED */
}
pid = pip->pid;
- make_cleanup (close_proc_file, pip);
+ make_cleanup_close_proc_file (pip);
}
else if (**argv != '\000')
{
if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
continue;
- make_cleanup (close_proc_file, pip);
+ make_cleanup_close_proc_file (pip);
if (!procfs_read_status (pip))
{
in the child and continue the parent. */
/* Third arg is pointer to new thread id. */
-#ifdef UNIXWARE
- lwp_id = read_memory_integer (pi->prstatus.pr_lwp.pr_sysarg[2], sizeof (int));
-#else
- lwp_id = read_memory_integer (pi->prstatus.pr_sysarg[2], sizeof (int));
-#endif
+ lwp_id = read_memory_integer (
+ THE_PR_LWP(pi->prstatus).pr_sysarg[2], sizeof (int));
lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
SUSPENDED or RUNNABLE. If runnable, we will simply signal it to run.
If suspended, we flag it to be continued later, when it has an event. */
-#ifdef UNIXWARE
- if (childpi->prstatus.pr_lwp.pr_why == PR_SUSPENDED)
-#else
- if (childpi->prstatus.pr_why == PR_SUSPENDED)
-#endif
+ if (THE_PR_LWP(childpi->prstatus).pr_why == PR_SUSPENDED)
childpi->new_child = 1; /* Flag this as an unseen child process */
else
{
}
fork_inferior (exec_file, allargs, env,
- proc_set_exec_trap, procfs_init_inferior, shell_file);
+ proc_set_exec_trap, procfs_init_inferior, NULL, shell_file);
/* We are at the first instruction we care about. */
/* Pedal to the metal... */
return buf;
}
#endif /* TIDGET */
+
\f
-struct target_ops procfs_ops = {
- "procfs", /* to_shortname */
- "Unix /proc child process", /* to_longname */
- "Unix /proc child process (started by the \"run\" command).", /* to_doc */
- procfs_open, /* to_open */
- 0, /* to_close */
- procfs_attach, /* to_attach */
- procfs_detach, /* to_detach */
- procfs_resume, /* to_resume */
- procfs_wait, /* to_wait */
- procfs_fetch_registers, /* to_fetch_registers */
- procfs_store_registers, /* to_store_registers */
- procfs_prepare_to_store, /* to_prepare_to_store */
- procfs_xfer_memory, /* to_xfer_memory */
- procfs_files_info, /* to_files_info */
- memory_insert_breakpoint, /* to_insert_breakpoint */
- memory_remove_breakpoint, /* to_remove_breakpoint */
- terminal_init_inferior, /* to_terminal_init */
- terminal_inferior, /* to_terminal_inferior */
- terminal_ours_for_output, /* to_terminal_ours_for_output */
- terminal_ours, /* to_terminal_ours */
- child_terminal_info, /* to_terminal_info */
- procfs_kill_inferior, /* to_kill */
- 0, /* to_load */
- 0, /* to_lookup_symbol */
- procfs_create_inferior, /* to_create_inferior */
- procfs_mourn_inferior, /* to_mourn_inferior */
- procfs_can_run, /* to_can_run */
- procfs_notice_signals, /* to_notice_signals */
- procfs_thread_alive, /* to_thread_alive */
- procfs_stop, /* to_stop */
- process_stratum, /* to_stratum */
- 0, /* to_next */
- 1, /* to_has_all_memory */
- 1, /* to_has_memory */
- 1, /* to_has_stack */
- 1, /* to_has_registers */
- 1, /* to_has_execution */
- 0, /* sections */
- 0, /* sections_end */
- OPS_MAGIC /* to_magic */
-};
+static void
+init_procfs_ops ()
+{
+ procfs_ops.to_shortname = "procfs";
+ procfs_ops.to_longname = "Unix /proc child process";
+ procfs_ops.to_doc = "Unix /proc child process (started by the \"run\" command).";
+ procfs_ops.to_open = procfs_open;
+ procfs_ops.to_attach = procfs_attach;
+ procfs_ops.to_detach = procfs_detach;
+ procfs_ops.to_resume = procfs_resume;
+ procfs_ops.to_wait = procfs_wait;
+ procfs_ops.to_fetch_registers = procfs_fetch_registers;
+ procfs_ops.to_store_registers = procfs_store_registers;
+ procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
+ procfs_ops.to_xfer_memory = procfs_xfer_memory;
+ procfs_ops.to_files_info = procfs_files_info;
+ procfs_ops.to_insert_breakpoint = memory_insert_breakpoint;
+ procfs_ops.to_remove_breakpoint = memory_remove_breakpoint;
+ procfs_ops.to_terminal_init = terminal_init_inferior;
+ procfs_ops.to_terminal_inferior = terminal_inferior;
+ procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
+ procfs_ops.to_terminal_ours = terminal_ours;
+ procfs_ops.to_terminal_info = child_terminal_info;
+ procfs_ops.to_kill = procfs_kill_inferior;
+ procfs_ops.to_create_inferior = procfs_create_inferior;
+ procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
+ procfs_ops.to_can_run = procfs_can_run;
+ procfs_ops.to_notice_signals = procfs_notice_signals;
+ procfs_ops.to_thread_alive = procfs_thread_alive;
+ procfs_ops.to_stop = procfs_stop;
+ procfs_ops.to_stratum = process_stratum;
+ procfs_ops.to_has_all_memory = 1;
+ procfs_ops.to_has_memory = 1;
+ procfs_ops.to_has_stack = 1;
+ procfs_ops.to_has_registers = 1;
+ procfs_ops.to_has_execution = 1;
+ procfs_ops.to_magic = OPS_MAGIC;
+}
void
_initialize_procfs ()
close (fd);
#endif
+ init_procfs_ops ();
add_target (&procfs_ops);
add_info ("processes", info_proc,
projects / deliverable / binutils-gdb.git / blobdiff