Initial creation of sourceware repositorygdb-4_18-branchpoint

1 files changed, 5764 insertions, 0 deletions

diff --git a/gdb/procfs.c b/gdb/procfs.c
new file mode 100644
index 0000000..ff20240
--- /dev/null
+++ b/gdb/procfs.c
@@ -0,0 +1,5764 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   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.
+
+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
+(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, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+/*			N  O  T  E  S
+
+For information on the details of using /proc consult section proc(4)
+in the UNIX System V Release 4 System Administrator's Reference Manual.
+
+The general register and floating point register sets are manipulated
+separately.  This file makes the assumption that if FP0_REGNUM is
+defined, then support for the floating point register set is desired,
+regardless of whether or not the actual target has floating point hardware.
+
+ */
+
+
+#include "defs.h"
+
+#include <sys/types.h>
+#include <time.h>
+#include <sys/fault.h>
+#include <sys/syscall.h>
+#include <sys/procfs.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "gdb_string.h"
+#include <stropts.h>
+#include <poll.h>
+#include <unistd.h>
+#include "gdb_stat.h"
+
+#include "inferior.h"
+#include "target.h"
+#include "command.h"
+#include "gdbcore.h"
+#include "gdbthread.h"
+
+#if !defined(SYS_lwp_create) && defined(SYS_lwpcreate)
+# define SYS_lwp_create SYS_lwpcreate
+#endif
+
+#if !defined(SYS_lwp_exit) && defined(SYS_lwpexit)
+# define SYS_lwp_exit SYS_lwpexit
+#endif
+
+#if !defined(SYS_lwp_wait) && defined(SYS_lwpwait)
+# define SYS_lwp_wait SYS_lwpwait
+#endif
+
+#if !defined(SYS_lwp_self) && defined(SYS_lwpself)
+# define SYS_lwp_self SYS_lwpself
+#endif
+
+#if !defined(SYS_lwp_info) && defined(SYS_lwpinfo)
+# define SYS_lwp_info SYS_lwpinfo
+#endif
+
+#if !defined(SYS_lwp_private) && defined(SYS_lwpprivate)
+# define SYS_lwp_private SYS_lwpprivate
+#endif
+
+#if !defined(SYS_lwp_kill) && defined(SYS_lwpkill)
+# define SYS_lwp_kill SYS_lwpkill
+#endif
+
+#if !defined(SYS_lwp_suspend) && defined(SYS_lwpsuspend)
+# define SYS_lwp_suspend SYS_lwpsuspend
+#endif
+
+#if !defined(SYS_lwp_continue) && defined(SYS_lwpcontinue)
+# define SYS_lwp_continue SYS_lwpcontinue
+#endif
+
+/* the name of the proc status struct depends on the implementation */
+/* 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 */
+
+/* proc name formats may vary depending on the proc implementation */
+#ifdef HAVE_MULTIPLE_PROC_FDS
+#  ifndef CTL_PROC_NAME_FMT
+#  define CTL_PROC_NAME_FMT "/proc/%d/ctl"
+#  define AS_PROC_NAME_FMT "/proc/%d/as"
+#  define MAP_PROC_NAME_FMT "/proc/%d/map"
+#  define STATUS_PROC_NAME_FMT "/proc/%d/status"
+#  endif
+#else /* HAVE_MULTIPLE_PROC_FDS */
+#  ifndef CTL_PROC_NAME_FMT
+#  define CTL_PROC_NAME_FMT "/proc/%05d"
+#  define AS_PROC_NAME_FMT "/proc/%05d"
+#  define MAP_PROC_NAME_FMT "/proc/%05d"
+#  define STATUS_PROC_NAME_FMT "/proc/%05d"
+#  endif
+#endif /* HAVE_MULTIPLE_PROC_FDS */
+
+
+/* These #ifdefs are for sol2.x in particular.  sol2.x has
+   both a "gregset_t" and a "prgregset_t", which have
+   similar uses but different layouts.  sol2.x gdb tries to
+   use prgregset_t (and prfpregset_t) everywhere. */
+
+#ifdef GDB_GREGSET_TYPE
+  typedef GDB_GREGSET_TYPE gdb_gregset_t;
+#else
+  typedef gregset_t gdb_gregset_t;
+#endif
+
+#ifdef GDB_FPREGSET_TYPE
+  typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
+#else
+  typedef fpregset_t gdb_fpregset_t;
+#endif
+
+
+#define MAX_PROC_NAME_SIZE sizeof("/proc/1234567890/status")
+
+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
+				   that can sit atop procfs, such as solaris
+				   thread support.  */
+
+#if 1	/* FIXME: Gross and ugly hack to resolve coredep.c global */
+CORE_ADDR kernel_u_addr;
+#endif
+
+#ifdef BROKEN_SIGINFO_H		/* Workaround broken SGS <sys/siginfo.h> */
+#undef si_pid
+#define si_pid _data._proc.pid
+#undef si_uid
+#define si_uid _data._proc._pdata._kill.uid
+#endif /* BROKEN_SIGINFO_H */
+
+/* Define structures for passing commands to /proc/pid/ctl file.  Note that
+   while we create these for the PROCFS_USE_READ_WRITE world, we use them
+   and ignore the extra cmd int in other proc schemes.
+*/
+/* generic ctl msg */
+struct proc_ctl {
+        int     cmd;
+        long    data;
+};
+
+/* set general registers */
+struct greg_ctl {
+        int             cmd;
+        gdb_gregset_t	gregset;
+};
+
+/* set fp registers */
+struct fpreg_ctl {
+        int             cmd;
+        gdb_fpregset_t	fpregset;
+};
+
+/* set signals to be traced */
+struct sig_ctl {
+        int             cmd;
+        sigset_t        sigset;
+};
+
+/* set faults to be traced */
+struct flt_ctl {
+        int             cmd;
+        fltset_t        fltset;
+};
+
+/* set system calls to be traced */
+struct sys_ctl {
+        int             cmd;
+        sysset_t        sysset;
+};
+
+/* set current signal to be traced */
+struct sigi_ctl {
+        int             cmd;
+        siginfo_t       siginfo;
+};
+
+/*  All access to the inferior, either one started by gdb or one that has
+    been attached to, is controlled by an instance of a procinfo structure,
+    defined below.  Since gdb currently only handles one inferior at a time,
+    the procinfo structure for the inferior is statically allocated and
+    only one exists at any given time.  There is a separate procinfo
+    structure for use by the "info proc" command, so that we can print
+    useful information about any random process without interfering with
+    the inferior's procinfo information. */
+
+struct procinfo {
+  struct procinfo *next;
+  int pid;			/* Process ID of inferior */
+  int ctl_fd;			/* File descriptor for /proc ctl file */
+  int status_fd;		/* File descriptor for /proc status file */
+  int as_fd;			/* File descriptor for /proc as file */
+  int map_fd;			/* File descriptor for /proc map file */
+  char *pathname;		/* Pathname to /proc entry */
+  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 */
+#ifdef HAVE_PRRUN_T
+  prrun_t prrun;		/* Control state when it is run */
+#endif
+  gdb_prstatus_t prstatus;	/* Current process status info */
+  struct greg_ctl gregset;	/* General register set */
+  struct fpreg_ctl fpregset;	/* Floating point register set */
+  struct flt_ctl fltset;	/* Current traced hardware fault set */
+  struct sig_ctl trace;		/* Current traced signal set */
+  struct sys_ctl exitset;	/* Current traced system call exit set */
+  struct sys_ctl entryset;	/* Current traced system call entry set */
+  struct sig_ctl saved_sighold;	/* Saved held signal set */
+  struct flt_ctl saved_fltset;  /* Saved traced hardware fault set */
+  struct sig_ctl saved_trace;   /* Saved traced signal set */
+  struct sys_ctl saved_exitset; /* Saved traced system call exit set */
+  struct sys_ctl saved_entryset;/* Saved traced system call entry set */
+  int num_syscall_handlers;	/* Number of syscall trap handlers
+				   currently installed */
+				/* Pointer to list of syscall trap handlers */
+  struct procfs_syscall_handler *syscall_handlers; 
+  int saved_rtnval;		/* return value and status for wait(), */
+  int saved_statval;		/*  as supplied by a syscall handler. */
+  int new_child;		/* Non-zero if it's a new thread */
+};
+
+/* List of inferior process information */
+static struct procinfo *procinfo_list = NULL;
+static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
+
+static int num_poll_list = 0;	/* Number of entries in poll_list */
+
+/*  Much of the information used in the /proc interface, particularly for
+    printing status information, is kept as tables of structures of the
+    following form.  These tables can be used to map numeric values to
+    their symbolic names and to a string that describes their specific use. */
+
+struct trans {
+  int value;			/* The numeric value */
+  char *name;			/* The equivalent symbolic value */
+  char *desc;			/* Short description of value */
+};
+
+/*  Translate bits in the pr_flags member of the prstatus structure, into the
+    names and desc information. */
+
+static struct trans pr_flag_table[] =
+{
+#if defined (PR_STOPPED)
+  { PR_STOPPED, "PR_STOPPED", "Process is stopped" },
+#endif
+#if defined (PR_ISTOP)
+  { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
+#endif
+#if defined (PR_DSTOP)
+  { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
+#endif
+#if defined (PR_ASLEEP)
+  { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call" },
+#endif
+#if defined (PR_FORK)
+  { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
+#endif
+#if defined (PR_RLC)
+  { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
+#endif
+#if defined (PR_PTRACE)
+  { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
+#endif
+#if defined (PR_PCINVAL)
+  { PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address" },
+#endif
+#if defined (PR_ISSYS)
+  { PR_ISSYS, "PR_ISSYS", "Is a system process" },
+#endif
+#if defined (PR_STEP)
+  { PR_STEP, "PR_STEP", "Process has single step pending" },
+#endif
+#if defined (PR_KLC)
+  { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
+#endif
+#if defined (PR_ASYNC)
+  { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
+#endif
+#if defined (PR_PCOMPAT)
+  { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
+#endif
+#if defined (PR_MSACCT)
+  { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" },
+#endif
+#if defined (PR_BPTADJ)
+  { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" },
+#endif
+#if defined (PR_ASLWP)
+  { PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP" },
+#endif
+  { 0, NULL, NULL }
+};
+
+/*  Translate values in the pr_why field of the prstatus struct. */
+
+static struct trans pr_why_table[] =
+{
+#if defined (PR_REQUESTED)
+  { PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
+#endif
+#if defined (PR_SIGNALLED)
+  { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
+#endif
+#if defined (PR_SYSENTRY)
+  { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
+#endif
+#if defined (PR_SYSEXIT)
+  { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
+#endif
+#if defined (PR_JOBCONTROL)
+  { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
+#endif
+#if defined (PR_FAULTED)
+  { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
+#endif
+#if defined (PR_SUSPENDED)
+  { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
+#endif
+#if defined (PR_CHECKPOINT)
+  { PR_CHECKPOINT, "PR_CHECKPOINT", "(???)" },
+#endif
+  { 0, NULL, NULL }
+};
+
+/*  Hardware fault translation table. */
+
+static struct trans faults_table[] =
+{
+#if defined (FLTILL)
+  { FLTILL, "FLTILL", "Illegal instruction" },
+#endif
+#if defined (FLTPRIV)
+  { FLTPRIV, "FLTPRIV", "Privileged instruction" },
+#endif
+#if defined (FLTBPT)
+  { FLTBPT, "FLTBPT", "Breakpoint trap" },
+#endif
+#if defined (FLTTRACE)
+  { FLTTRACE, "FLTTRACE", "Trace trap" },
+#endif
+#if defined (FLTACCESS)
+  { FLTACCESS, "FLTACCESS", "Memory access fault" },
+#endif
+#if defined (FLTBOUNDS)
+  { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
+#endif
+#if defined (FLTIOVF)
+  { FLTIOVF, "FLTIOVF", "Integer overflow" },
+#endif
+#if defined (FLTIZDIV)
+  { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
+#endif
+#if defined (FLTFPE)
+  { FLTFPE, "FLTFPE", "Floating-point exception" },
+#endif
+#if defined (FLTSTACK)
+  { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
+#endif
+#if defined (FLTPAGE)
+  { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
+#endif
+  { 0, NULL, NULL }
+};
+
+/* Translation table for signal generation information.  See UNIX System
+   V Release 4 Programmer's Reference Manual, siginfo(5).  */
+
+static struct sigcode {
+  int signo;
+  int code;
+  char *codename;
+  char *desc;
+} siginfo_table[] = {
+#if defined (SIGILL) && defined (ILL_ILLOPC)
+  { SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode" },
+#endif
+#if defined (SIGILL) && defined (ILL_ILLOPN)
+  { SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand", },
+#endif
+#if defined (SIGILL) && defined (ILL_ILLADR)
+  { SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode" },
+#endif
+#if defined (SIGILL) && defined (ILL_ILLTRP)
+  { SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap" },
+#endif
+#if defined (SIGILL) && defined (ILL_PRVOPC)
+  { SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode" },
+#endif
+#if defined (SIGILL) && defined (ILL_PRVREG)
+  { SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register" },
+#endif
+#if defined (SIGILL) && defined (ILL_COPROC)
+  { SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error" },
+#endif
+#if defined (SIGILL) && defined (ILL_BADSTK)
+  { SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error" },
+#endif
+#if defined (SIGFPE) && defined (FPE_INTDIV)
+  { SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero" },
+#endif
+#if defined (SIGFPE) && defined (FPE_INTOVF)
+  { SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTDIV)
+  { SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTOVF)
+  { SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTUND)
+  { SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTRES)
+  { SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTINV)
+  { SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation" },
+#endif
+#if defined (SIGFPE) && defined (FPE_FLTSUB)
+  { SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range" },
+#endif
+#if defined (SIGSEGV) && defined (SEGV_MAPERR)
+  { SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object" },
+#endif
+#if defined (SIGSEGV) && defined (SEGV_ACCERR)
+  { SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object" },
+#endif
+#if defined (SIGBUS) && defined (BUS_ADRALN)
+  { SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment" },
+#endif
+#if defined (SIGBUS) && defined (BUS_ADRERR)
+  { SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address" },
+#endif
+#if defined (SIGBUS) && defined (BUS_OBJERR)
+  { SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error" },
+#endif
+#if defined (SIGTRAP) && defined (TRAP_BRKPT)
+  { SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint" },
+#endif
+#if defined (SIGTRAP) && defined (TRAP_TRACE)
+  { SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap" },
+#endif
+#if defined (SIGCLD) && defined (CLD_EXITED)
+  { SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited" },
+#endif
+#if defined (SIGCLD) && defined (CLD_KILLED)
+  { SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed" },
+#endif
+#if defined (SIGCLD) && defined (CLD_DUMPED)
+  { SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally" },
+#endif
+#if defined (SIGCLD) && defined (CLD_TRAPPED)
+  { SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped" },
+#endif
+#if defined (SIGCLD) && defined (CLD_STOPPED)
+  { SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped" },
+#endif
+#if defined (SIGCLD) && defined (CLD_CONTINUED)
+  { SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_IN)
+  { SIGPOLL, POLL_IN, "POLL_IN", "Input input available" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_OUT)
+  { SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_MSG)
+  { SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_ERR)
+  { SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_PRI)
+  { SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available" },
+#endif
+#if defined (SIGPOLL) && defined (POLL_HUP)
+  { SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected" },
+#endif
+  { 0, 0, NULL, NULL }
+};
+
+static char *syscall_table[MAX_SYSCALLS];
+
+/* Prototypes for local functions */
+
+static void procfs_stop PARAMS ((void));
+
+static int procfs_thread_alive PARAMS ((int));
+
+static int procfs_can_run PARAMS ((void));
+
+static void procfs_mourn_inferior PARAMS ((void));
+
+static void procfs_fetch_registers PARAMS ((int));
+
+static int procfs_wait PARAMS ((int, struct target_waitstatus *));
+
+static void procfs_open PARAMS ((char *, int));
+
+static void procfs_files_info PARAMS ((struct target_ops *));
+
+static void procfs_prepare_to_store PARAMS ((void));
+
+static void procfs_detach PARAMS ((char *, int));
+
+static void procfs_attach PARAMS ((char *, int));
+
+static void proc_set_exec_trap PARAMS ((void));
+
+static void  procfs_init_inferior PARAMS ((int));
+
+static struct procinfo *create_procinfo PARAMS ((int));
+
+static void procfs_store_registers PARAMS ((int));
+
+static int procfs_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+
+static void procfs_kill_inferior PARAMS ((void));
+
+static char *sigcodedesc PARAMS ((siginfo_t *));
+
+static char *sigcodename PARAMS ((siginfo_t *));
+
+static struct procinfo *wait_fd PARAMS ((void));
+
+static void remove_fd PARAMS ((struct procinfo *));
+
+static void add_fd PARAMS ((struct procinfo *));
+
+static void set_proc_siginfo PARAMS ((struct procinfo *, int));
+
+static void init_syscall_table PARAMS ((void));
+
+static char *syscallname PARAMS ((int));
+
+static char *signalname PARAMS ((int));
+
+static char *errnoname PARAMS ((int));
+
+static int proc_address_to_fd PARAMS ((struct procinfo *, CORE_ADDR, int));
+
+static int open_proc_file PARAMS ((int, struct procinfo *, int, int));
+
+static void 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 info_proc PARAMS ((char *, int));
+
+static void info_proc_flags PARAMS ((struct procinfo *, int));
+
+static void info_proc_stop PARAMS ((struct procinfo *, int));
+
+static void info_proc_siginfo PARAMS ((struct procinfo *, int));
+
+static void info_proc_syscalls PARAMS ((struct procinfo *, int));
+
+static void info_proc_mappings PARAMS ((struct procinfo *, int));
+
+static void info_proc_signals PARAMS ((struct procinfo *, int));
+
+static void info_proc_faults PARAMS ((struct procinfo *, int));
+
+static char *mappingflags PARAMS ((long));
+
+static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
+
+static char *lookupdesc PARAMS ((struct trans *, unsigned int));
+
+static int do_attach PARAMS ((int pid));
+
+static void do_detach PARAMS ((int siggnal));
+
+static void procfs_create_inferior PARAMS ((char *, char *, char **));
+
+static void procfs_notice_signals PARAMS ((int pid));
+
+static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *));
+
+static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
+
+static int procfs_write_pcwstop PARAMS ((struct procinfo *));
+static int procfs_read_status PARAMS ((struct procinfo *));
+static void procfs_write_pckill PARAMS ((struct procinfo *));
+
+typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num,
+				    int why, int *rtnval, int *statval));
+
+static void procfs_set_syscall_trap PARAMS ((struct procinfo *pi,
+					     int syscall_num, int flags,
+					     syscall_func_t *func));
+
+static void procfs_clear_syscall_trap PARAMS ((struct procinfo *pi,
+					       int syscall_num, int errok));
+
+#define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
+#define PROCFS_SYSCALL_EXIT 0x2	/* Trap on exit from sys call */
+
+static syscall_func_t procfs_exit_handler;
+
+static syscall_func_t procfs_exec_handler;
+
+#ifdef SYS_sproc
+static syscall_func_t procfs_sproc_handler;
+static syscall_func_t procfs_fork_handler;
+#endif
+
+#ifdef SYS_lwp_create
+static syscall_func_t procfs_lwp_creation_handler;
+#endif
+
+static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
+static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
+
+/* */
+
+struct procfs_syscall_handler
+{
+  int syscall_num;		/* The number of the system call being handled */
+				/* The function to be called */
+  syscall_func_t *func;
+};
+
+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. */
+
+extern void supply_gregset PARAMS ((gdb_gregset_t *));
+
+extern void fill_gregset PARAMS ((gdb_gregset_t *, int));
+
+#ifdef FP0_REGNUM
+extern void supply_fpregset PARAMS ((gdb_fpregset_t *));
+
+extern void fill_fpregset PARAMS ((gdb_fpregset_t *, int));
+#endif
+
+/*
+
+LOCAL FUNCTION
+
+	find_procinfo -- convert a process id to a struct procinfo
+
+SYNOPSIS
+
+	static struct procinfo * find_procinfo (pid_t pid, int okfail);
+
+DESCRIPTION
+	
+	Given a process id, look it up in the procinfo chain.  Returns
+	a struct procinfo *.  If can't find pid, then call error(),
+	unless okfail is set, in which case, return NULL;
+ */
+
+static struct procinfo *
+find_procinfo (pid, okfail)
+     pid_t pid;
+     int okfail;
+{
+  struct procinfo *procinfo;
+
+  for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
+    if (procinfo->pid == pid)
+      return procinfo;
+
+  if (okfail)
+    return NULL;
+
+  error ("procfs (find_procinfo):  Couldn't locate pid %d", pid);
+}
+
+/*
+
+LOCAL MACRO
+
+	current_procinfo -- convert inferior_pid to a struct procinfo
+
+SYNOPSIS
+
+	static struct procinfo * current_procinfo;
+
+DESCRIPTION
+	
+	Looks up inferior_pid in the procinfo chain.  Always returns a
+	struct procinfo *.  If process can't be found, we error() out.
+ */
+
+#define current_procinfo find_procinfo (inferior_pid, 0)
+
+/*
+
+LOCAL FUNCTION
+
+	add_fd -- Add the fd to the poll/select list
+
+SYNOPSIS
+
+	static void add_fd (struct procinfo *);
+
+DESCRIPTION
+	
+	Add the fd of the supplied procinfo to the list of fds used for
+	poll/select operations.
+ */
+
+static void
+add_fd (pi)
+     struct procinfo *pi;
+{
+  if (num_poll_list <= 0)
+    poll_list = (struct pollfd *) xmalloc (sizeof (struct pollfd));
+  else
+    poll_list = (struct pollfd *) xrealloc (poll_list,
+					    (num_poll_list + 1)
+					    * sizeof (struct pollfd));
+  poll_list[num_poll_list].fd = pi->ctl_fd;
+#ifdef UNIXWARE
+  poll_list[num_poll_list].events = POLLWRNORM;
+#else
+  poll_list[num_poll_list].events = POLLPRI;
+#endif
+
+  num_poll_list++;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	remove_fd -- Remove the fd from the poll/select list
+
+SYNOPSIS
+
+	static void remove_fd (struct procinfo *);
+
+DESCRIPTION
+	
+	Remove the fd of the supplied procinfo from the list of fds used 
+	for poll/select operations.
+ */
+
+static void
+remove_fd (pi)
+     struct procinfo *pi;
+{
+  int i;
+
+  for (i = 0; i < num_poll_list; i++)
+    {
+      if (poll_list[i].fd == pi->ctl_fd)
+	{
+	  if (i != num_poll_list - 1)
+	    memcpy (poll_list + i, poll_list + i + 1,
+		    (num_poll_list - i - 1) * sizeof (struct pollfd));
+
+	  num_poll_list--;
+
+	  if (num_poll_list == 0)
+	    free (poll_list);
+	  else
+	    poll_list = (struct pollfd *) xrealloc (poll_list,
+						    num_poll_list
+						    * sizeof (struct pollfd));
+	  return;
+	}
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_read_status - get procfs fd status
+
+SYNOPSIS
+
+	static int procfs_read_status (pi) struct procinfo *pi;
+
+DESCRIPTION
+	
+	Given a pointer to a procinfo struct, get the status of
+	the status_fd in the appropriate way.  Returns 0 on failure,
+	1 on success.
+ */
+
+static int
+procfs_read_status (pi)
+  struct procinfo *pi;
+{
+#ifdef PROCFS_USE_READ_WRITE
+   if ((lseek (pi->status_fd, 0, SEEK_SET) < 0) ||
+           (read (pi->status_fd, (char *) &pi->prstatus, 
+             sizeof (gdb_prstatus_t)) != sizeof (gdb_prstatus_t)))
+#else
+  if (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) < 0)
+#endif
+    return 0;
+  else
+    return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_write_pcwstop - send a PCWSTOP to procfs fd
+
+SYNOPSIS
+
+	static int procfs_write_pcwstop (pi) struct procinfo *pi;
+
+DESCRIPTION
+	
+	Given a pointer to a procinfo struct, send a PCWSTOP to
+	the ctl_fd in the appropriate way.  Returns 0 on failure,
+	1 on success.
+ */
+
+static int
+procfs_write_pcwstop (pi)
+  struct procinfo *pi;
+{
+#ifdef PROCFS_USE_READ_WRITE
+  long cmd = PCWSTOP;
+  if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
+#else
+  if (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) < 0)
+#endif
+    return 0;
+  else
+    return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_write_pckill - send a kill to procfs fd
+
+SYNOPSIS
+
+	static void procfs_write_pckill (pi) struct procinfo *pi;
+
+DESCRIPTION
+	
+	Given a pointer to a procinfo struct, send a kill to
+	the ctl_fd in the appropriate way.  Returns 0 on failure,
+	1 on success.
+ */
+
+static void
+procfs_write_pckill (pi)
+  struct procinfo *pi;
+{
+#ifdef PROCFS_USE_READ_WRITE
+  struct proc_ctl pctl;
+  pctl.cmd = PCKILL;
+  pctl.data = SIGKILL;
+  write (pi->ctl_fd, &pctl, sizeof (struct proc_ctl));
+#else
+  int signo = SIGKILL;
+  ioctl (pi->ctl_fd, PIOCKILL, &signo);
+#endif
+}
+
+static struct procinfo *
+wait_fd ()
+{
+  struct procinfo *pi, *next_pi;
+#ifndef LOSING_POLL
+  int num_fds;
+  int i;
+#endif
+
+  set_sigint_trap ();	/* Causes SIGINT to be passed on to the
+			   attached process. */
+  set_sigio_trap ();
+
+ wait_again:
+#ifndef LOSING_POLL
+  while (1)
+    {
+      num_fds = poll (poll_list, num_poll_list, -1);
+      if (num_fds > 0)
+	break;
+      if (num_fds < 0 && errno == EINTR)
+	continue;
+      print_sys_errmsg ("poll failed", errno);
+      error ("Poll failed, returned %d", num_fds);
+    }
+#else /* LOSING_POLL */
+  pi = current_procinfo;
+
+  while (!procfs_write_pcwstop (pi))
+    {
+      if (errno == ENOENT)
+	{
+	  /* Process exited.  */
+	  pi->prstatus.pr_flags = 0;
+	  break;
+	}
+      else if (errno != EINTR)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("procfs_write_pcwstop failed");
+	}
+    }
+  pi->had_event = 1;
+#endif /* LOSING_POLL */
+  
+  clear_sigint_trap ();
+  clear_sigio_trap ();
+
+#ifndef LOSING_POLL
+
+  for (i = 0; i < num_poll_list && num_fds > 0; i++)
+    {
+      if (0 == (poll_list[i].revents & 
+		(POLLWRNORM | POLLPRI | POLLERR | POLLHUP | POLLNVAL)))
+	continue;
+      for (pi = procinfo_list; pi; pi = next_pi)
+	{
+	  next_pi = pi->next;
+	  if (poll_list[i].fd == pi->ctl_fd)
+	    {
+	      num_fds--;
+	      if ((poll_list[i].revents & POLLHUP) != 0	||
+		  !procfs_read_status(pi))
+		{ /* The LWP has apparently terminated.  */
+		  if (num_poll_list <= 1)
+		    {
+		      pi->prstatus.pr_flags = 0;
+		      pi->had_event = 1;
+		      break;
+		    }
+		  if (info_verbose)
+		    printf_filtered ("LWP %d exited.\n", 
+				     (pi->pid >> 16) & 0xffff);
+		  close_proc_file (pi);
+		  i--;			/* don't skip deleted entry */
+		  if (num_fds != 0)
+		    break;		/* already another event to process */
+		  else
+		    goto wait_again; 	/* wait for another event */
+		}
+	      pi->had_event = 1;
+	      break;
+	    }
+	}
+      if (!pi)
+	error ("wait_fd: Couldn't find procinfo for fd %d\n",
+	       poll_list[i].fd);
+    }
+#endif /* LOSING_POLL */
+
+  return pi;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	lookupdesc -- translate a value to a summary desc string
+
+SYNOPSIS
+
+	static char *lookupdesc (struct trans *transp, unsigned int val);
+
+DESCRIPTION
+	
+	Given a pointer to a translation table and a value to be translated,
+	lookup the desc string and return it.
+ */
+
+static char *
+lookupdesc (transp, val)
+     struct trans *transp;
+     unsigned int val;
+{
+  char *desc;
+  
+  for (desc = NULL; transp -> name != NULL; transp++)
+    {
+      if (transp -> value == val)
+	{
+	  desc = transp -> desc;
+	  break;
+	}
+    }
+
+  /* Didn't find a translation for the specified value, set a default one. */
+
+  if (desc == NULL)
+    {
+      desc = "Unknown";
+    }
+  return (desc);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	lookupname -- translate a value to symbolic name
+
+SYNOPSIS
+
+	static char *lookupname (struct trans *transp, unsigned int val,
+				 char *prefix);
+
+DESCRIPTION
+	
+	Given a pointer to a translation table, a value to be translated,
+	and a default prefix to return if the value can't be translated,
+	match the value with one of the translation table entries and
+	return a pointer to the symbolic name.
+
+	If no match is found it just returns the value as a printable string,
+	with the given prefix.  The previous such value, if any, is freed
+	at this time.
+ */
+
+static char *
+lookupname (transp, val, prefix)
+     struct trans *transp;
+     unsigned int val;
+     char *prefix;
+{
+  static char *locbuf;
+  char *name;
+  
+  for (name = NULL; transp -> name != NULL; transp++)
+    {
+      if (transp -> value == val)
+	{
+	  name = transp -> name;
+	  break;
+	}
+    }
+
+  /* Didn't find a translation for the specified value, build a default
+     one using the specified prefix and return it.  The lifetime of
+     the value is only until the next one is needed. */
+
+  if (name == NULL)
+    {
+      if (locbuf != NULL)
+	{
+	  free (locbuf);
+	}
+      locbuf = xmalloc (strlen (prefix) + 16);
+      sprintf (locbuf, "%s %u", prefix, val);
+      name = locbuf;
+    }
+  return (name);
+}
+
+static char *
+sigcodename (sip)
+     siginfo_t *sip;
+{
+  struct sigcode *scp;
+  char *name = NULL;
+  static char locbuf[32];
+  
+  for (scp = siginfo_table; scp -> codename != NULL; scp++)
+    {
+      if ((scp -> signo == sip -> si_signo) &&
+	  (scp -> code == sip -> si_code))
+	{
+	  name = scp -> codename;
+	  break;
+	}
+    }
+  if (name == NULL)
+    {
+      sprintf (locbuf, "sigcode %u", sip -> si_signo);
+      name = locbuf;
+    }
+  return (name);
+}
+
+static char *
+sigcodedesc (sip)
+     siginfo_t *sip;
+{
+  struct sigcode *scp;
+  char *desc = NULL;
+  
+  for (scp = siginfo_table; scp -> codename != NULL; scp++)
+    {
+      if ((scp -> signo == sip -> si_signo) &&
+	  (scp -> code == sip -> si_code))
+	{
+	  desc = scp -> desc;
+	  break;
+	}
+    }
+  if (desc == NULL)
+    {
+      desc = "Unrecognized signal or trap use";
+    }
+  return (desc);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	syscallname - translate a system call number into a system call name
+
+SYNOPSIS
+
+	char *syscallname (int syscallnum)
+
+DESCRIPTION
+
+	Given a system call number, translate it into the printable name
+	of a system call, or into "syscall <num>" if it is an unknown
+	number.
+ */
+
+static char *
+syscallname (syscallnum)
+     int syscallnum;
+{
+  static char locbuf[32];
+  
+  if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS
+      && syscall_table[syscallnum] != NULL)
+    return syscall_table[syscallnum];
+  else
+    {
+      sprintf (locbuf, "syscall %u", syscallnum);
+      return locbuf;
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	init_syscall_table - initialize syscall translation table
+
+SYNOPSIS
+
+	void init_syscall_table (void)
+
+DESCRIPTION
+
+	Dynamically initialize the translation table to convert system
+	call numbers into printable system call names.  Done once per
+	gdb run, on initialization.
+
+NOTES
+
+	This is awfully ugly, but preprocessor tricks to make it prettier
+	tend to be nonportable.
+ */
+
+static void
+init_syscall_table ()
+{
+#if defined (SYS_exit)
+  syscall_table[SYS_exit] = "exit";
+#endif
+#if defined (SYS_fork)
+  syscall_table[SYS_fork] = "fork";
+#endif
+#if defined (SYS_read)
+  syscall_table[SYS_read] = "read";
+#endif
+#if defined (SYS_write)
+  syscall_table[SYS_write] = "write";
+#endif
+#if defined (SYS_open)
+  syscall_table[SYS_open] = "open";
+#endif
+#if defined (SYS_close)
+  syscall_table[SYS_close] = "close";
+#endif
+#if defined (SYS_wait)
+  syscall_table[SYS_wait] = "wait";
+#endif
+#if defined (SYS_creat)
+  syscall_table[SYS_creat] = "creat";
+#endif
+#if defined (SYS_link)
+  syscall_table[SYS_link] = "link";
+#endif
+#if defined (SYS_unlink)
+  syscall_table[SYS_unlink] = "unlink";
+#endif
+#if defined (SYS_exec)
+  syscall_table[SYS_exec] = "exec";
+#endif
+#if defined (SYS_execv)
+  syscall_table[SYS_execv] = "execv";
+#endif
+#if defined (SYS_execve)
+  syscall_table[SYS_execve] = "execve";
+#endif
+#if defined (SYS_chdir)
+  syscall_table[SYS_chdir] = "chdir";
+#endif
+#if defined (SYS_time)
+  syscall_table[SYS_time] = "time";
+#endif
+#if defined (SYS_mknod)
+  syscall_table[SYS_mknod] = "mknod";
+#endif
+#if defined (SYS_chmod)
+  syscall_table[SYS_chmod] = "chmod";
+#endif
+#if defined (SYS_chown)
+  syscall_table[SYS_chown] = "chown";
+#endif
+#if defined (SYS_brk)
+  syscall_table[SYS_brk] = "brk";
+#endif
+#if defined (SYS_stat)
+  syscall_table[SYS_stat] = "stat";
+#endif
+#if defined (SYS_lseek)
+  syscall_table[SYS_lseek] = "lseek";
+#endif
+#if defined (SYS_getpid)
+  syscall_table[SYS_getpid] = "getpid";
+#endif
+#if defined (SYS_mount)
+  syscall_table[SYS_mount] = "mount";
+#endif
+#if defined (SYS_umount)
+  syscall_table[SYS_umount] = "umount";
+#endif
+#if defined (SYS_setuid)
+  syscall_table[SYS_setuid] = "setuid";
+#endif
+#if defined (SYS_getuid)
+  syscall_table[SYS_getuid] = "getuid";
+#endif
+#if defined (SYS_stime)
+  syscall_table[SYS_stime] = "stime";
+#endif
+#if defined (SYS_ptrace)
+  syscall_table[SYS_ptrace] = "ptrace";
+#endif
+#if defined (SYS_alarm)
+  syscall_table[SYS_alarm] = "alarm";
+#endif
+#if defined (SYS_fstat)
+  syscall_table[SYS_fstat] = "fstat";
+#endif
+#if defined (SYS_pause)
+  syscall_table[SYS_pause] = "pause";
+#endif
+#if defined (SYS_utime)
+  syscall_table[SYS_utime] = "utime";
+#endif
+#if defined (SYS_stty)
+  syscall_table[SYS_stty] = "stty";
+#endif
+#if defined (SYS_gtty)
+  syscall_table[SYS_gtty] = "gtty";
+#endif
+#if defined (SYS_access)
+  syscall_table[SYS_access] = "access";
+#endif
+#if defined (SYS_nice)
+  syscall_table[SYS_nice] = "nice";
+#endif
+#if defined (SYS_statfs)
+  syscall_table[SYS_statfs] = "statfs";
+#endif
+#if defined (SYS_sync)
+  syscall_table[SYS_sync] = "sync";
+#endif
+#if defined (SYS_kill)
+  syscall_table[SYS_kill] = "kill";
+#endif
+#if defined (SYS_fstatfs)
+  syscall_table[SYS_fstatfs] = "fstatfs";
+#endif
+#if defined (SYS_pgrpsys)
+  syscall_table[SYS_pgrpsys] = "pgrpsys";
+#endif
+#if defined (SYS_xenix)
+  syscall_table[SYS_xenix] = "xenix";
+#endif
+#if defined (SYS_dup)
+  syscall_table[SYS_dup] = "dup";
+#endif
+#if defined (SYS_pipe)
+  syscall_table[SYS_pipe] = "pipe";
+#endif
+#if defined (SYS_times)
+  syscall_table[SYS_times] = "times";
+#endif
+#if defined (SYS_profil)
+  syscall_table[SYS_profil] = "profil";
+#endif
+#if defined (SYS_plock)
+  syscall_table[SYS_plock] = "plock";
+#endif
+#if defined (SYS_setgid)
+  syscall_table[SYS_setgid] = "setgid";
+#endif
+#if defined (SYS_getgid)
+  syscall_table[SYS_getgid] = "getgid";
+#endif
+#if defined (SYS_signal)
+  syscall_table[SYS_signal] = "signal";
+#endif
+#if defined (SYS_msgsys)
+  syscall_table[SYS_msgsys] = "msgsys";
+#endif
+#if defined (SYS_sys3b)
+  syscall_table[SYS_sys3b] = "sys3b";
+#endif
+#if defined (SYS_sysi86)
+  syscall_table[SYS_sysi86] = "sysi86";
+#endif
+#if defined (SYS_acct)
+  syscall_table[SYS_acct] = "acct";
+#endif
+#if defined (SYS_shmsys)
+  syscall_table[SYS_shmsys] = "shmsys";
+#endif
+#if defined (SYS_semsys)
+  syscall_table[SYS_semsys] = "semsys";
+#endif
+#if defined (SYS_ioctl)
+  syscall_table[SYS_ioctl] = "ioctl";
+#endif
+#if defined (SYS_uadmin)
+  syscall_table[SYS_uadmin] = "uadmin";
+#endif
+#if defined (SYS_utssys)
+  syscall_table[SYS_utssys] = "utssys";
+#endif
+#if defined (SYS_fsync)
+  syscall_table[SYS_fsync] = "fsync";
+#endif
+#if defined (SYS_umask)
+  syscall_table[SYS_umask] = "umask";
+#endif
+#if defined (SYS_chroot)
+  syscall_table[SYS_chroot] = "chroot";
+#endif
+#if defined (SYS_fcntl)
+  syscall_table[SYS_fcntl] = "fcntl";
+#endif
+#if defined (SYS_ulimit)
+  syscall_table[SYS_ulimit] = "ulimit";
+#endif
+#if defined (SYS_rfsys)
+  syscall_table[SYS_rfsys] = "rfsys";
+#endif
+#if defined (SYS_rmdir)
+  syscall_table[SYS_rmdir] = "rmdir";
+#endif
+#if defined (SYS_mkdir)
+  syscall_table[SYS_mkdir] = "mkdir";
+#endif
+#if defined (SYS_getdents)
+  syscall_table[SYS_getdents] = "getdents";
+#endif
+#if defined (SYS_sysfs)
+  syscall_table[SYS_sysfs] = "sysfs";
+#endif
+#if defined (SYS_getmsg)
+  syscall_table[SYS_getmsg] = "getmsg";
+#endif
+#if defined (SYS_putmsg)
+  syscall_table[SYS_putmsg] = "putmsg";
+#endif
+#if defined (SYS_poll)
+  syscall_table[SYS_poll] = "poll";
+#endif
+#if defined (SYS_lstat)
+  syscall_table[SYS_lstat] = "lstat";
+#endif
+#if defined (SYS_symlink)
+  syscall_table[SYS_symlink] = "symlink";
+#endif
+#if defined (SYS_readlink)
+  syscall_table[SYS_readlink] = "readlink";
+#endif
+#if defined (SYS_setgroups)
+  syscall_table[SYS_setgroups] = "setgroups";
+#endif
+#if defined (SYS_getgroups)
+  syscall_table[SYS_getgroups] = "getgroups";
+#endif
+#if defined (SYS_fchmod)
+  syscall_table[SYS_fchmod] = "fchmod";
+#endif
+#if defined (SYS_fchown)
+  syscall_table[SYS_fchown] = "fchown";
+#endif
+#if defined (SYS_sigprocmask)
+  syscall_table[SYS_sigprocmask] = "sigprocmask";
+#endif
+#if defined (SYS_sigsuspend)
+  syscall_table[SYS_sigsuspend] = "sigsuspend";
+#endif
+#if defined (SYS_sigaltstack)
+  syscall_table[SYS_sigaltstack] = "sigaltstack";
+#endif
+#if defined (SYS_sigaction)
+  syscall_table[SYS_sigaction] = "sigaction";
+#endif
+#if defined (SYS_sigpending)
+  syscall_table[SYS_sigpending] = "sigpending";
+#endif
+#if defined (SYS_context)
+  syscall_table[SYS_context] = "context";
+#endif
+#if defined (SYS_evsys)
+  syscall_table[SYS_evsys] = "evsys";
+#endif
+#if defined (SYS_evtrapret)
+  syscall_table[SYS_evtrapret] = "evtrapret";
+#endif
+#if defined (SYS_statvfs)
+  syscall_table[SYS_statvfs] = "statvfs";
+#endif
+#if defined (SYS_fstatvfs)
+  syscall_table[SYS_fstatvfs] = "fstatvfs";
+#endif
+#if defined (SYS_nfssys)
+  syscall_table[SYS_nfssys] = "nfssys";
+#endif
+#if defined (SYS_waitsys)
+  syscall_table[SYS_waitsys] = "waitsys";
+#endif
+#if defined (SYS_sigsendsys)
+  syscall_table[SYS_sigsendsys] = "sigsendsys";
+#endif
+#if defined (SYS_hrtsys)
+  syscall_table[SYS_hrtsys] = "hrtsys";
+#endif
+#if defined (SYS_acancel)
+  syscall_table[SYS_acancel] = "acancel";
+#endif
+#if defined (SYS_async)
+  syscall_table[SYS_async] = "async";
+#endif
+#if defined (SYS_priocntlsys)
+  syscall_table[SYS_priocntlsys] = "priocntlsys";
+#endif
+#if defined (SYS_pathconf)
+  syscall_table[SYS_pathconf] = "pathconf";
+#endif
+#if defined (SYS_mincore)
+  syscall_table[SYS_mincore] = "mincore";
+#endif
+#if defined (SYS_mmap)
+  syscall_table[SYS_mmap] = "mmap";
+#endif
+#if defined (SYS_mprotect)
+  syscall_table[SYS_mprotect] = "mprotect";
+#endif
+#if defined (SYS_munmap)
+  syscall_table[SYS_munmap] = "munmap";
+#endif
+#if defined (SYS_fpathconf)
+  syscall_table[SYS_fpathconf] = "fpathconf";
+#endif
+#if defined (SYS_vfork)
+  syscall_table[SYS_vfork] = "vfork";
+#endif
+#if defined (SYS_fchdir)
+  syscall_table[SYS_fchdir] = "fchdir";
+#endif
+#if defined (SYS_readv)
+  syscall_table[SYS_readv] = "readv";
+#endif
+#if defined (SYS_writev)
+  syscall_table[SYS_writev] = "writev";
+#endif
+#if defined (SYS_xstat)
+  syscall_table[SYS_xstat] = "xstat";
+#endif
+#if defined (SYS_lxstat)
+  syscall_table[SYS_lxstat] = "lxstat";
+#endif
+#if defined (SYS_fxstat)
+  syscall_table[SYS_fxstat] = "fxstat";
+#endif
+#if defined (SYS_xmknod)
+  syscall_table[SYS_xmknod] = "xmknod";
+#endif
+#if defined (SYS_clocal)
+  syscall_table[SYS_clocal] = "clocal";
+#endif
+#if defined (SYS_setrlimit)
+  syscall_table[SYS_setrlimit] = "setrlimit";
+#endif
+#if defined (SYS_getrlimit)
+  syscall_table[SYS_getrlimit] = "getrlimit";
+#endif
+#if defined (SYS_lchown)
+  syscall_table[SYS_lchown] = "lchown";
+#endif
+#if defined (SYS_memcntl)
+  syscall_table[SYS_memcntl] = "memcntl";
+#endif
+#if defined (SYS_getpmsg)
+  syscall_table[SYS_getpmsg] = "getpmsg";
+#endif
+#if defined (SYS_putpmsg)
+  syscall_table[SYS_putpmsg] = "putpmsg";
+#endif
+#if defined (SYS_rename)
+  syscall_table[SYS_rename] = "rename";
+#endif
+#if defined (SYS_uname)
+  syscall_table[SYS_uname] = "uname";
+#endif
+#if defined (SYS_setegid)
+  syscall_table[SYS_setegid] = "setegid";
+#endif
+#if defined (SYS_sysconfig)
+  syscall_table[SYS_sysconfig] = "sysconfig";
+#endif
+#if defined (SYS_adjtime)
+  syscall_table[SYS_adjtime] = "adjtime";
+#endif
+#if defined (SYS_systeminfo)
+  syscall_table[SYS_systeminfo] = "systeminfo";
+#endif
+#if defined (SYS_seteuid)
+  syscall_table[SYS_seteuid] = "seteuid";
+#endif
+#if defined (SYS_sproc)
+  syscall_table[SYS_sproc] = "sproc";
+#endif
+#if defined (SYS_keyctl)
+  syscall_table[SYS_keyctl] = "keyctl";
+#endif
+#if defined (SYS_secsys)
+  syscall_table[SYS_secsys] = "secsys";
+#endif
+#if defined (SYS_filepriv)
+  syscall_table[SYS_filepriv] = "filepriv";
+#endif
+#if defined (SYS_procpriv)
+  syscall_table[SYS_procpriv] = "procpriv";
+#endif
+#if defined (SYS_devstat)
+  syscall_table[SYS_devstat] = "devstat";
+#endif
+#if defined (SYS_aclipc)
+  syscall_table[SYS_aclipc] = "aclipc";
+#endif
+#if defined (SYS_fdevstat)
+  syscall_table[SYS_fdevstat] = "fdevstat";
+#endif
+#if defined (SYS_flvlfile)
+  syscall_table[SYS_flvlfile] = "flvlfile";
+#endif
+#if defined (SYS_lvlfile)
+  syscall_table[SYS_lvlfile] = "lvlfile";
+#endif
+#if defined (SYS_lvlequal)
+  syscall_table[SYS_lvlequal] = "lvlequal";
+#endif
+#if defined (SYS_lvlproc)
+  syscall_table[SYS_lvlproc] = "lvlproc";
+#endif
+#if defined (SYS_lvlipc)
+  syscall_table[SYS_lvlipc] = "lvlipc";
+#endif
+#if defined (SYS_acl)
+  syscall_table[SYS_acl] = "acl";
+#endif
+#if defined (SYS_auditevt)
+  syscall_table[SYS_auditevt] = "auditevt";
+#endif
+#if defined (SYS_auditctl)
+  syscall_table[SYS_auditctl] = "auditctl";
+#endif
+#if defined (SYS_auditdmp)
+  syscall_table[SYS_auditdmp] = "auditdmp";
+#endif
+#if defined (SYS_auditlog)
+  syscall_table[SYS_auditlog] = "auditlog";
+#endif
+#if defined (SYS_auditbuf)
+  syscall_table[SYS_auditbuf] = "auditbuf";
+#endif
+#if defined (SYS_lvldom)
+  syscall_table[SYS_lvldom] = "lvldom";
+#endif
+#if defined (SYS_lvlvfs)
+  syscall_table[SYS_lvlvfs] = "lvlvfs";
+#endif
+#if defined (SYS_mkmld)
+  syscall_table[SYS_mkmld] = "mkmld";
+#endif
+#if defined (SYS_mldmode)
+  syscall_table[SYS_mldmode] = "mldmode";
+#endif
+#if defined (SYS_secadvise)
+  syscall_table[SYS_secadvise] = "secadvise";
+#endif
+#if defined (SYS_online)
+  syscall_table[SYS_online] = "online";
+#endif
+#if defined (SYS_setitimer)
+  syscall_table[SYS_setitimer] = "setitimer";
+#endif
+#if defined (SYS_getitimer)
+  syscall_table[SYS_getitimer] = "getitimer";
+#endif
+#if defined (SYS_gettimeofday)
+  syscall_table[SYS_gettimeofday] = "gettimeofday";
+#endif
+#if defined (SYS_settimeofday)
+  syscall_table[SYS_settimeofday] = "settimeofday";
+#endif
+#if defined (SYS_lwp_create)
+  syscall_table[SYS_lwp_create] = "_lwp_create";
+#endif
+#if defined (SYS_lwp_exit)
+  syscall_table[SYS_lwp_exit] = "_lwp_exit";
+#endif
+#if defined (SYS_lwp_wait)
+  syscall_table[SYS_lwp_wait] = "_lwp_wait";
+#endif
+#if defined (SYS_lwp_self)
+  syscall_table[SYS_lwp_self] = "_lwp_self";
+#endif
+#if defined (SYS_lwp_info)
+  syscall_table[SYS_lwp_info] = "_lwp_info";
+#endif
+#if defined (SYS_lwp_private)
+  syscall_table[SYS_lwp_private] = "_lwp_private";
+#endif
+#if defined (SYS_processor_bind)
+  syscall_table[SYS_processor_bind] = "processor_bind";
+#endif
+#if defined (SYS_processor_exbind)
+  syscall_table[SYS_processor_exbind] = "processor_exbind";
+#endif
+#if defined (SYS_prepblock)
+  syscall_table[SYS_prepblock] = "prepblock";
+#endif
+#if defined (SYS_block)
+  syscall_table[SYS_block] = "block";
+#endif
+#if defined (SYS_rdblock)
+  syscall_table[SYS_rdblock] = "rdblock";
+#endif
+#if defined (SYS_unblock)
+  syscall_table[SYS_unblock] = "unblock";
+#endif
+#if defined (SYS_cancelblock)
+  syscall_table[SYS_cancelblock] = "cancelblock";
+#endif
+#if defined (SYS_pread)
+  syscall_table[SYS_pread] = "pread";
+#endif
+#if defined (SYS_pwrite)
+  syscall_table[SYS_pwrite] = "pwrite";
+#endif
+#if defined (SYS_truncate)
+  syscall_table[SYS_truncate] = "truncate";
+#endif
+#if defined (SYS_ftruncate)
+  syscall_table[SYS_ftruncate] = "ftruncate";
+#endif
+#if defined (SYS_lwp_kill)
+  syscall_table[SYS_lwp_kill] = "_lwp_kill";
+#endif
+#if defined (SYS_sigwait)
+  syscall_table[SYS_sigwait] = "sigwait";
+#endif
+#if defined (SYS_fork1)
+  syscall_table[SYS_fork1] = "fork1";
+#endif
+#if defined (SYS_forkall)
+  syscall_table[SYS_forkall] = "forkall";
+#endif
+#if defined (SYS_modload)
+  syscall_table[SYS_modload] = "modload";
+#endif
+#if defined (SYS_moduload)
+  syscall_table[SYS_moduload] = "moduload";
+#endif
+#if defined (SYS_modpath)
+  syscall_table[SYS_modpath] = "modpath";
+#endif
+#if defined (SYS_modstat)
+  syscall_table[SYS_modstat] = "modstat";
+#endif
+#if defined (SYS_modadm)
+  syscall_table[SYS_modadm] = "modadm";
+#endif
+#if defined (SYS_getksym)
+  syscall_table[SYS_getksym] = "getksym";
+#endif
+#if defined (SYS_lwp_suspend)
+  syscall_table[SYS_lwp_suspend] = "_lwp_suspend";
+#endif
+#if defined (SYS_lwp_continue)
+  syscall_table[SYS_lwp_continue] = "_lwp_continue";
+#endif
+#if defined (SYS_priocntllst)
+  syscall_table[SYS_priocntllst] = "priocntllst";
+#endif
+#if defined (SYS_sleep)
+  syscall_table[SYS_sleep] = "sleep";
+#endif
+#if defined (SYS_lwp_sema_wait)
+  syscall_table[SYS_lwp_sema_wait] = "_lwp_sema_wait";
+#endif
+#if defined (SYS_lwp_sema_post)
+  syscall_table[SYS_lwp_sema_post] = "_lwp_sema_post";
+#endif
+#if defined (SYS_lwp_sema_trywait)
+  syscall_table[SYS_lwp_sema_trywait] = "lwp_sema_trywait";
+#endif
+#if defined(SYS_fstatvfs64)
+  syscall_table[SYS_fstatvfs64] = "fstatvfs64";
+#endif
+#if defined(SYS_statvfs64)
+  syscall_table[SYS_statvfs64] = "statvfs64";
+#endif
+#if defined(SYS_ftruncate64)
+  syscall_table[SYS_ftruncate64] = "ftruncate64";
+#endif
+#if defined(SYS_truncate64)
+  syscall_table[SYS_truncate64] = "truncate64";
+#endif
+#if defined(SYS_getrlimit64)
+  syscall_table[SYS_getrlimit64] = "getrlimit64";
+#endif
+#if defined(SYS_setrlimit64)
+  syscall_table[SYS_setrlimit64] = "setrlimit64";
+#endif
+#if defined(SYS_lseek64)
+  syscall_table[SYS_lseek64] = "lseek64";
+#endif
+#if defined(SYS_mmap64)
+  syscall_table[SYS_mmap64] = "mmap64";
+#endif
+#if defined(SYS_pread64)
+  syscall_table[SYS_pread64] = "pread64";
+#endif
+#if defined(SYS_creat64)
+  syscall_table[SYS_creat64] = "creat64";
+#endif
+#if defined(SYS_dshmsys)
+  syscall_table[SYS_dshmsys] = "dshmsys";
+#endif
+#if defined(SYS_invlpg)
+  syscall_table[SYS_invlpg] = "invlpg";
+#endif
+#if defined(SYS_cg_ids)
+  syscall_table[SYS_cg_ids] = "cg_ids";
+#endif
+#if defined(SYS_cg_processors)
+  syscall_table[SYS_cg_processors] = "cg_processors";
+#endif
+#if defined(SYS_cg_info)
+  syscall_table[SYS_cg_info] = "cg_info";
+#endif
+#if defined(SYS_cg_bind)
+  syscall_table[SYS_cg_bind] = "cg_bind";
+#endif
+#if defined(SYS_cg_current)
+  syscall_table[SYS_cg_current] = "cg_current";
+#endif
+#if defined(SYS_cg_memloc)
+  syscall_table[SYS_cg_memloc] = "cg_memloc";
+#endif
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_kill_inferior - kill any currently inferior
+
+SYNOPSIS
+
+	void procfs_kill_inferior (void)
+
+DESCRIPTION
+
+	Kill any current inferior.
+
+NOTES
+
+	Kills even attached inferiors.  Presumably the user has already
+	been prompted that the inferior is an attached one rather than
+	one started by gdb.  (FIXME?)
+
+*/
+
+static void
+procfs_kill_inferior ()
+{
+  target_mourn_inferior ();
+}
+
+/*
+
+LOCAL FUNCTION
+
+	unconditionally_kill_inferior - terminate the inferior
+
+SYNOPSIS
+
+	static void unconditionally_kill_inferior (struct procinfo *)
+
+DESCRIPTION
+
+	Kill the specified inferior.
+
+NOTE
+
+	A possibly useful enhancement would be to first try sending
+	the inferior a terminate signal, politely asking it to commit
+	suicide, before we murder it (we could call that
+	politely_kill_inferior()).
+
+*/
+
+static void
+unconditionally_kill_inferior (pi)
+     struct procinfo *pi;
+{
+  int ppid;
+  struct proc_ctl pctl;
+  
+  ppid = pi->prstatus.pr_ppid;
+
+#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
+  /* Alpha OSF/1-3.x procfs needs a clear of the current signal
+     before the PIOCKILL, otherwise it might generate a corrupted core
+     file for the inferior.  */
+  ioctl (pi->ctl_fd, PIOCSSIG, NULL);
+#endif
+#ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
+  /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
+     to kill the inferior, otherwise it might remain stopped with a
+     pending SIGKILL.
+     We do not check the result of the PIOCSSIG, the inferior might have
+     died already.  */
+  {
+    struct siginfo newsiginfo;
+
+    memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
+    newsiginfo.si_signo = SIGKILL;
+    newsiginfo.si_code = 0;
+    newsiginfo.si_errno = 0;
+    newsiginfo.si_pid = getpid ();
+    newsiginfo.si_uid = getuid ();
+    ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
+  }
+#else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
+  procfs_write_pckill (pi);
+#endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
+
+  close_proc_file (pi);
+
+/* Only wait() for our direct children.  Our grandchildren zombies are killed
+   by the death of their parents.  */
+
+  if (ppid == getpid())
+    wait ((int *) 0);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_xfer_memory -- copy data to or from inferior memory space
+
+SYNOPSIS
+
+	int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+		int dowrite, struct target_ops target)
+
+DESCRIPTION
+
+	Copy LEN bytes to/from inferior's memory starting at MEMADDR
+	from/to debugger memory starting at MYADDR.  Copy from inferior
+	if DOWRITE is zero or to inferior if DOWRITE is nonzero.
+  
+	Returns the length copied, which is either the LEN argument or
+	zero.  This xfer function does not do partial moves, since procfs_ops
+	doesn't allow memory operations to cross below us in the target stack
+	anyway.
+
+NOTES
+
+	The /proc interface makes this an almost trivial task.
+ */
+
+static int
+procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+     int dowrite;
+     struct target_ops *target; /* ignored */
+{
+  int nbytes = 0;
+  struct procinfo *pi;
+
+  pi = current_procinfo;
+
+  if (lseek(pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
+    {
+      if (dowrite)
+	{
+	  nbytes = write (pi->as_fd, myaddr, len);
+	}
+      else
+	{
+	  nbytes = read (pi->as_fd, myaddr, len);
+	}
+      if (nbytes < 0)
+	{
+	  nbytes = 0;
+	}
+    }
+  return (nbytes);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_store_registers -- copy register values back to inferior
+
+SYNOPSIS
+
+	void procfs_store_registers (int regno)
+
+DESCRIPTION
+
+	Store our current register values back into the inferior.  If
+	REGNO is -1 then store all the register, otherwise store just
+	the value specified by REGNO.
+
+NOTES
+
+	If we are storing only a single register, we first have to get all
+	the current values from the process, overwrite the desired register
+	in the gregset with the one we want from gdb's registers, and then
+	send the whole set back to the process.  For writing all the
+	registers, all we have to do is generate the gregset and send it to
+	the process.
+
+	Also note that the process has to be stopped on an event of interest
+	for this to work, which basically means that it has to have been
+	run under the control of one of the other /proc ioctl calls and not
+	ptrace.  Since we don't use ptrace anyway, we don't worry about this
+	fine point, but it is worth noting for future reference.
+
+	Gdb is confused about what this function is supposed to return.
+	Some versions return a value, others return nothing.  Some are
+	declared to return a value and actually return nothing.  Gdb ignores
+	anything returned.  (FIXME)
+
+ */
+
+static void
+procfs_store_registers (regno)
+     int regno;
+{
+  struct procinfo *pi;
+#ifdef PROCFS_USE_READ_WRITE
+  struct greg_ctl greg;
+  struct fpreg_ctl fpreg;
+#endif
+
+  pi = current_procinfo;
+
+#ifdef PROCFS_USE_READ_WRITE
+  if (regno != -1)
+    {
+      procfs_read_status (pi);
+      memcpy ((char *) &greg.gregset,
+         (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs,
+         sizeof (gdb_gregset_t));
+    }
+  fill_gregset (&greg.gregset, regno);
+  greg.cmd = PCSREG;
+  write (pi->ctl_fd, &greg, sizeof (greg));
+#else /* PROCFS_USE_READ_WRITE */
+  if (regno != -1)
+    {
+      ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset);
+    }
+  fill_gregset (&pi->gregset.gregset, regno);
+  ioctl (pi->ctl_fd, PIOCSREG, &pi->gregset.gregset);
+#endif /* PROCFS_USE_READ_WRITE */
+
+#if defined (FP0_REGNUM)
+
+  /* Now repeat everything using the floating point register set, if the
+     target has floating point hardware. Since we ignore the returned value,
+     we'll never know whether it worked or not anyway. */
+
+#ifdef PROCFS_USE_READ_WRITE
+  if (regno != -1)
+    {
+      procfs_read_status (pi);
+      memcpy ((char *) &fpreg.fpregset,
+          (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs,
+          sizeof (gdb_fpregset_t));
+    }
+  fill_fpregset (&fpreg.fpregset, regno);
+  fpreg.cmd = PCSFPREG;
+  write (pi->ctl_fd, &fpreg, sizeof (fpreg));
+#else /* PROCFS_USE_READ_WRITE */
+  if (regno != -1)
+    {
+      ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset);
+    }
+  fill_fpregset (&pi->fpregset.fpregset, regno);
+  ioctl (pi->ctl_fd, PIOCSFPREG, &pi->fpregset.fpregset);
+#endif /* PROCFS_USE_READ_WRITE */
+
+#endif	/* FP0_REGNUM */
+
+}
+
+/*
+
+LOCAL FUNCTION
+
+	init_procinfo - setup a procinfo struct and connect it to a process
+
+SYNOPSIS
+
+	struct procinfo * init_procinfo (int pid)
+
+DESCRIPTION
+
+	Allocate a procinfo structure, open the /proc file and then set up the
+	set of signals and faults that are to be traced.  Returns a pointer to
+	the new procinfo structure.  
+
+NOTES
+
+	If proc_init_failed ever gets called, control returns to the command
+	processing loop via the standard error handling code.
+
+ */
+
+static struct procinfo *
+init_procinfo (pid, kill)
+     int pid;
+     int kill;
+{
+  struct procinfo *pi = (struct procinfo *) 
+    xmalloc (sizeof (struct procinfo));
+  struct sig_ctl  sctl;
+  struct flt_ctl  fctl;
+
+  memset ((char *) pi, 0, sizeof (*pi));
+  if (!open_proc_file (pid, pi, O_RDWR, 1))
+    proc_init_failed (pi, "can't open process file", kill);
+
+  /* open_proc_file may modify pid.  */
+
+  pid = pi -> pid;
+
+  /* Add new process to process info list */
+
+  pi->next = procinfo_list;
+  procinfo_list = pi;
+
+  add_fd (pi);			/* Add to list for poll/select */
+
+  /*  Remember some things about the inferior that we will, or might, change
+      so that we can restore them when we detach. */
+#ifdef UNIXWARE
+  memcpy ((char *) &pi->saved_trace.sigset,
+	  (char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t));
+  memcpy ((char *) &pi->saved_fltset.fltset,
+	  (char *) &pi->prstatus.pr_flttrace, sizeof (fltset_t));
+  memcpy ((char *) &pi->saved_entryset.sysset,
+	  (char *) &pi->prstatus.pr_sysentry, sizeof (sysset_t));
+  memcpy ((char *) &pi->saved_exitset.sysset,
+	  (char *) &pi->prstatus.pr_sysexit, sizeof (sysset_t));
+
+  /* Set up trace and fault sets, as gdb expects them. */
+
+  prfillset (&sctl.sigset);
+  notice_signals (pi, &sctl);
+  prfillset (&fctl.fltset);
+  prdelset (&fctl.fltset, FLTPAGE);
+
+#else /* ! UNIXWARE */
+  ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset);
+  ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset);
+  ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset);
+  ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset);
+  ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset);
+  
+  /* Set up trace and fault sets, as gdb expects them. */
+  
+  memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
+  prfillset (&pi->prrun.pr_trace);
+  procfs_notice_signals (pid);
+  prfillset (&pi->prrun.pr_fault);
+  prdelset (&pi->prrun.pr_fault, FLTPAGE);
+#ifdef PROCFS_DONT_TRACE_FAULTS
+  premptyset (&pi->prrun.pr_fault);
+#endif
+#endif /* UNIXWARE */
+
+  if (!procfs_read_status (pi))
+    proc_init_failed (pi, "procfs_read_status failed", kill);
+
+  return pi;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	create_procinfo - initialize access to a /proc entry
+
+SYNOPSIS
+
+	struct procinfo * create_procinfo (int pid)
+
+DESCRIPTION
+
+	Allocate a procinfo structure, open the /proc file and then set up the
+	set of signals and faults that are to be traced.  Returns a pointer to
+	the new procinfo structure.
+
+NOTES
+
+	If proc_init_failed ever gets called, control returns to the command
+	processing loop via the standard error handling code.
+
+ */
+
+static struct procinfo *
+create_procinfo (pid)
+     int pid;
+{
+  struct procinfo *pi;
+  struct sig_ctl  sctl;
+  struct flt_ctl  fctl;
+
+  pi = find_procinfo (pid, 1);
+  if (pi != NULL)
+    return pi;			/* All done!  It already exists */
+
+  pi = init_procinfo (pid, 1);
+
+#ifndef UNIXWARE
+/* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are
+   already stopped, even if they all have PR_ASYNC set.  */
+  if (!(pi->prstatus.pr_flags & PR_STOPPED))
+#endif
+    if (!procfs_write_pcwstop (pi))
+      proc_init_failed (pi, "procfs_write_pcwstop failed", 1);
+
+#ifdef PROCFS_USE_READ_WRITE
+  fctl.cmd = PCSFAULT;
+  if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
+    proc_init_failed (pi, "PCSFAULT failed", 1);
+#else
+  if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
+    proc_init_failed (pi, "PIOCSFAULT failed", 1);
+#endif
+
+  return pi;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_exit_handler - handle entry into the _exit syscall
+
+SYNOPSIS
+
+	int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+	This routine is called when an inferior process enters the _exit()
+	system call.  It continues the process, and then collects the exit
+	status and pid which are returned in *statvalp and *rtnvalp.  After
+	that it returns non-zero to indicate that procfs_wait should wake up.
+
+NOTES
+	There is probably a better way to do this.
+
+ */
+
+static int
+procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
+     struct procinfo *pi;
+     int syscall_num;
+     int why;
+     int *rtnvalp;
+     int *statvalp;
+{
+  struct procinfo *temp_pi, *next_pi;
+  struct proc_ctl pctl;
+
+#ifdef UNIXWARE
+  pctl.cmd = PCRUN;
+  pctl.data = PRCFAULT;
+#else
+  pi->prrun.pr_flags = PRCFAULT;
+#endif
+
+#ifdef PROCFS_USE_READ_WRITE
+  if (write (pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+#else
+  if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+#endif
+    perror_with_name (pi->pathname);
+
+  if (attach_flag)
+    {
+      /* Claim it exited (don't call wait). */
+      if (info_verbose)
+	printf_filtered ("(attached process has exited)\n");
+      *statvalp = 0;
+      *rtnvalp  = inferior_pid;
+    }
+  else
+    {
+      *rtnvalp = wait (statvalp);
+      if (*rtnvalp >= 0)
+	*rtnvalp = pi->pid;
+    }
+
+  /* Close ALL open proc file handles,
+     except the one that called SYS_exit. */
+  for (temp_pi = procinfo_list; temp_pi; temp_pi = next_pi)
+    {
+      next_pi = temp_pi->next;
+      if (temp_pi == pi)
+	continue;		/* Handled below */
+      close_proc_file (temp_pi);
+    }
+  return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_exec_handler - handle exit from the exec family of syscalls
+
+SYNOPSIS
+
+	int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+	This routine is called when an inferior process is about to finish any
+	of the exec() family of	system calls.  It pretends that we got a
+	SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
+	to tell procfs_wait to wake up.
+
+NOTES
+	This need for compatibility with ptrace is questionable.  In the
+	future, it shouldn't be necessary.
+
+ */
+
+static int
+procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
+     struct procinfo *pi;
+     int syscall_num;
+     int why;
+     int *rtnvalp;
+     int *statvalp;
+{
+  *statvalp = (SIGTRAP << 8) | 0177;
+
+  return 1;
+}
+
+#if defined(SYS_sproc) && !defined(UNIXWARE)
+/* IRIX lwp creation system call */
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_sproc_handler - handle exit from the sproc syscall
+
+SYNOPSIS
+
+	int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+	This routine is called when an inferior process is about to finish an
+	sproc() system call.  This is the system call that IRIX uses to create
+	a lightweight process.  When the target process gets this event, we can
+	look at rval1 to find the new child processes ID, and create a new
+	procinfo struct from that.
+
+	After that, it pretends that we got a SIGTRAP, and returns non-zero
+	to tell procfs_wait to wake up.  Subsequently, wait_for_inferior gets
+	woken up, sees the new process and continues it.
+
+NOTES
+	We actually never see the child exiting from sproc because we will
+	shortly stop the child with PIOCSTOP, which is then registered as the
+	event of interest.
+ */
+
+static int
+procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
+     struct procinfo *pi;
+     int syscall_num;
+     int why;
+     int *rtnvalp;
+     int *statvalp;
+{
+/* We've just detected the completion of an sproc system call.  Now we need to
+   setup a procinfo struct for this thread, and notify the thread system of the
+   new arrival.  */
+
+/* If sproc failed, then nothing interesting happened.  Continue the process
+   and go back to sleep. */
+
+  if (pi->prstatus.pr_errno != 0)
+    {
+      pi->prrun.pr_flags &= PRSTEP;
+      pi->prrun.pr_flags |= PRCFAULT;
+
+      if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+	perror_with_name (pi->pathname);
+
+      return 0;
+    }
+
+  /* At this point, the new thread is stopped at it's first instruction, and
+     the parent is stopped at the exit from sproc.  */
+
+  /* Notify the caller of the arrival of a new thread. */
+  create_procinfo (pi->prstatus.pr_rval1);
+
+  *rtnvalp = pi->prstatus.pr_rval1;
+  *statvalp = (SIGTRAP << 8) | 0177;
+
+  return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_fork_handler - handle exit from the fork syscall
+
+SYNOPSIS
+
+	int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+	This routine is called when an inferior process is about to finish a
+	fork() system call.  We will open up the new process, and then close
+	it, which releases it from the clutches of the debugger.
+
+	After that, we continue the target process as though nothing had
+	happened.
+
+NOTES
+	This is necessary for IRIX because we have to set PR_FORK in order
+	to catch the creation of lwps (via sproc()).  When an actual fork
+	occurs, it becomes necessary to reset the forks debugger flags and
+	continue it because we can't hack multiple processes yet.
+ */
+
+static int
+procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
+     struct procinfo *pi;
+     int syscall_num;
+     int why;
+     int *rtnvalp;
+     int *statvalp;
+{
+  struct procinfo *pitemp;
+
+/* At this point, we've detected the completion of a fork (or vfork) call in
+   our child.  The grandchild is also stopped because we set inherit-on-fork
+   earlier.  (Note that nobody has the grandchilds' /proc file open at this
+   point.)  We will release the grandchild from the debugger by opening it's
+   /proc file and then closing it.  Since run-on-last-close is set, the
+   grandchild continues on its' merry way.  */
+
+
+  pitemp = create_procinfo (pi->prstatus.pr_rval1);
+  if (pitemp)
+    close_proc_file (pitemp);
+
+  if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+    perror_with_name (pi->pathname);
+
+  return 0;
+}
+#endif /* SYS_sproc && !UNIXWARE */
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_set_inferior_syscall_traps - setup the syscall traps 
+
+SYNOPSIS
+
+	void procfs_set_inferior_syscall_traps (struct procinfo *pip)
+
+DESCRIPTION
+
+	Called for each "procinfo" (process, thread, or LWP) in the
+	inferior, to register for notification of and handlers for
+	syscall traps in the inferior.
+
+ */
+
+static void
+procfs_set_inferior_syscall_traps (pip)
+     struct procinfo *pip;
+{
+  procfs_set_syscall_trap (pip, SYS_exit, PROCFS_SYSCALL_ENTRY,
+			   procfs_exit_handler);
+
+#ifndef PRFS_STOPEXEC
+#ifdef SYS_exec
+  procfs_set_syscall_trap (pip, SYS_exec, PROCFS_SYSCALL_EXIT,
+			   procfs_exec_handler);
+#endif
+#ifdef SYS_execv
+  procfs_set_syscall_trap (pip, SYS_execv, PROCFS_SYSCALL_EXIT,
+			   procfs_exec_handler);
+#endif
+#ifdef SYS_execve
+  procfs_set_syscall_trap (pip, SYS_execve, PROCFS_SYSCALL_EXIT,
+			   procfs_exec_handler);
+#endif
+#endif  /* PRFS_STOPEXEC */
+
+  /* Setup traps on exit from sproc() */
+
+#ifdef SYS_sproc
+  procfs_set_syscall_trap (pip, SYS_sproc, PROCFS_SYSCALL_EXIT,
+			   procfs_sproc_handler);
+  procfs_set_syscall_trap (pip, SYS_fork, PROCFS_SYSCALL_EXIT,
+			   procfs_fork_handler);
+#ifdef SYS_vfork
+  procfs_set_syscall_trap (pip, SYS_vfork, PROCFS_SYSCALL_EXIT,
+			   procfs_fork_handler);
+#endif
+/* Turn on inherit-on-fork flag so that all children of the target process
+   start with tracing flags set.  This allows us to trap lwp creation.  Note
+   that we also have to trap on fork and vfork in order to disable all tracing
+   in the targets child processes.  */
+
+  modify_inherit_on_fork_flag (pip->ctl_fd, 1);
+#endif
+
+#ifdef SYS_lwp_create
+  procfs_set_syscall_trap (pip, SYS_lwp_create, PROCFS_SYSCALL_EXIT,
+			   procfs_lwp_creation_handler);
+#endif
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_init_inferior - initialize target vector and access to a
+	/proc entry
+
+SYNOPSIS
+
+	void procfs_init_inferior (int pid)
+
+DESCRIPTION
+
+	When gdb starts an inferior, this function is called in the parent
+	process immediately after the fork.  It waits for the child to stop
+	on the return from the exec system call (the child itself takes care
+	of ensuring that this is set up), then sets up the set of signals
+	and faults that are to be traced.  Returns the pid, which may have had
+	the thread-id added to it.
+
+NOTES
+
+	If proc_init_failed ever gets called, control returns to the command
+	processing loop via the standard error handling code.
+
+ */
+
+static void 
+procfs_init_inferior (pid)
+     int pid;
+{
+  struct procinfo *pip;
+
+  push_target (&procfs_ops);
+
+  pip = create_procinfo (pid);
+
+  procfs_set_inferior_syscall_traps (pip);
+
+  /* create_procinfo may change the pid, so we have to update inferior_pid
+     here before calling other gdb routines that need the right pid.  */
+
+  pid = pip -> pid;
+  inferior_pid = pid;
+
+  add_thread (pip -> pid);	/* Setup initial thread */
+
+#ifdef START_INFERIOR_TRAPS_EXPECTED
+  startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+#else
+  /* One trap to exec the shell, one to exec the program being debugged.  */
+  startup_inferior (2);
+#endif
+}
+
+/*
+
+GLOBAL FUNCTION
+
+	procfs_notice_signals
+
+SYNOPSIS
+
+	static void procfs_notice_signals (int pid);
+
+DESCRIPTION
+
+	When the user changes the state of gdb's signal handling via the
+	"handle" command, this function gets called to see if any change
+	in the /proc interface is required.  It is also called internally
+	by other /proc interface functions to initialize the state of
+	the traced signal set.
+
+	One thing it does is that signals for which the state is "nostop",
+	"noprint", and "pass", have their trace bits reset in the pr_trace
+	field, so that they are no longer traced.  This allows them to be
+	delivered directly to the inferior without the debugger ever being
+	involved.
+ */
+
+static void
+procfs_notice_signals (pid)
+     int pid;
+{
+  struct procinfo *pi;
+  struct sig_ctl  sctl;
+
+  pi = find_procinfo (pid, 0);
+
+#ifndef HAVE_PRRUN_T
+  premptyset (&sctl.sigset);
+#else
+  sctl.sigset = pi->prrun.pr_trace;
+#endif
+
+  notice_signals (pi, &sctl);
+
+#ifdef HAVE_PRRUN_T
+  pi->prrun.pr_trace = sctl.sigset;
+#endif
+}
+
+static void
+notice_signals (pi, sctl)
+	struct procinfo *pi;
+	struct sig_ctl *sctl;
+{
+  int signo;
+
+  for (signo = 0; signo < NSIG; signo++)
+    {
+      if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
+	  signal_print_state (target_signal_from_host (signo)) == 0 &&
+	  signal_pass_state (target_signal_from_host (signo)) == 1)
+	{
+	  prdelset (&sctl->sigset, signo);
+	}
+      else
+	{
+	  praddset (&sctl->sigset, signo);
+	}
+    }
+#ifdef PROCFS_USE_READ_WRITE
+  sctl->cmd = PCSTRACE;
+  if (write (pi->ctl_fd, (char *) sctl, sizeof (struct sig_ctl)) < 0)
+#else
+  if (ioctl (pi->ctl_fd, PIOCSTRACE, &sctl->sigset))
+#endif
+    {
+      print_sys_errmsg ("PIOCSTRACE failed", errno);
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	proc_set_exec_trap -- arrange for exec'd child to halt at startup
+
+SYNOPSIS
+
+	void proc_set_exec_trap (void)
+
+DESCRIPTION
+
+	This function is called in the child process when starting up
+	an inferior, prior to doing the exec of the actual inferior.
+	It sets the child process's exitset to make exit from the exec
+	system call an event of interest to stop on, and then simply
+	returns.  The child does the exec, the system call returns, and
+	the child stops at the first instruction, ready for the gdb
+	parent process to take control of it.
+
+NOTE
+
+	We need to use all local variables since the child may be sharing
+	it's data space with the parent, if vfork was used rather than
+	fork.
+
+	Also note that we want to turn off the inherit-on-fork flag in
+	the child process so that any grand-children start with all
+	tracing flags cleared.
+ */
+
+static void
+proc_set_exec_trap ()
+{
+  struct sys_ctl exitset;
+  struct sys_ctl entryset;
+  char procname[MAX_PROC_NAME_SIZE];
+  int fd;
+  
+  sprintf (procname, CTL_PROC_NAME_FMT, getpid ());
+#ifdef UNIXWARE
+  if ((fd = open (procname, O_WRONLY)) < 0)
+#else
+  if ((fd = open (procname, O_RDWR)) < 0)
+#endif
+    {
+      perror (procname);
+      gdb_flush (gdb_stderr);
+      _exit (127);
+    }
+  premptyset (&exitset.sysset);
+  premptyset (&entryset.sysset);
+
+#ifdef PRFS_STOPEXEC
+  /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
+     exits from exec system calls because of the user level loader.  */
+  {
+    int prfs_flags;
+
+    if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
+      {
+	perror (procname);
+	gdb_flush (gdb_stderr);
+	_exit (127);
+      }
+    prfs_flags |= PRFS_STOPEXEC;
+    if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
+      {
+	perror (procname);
+	gdb_flush (gdb_stderr);
+	_exit (127);
+      }
+  }
+#else /* PRFS_STOPEXEC */
+  /* GW: Rationale...
+     Not all systems with /proc have all the exec* syscalls with the same
+     names.  On the SGI, for example, there is no SYS_exec, but there
+     *is* a SYS_execv.  So, we try to account for that. */
+
+#ifdef SYS_exec
+  praddset (&exitset.sysset, SYS_exec);
+#endif
+#ifdef SYS_execve
+  praddset (&exitset.sysset, SYS_execve);
+#endif
+#ifdef SYS_execv
+  praddset (&exitset.sysset, SYS_execv);
+#endif
+
+#ifdef PROCFS_USE_READ_WRITE
+  exitset.cmd = PCSEXIT;
+  if (write (fd, (char *) &exitset, sizeof (struct sys_ctl)) < 0)
+#else
+  if (ioctl (fd, PIOCSEXIT, &exitset.sysset) < 0)
+#endif
+    {
+      perror (procname);
+      gdb_flush (gdb_stderr);
+      _exit (127);
+    }
+#endif /* PRFS_STOPEXEC */
+
+  praddset (&entryset.sysset, SYS_exit);
+
+#ifdef PROCFS_USE_READ_WRITE
+  entryset.cmd = PCSENTRY;
+  if (write (fd, (char *) &entryset, sizeof (struct sys_ctl)) < 0)
+#else
+  if (ioctl (fd, PIOCSENTRY, &entryset.sysset) < 0)
+#endif
+    {
+      perror (procname);
+      gdb_flush (gdb_stderr);
+      _exit (126);
+    }
+
+  /* Turn off inherit-on-fork flag so that all grand-children of gdb
+     start with tracing flags cleared. */
+
+  modify_inherit_on_fork_flag (fd, 0);
+
+  /* Turn on run-on-last-close flag so that this process will not hang
+     if GDB goes away for some reason.  */
+
+  modify_run_on_last_close_flag (fd, 1);
+
+#ifndef UNIXWARE	/* since this is a solaris-ism, we don't want it */
+			/* NOTE: revisit when doing thread support for UW */
+#ifdef PR_ASYNC
+  {
+    long pr_flags;
+    struct proc_ctl pctl;
+
+/* Solaris needs this to make procfs treat all threads seperately.  Without
+   this, all threads halt whenever something happens to any thread.  Since
+   GDB wants to control all this itself, it needs to set PR_ASYNC.  */
+
+    pr_flags = PR_ASYNC;
+#ifdef PROCFS_USE_READ_WRITE
+    pctl.cmd = PCSET;
+    pctl.data = PR_FORK|PR_ASYNC;
+    write (fd, (char *) &pctl, sizeof (struct proc_ctl));
+#else
+    ioctl (fd, PIOCSET, &pr_flags);
+#endif
+  }
+#endif	/* PR_ASYNC */
+#endif	/* !UNIXWARE */
+}
+
+/*
+
+GLOBAL FUNCTION
+
+	proc_iterate_over_mappings -- call function for every mapped space
+
+SYNOPSIS
+
+	int proc_iterate_over_mappings (int (*func)())
+
+DESCRIPTION
+
+	Given a pointer to a function, call that function for every
+	mapped address space, passing it an open file descriptor for
+	the file corresponding to that mapped address space (if any)
+	and the base address of the mapped space.  Quit when we hit
+	the end of the mappings or the function returns nonzero.
+ */
+
+#ifdef UNIXWARE
+int
+proc_iterate_over_mappings (func)
+     int (*func) PARAMS ((int, CORE_ADDR));
+{
+  int nmap;
+  int fd;
+  int funcstat = 0;
+  prmap_t *prmaps;
+  prmap_t *prmap;
+  struct procinfo *pi;
+  struct stat sbuf;
+
+  pi = current_procinfo;
+
+  if (fstat (pi->map_fd, &sbuf) < 0)
+    return 0;
+
+  nmap = sbuf.st_size / sizeof (prmap_t);
+  prmaps = (prmap_t *) alloca (nmap * sizeof(prmap_t));
+  if ((lseek (pi->map_fd, 0, SEEK_SET) == 0) &&
+	(read (pi->map_fd, (char *) prmaps, nmap * sizeof (prmap_t)) ==
+	(nmap * sizeof (prmap_t))))
+    {
+      int i = 0;
+      for (prmap = prmaps; i < nmap && funcstat == 0; ++prmap, ++i)
+        {
+          char name[sizeof ("/proc/1234567890/object") +
+		sizeof (prmap->pr_mapname)];
+          sprintf (name, "/proc/%d/object/%s", pi->pid, prmap->pr_mapname);
+          if ((fd = open (name, O_RDONLY)) == -1)
+            {
+              funcstat = 1;
+              break;
+            }
+          funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
+          close (fd);
+        }
+    }
+  return (funcstat);
+}
+#else /* UNIXWARE */
+int
+proc_iterate_over_mappings (func)
+     int (*func) PARAMS ((int, CORE_ADDR));
+{
+  int nmap;
+  int fd;
+  int funcstat = 0;
+  struct prmap *prmaps;
+  struct prmap *prmap;
+  struct procinfo *pi;
+
+  pi = current_procinfo;
+
+  if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
+    {
+      prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
+      if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
+	{
+	  for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
+	    {
+	      fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
+	      funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
+	      close (fd);
+	    }
+	}
+    }
+  return (funcstat);
+}
+#endif /* UNIXWARE */
+
+#if 0	/* Currently unused */
+/*
+
+GLOBAL FUNCTION
+
+	proc_base_address -- find base address for segment containing address
+
+SYNOPSIS
+
+	CORE_ADDR proc_base_address (CORE_ADDR addr)
+
+DESCRIPTION
+
+	Given an address of a location in the inferior, find and return
+	the base address of the mapped segment containing that address.
+
+	This is used for example, by the shared library support code,
+	where we have the pc value for some location in the shared library
+	where we are stopped, and need to know the base address of the
+	segment containing that address.
+*/
+
+CORE_ADDR
+proc_base_address (addr)
+     CORE_ADDR addr;
+{
+  int nmap;
+  struct prmap *prmaps;
+  struct prmap *prmap;
+  CORE_ADDR baseaddr = 0;
+  struct procinfo *pi;
+
+  pi = current_procinfo;
+
+  if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
+    {
+      prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
+      if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
+	{
+	  for (prmap = prmaps; prmap -> pr_size; ++prmap)
+	    {
+	      if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
+		  (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
+		{
+		  baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
+		  break;
+		}
+	    }
+	}
+    }
+  return (baseaddr);
+}
+
+#endif	/* 0 */
+
+#ifndef UNIXWARE
+/*
+
+LOCAL FUNCTION
+
+	proc_address_to_fd -- return open fd for file mapped to address
+
+SYNOPSIS
+
+	int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
+
+DESCRIPTION
+
+	Given an address in the current inferior's address space, use the
+	/proc interface to find an open file descriptor for the file that
+	this address was mapped in from.  Return -1 if there is no current
+	inferior.  Print a warning message if there is an inferior but
+	the address corresponds to no file (IE a bogus address).
+
+*/
+
+static int
+proc_address_to_fd (pi, addr, complain)
+     struct procinfo *pi;
+     CORE_ADDR addr;
+     int complain;
+{
+  int fd = -1;
+
+  if ((fd = ioctl (pi->ctl_fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
+    {
+      if (complain)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  warning ("can't find mapped file for address 0x%x", addr);
+	}
+    }
+  return (fd);
+}
+#endif /* !UNIXWARE */
+
+/* Attach to process PID, then initialize for debugging it
+   and wait for the trace-trap that results from attaching.  */
+
+static void
+procfs_attach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  char *exec_file;
+  int pid;
+
+  if (!args)
+    error_no_arg ("process-id to attach");
+
+  pid = atoi (args);
+
+  if (pid == getpid())		/* Trying to masturbate? */
+    error ("I refuse to debug myself!");
+
+  if (from_tty)
+    {
+      exec_file = (char *) get_exec_file (0);
+
+      if (exec_file)
+	printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
+      else
+	printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
+
+      gdb_flush (gdb_stdout);
+    }
+
+  inferior_pid = pid = do_attach (pid);
+  push_target (&procfs_ops);
+}
+
+
+/* Take a program previously attached to and detaches it.
+   The program resumes execution and will no longer stop
+   on signals, etc.  We'd better not have left any breakpoints
+   in the program or it'll die when it hits one.  For this
+   to work, it may be necessary for the process to have been
+   previously attached.  It *might* work if the program was
+   started via the normal ptrace (PTRACE_TRACEME).  */
+
+static void
+procfs_detach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  int siggnal = 0;
+
+  if (from_tty)
+    {
+      char *exec_file = get_exec_file (0);
+      if (exec_file == 0)
+	exec_file = "";
+      printf_unfiltered ("Detaching from program: %s %s\n",
+	      exec_file, target_pid_to_str (inferior_pid));
+      gdb_flush (gdb_stdout);
+    }
+  if (args)
+    siggnal = atoi (args);
+  
+  do_detach (siggnal);
+  inferior_pid = 0;
+  unpush_target (&procfs_ops);		/* Pop out of handling an inferior */
+}
+
+/* Get ready to modify the registers array.  On machines which store
+   individual registers, this doesn't need to do anything.  On machines
+   which store all the registers in one fell swoop, this makes sure
+   that registers contains all the registers from the program being
+   debugged.  */
+
+static void
+procfs_prepare_to_store ()
+{
+#ifdef CHILD_PREPARE_TO_STORE
+  CHILD_PREPARE_TO_STORE ();
+#endif
+}
+
+/* Print status information about what we're accessing.  */
+
+static void
+procfs_files_info (ignore)
+     struct target_ops *ignore;
+{
+  printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
+	  attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
+}
+
+/* ARGSUSED */
+static void
+procfs_open (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  error ("Use the \"run\" command to start a Unix child process.");
+}
+
+/*
+
+LOCAL FUNCTION
+
+	do_attach -- attach to an already existing process
+
+SYNOPSIS
+
+	int do_attach (int pid)
+
+DESCRIPTION
+
+	Attach to an already existing process with the specified process
+	id.  If the process is not already stopped, query whether to
+	stop it or not.
+
+NOTES
+
+	The option of stopping at attach time is specific to the /proc
+	versions of gdb.  Versions using ptrace force the attachee
+	to stop.  (I have changed this version to do so, too.  All you
+	have to do is "continue" to make it go on. -- gnu@cygnus.com)
+
+*/
+
+static int
+do_attach (pid)
+     int pid;
+{
+  struct procinfo *pi;
+  struct sig_ctl sctl;
+  struct flt_ctl fctl;
+  int nlwp, *lwps;
+
+  pi  = init_procinfo (pid, 0);
+
+#ifdef PIOCLWPIDS
+  nlwp = pi->prstatus.pr_nlwp;
+  lwps = alloca ((2 * nlwp + 2) * sizeof (id_t));
+
+  if (ioctl (pi->ctl_fd, PIOCLWPIDS, lwps))
+    {
+      print_sys_errmsg (pi -> pathname, errno);
+      error ("PIOCLWPIDS failed");
+    }
+#else /* PIOCLWPIDS */
+  nlwp = 1;
+  lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
+  lwps[0] = 0;
+#endif
+  for (; nlwp > 0; nlwp--, lwps++)
+    {
+      /* First one has already been created above.  */
+      if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0)
+	pi = init_procinfo ((*lwps << 16) | pid, 0);
+
+      if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
+	{
+	  pi->was_stopped = 1;
+	}
+      else
+	{
+	  pi->was_stopped = 0;
+	  if (1 || query ("Process is currently running, stop it? "))
+	    {
+	      long cmd;
+	      /* Make it run again when we close it.  */
+	      modify_run_on_last_close_flag (pi->ctl_fd, 1);
+#ifdef PROCFS_USE_READ_WRITE
+	      cmd = PCSTOP;
+	      if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
+#else
+	      if (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) < 0)
+#endif
+		{
+		  print_sys_errmsg (pi->pathname, errno);
+		  close_proc_file (pi);
+		  error ("PIOCSTOP failed");
+		}
+#ifdef UNIXWARE
+	      if (!procfs_read_status (pi))
+		{
+		  print_sys_errmsg (pi->pathname, errno);
+		  close_proc_file (pi);
+		  error ("procfs_read_status failed");
+		} 
+#endif
+	      pi->nopass_next_sigstop = 1;
+	    }
+	  else
+	    {
+	      printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", 
+				 target_pid_to_str (pi->pid));
+	    }
+	}
+
+#ifdef PROCFS_USE_READ_WRITE
+      fctl.cmd = PCSFAULT;
+      if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
+	print_sys_errmsg ("PCSFAULT failed", errno);
+#else /* PROCFS_USE_READ_WRITE */
+      if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault))
+	{
+	  print_sys_errmsg ("PIOCSFAULT failed", errno);
+	}
+      if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace))
+	{
+	  print_sys_errmsg ("PIOCSTRACE failed", errno);
+	}
+      add_thread (pi->pid);
+      procfs_set_inferior_syscall_traps (pi);
+#endif /* PROCFS_USE_READ_WRITE */
+    }
+  attach_flag = 1;
+  return (pi->pid);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	do_detach -- detach from an attached-to process
+
+SYNOPSIS
+
+	void do_detach (int signal)
+
+DESCRIPTION
+
+	Detach from the current attachee.
+
+	If signal is non-zero, the attachee is started running again and sent
+	the specified signal.
+
+	If signal is zero and the attachee was not already stopped when we
+	attached to it, then we make it runnable again when we detach.
+
+	Otherwise, we query whether or not to make the attachee runnable
+	again, since we may simply want to leave it in the state it was in
+	when we attached.
+
+	We report any problems, but do not consider them errors, since we
+	MUST detach even if some things don't seem to go right.  This may not
+	be the ideal situation.  (FIXME).
+ */
+
+static void
+do_detach (signal)
+     int signal;
+{
+  struct procinfo *pi;
+
+  for (pi = procinfo_list; pi; pi = pi->next)
+    {
+      if (signal)
+	{
+	  set_proc_siginfo (pi, signal);
+	}
+#ifdef PROCFS_USE_READ_WRITE
+      pi->saved_exitset.cmd = PCSEXIT;
+      if (write (pi->ctl_fd, (char *) &pi->saved_exitset,
+		 sizeof (struct sys_ctl)) < 0)
+#else
+	if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
+#endif
+	  {
+	    print_sys_errmsg (pi->pathname, errno);
+	    printf_unfiltered ("PIOCSEXIT failed.\n");
+	  }
+#ifdef PROCFS_USE_READ_WRITE
+      pi->saved_entryset.cmd = PCSENTRY;
+      if (write (pi->ctl_fd, (char *) &pi->saved_entryset,
+		 sizeof (struct sys_ctl)) < 0)
+#else
+	if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
+#endif
+	  {
+	    print_sys_errmsg (pi->pathname, errno);
+	    printf_unfiltered ("PIOCSENTRY failed.\n");
+	  }
+#ifdef PROCFS_USE_READ_WRITE
+      pi->saved_trace.cmd = PCSTRACE;
+      if (write (pi->ctl_fd, (char *) &pi->saved_trace,
+		 sizeof (struct sig_ctl)) < 0)
+#else
+	if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
+#endif
+	  {
+	    print_sys_errmsg (pi->pathname, errno);
+	    printf_unfiltered ("PIOCSTRACE failed.\n");
+	  }
+#ifndef UNIXWARE
+      if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  printf_unfiltered ("PIOSCHOLD failed.\n");
+	}
+#endif
+#ifdef PROCFS_USE_READ_WRITE
+      pi->saved_fltset.cmd = PCSFAULT;
+      if (write (pi->ctl_fd, (char *) &pi->saved_fltset,
+		 sizeof (struct flt_ctl)) < 0)
+#else
+      if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0)
+#endif
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  printf_unfiltered ("PIOCSFAULT failed.\n");
+	}
+      if (!procfs_read_status (pi))
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  printf_unfiltered ("procfs_read_status failed.\n");
+	}
+      else
+	{
+	  if (signal
+	  || (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
+	    {
+	      long cmd;
+	      struct proc_ctl pctl;
+
+	      if (signal || !pi->was_stopped ||
+		  query ("Was stopped when attached, make it runnable again? "))
+		{
+		  /* Clear any pending signal if we want to detach without
+		     a signal.  */
+		  if (signal == 0)
+		    set_proc_siginfo (pi, signal);
+
+		  /* Clear any fault that might have stopped it.  */
+#ifdef PROCFS_USE_READ_WRITE
+		  cmd = PCCFAULT;
+		  if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
+#else
+		  if (ioctl (pi->ctl_fd, PIOCCFAULT, 0))
+#endif
+		    {
+		      print_sys_errmsg (pi->pathname, errno);
+		      printf_unfiltered ("PIOCCFAULT failed.\n");
+		    }
+
+		  /* Make it run again when we close it.  */
+
+		  modify_run_on_last_close_flag (pi->ctl_fd, 1);
+		}
+	    }
+	}
+      close_proc_file (pi);
+    }
+  attach_flag = 0;
+}
+
+/*  emulate wait() as much as possible.
+    Wait for child to do something.  Return pid of child, or -1 in case
+    of error; store status in *OURSTATUS.
+
+    Not sure why we can't
+    just use wait(), but it seems to have problems when applied to a
+    process being controlled with the /proc interface.
+
+    We have a race problem here with no obvious solution.  We need to let
+    the inferior run until it stops on an event of interest, which means
+    that we need to use the PIOCWSTOP ioctl.  However, we cannot use this
+    ioctl if the process is already stopped on something that is not an
+    event of interest, or the call will hang indefinitely.  Thus we first
+    use PIOCSTATUS to see if the process is not stopped.  If not, then we
+    use PIOCWSTOP.  But during the window between the two, if the process
+    stops for any reason that is not an event of interest (such as a job
+    control signal) then gdb will hang.  One possible workaround is to set
+    an alarm to wake up every minute of so and check to see if the process
+    is still running, and if so, then reissue the PIOCWSTOP.  But this is
+    a real kludge, so has not been implemented.  FIXME: investigate
+    alternatives.
+
+    FIXME:  Investigate why wait() seems to have problems with programs
+    being control by /proc routines.  */
+static int
+procfs_wait (pid, ourstatus)
+     int pid;
+     struct target_waitstatus *ourstatus;
+{
+  short what;
+  short why;
+  int statval = 0;
+  int checkerr = 0;
+  int rtnval = -1;
+  struct procinfo *pi;
+  struct proc_ctl pctl;
+
+scan_again:
+
+  /* handle all syscall events first, otherwise we might not
+     notice a thread was created until too late. */
+
+  for (pi = procinfo_list; pi; pi = pi->next)
+    {
+      if (!pi->had_event)
+	continue;
+
+      if (! (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)) )
+	continue;
+
+      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;
+	  int found_handler = 0;
+
+	  for (i = 0; i < pi->num_syscall_handlers; i++)
+	    if (pi->syscall_handlers[i].syscall_num == what)
+	      {
+		found_handler = 1;
+		pi->saved_rtnval = pi->pid;
+		pi->saved_statval = 0;
+		if (!pi->syscall_handlers[i].func
+		    (pi, what, why, &pi->saved_rtnval, &pi->saved_statval))
+		  pi->had_event = 0;
+		break;
+	      }
+
+	  if (!found_handler)
+	    {
+	      if (why == PR_SYSENTRY)
+		error ("PR_SYSENTRY, unhandled system call %d", what);
+	      else
+		error ("PR_SYSEXIT, unhandled system call %d", what);
+	    }
+	}
+    }
+
+  /* find a relevant process with an event */
+
+  for (pi = procinfo_list; pi; pi = pi->next)
+    if (pi->had_event && (pid == -1 || pi->pid == pid))
+      break;
+
+  if (!pi)
+    {
+      wait_fd ();
+      goto scan_again;
+    }
+
+  if (!checkerr
+  && !(THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
+    {
+      if (!procfs_write_pcwstop (pi))
+	{
+	  checkerr++;
+	}
+    }
+  if (checkerr)
+    {
+      if (errno == ENOENT)
+	{
+	  /* XXX Fixme -- what to do if attached?  Can't call wait... */
+	  rtnval = wait (&statval);
+	  if ((rtnval) != (PIDGET (inferior_pid)))
+	    {
+	      print_sys_errmsg (pi->pathname, errno);
+	      error ("procfs_wait: wait failed, returned %d", rtnval);
+	      /* NOTREACHED */
+	    }
+	}
+      else
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCSTATUS or PIOCWSTOP failed.");
+	  /* NOTREACHED */
+	}
+    }
+  else if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
+    {
+#ifdef UNIXWARE
+      rtnval = pi->prstatus.pr_pid;
+#else
+      rtnval = pi->pid;
+#endif
+      why = THE_PR_LWP(pi->prstatus).pr_why;
+      what = THE_PR_LWP(pi->prstatus).pr_what;
+
+      switch (why)
+	{
+	case PR_SIGNALLED:
+	  statval = (what << 8) | 0177;
+	  break;
+	case PR_SYSENTRY:
+	case PR_SYSEXIT:
+	  rtnval = pi->saved_rtnval;
+	  statval = pi->saved_statval;
+	  break;
+	case PR_REQUESTED:
+	  statval = (SIGSTOP << 8) | 0177;
+	  break;
+	case PR_JOBCONTROL:
+	  statval = (what << 8) | 0177;
+	  break;
+	case PR_FAULTED:
+	  switch (what)
+	    {
+#ifdef FLTWATCH
+	    case FLTWATCH:
+	      statval = (SIGTRAP << 8) | 0177;
+	      break;
+#endif
+#ifdef FLTKWATCH
+	    case FLTKWATCH:
+	      statval = (SIGTRAP << 8) | 0177;
+	      break;
+#endif
+#ifndef FAULTED_USE_SIGINFO
+	      /* Irix, contrary to the documentation, fills in 0 for si_signo.
+		 Solaris fills in si_signo.  I'm not sure about others.  */
+	    case FLTPRIV:
+	    case FLTILL:
+	      statval = (SIGILL << 8) | 0177;
+	      break;
+	    case FLTBPT:
+	    case FLTTRACE:
+	      statval = (SIGTRAP << 8) | 0177;
+	      break;
+	    case FLTSTACK:
+	    case FLTACCESS:
+	    case FLTBOUNDS:
+	      statval = (SIGSEGV << 8) | 0177;
+	      break;
+	    case FLTIOVF:
+	    case FLTIZDIV:
+	    case FLTFPE:
+	      statval = (SIGFPE << 8) | 0177;
+	      break;
+	    case FLTPAGE:		/* Recoverable page fault */
+#endif /* not FAULTED_USE_SIGINFO */
+	    default:
+	      /* 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.  */
+              statval =
+		 ((THE_PR_LWP(pi->prstatus).pr_info.si_signo) << 8) | 0177;
+	      break;
+	    }
+	  break;
+	default:
+	  error ("PIOCWSTOP, unknown why %d, what %d", why, what);
+	}
+      /* Stop all the other threads when any of them stops.  */
+
+      {
+	struct procinfo *procinfo, *next_pi;
+
+	for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
+	  {
+	    next_pi = procinfo->next;
+	    if (!procinfo->had_event)
+	      {
+#ifdef PROCFS_USE_READ_WRITE
+		long cmd = PCSTOP;
+		if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
+		  {
+		    print_sys_errmsg (procinfo->pathname, errno);
+		    error ("PCSTOP failed");
+		  }
+#else
+		/* A bug in Solaris (2.5) causes us to hang when trying to
+		   stop a stopped process.  So, we have to check first in
+		   order to avoid the hang. */
+		if (!procfs_read_status (procinfo))
+		  {
+		    /* The LWP has apparently terminated.  */
+		    if (info_verbose)
+		      printf_filtered ("LWP %d doesn't respond.\n", 
+				       (procinfo->pid >> 16) & 0xffff);
+		    close_proc_file (procinfo);
+		    continue;
+		  }
+
+		if (!(procinfo->prstatus.pr_flags & PR_STOPPED))
+		  if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus)
+		      < 0)
+		    {
+		      print_sys_errmsg (procinfo->pathname, errno);
+		      warning ("PIOCSTOP failed");
+		    }
+#endif
+	      }
+	  }
+      }
+    }
+  else
+    {
+      error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
+	     THE_PR_LWP(pi->prstatus).pr_flags);
+    }
+
+  store_waitstatus (ourstatus, statval);
+
+  if (rtnval == -1)		/* No more children to wait for */
+    {
+      warning ("Child process unexpectedly missing");
+      /* Claim it exited with unknown signal.  */
+      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+      ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+      return rtnval;
+    }
+
+  pi->had_event = 0;		/* Indicate that we've seen this one */
+  return (rtnval);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	set_proc_siginfo - set a process's current signal info
+
+SYNOPSIS
+
+	void set_proc_siginfo (struct procinfo *pip, int signo);
+
+DESCRIPTION
+
+	Given a pointer to a process info struct in PIP and a signal number
+	in SIGNO, set the process's current signal and its associated signal
+	information.  The signal will be delivered to the process immediately
+	after execution is resumed, even if it is being held.  In addition,
+	this particular delivery will not cause another PR_SIGNALLED stop
+	even if the signal is being traced.
+
+	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
+	"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
+	to continue with a different signal.
+
+	Note that when continuing the inferior from a stop due to receipt
+	of a traced signal, we either have set PRCSIG to clear the existing
+	signal, or we have to call this function to do a PIOCSSIG with either
+	the existing siginfo struct from pr_info, or one we have synthesized
+	appropriately for the signal we want to deliver.  Otherwise if the
+	signal is still being traced, the inferior will immediately stop
+	again.
+
+	See siginfo(5) for more details.
+*/
+
+static void
+set_proc_siginfo (pip, signo)
+     struct procinfo *pip;
+     int signo;
+{
+  struct siginfo newsiginfo;
+  struct siginfo *sip;
+  struct sigi_ctl sictl;
+
+#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
+  /* 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.  */
+  if (signo == THE_PR_LWP(pip->prstatus).pr_cursig)
+    return;
+#endif
+
+#ifdef UNIXWARE
+  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 == THE_PR_LWP(pip->prstatus).pr_info.si_signo)
+    {
+      sip = &pip -> prstatus.pr_info;
+    }
+#endif
+  else
+    {
+#ifdef UNIXWARE
+      siginfo_t *sip = &sictl.siginfo;
+      memset ((char *) sip, 0, sizeof (siginfo_t));
+#else
+      memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
+      sip = &newsiginfo;
+#endif
+      sip -> si_signo = signo;
+      sip -> si_code = 0;
+      sip -> si_errno = 0;
+      sip -> si_pid = getpid ();
+      sip -> si_uid = getuid ();
+    }
+#ifdef PROCFS_USE_READ_WRITE
+  sictl.cmd = PCSSIG;
+  if (write (pip->ctl_fd, (char *) &sictl, sizeof (struct sigi_ctl)) < 0)
+#else
+  if (ioctl (pip->ctl_fd, PIOCSSIG, sip) < 0)
+#endif
+    {
+      print_sys_errmsg (pip -> pathname, errno);
+      warning ("PIOCSSIG failed");
+    }
+}
+
+/* Resume execution of process PID.  If STEP is nozero, then
+   just single step it.  If SIGNAL is nonzero, restart it with that
+   signal activated.  */
+
+static void
+procfs_resume (pid, step, signo)
+     int pid;
+     int step;
+     enum target_signal signo;
+{
+  int signal_to_pass;
+  struct procinfo *pi, *procinfo, *next_pi;
+  struct proc_ctl pctl;
+
+  pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
+
+  errno = 0;
+#ifdef UNIXWARE
+  pctl.cmd = PCRUN;
+  pctl.data = PRCFAULT;
+#else
+  pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
+#endif
+
+#if 0
+  /* It should not be necessary.  If the user explicitly changes the value,
+     value_assign calls write_register_bytes, which writes it.  */
+/*	It may not be absolutely necessary to specify the PC value for
+	restarting, but to be safe we use the value that gdb considers
+	to be current.  One case where this might be necessary is if the
+	user explicitly changes the PC value that gdb considers to be
+	current.  FIXME:  Investigate if this is necessary or not.  */
+
+#ifdef PRSVADDR_BROKEN
+/* Can't do this under Solaris running on a Sparc, as there seems to be no
+   place to put nPC.  In fact, if you use this, nPC seems to be set to some
+   random garbage.  We have to rely on the fact that PC and nPC have been
+   written previously via PIOCSREG during a register flush. */
+
+  pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
+  pi->prrun.pr_flags != PRSVADDR;
+#endif
+#endif
+
+  if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
+    /* When attaching to a child process, if we forced it to stop with
+       a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
+       Upon resuming the first time after such a stop, we explicitly
+       inhibit sending it another SIGSTOP, which would be the normal
+       result of default signal handling.  One potential drawback to
+       this is that we will also ignore any attempt to by the user
+       to explicitly continue after the attach with a SIGSTOP.  Ultimately
+       this problem should be dealt with by making the routines that
+       deal with the inferior a little smarter, and possibly even allow
+       an inferior to continue running at the same time as gdb.  (FIXME?)  */
+    signal_to_pass = 0;
+  else if (signo == TARGET_SIGNAL_TSTP
+	   && 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
+       SIG_DFL.  The SIG_DFL action for a SIGTSTP is to stop
+       (notifying the parent via wait()), and then keep going from the
+       same place when the parent is ready for you to keep going.  So
+       under the debugger, it should do nothing (as if the program had
+       been stopped and then later resumed.  Under ptrace, this
+       happens for us, but under /proc, the system obligingly stops
+       the process, and wait_for_inferior would have no way of
+       distinguishing that type of stop (which indicates that we
+       should just start it again), with a stop due to the pr_trace
+       field of the prrun_t struct.
+
+       Note that if the SIGTSTP is being caught, we *do* need to pass it,
+       because the handler needs to get executed.  */
+    signal_to_pass = 0;
+  else
+    signal_to_pass = target_signal_to_host (signo);
+
+  if (signal_to_pass)
+    {
+      set_proc_siginfo (pi, signal_to_pass);
+    }
+  else
+    {
+#ifdef UNIXWARE
+      pctl.data |= PRCSIG;
+#else
+      pi->prrun.pr_flags |= PRCSIG;
+#endif
+    }
+  pi->nopass_next_sigstop = 0;
+  if (step)
+    {
+#ifdef UNIXWARE
+      pctl.data |= PRSTEP;
+#else
+      pi->prrun.pr_flags |= PRSTEP;
+#endif
+    }
+  pi->had_event = 0;
+  /* Don't try to start a process unless it's stopped on an
+     `event of interest'.  Doing so will cause errors.  */
+
+  if (!procfs_read_status (pi))
+    {
+      /* The LWP has apparently terminated.  */
+      if (info_verbose)
+	printf_filtered ("LWP %d doesn't respond.\n", 
+			 (pi->pid >> 16) & 0xffff);
+      close_proc_file (pi);
+    }
+  else
+    {
+#ifdef PROCFS_USE_READ_WRITE
+      if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+#else
+      if ((pi->prstatus.pr_flags & PR_ISTOP)
+	  && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+#endif
+	{
+	  /* The LWP has apparently terminated.  */
+	  if (info_verbose)
+	    printf_filtered ("LWP %d doesn't respond.\n", 
+			     (pi->pid >> 16) & 0xffff);
+	  close_proc_file (pi);
+	}
+    }
+
+  /* Continue all the other threads that haven't had an event of interest.
+     Also continue them if they have NOPASS_NEXT_SIGSTOP set; this is only
+     set by do_attach, and means this is the first resume after an attach.  
+     All threads were CSTOP'd by do_attach, and should be resumed now.  */
+
+  if (pid == -1)
+    for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
+      {
+	next_pi = procinfo->next;
+	if (pi != procinfo)
+	  if (!procinfo->had_event || 
+	      (procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP))
+	    {
+	      procinfo->had_event = procinfo->nopass_next_sigstop = 0;
+#ifdef PROCFS_USE_READ_WRITE
+	      pctl.data = PRCFAULT | PRCSIG;
+	      if (write (procinfo->ctl_fd, (char *) &pctl,
+			 sizeof (struct proc_ctl)) < 0)
+		{
+		  if (!procfs_read_status (procinfo))
+		    fprintf_unfiltered(gdb_stderr, 
+				       "procfs_read_status failed, errno=%d\n",
+				       errno);
+		  print_sys_errmsg (procinfo->pathname, errno);
+		  error ("PCRUN failed");
+		}
+#else
+	      procinfo->prrun.pr_flags &= PRSTEP;
+	      procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
+	      if (!procfs_read_status (procinfo))
+		{
+		  /* The LWP has apparently terminated.  */
+		  if (info_verbose)
+		    printf_filtered ("LWP %d doesn't respond.\n", 
+				     (procinfo->pid >> 16) & 0xffff);
+		  close_proc_file (procinfo);
+		  continue;
+		}
+
+	      /* Don't try to start a process unless it's stopped on an
+		 `event of interest'.  Doing so will cause errors.  */
+
+	      if ((procinfo->prstatus.pr_flags & PR_ISTOP)
+		  && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0)
+		{
+		  if (!procfs_read_status (procinfo))
+		    fprintf_unfiltered(gdb_stderr, 
+				       "procfs_read_status failed, errno=%d\n",
+				       errno);
+		  print_sys_errmsg (procinfo->pathname, errno);
+		  warning ("PIOCRUN failed");
+		}
+#endif
+	    }
+	procfs_read_status (procinfo);
+      }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_fetch_registers -- fetch current registers from inferior
+
+SYNOPSIS
+
+	void procfs_fetch_registers (int regno)
+
+DESCRIPTION
+
+	Read the current values of the inferior's registers, both the
+	general register set and floating point registers (if supported)
+	and update gdb's idea of their current values.
+
+*/
+
+static void
+procfs_fetch_registers (regno)
+     int regno;
+{
+  struct procinfo *pi;
+
+  pi = current_procinfo;
+
+#ifdef UNIXWARE
+  if (procfs_read_status (pi))
+    {
+      supply_gregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
+#if defined (FP0_REGNUM)
+      supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs); 
+#endif
+    }
+#else /* UNIXWARE */
+  if (ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset) != -1)
+    {
+      supply_gregset (&pi->gregset.gregset);
+    }
+#if defined (FP0_REGNUM)
+  if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset) != -1)
+    {
+      supply_fpregset (&pi->fpregset.fpregset);
+    }
+#endif
+#endif /* UNIXWARE */
+}
+
+/*
+
+LOCAL FUNCTION
+
+	proc_init_failed - called when /proc access initialization fails
+fails
+
+SYNOPSIS
+
+	static void proc_init_failed (struct procinfo *pi, 
+				      char *why, int kill_p)
+
+DESCRIPTION
+
+	This function is called whenever initialization of access to a /proc
+	entry fails.  It prints a suitable error message, does some cleanup,
+	and then invokes the standard error processing routine which dumps
+	us back into the command loop.  If KILL_P is true, sends SIGKILL.
+ */
+
+static void
+proc_init_failed (pi, why, kill_p)
+     struct procinfo *pi;
+     char *why;
+     int  kill_p;
+{
+  print_sys_errmsg (pi->pathname, errno);
+  if (kill_p)
+    kill (pi->pid, SIGKILL);
+  close_proc_file (pi);
+  error (why);
+  /* NOTREACHED */
+}
+
+/*
+
+LOCAL FUNCTION
+
+	close_proc_file - close any currently open /proc entry
+
+SYNOPSIS
+
+	static void close_proc_file (struct procinfo *pip)
+
+DESCRIPTION
+
+	Close any currently open /proc entry and mark the process information
+	entry as invalid.  In order to ensure that we don't try to reuse any
+	stale information, the pid, fd, and pathnames are explicitly
+	invalidated, which may be overkill.
+
+ */
+
+static void
+close_proc_file (pip)
+     struct procinfo *pip;
+{
+  struct procinfo *procinfo;
+
+  delete_thread (pip->pid);	/* remove thread from GDB's thread list */
+  remove_fd (pip);		/* Remove fd from poll/select list */
+
+  close (pip->ctl_fd);
+#ifdef HAVE_MULTIPLE_PROC_FDS
+  close (pip->as_fd);
+  close (pip->status_fd);
+  close (pip->map_fd);
+#endif
+
+  free (pip -> pathname);
+
+  /* Unlink pip from the procinfo chain.  Note pip might not be on the list. */
+
+  if (procinfo_list == pip)
+    procinfo_list = pip->next;
+  else
+    {
+      for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
+        {
+          if (procinfo->next == pip)
+	    {
+	      procinfo->next = pip->next;
+	      break;
+	    }
+        }
+      free (pip);
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	open_proc_file - open a /proc entry for a given process id
+
+SYNOPSIS
+
+	static int open_proc_file (int pid, struct procinfo *pip, int mode)
+
+DESCRIPTION
+
+	Given a process id and a mode, close the existing open /proc
+	entry (if any) and open one for the new process id, in the
+	specified mode.  Once it is open, then mark the local process
+	information structure as valid, which guarantees that the pid,
+	fd, and pathname fields match an open /proc entry.  Returns
+	zero if the open fails, nonzero otherwise.
+
+	Note that the pathname is left intact, even when the open fails,
+	so that callers can use it to construct meaningful error messages
+	rather than just "file open failed".
+
+	Note that for Solaris, the process-id also includes an LWP-id, so we
+	actually attempt to open that.  If we are handed a pid with a 0 LWP-id,
+	then we will ask the kernel what it is and add it to the pid.  Hence,
+	the pid can be changed by us.
+ */
+
+static int
+open_proc_file (pid, pip, mode, control)
+     int pid;
+     struct procinfo *pip;
+     int mode;
+     int control;
+{
+  int tmp, tmpfd;
+
+  pip -> next = NULL;
+  pip -> had_event = 0;
+  pip -> pathname = xmalloc (MAX_PROC_NAME_SIZE);
+  pip -> pid = pid;
+
+#ifndef PIOCOPENLWP
+  tmp = pid;
+#else
+  tmp = pid & 0xffff;
+#endif
+
+#ifdef HAVE_MULTIPLE_PROC_FDS
+  sprintf (pip->pathname, STATUS_PROC_NAME_FMT, tmp);
+  if ((pip->status_fd = open (pip->pathname, O_RDONLY)) < 0)
+    {
+      return 0;
+    }
+
+  sprintf (pip->pathname, AS_PROC_NAME_FMT, tmp);
+  if ((pip->as_fd = open (pip->pathname, O_RDWR)) < 0)
+    {
+      close (pip->status_fd);
+      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);
+      if ((pip->ctl_fd = open (pip->pathname, O_WRONLY)) < 0)
+	{
+	  close (pip->status_fd);
+          close (pip->as_fd);
+          close (pip->map_fd);
+          return 0;
+        }
+    }
+
+#else /* HAVE_MULTIPLE_PROC_FDS */
+  sprintf (pip -> pathname, CTL_PROC_NAME_FMT, tmp);
+
+  if ((tmpfd = open (pip -> pathname, mode)) < 0)
+    return 0;
+
+#ifndef PIOCOPENLWP
+    pip -> ctl_fd = tmpfd;
+    pip -> as_fd = tmpfd;
+    pip -> map_fd = tmpfd;
+    pip -> status_fd = tmpfd;
+#else
+  tmp = (pid >> 16) & 0xffff;	/* Extract thread id */
+
+  if (tmp == 0)
+    {				/* Don't know thread id yet */
+      if (ioctl (tmpfd, PIOCSTATUS, &pip -> prstatus) < 0)
+	{
+	  print_sys_errmsg (pip -> pathname, errno);
+	  close (tmpfd);
+	  error ("open_proc_file: PIOCSTATUS failed");
+	}
+
+      tmp = pip -> prstatus.pr_who; /* Get thread id from prstatus_t */
+      pip -> pid = (tmp << 16) | pid; /* Update pip */
+    }
+
+  if ((pip -> ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
+    {
+      close (tmpfd);
+      return 0;
+    }
+
+#ifdef PIOCSET			/* New method */
+  {
+      long pr_flags;
+      pr_flags = PR_ASYNC;
+      ioctl (pip -> ctl_fd, PIOCSET, &pr_flags);
+  }
+#endif
+
+  /* keep extra fds in sync */
+  pip->as_fd = pip->ctl_fd;
+  pip->map_fd = pip->ctl_fd;
+  pip->status_fd = pip->ctl_fd;
+
+  close (tmpfd);		/* All done with main pid */
+#endif	/* PIOCOPENLWP */
+
+#endif /* HAVE_MULTIPLE_PROC_FDS */
+
+  return 1;
+}
+
+static char *
+mappingflags (flags)
+     long flags;
+{
+  static char asciiflags[8];
+  
+  strcpy (asciiflags, "-------");
+#if defined (MA_PHYS)
+  if (flags & MA_PHYS)   asciiflags[0] = 'd';
+#endif
+  if (flags & MA_STACK)  asciiflags[1] = 's';
+  if (flags & MA_BREAK)  asciiflags[2] = 'b';
+  if (flags & MA_SHARED) asciiflags[3] = 's';
+  if (flags & MA_READ)   asciiflags[4] = 'r';
+  if (flags & MA_WRITE)  asciiflags[5] = 'w';
+  if (flags & MA_EXEC)   asciiflags[6] = 'x';
+  return (asciiflags);
+}
+
+static void
+info_proc_flags (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  struct trans *transp;
+#ifdef UNIXWARE
+  long flags = pip->prstatus.pr_flags | pip->prstatus.pr_lwp.pr_flags;
+#else
+  long flags = pip->prstatus.pr_flags;
+#endif
+
+  printf_filtered ("%-32s", "Process status flags:");
+  if (!summary)
+    {
+      printf_filtered ("\n\n");
+    }
+  for (transp = pr_flag_table; transp -> name != NULL; transp++)
+    {
+      if (flags & transp -> value)
+	{
+	  if (summary)
+	    {
+	      printf_filtered ("%s ", transp -> name);
+	    }
+	  else
+	    {
+	      printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
+	    }
+	}
+    }
+  printf_filtered ("\n");
+}
+
+static void
+info_proc_stop (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  struct trans *transp;
+  int why;
+  int what;
+
+  why = THE_PR_LWP(pip->prstatus).pr_why;
+  what = THE_PR_LWP(pip->prstatus).pr_what;
+
+  if (THE_PR_LWP(pip->prstatus).pr_flags & PR_STOPPED)
+    {
+      printf_filtered ("%-32s", "Reason for stopping:");
+      if (!summary)
+	{
+	  printf_filtered ("\n\n");
+	}
+      for (transp = pr_why_table; transp -> name != NULL; transp++)
+	{
+	  if (why == transp -> value)
+	    {
+	      if (summary)
+		{
+		  printf_filtered ("%s ", transp -> name);
+		}
+	      else
+		{
+		  printf_filtered ("\t%-16s %s.\n",
+				   transp -> name, transp -> desc);
+		}
+	      break;
+	    }
+	}
+      
+      /* Use the pr_why field to determine what the pr_what field means, and
+	 print more information. */
+      
+      switch (why)
+	{
+	  case PR_REQUESTED:
+	    /* pr_what is unused for this case */
+	    break;
+	  case PR_JOBCONTROL:
+	  case PR_SIGNALLED:
+	    if (summary)
+	      {
+		printf_filtered ("%s ", signalname (what));
+	      }
+	    else
+	      {
+		printf_filtered ("\t%-16s %s.\n", signalname (what),
+				 safe_strsignal (what));
+	      }
+	    break;
+	  case PR_SYSENTRY:
+	    if (summary)
+	      {
+		printf_filtered ("%s ", syscallname (what));
+	      }
+	    else
+	      {
+		printf_filtered ("\t%-16s %s.\n", syscallname (what),
+				 "Entered this system call");
+	      }
+	    break;
+	  case PR_SYSEXIT:
+	    if (summary)
+	      {
+		printf_filtered ("%s ", syscallname (what));
+	      }
+	    else
+	      {
+		printf_filtered ("\t%-16s %s.\n", syscallname (what),
+				 "Returned from this system call");
+	      }
+	    break;
+	  case PR_FAULTED:
+	    if (summary)
+	      {
+		printf_filtered ("%s ",
+				 lookupname (faults_table, what, "fault"));
+	      }
+	    else
+	      {
+		printf_filtered ("\t%-16s %s.\n",
+				 lookupname (faults_table, what, "fault"),
+				 lookupdesc (faults_table, what));
+	      }
+	    break;
+	  }
+      printf_filtered ("\n");
+    }
+}
+
+static void
+info_proc_siginfo (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  struct siginfo *sip;
+
+  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:");
+      sip = &(THE_PR_LWP(pip->prstatus).pr_info);
+      if (summary)
+	{
+	  printf_filtered ("%s ", signalname (sip -> si_signo));
+	  if (sip -> si_errno > 0)
+	    {
+	      printf_filtered ("%s ", errnoname (sip -> si_errno));
+	    }
+	  if (sip -> si_code <= 0)
+	    {
+	      printf_filtered ("sent by %s, uid %d ",
+			       target_pid_to_str (sip -> si_pid),
+			       sip -> si_uid);
+	    }
+	  else
+	    {
+	      printf_filtered ("%s ", sigcodename (sip));
+	      if ((sip -> si_signo == SIGILL) ||
+		  (sip -> si_signo == SIGFPE) ||
+		  (sip -> si_signo == SIGSEGV) ||
+		  (sip -> si_signo == SIGBUS))
+		{
+		  printf_filtered ("addr=%#lx ",
+				   (unsigned long) sip -> si_addr);
+		}
+	      else if ((sip -> si_signo == SIGCHLD))
+		{
+		  printf_filtered ("child %s, status %u ",
+				   target_pid_to_str (sip -> si_pid),
+				   sip -> si_status);
+		}
+	      else if ((sip -> si_signo == SIGPOLL))
+		{
+		  printf_filtered ("band %u ", sip -> si_band);
+		}
+	    }
+	}
+      else
+	{
+	  printf_filtered ("\n\n");
+	  printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
+			   safe_strsignal (sip -> si_signo));
+	  if (sip -> si_errno > 0)
+	    {
+	      printf_filtered ("\t%-16s %s.\n",
+			       errnoname (sip -> si_errno),
+			       safe_strerror (sip -> si_errno));
+	    }
+	  if (sip -> si_code <= 0)
+	    {
+	      printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
+			       "PID of process sending signal");
+	      printf_filtered ("\t%-16u %s\n", sip -> si_uid,
+			       "UID of process sending signal");
+	    }
+	  else
+	    {
+	      printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
+			       sigcodedesc (sip));
+	      if ((sip -> si_signo == SIGILL) ||
+		  (sip -> si_signo == SIGFPE))
+		{
+		  printf_filtered ("\t%#-16lx %s.\n",
+				   (unsigned long) sip -> si_addr,
+				   "Address of faulting instruction");
+		}
+	      else if ((sip -> si_signo == SIGSEGV) ||
+		       (sip -> si_signo == SIGBUS))
+		{
+		  printf_filtered ("\t%#-16lx %s.\n",
+				   (unsigned long) sip -> si_addr,
+				   "Address of faulting memory reference");
+		}
+	      else if ((sip -> si_signo == SIGCHLD))
+		{
+		  printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
+				   "Child process ID");
+		  printf_filtered ("\t%-16u %s.\n", sip -> si_status,
+				   "Child process exit value or signal");
+		}
+	      else if ((sip -> si_signo == SIGPOLL))
+		{
+		  printf_filtered ("\t%-16u %s.\n", sip -> si_band,
+				   "Band event for POLL_{IN,OUT,MSG}");
+		}
+	    }
+	}
+      printf_filtered ("\n");
+    }
+}
+
+static void
+info_proc_syscalls (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  int syscallnum;
+
+  if (!summary)
+    {
+
+#if 0	/* FIXME:  Needs to use gdb-wide configured info about system calls. */
+      if (pip -> prstatus.pr_flags & PR_ASLEEP)
+	{
+	  int syscallnum = pip -> prstatus.pr_reg[R_D0];
+	  if (summary)
+	    {
+	      printf_filtered ("%-32s", "Sleeping in system call:");
+	      printf_filtered ("%s", syscallname (syscallnum));
+	    }
+	  else
+	    {
+	      printf_filtered ("Sleeping in system call '%s'.\n",
+			       syscallname (syscallnum));
+	    }
+	}
+#endif
+
+#ifndef UNIXWARE
+      if (ioctl (pip -> ctl_fd, PIOCGENTRY, &pip -> entryset) < 0)
+	{
+	  print_sys_errmsg (pip -> pathname, errno);
+	  error ("PIOCGENTRY failed");
+	}
+      
+      if (ioctl (pip -> ctl_fd, PIOCGEXIT, &pip -> exitset) < 0)
+	{
+	  print_sys_errmsg (pip -> pathname, errno);
+	  error ("PIOCGEXIT failed");
+	}
+#endif
+      
+      printf_filtered ("System call tracing information:\n\n");
+      
+      printf_filtered ("\t%-12s %-8s %-8s\n",
+		       "System call",
+		       "Entry",
+		       "Exit");
+      for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
+	{
+	  QUIT;
+	  if (syscall_table[syscallnum] != NULL)
+	    printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
+	  else
+	    printf_filtered ("\t%-12d ", syscallnum);
+
+#ifdef UNIXWARE
+	  printf_filtered ("%-8s ",
+			   prismember (&pip->prstatus.pr_sysentry, syscallnum)
+			   ? "on" : "off");
+	  printf_filtered ("%-8s ",
+			   prismember (&pip->prstatus.pr_sysexit, syscallnum)
+			   ? "on" : "off");
+#else
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> entryset, syscallnum)
+			   ? "on" : "off");
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> exitset, syscallnum)
+			   ? "on" : "off");
+#endif
+	  printf_filtered ("\n");
+	}
+      printf_filtered ("\n");
+    }
+}
+
+static char *
+signalname (signo)
+     int signo;
+{
+  const char *name;
+  static char locbuf[32];
+
+  name = strsigno (signo);
+  if (name == NULL)
+    {
+      sprintf (locbuf, "Signal %d", signo);
+    }
+  else
+    {
+      sprintf (locbuf, "%s (%d)", name, signo);
+    }
+  return (locbuf);
+}
+
+static char *
+errnoname (errnum)
+     int errnum;
+{
+  const char *name;
+  static char locbuf[32];
+
+  name = strerrno (errnum);
+  if (name == NULL)
+    {
+      sprintf (locbuf, "Errno %d", errnum);
+    }
+  else
+    {
+      sprintf (locbuf, "%s (%d)", name, errnum);
+    }
+  return (locbuf);
+}
+
+static void
+info_proc_signals (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  int signo;
+
+  if (!summary)
+    {
+#ifndef PROCFS_USE_READ_WRITE
+      if (ioctl (pip -> ctl_fd, PIOCGTRACE, &pip -> trace) < 0)
+	{
+	  print_sys_errmsg (pip -> pathname, errno);
+	  error ("PIOCGTRACE failed");
+	}
+#endif
+      
+      printf_filtered ("Disposition of signals:\n\n");
+      printf_filtered ("\t%-15s %-8s %-8s %-8s  %s\n\n",
+		       "Signal", "Trace", "Hold", "Pending", "Description");
+      for (signo = 0; signo < NSIG; signo++)
+	{
+	  QUIT;
+	  printf_filtered ("\t%-15s ", signalname (signo));
+#ifdef UNIXWARE
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> prstatus.pr_sigtrace, signo)
+			   ? "on" : "off");
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> prstatus.pr_lwp.pr_context.uc_sigmask, signo)
+			   ? "on" : "off");
+#else
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> trace, signo)
+			   ? "on" : "off");
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> prstatus.pr_sighold, signo)
+			   ? "on" : "off");
+#endif
+
+#ifdef UNIXWARE
+	  if (prismember (&pip->prstatus.pr_sigpend, signo) ||
+		prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
+	    printf_filtered("%-8s ", "yes");
+	  else
+	    printf_filtered("%-8s ", "no");
+#else /* UNIXWARE */
+#ifdef PROCFS_SIGPEND_OFFSET
+	  /* Alpha OSF/1 numbers the pending signals from 1.  */
+	  printf_filtered ("%-8s ",
+			   (signo ? prismember (&pip -> prstatus.pr_sigpend,
+						signo - 1)
+				  : 0)
+			   ? "yes" : "no");
+#else
+	  printf_filtered ("%-8s ",
+			   prismember (&pip -> prstatus.pr_sigpend, signo)
+			   ? "yes" : "no");
+#endif
+#endif /* UNIXWARE */
+	  printf_filtered (" %s\n", safe_strsignal (signo));
+	}
+      printf_filtered ("\n");
+    }
+}
+
+static void
+info_proc_faults (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  struct trans *transp;
+
+  if (!summary)
+    {
+#ifndef UNIXWARE
+      if (ioctl (pip -> ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
+	{
+	  print_sys_errmsg (pip -> pathname, errno);
+	  error ("PIOCGFAULT failed");
+	}
+#endif
+      
+      printf_filtered ("Current traced hardware fault set:\n\n");
+      printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
+
+      for (transp = faults_table; transp -> name != NULL; transp++)
+	{
+	  QUIT;
+	  printf_filtered ("\t%-12s ", transp -> name);
+#ifdef UNIXWARE
+	  printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp -> value)
+			   ? "on" : "off");
+#else
+	  printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp -> value)
+			   ? "on" : "off");
+#endif
+	  printf_filtered ("\n");
+	}
+      printf_filtered ("\n");
+    }
+}
+
+static void
+info_proc_mappings (pip, summary)
+     struct procinfo *pip;
+     int summary;
+{
+  int nmap;
+  struct prmap *prmaps;
+  struct prmap *prmap;
+  struct stat sbuf;
+
+  if (!summary)
+    {
+      printf_filtered ("Mapped address spaces:\n\n");
+#ifdef BFD_HOST_64_BIT
+      printf_filtered ("  %18s %18s %10s %10s %7s\n",
+#else
+      printf_filtered ("\t%10s %10s %10s %10s %7s\n",
+#endif
+		       "Start Addr",
+		       "  End Addr",
+		       "      Size",
+		       "    Offset",
+		       "Flags");
+#ifdef PROCFS_USE_READ_WRITE
+      if (fstat (pip->map_fd, &sbuf) == 0)
+        {
+          nmap = sbuf.st_size / sizeof (prmap_t);
+	  prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
+          if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
+		(read (pip->map_fd, (char *) prmaps,
+		nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
+	    {
+	      int i = 0;
+	      for (prmap = prmaps; i < nmap; ++prmap, ++i)
+#else
+      if (ioctl (pip -> ctl_fd, PIOCNMAP, &nmap) == 0)
+	{
+	  prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
+	  if (ioctl (pip -> ctl_fd, PIOCMAP, prmaps) == 0)
+	    {
+	      for (prmap = prmaps; prmap -> pr_size; ++prmap)
+#endif /* PROCFS_USE_READ_WRITE */
+		{
+#ifdef BFD_HOST_64_BIT
+		  printf_filtered ("  %#18lx %#18lx %#10x %#10x %7s\n",
+#else
+		  printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
+#endif
+				   (unsigned long)prmap -> pr_vaddr,
+				   (unsigned long)prmap -> pr_vaddr
+				     + prmap -> pr_size - 1,
+				   prmap -> pr_size,
+				   prmap -> pr_off,
+				   mappingflags (prmap -> pr_mflags));
+		}
+	    }
+	}
+      printf_filtered ("\n");
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+	info_proc -- implement the "info proc" command
+
+SYNOPSIS
+
+	void info_proc (char *args, int from_tty)
+
+DESCRIPTION
+
+	Implement gdb's "info proc" command by using the /proc interface
+	to print status information about any currently running process.
+
+	Examples of the use of "info proc" are:
+
+	info proc		(prints summary info for current inferior)
+	info proc 123		(prints summary info for process with pid 123)
+	info proc mappings	(prints address mappings)
+	info proc times		(prints process/children times)
+	info proc id		(prints pid, ppid, gid, sid, etc)
+		FIXME:  i proc id not implemented.
+	info proc status	(prints general process state info)
+		FIXME:  i proc status not implemented.
+	info proc signals	(prints info about signal handling)
+	info proc all		(prints all info)
+
+ */
+
+static void
+info_proc (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  int pid;
+  struct procinfo *pip;
+  struct cleanup *old_chain;
+  char **argv;
+  int argsize;
+  int summary = 1;
+  int flags = 0;
+  int syscalls = 0;
+  int signals = 0;
+  int faults = 0;
+  int mappings = 0;
+  int times = 0;
+  int id = 0;
+  int status = 0;
+  int all = 0;
+  int nlwp;
+  int *lwps;
+
+  old_chain = make_cleanup (null_cleanup, 0);
+
+  /* Default to using the current inferior if no pid specified.  Note
+     that inferior_pid may be 0, hence we set okerr.  */
+
+  pid = inferior_pid & 0x7fffffff;		/* strip off sol-thread bit */
+  if (!(pip = find_procinfo (pid, 1)))		/* inferior_pid no good?  */
+    pip = procinfo_list;			/* take first available */
+  pid = pid & 0xffff;				/* extract "real" pid */
+
+  if (args != NULL)
+    {
+      if ((argv = buildargv (args)) == NULL)
+	{
+	  nomem (0);
+	}
+      make_cleanup (freeargv, (char *) argv);
+
+      while (*argv != NULL)
+	{
+	  argsize = strlen (*argv);
+	  if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
+	    {
+	      summary = 0;
+	      all = 1;
+	    }
+	  else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
+	    {
+	      summary = 0;
+	      faults = 1;
+	    }
+	  else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
+	    {
+	      summary = 0;
+	      flags = 1;
+	    }
+	  else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
+	    {
+	      summary = 0;
+	      id = 1;
+	    }
+	  else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
+	    {
+	      summary = 0;
+	      mappings = 1;
+	    }
+	  else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
+	    {
+	      summary = 0;
+	      signals = 1;
+	    }
+	  else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
+	    {
+	      summary = 0;
+	      status = 1;
+	    }
+	  else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
+	    {
+	      summary = 0;
+	      syscalls = 1;
+	    }
+	  else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
+	    {
+	      summary = 0;
+	      times = 1;
+	    }
+	  else if ((pid = atoi (*argv)) > 0)
+	    {
+	      pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
+	      memset (pip, 0, sizeof (*pip));
+
+	      pip->pid = pid;
+	      if (!open_proc_file (pid, pip, O_RDONLY, 0))
+		{
+		  perror_with_name (pip -> pathname);
+		  /* NOTREACHED */
+		}
+	      pid = pip->pid;
+	      make_cleanup (close_proc_file, pip);
+	    }
+	  else if (**argv != '\000')
+	    {
+	      error ("Unrecognized or ambiguous keyword `%s'.", *argv);
+	    }
+	  argv++;
+	}
+    }
+
+  /* If we don't have a valid open process at this point, then we have no
+     inferior or didn't specify a specific pid. */
+
+  if (!pip)
+    {
+      error ("\
+No process.  Start debugging a program or specify an explicit process ID.");
+    }
+
+  if (!procfs_read_status (pip))
+    {
+      print_sys_errmsg (pip -> pathname, errno);
+      error ("procfs_read_status failed");
+    }
+
+#ifndef PROCFS_USE_READ_WRITE
+#ifdef PIOCLWPIDS
+  nlwp = pip->prstatus.pr_nlwp;
+  lwps = alloca ((2 * nlwp + 2) * sizeof (*lwps));
+
+  if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps))
+    {
+      print_sys_errmsg (pip -> pathname, errno);
+      error ("PIOCLWPIDS failed");
+    }
+#else /* PIOCLWPIDS */
+  nlwp = 1;
+  lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
+  lwps[0] = 0;
+#endif /* PIOCLWPIDS */
+
+  for (; nlwp > 0; nlwp--, lwps++)
+    {
+      pip = find_procinfo ((*lwps << 16) | pid, 1);
+
+      if (!pip)
+	{
+	  pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
+	  memset (pip, 0, sizeof (*pip));
+	  if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
+	    continue;
+
+	  make_cleanup (close_proc_file, pip);
+
+	  if (!procfs_read_status (pip))
+	    {
+	      print_sys_errmsg (pip -> pathname, errno);
+	      error ("procfs_read_status failed");
+	    }
+	}
+
+#endif /* PROCFS_USE_READ_WRITE */
+
+      /* Print verbose information of the requested type(s), or just a summary
+	 of the information for all types. */
+
+      printf_filtered ("\nInformation for %s.%d:\n\n", pip -> pathname, *lwps);
+      if (summary || all || flags)
+	{
+	  info_proc_flags (pip, summary);
+	}
+      if (summary || all)
+	{
+	  info_proc_stop (pip, summary);
+#ifdef UNIXWARE
+	  supply_gregset (&pip->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
+#else
+	  supply_gregset (&pip->prstatus.pr_reg);
+#endif
+	  printf_filtered ("PC: ");
+	  print_address (read_pc (), gdb_stdout);
+	  printf_filtered ("\n");
+	}
+      if (summary || all || signals || faults)
+	{
+	  info_proc_siginfo (pip, summary);
+	}
+      if (summary || all || syscalls)
+	{
+	  info_proc_syscalls (pip, summary);
+	}
+      if (summary || all || mappings)
+	{
+	  info_proc_mappings (pip, summary);
+	}
+      if (summary || all || signals)
+	{
+	  info_proc_signals (pip, summary);
+	}
+      if (summary || all || faults)
+	{
+	  info_proc_faults (pip, summary);
+	}
+      printf_filtered ("\n");
+
+      /* All done, deal with closing any temporary process info structure,
+	 freeing temporary memory , etc. */
+
+      do_cleanups (old_chain);
+#ifndef PROCFS_USE_READ_WRITE
+    }
+#endif
+}
+
+/*
+
+LOCAL FUNCTION
+
+	modify_inherit_on_fork_flag - Change the inherit-on-fork flag
+
+SYNOPSIS
+
+	void modify_inherit_on_fork_flag (fd, flag)
+
+DESCRIPTION
+
+	Call this routine to modify the inherit-on-fork flag.  This routine is
+	just a nice wrapper to hide the #ifdefs needed by various systems to
+	control this flag.
+
+ */
+
+static void
+modify_inherit_on_fork_flag (fd, flag)
+     int fd;
+     int flag;
+{
+#if defined (PIOCSET) || defined (PCSET)
+  long pr_flags;
+#endif
+  int retval = 0;
+  struct proc_ctl pctl;
+
+#if defined (PIOCSET) || defined (PCSET)	/* New method */
+  pr_flags = PR_FORK;
+  if (flag)
+    {
+#ifdef PROCFS_USE_READ_WRITE
+      pctl.cmd = PCSET;
+      pctl.data = PR_FORK;
+      if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+	retval = -1;
+#else
+      retval = ioctl (fd, PIOCSET, &pr_flags);
+#endif
+    }
+  else
+    {
+#ifdef PROCFS_USE_READ_WRITE
+      pctl.cmd = PCRESET;
+      pctl.data = PR_FORK;
+      if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+	retval = -1;
+#else
+      retval = ioctl (fd, PIOCRESET, &pr_flags);
+#endif
+    }
+
+#else
+#ifdef PIOCSFORK		/* Original method */
+  if (flag)
+    {
+      retval = ioctl (fd, PIOCSFORK, NULL);
+    }
+  else
+    {
+      retval = ioctl (fd, PIOCRFORK, NULL);
+    }
+#else
+  Neither PR_FORK nor PIOCSFORK exist!!!
+#endif
+#endif
+
+  if (!retval)
+    return;
+
+  print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
+  error ("PIOCSFORK or PR_FORK modification failed");
+}
+
+/*
+
+LOCAL FUNCTION
+
+	modify_run_on_last_close_flag - Change the run-on-last-close flag
+
+SYNOPSIS
+
+	void modify_run_on_last_close_flag (fd, flag)
+
+DESCRIPTION
+
+	Call this routine to modify the run-on-last-close flag.  This routine
+	is just a nice wrapper to hide the #ifdefs needed by various systems to
+	control this flag.
+
+ */
+
+static void
+modify_run_on_last_close_flag (fd, flag)
+     int fd;
+     int flag;
+{
+#if defined (PIOCSET) || defined (PCSET)
+  long pr_flags;
+#endif
+  int retval = 0;
+  struct proc_ctl pctl;
+
+#if defined (PIOCSET) || defined (PCSET)	/* New method */
+  pr_flags = PR_RLC;
+  if (flag)
+    {
+#ifdef PROCFS_USE_READ_WRITE
+      pctl.cmd = PCSET;
+      pctl.data = PR_RLC;
+      if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+	retval = -1;
+#else
+      retval = ioctl (fd, PIOCSET, &pr_flags);
+#endif
+    }
+  else
+    {
+#ifdef PROCFS_USE_READ_WRITE
+      pctl.cmd = PCRESET;
+      pctl.data = PR_RLC;
+      if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+	retval = -1;
+#else
+      retval = ioctl (fd, PIOCRESET, &pr_flags);
+#endif
+    }
+
+#else
+#ifdef PIOCSRLC			/* Original method */
+  if (flag)
+    retval = ioctl (fd, PIOCSRLC, NULL);
+  else
+    retval = ioctl (fd, PIOCRRLC, NULL);
+#else
+  Neither PR_RLC nor PIOCSRLC exist!!!
+#endif
+#endif
+
+  if (!retval)
+    return;
+
+  print_sys_errmsg ("modify_run_on_last_close_flag", errno);
+  error ("PIOCSRLC or PR_RLC modification failed");
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
+
+SYNOPSIS
+
+	void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
+
+DESCRIPTION
+
+	This function function disables traps for the specified system call.
+	errok is non-zero if errors should be ignored.
+ */
+
+static void
+procfs_clear_syscall_trap (pi, syscall_num, errok)
+     struct procinfo *pi;
+     int syscall_num;
+     int errok;
+{
+  sysset_t sysset;
+  int goterr, i;
+
+#ifndef UNIXWARE
+  goterr = ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0;
+
+  if (goterr && !errok)
+    {
+      print_sys_errmsg (pi->pathname, errno);
+      error ("PIOCGENTRY failed");
+    }
+
+  if (!goterr)
+    {
+      prdelset (&sysset, syscall_num);
+
+      if ((ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0) && !errok)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCSENTRY failed");
+	}
+    }
+
+  goterr = ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0;
+
+  if (goterr && !errok)
+    {
+      procfs_clear_syscall_trap (pi, syscall_num, 1);
+      print_sys_errmsg (pi->pathname, errno);
+      error ("PIOCGEXIT failed");
+    }
+
+  if (!goterr)
+    {
+      praddset (&sysset, syscall_num);
+
+      if ((ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0) && !errok)
+	{
+	  procfs_clear_syscall_trap (pi, syscall_num, 1);
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCSEXIT failed");
+	}
+    }
+#endif
+
+  if (!pi->syscall_handlers)
+    {
+      if (!errok)
+	error ("procfs_clear_syscall_trap:  syscall_handlers is empty");
+      return;
+    }
+
+  /* Remove handler func from the handler list */
+
+  for (i = 0; i < pi->num_syscall_handlers; i++)
+    if (pi->syscall_handlers[i].syscall_num == syscall_num)
+      {
+	if (i + 1 != pi->num_syscall_handlers)
+	  {			/* Not the last entry.
+				   Move subsequent entries fwd. */
+	    memcpy (&pi->syscall_handlers[i], &pi->syscall_handlers[i + 1],
+		    (pi->num_syscall_handlers - i - 1)
+		    * sizeof (struct procfs_syscall_handler));
+	  }
+
+	pi->syscall_handlers = xrealloc (pi->syscall_handlers,
+					 (pi->num_syscall_handlers - 1)
+					 * sizeof (struct procfs_syscall_handler));
+	pi->num_syscall_handlers--;
+	return;
+      }
+
+  if (!errok)
+    error ("procfs_clear_syscall_trap:  Couldn't find handler for sys call %d",
+	   syscall_num);
+}
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_set_syscall_trap -- arrange for a function to be called when the
+				   child executes the specified system call.
+
+SYNOPSIS
+
+	void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
+				      syscall_func_t *function)
+
+DESCRIPTION
+
+	This function sets up an entry and/or exit trap for the specified system
+	call.  When the child executes the specified system call, your function
+	will be	called with the call #, a flag that indicates entry or exit, and
+	pointers to rtnval and statval (which are used by procfs_wait).  The
+	function should return non-zero if something interesting happened, zero
+	otherwise.
+ */
+
+static void
+procfs_set_syscall_trap (pi, syscall_num, flags, func)
+     struct procinfo *pi;
+     int syscall_num;
+     int flags;
+     syscall_func_t *func;
+{
+  sysset_t sysset;
+
+#ifndef UNIXWARE
+  if (flags & PROCFS_SYSCALL_ENTRY)
+    {
+      if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCGENTRY failed");
+	}
+
+      praddset (&sysset, syscall_num);
+
+      if (ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0)
+	{
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCSENTRY failed");
+	}
+    }
+
+  if (flags & PROCFS_SYSCALL_EXIT)
+    {
+      if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0)
+	{
+	  procfs_clear_syscall_trap (pi, syscall_num, 1);
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCGEXIT failed");
+	}
+
+      praddset (&sysset, syscall_num);
+
+      if (ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0)
+	{
+	  procfs_clear_syscall_trap (pi, syscall_num, 1);
+	  print_sys_errmsg (pi->pathname, errno);
+	  error ("PIOCSEXIT failed");
+	}
+    }
+#endif
+
+  if (!pi->syscall_handlers)
+    {
+      pi->syscall_handlers = xmalloc (sizeof (struct procfs_syscall_handler));
+      pi->syscall_handlers[0].syscall_num = syscall_num;
+      pi->syscall_handlers[0].func = func;
+      pi->num_syscall_handlers = 1;
+    }
+  else
+    {
+      int i;
+
+      for (i = 0; i < pi->num_syscall_handlers; i++)
+	if (pi->syscall_handlers[i].syscall_num == syscall_num)
+	  {
+	    pi->syscall_handlers[i].func = func;
+	    return;
+	  }
+
+      pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
+				       * sizeof (struct procfs_syscall_handler));
+      pi->syscall_handlers[i].syscall_num = syscall_num;
+      pi->syscall_handlers[i].func = func;
+      pi->num_syscall_handlers++;
+    }
+}
+
+#ifdef SYS_lwp_create
+
+/*
+
+LOCAL FUNCTION
+
+	procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
+
+SYNOPSIS
+
+	int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+	This routine is called both when an inferior process and it's new lwp
+	are about to finish a _lwp_create() system call.  This is the system
+	call that Solaris uses to create a lightweight process.  When the
+	target process gets this event, we can look at sysarg[2] to find the
+	new childs lwp ID, and create a procinfo struct from that.  After that,
+	we pretend that we got a SIGTRAP, and return non-zero to tell
+	procfs_wait to wake up.  Subsequently, wait_for_inferior gets woken up,
+	sees the new process and continues it.
+
+	When we see the child exiting from lwp_create, we just contine it,
+	since everything was handled when the parent trapped.
+
+NOTES
+	In effect, we are only paying attention to the parent's completion of
+	the lwp_create syscall.  If we only paid attention to the child
+	instead, then we wouldn't detect the creation of a suspended thread.
+ */
+
+static int
+procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
+     struct procinfo *pi;
+     int syscall_num;
+     int why;
+     int *rtnvalp;
+     int *statvalp;
+{
+  int lwp_id;
+  struct procinfo *childpi;
+  struct proc_ctl pctl;
+
+  /* We've just detected the completion of an lwp_create system call.  Now we
+     need to setup a procinfo struct for this thread, and notify the thread
+     system of the new arrival.  */
+
+  /* If lwp_create failed, then nothing interesting happened.  Continue the
+     process and go back to sleep. */
+
+#ifdef UNIXWARE
+  /* Joel ... can you check this logic out please? JKJ */
+  if (pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs[R_EFL] & 1)
+    { /* _lwp_create failed */
+      pctl.cmd = PCRUN;
+      pctl.data = PRCFAULT;
+
+      if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
+	perror_with_name (pi->pathname);
+
+      return 0;
+    }
+#else /* UNIXWARE */
+  if (PROCFS_GET_CARRY (pi->prstatus.pr_reg))
+    {				/* _lwp_create failed */
+      pi->prrun.pr_flags &= PRSTEP;
+      pi->prrun.pr_flags |= PRCFAULT;
+
+      if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+	perror_with_name (pi->pathname);
+
+      return 0;
+    }
+#endif
+
+  /* At this point, the new thread is stopped at it's first instruction, and
+     the parent is stopped at the exit from lwp_create.  */
+
+  if (pi->new_child)		/* Child? */
+    {				/* Yes, just continue it */
+#ifdef UNIXWARE
+      pctl.cmd = PCRUN;
+      pctl.data = PRCFAULT;
+
+      if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+#else /* !UNIXWARE */
+      pi->prrun.pr_flags &= PRSTEP;
+      pi->prrun.pr_flags |= PRCFAULT;
+
+      if ((pi->prstatus.pr_flags & PR_ISTOP)
+	  && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+#endif /* !UNIXWARE */
+	perror_with_name (pi->pathname);
+
+      pi->new_child = 0;	/* No longer new */
+
+      return 0;
+    }
+
+  /* We're the proud parent of a new thread.  Setup an exit trap for lwp_create
+     in the child and continue the parent.  */
+
+  /* Third arg is pointer to new thread id. */
+  lwp_id = read_memory_integer (
+     THE_PR_LWP(pi->prstatus).pr_sysarg[2], sizeof (int));
+
+  lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
+
+  childpi = create_procinfo (lwp_id);
+
+  /* The new process has actually inherited the lwp_create syscall trap from
+     it's parent, but we still have to call this to register handlers for
+     that child.  */
+
+  procfs_set_inferior_syscall_traps (childpi);
+  add_thread (lwp_id);
+  printf_filtered ("[New %s]\n", target_pid_to_str (lwp_id));
+
+  /* Continue the parent */
+#ifdef UNIXWARE
+  pctl.cmd = PCRUN;
+  pctl.data = PRCFAULT;
+
+  if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+#else
+  pi->prrun.pr_flags &= PRSTEP;
+  pi->prrun.pr_flags |= PRCFAULT;
+  if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
+#endif
+    perror_with_name (pi->pathname);
+
+  /* The new child may have been created in one of two states: 
+     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.  */
+
+  if (THE_PR_LWP(childpi->prstatus).pr_why == PR_SUSPENDED)
+    childpi->new_child = 1;	/* Flag this as an unseen child process */
+  else
+    {
+      /* Continue the child */
+#ifdef UNIXWARE
+      pctl.cmd = PCRUN;
+      pctl.data = PRCFAULT;
+
+      if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+#else
+      childpi->prrun.pr_flags &= PRSTEP;
+      childpi->prrun.pr_flags |= PRCFAULT;
+
+      if (ioctl (childpi->ctl_fd, PIOCRUN, &childpi->prrun) != 0)
+#endif
+	perror_with_name (childpi->pathname);
+    }
+  return 0;
+}
+#endif /* SYS_lwp_create */
+
+/* Fork an inferior process, and start debugging it with /proc.  */
+
+static void
+procfs_create_inferior (exec_file, allargs, env)
+     char *exec_file;
+     char *allargs;
+     char **env;
+{
+  char *shell_file = getenv ("SHELL");
+  char *tryname;
+  if (shell_file != NULL && strchr (shell_file, '/') == NULL)
+    {
+
+      /* We will be looking down the PATH to find shell_file.  If we
+	 just do this the normal way (via execlp, which operates by
+	 attempting an exec for each element of the PATH until it
+	 finds one which succeeds), then there will be an exec for
+	 each failed attempt, each of which will cause a PR_SYSEXIT
+	 stop, and we won't know how to distinguish the PR_SYSEXIT's
+	 for these failed execs with the ones for successful execs
+	 (whether the exec has succeeded is stored at that time in the
+	 carry bit or some such architecture-specific and
+	 non-ABI-specified place).
+
+	 So I can't think of anything better than to search the PATH
+	 now.  This has several disadvantages: (1) There is a race
+	 condition; if we find a file now and it is deleted before we
+	 exec it, we lose, even if the deletion leaves a valid file
+	 further down in the PATH, (2) there is no way to know exactly
+	 what an executable (in the sense of "capable of being
+	 exec'd") file is.  Using access() loses because it may lose
+	 if the caller is the superuser; failing to use it loses if
+	 there are ACLs or some such.  */
+
+      char *p;
+      char *p1;
+      /* FIXME-maybe: might want "set path" command so user can change what
+	 path is used from within GDB.  */
+      char *path = getenv ("PATH");
+      int len;
+      struct stat statbuf;
+
+      if (path == NULL)
+	path = "/bin:/usr/bin";
+
+      tryname = alloca (strlen (path) + strlen (shell_file) + 2);
+      for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
+	{
+	  p1 = strchr (p, ':');
+	  if (p1 != NULL)
+	    len = p1 - p;
+	  else
+	    len = strlen (p);
+	  strncpy (tryname, p, len);
+	  tryname[len] = '\0';
+	  strcat (tryname, "/");
+	  strcat (tryname, shell_file);
+	  if (access (tryname, X_OK) < 0)
+	    continue;
+	  if (stat (tryname, &statbuf) < 0)
+	    continue;
+	  if (!S_ISREG (statbuf.st_mode))
+	    /* We certainly need to reject directories.  I'm not quite
+	       as sure about FIFOs, sockets, etc., but I kind of doubt
+	       that people want to exec() these things.  */
+	    continue;
+	  break;
+	}
+      if (p == NULL)
+	/* Not found.  This must be an error rather than merely passing
+	   the file to execlp(), because execlp() would try all the
+	   exec()s, causing GDB to get confused.  */
+	error ("Can't find shell %s in PATH", shell_file);
+
+      shell_file = tryname;
+    }
+
+  fork_inferior (exec_file, allargs, env,
+		 proc_set_exec_trap, procfs_init_inferior, NULL, shell_file);
+
+  /* We are at the first instruction we care about.  */
+  /* Pedal to the metal... */
+
+  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+}
+
+/* Clean up after the inferior dies.  */
+
+static void
+procfs_mourn_inferior ()
+{
+  struct procinfo *pi;
+  struct procinfo *next_pi;
+
+  for (pi = procinfo_list; pi; pi = next_pi)
+    {
+      next_pi = pi->next;
+      unconditionally_kill_inferior (pi);
+    }
+
+  unpush_target (&procfs_ops);
+  generic_mourn_inferior ();
+}
+
+
+/* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
+static int
+procfs_can_run ()
+{
+  /* This variable is controlled by modules that sit atop procfs that may layer
+     their own process structure atop that provided here.  sol-thread.c does
+     this because of the Solaris two-level thread model.  */
+
+  return !procfs_suppress_run;
+}
+#ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
+#ifndef UNIXWARE
+
+/* Insert a watchpoint */
+int
+procfs_set_watchpoint(pid, addr, len, rw)
+     int		pid;
+     CORE_ADDR		addr;
+     int		len;
+     int		rw;
+{
+  struct procinfo	*pi;
+  prwatch_t		wpt;
+
+  pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
+  wpt.pr_vaddr = (caddr_t)addr;
+  wpt.pr_size = len;
+  wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
+  if (ioctl (pi->ctl_fd, PIOCSWATCH, &wpt) < 0)
+    {
+      if (errno == E2BIG)
+	return -1;
+      /* Currently it sometimes happens that the same watchpoint gets
+	 deleted twice - don't die in this case (FIXME please) */
+      if (errno == ESRCH && len == 0)
+	return 0;
+      print_sys_errmsg (pi->pathname, errno);
+      error ("PIOCSWATCH failed");
+    }
+  return 0;
+}
+
+int
+procfs_stopped_by_watchpoint(pid)
+    int			pid;
+{
+  struct procinfo	*pi;
+  short 		what;
+  short 		why;
+
+  pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
+  if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
+    {
+      why = pi->prstatus.pr_why;
+      what = pi->prstatus.pr_what;
+      if (why == PR_FAULTED 
+#if defined (FLTWATCH) && defined (FLTKWATCH)
+	  && (what == FLTWATCH || what == FLTKWATCH)
+#else
+#ifdef FLTWATCH
+	  && (what == FLTWATCH) 
+#endif
+#ifdef FLTKWATCH
+	  && (what == FLTKWATCH)
+#endif
+#endif
+	  )
+	return what;
+    }
+  return 0;
+}
+#endif /* !UNIXWARE */
+#endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
+
+/* Why is this necessary?  Shouldn't dead threads just be removed from the
+   thread database?  */
+
+static int
+procfs_thread_alive (pid)
+     int pid;
+{
+  struct procinfo *pi, *next_pi;
+
+  for (pi = procinfo_list; pi; pi = next_pi)
+    {
+      next_pi = pi->next;
+      if (pi -> pid == pid)
+	if (procfs_read_status (pi))	/* alive */
+	  return 1;
+	else				/* defunct (exited) */
+	  {
+	    close_proc_file (pi);
+	    return 0;
+	  }
+    }
+  return 0;
+}
+
+int
+procfs_first_available ()
+{
+  struct procinfo *pi;
+
+  for (pi = procinfo_list; pi; pi = pi->next)
+    {
+      if (procfs_read_status (pi))
+	return pi->pid;
+    }
+  return -1;
+}
+
+int
+procfs_get_pid_fd (pid)
+     int pid;
+{
+  struct procinfo *pi = find_procinfo (pid, 1);
+
+  if (pi == NULL)
+    return -1;
+
+  return pi->ctl_fd;
+}
+
+/* Send a SIGINT to the process group.  This acts just like the user typed a
+   ^C on the controlling terminal.
+
+   XXX - This may not be correct for all systems.  Some may want to use
+   killpg() instead of kill (-pgrp). */
+
+static void
+procfs_stop ()
+{
+  extern pid_t inferior_process_group;
+
+  kill (-inferior_process_group, SIGINT);
+}
+
+/* Convert a pid to printable form. */
+
+#ifdef TIDGET
+char *
+procfs_pid_to_str (pid)
+     int pid;
+{
+  static char buf[100];
+
+  sprintf (buf, "Kernel thread %d", TIDGET (pid));
+
+  return buf;
+}
+#endif /* TIDGET */
+
+
+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 ()
+{
+#ifdef HAVE_OPTIONAL_PROC_FS
+  char procname[MAX_PROC_NAME_SIZE];
+  int fd;
+
+  /* If we have an optional /proc filesystem (e.g. under OSF/1),
+     don't add procfs support if we cannot access the running
+     GDB via /proc.  */
+  sprintf (procname, STATUS_PROC_NAME_FMT, getpid ());
+  if ((fd = open (procname, O_RDONLY)) < 0)
+    return;
+  close (fd);
+#endif
+
+  init_procfs_ops ();
+  add_target (&procfs_ops);
+
+  add_info ("processes", info_proc, 
+"Show process status information using /proc entry.\n\
+Specify process id or use current inferior by default.\n\
+Specify keywords for detailed information; default is summary.\n\
+Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
+`status', `syscalls', and `times'.\n\
+Unambiguous abbreviations may be used.");
+
+  init_syscall_table ();
+}